第K小子串(客户端开发卷)

s=input().strip()
k=int(input())
A=[]
for i in range(len(s)-k):
    A.append(s[i:i+k])
if k==1:
    A=sorted(A,key=lambda x:(x[0]))
elif k==2:
    A=sorted(A,key=lambda x:(x[0],x[1]))
elif k==3:
    A=sorted(A,key=lambda x:(x[0],x[1],x[2]))
elif k==4:
    A=sorted(A,key=lambda x:(x[0],x[1],x[2],x[3]))
else:
    A=sorted(A,key=lambda x:(x[0],x[1],x[2],x[3],x[4]))
print(A[0])

import java.util.*;
import java.io.*;
public class Main{
    public static void main(String[] args) throws IOException{
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String sss = in.readLine();
        int k = Integer.parseInt(in.readLine());
        StringBuilder par = new StringBuilder("a");
        while(k > 0){
            if(sss.indexOf(par.toString()) != -1){
                k--;
                if(k == 0) break;
                par.append("a");
            }else{
                next(par);
            }
        }
        System.out.println(par.toString());
    }
    public static void next(StringBuilder ss){
        while(ss.charAt(ss.length()-1) == 'z'){
            ss.deleteCharAt(ss.length()-1); 
        }
        char c = ss.charAt(ss.length()-1);
        ss.deleteCharAt(ss.length()-1);
        ss.append((char)(c+1));
    }
}

#include<bits/stdc++.h>
using namespace std;
const int nn =5100;
const int inff = 0x3fffffff;
const double eps = 1e-8;
typedef long long LL;
const double pi = acos(-1.0);
const LL mod = 1000000007;
string s;
int k;
int main()
{
    cin>>s;
    cin>>k;
    set<string>se;
    int ls=s.size();
    for(int i=0;i<ls;i++)
    {
        string tem;
        for(int j=i;j<ls;j++)
        {
            tem+=s[j];
            if(se.size()>=k)
            {
                if(tem>=*(--se.end()))
                    break;
            }
            se.insert(tem);
            if(se.size()>k)
            {
                se.erase(--se.end());
            }
        }
    }
    cout<<*(--se.end())<<endl;
    return 0;
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.HashSet;
import java.util.PriorityQueue;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = br.readLine();
        int k = Integer.parseInt(br.readLine());
        HashSet<String> set = new HashSet<>();
        PriorityQueue<String> queue = new PriorityQueue<>((s1, s2) -> s2.compareTo(s1));
        for(int len = 1; len <= k; len ++){
            for(int i = 0; i < str.length() - len + 1; i++){
                String substr = str.substring(i, i + len);
                if(!set.contains(substr)){
                    if(queue.size() < k){
                        queue.offer(substr);
                    }else{
                        if(substr.compareTo(queue.peek()) < 0){
                            queue.poll();
                            queue.offer(substr);
                        }
                    }
                    set.add(substr);
                }
            }
        }
        System.out.println(queue.peek());
    }
}

#include <bits/stdc++.h>
using namespace std;

struct Data {
    string s;
    int next;
    Data(string s, int next) : s(s), next(next) {}
};
struct Cmp {
    bool operator()(Data &a, Data &b) {
        return a.s > b.s;
    }
};

int main() {
    char str[5005];
    int k;
    scanf("%s", str);
    scanf("%d", &k);
    priority_queue<Data, vector<Data>, Cmp> heap;
    for (int i = 0; i < strlen(str); i++) {
        string tmp = string("") + str[i];
        heap.push(Data(tmp, i + 1));
    }
    int cnt = 0;
    set<string> vis;
    string ans;
    while (cnt < k) {
        Data t = heap.top();
        heap.pop();
        if (!vis.count(t.s)) {
            vis.insert(t.s);
            ans = t.s;
            cnt++;
        }
        if (t.next < strlen(str)) {
            string tmp = t.s + str[t.next];
            heap.push(Data(tmp, t.next + 1));
        }
    }
    printf("%s\n", ans.c_str());

    return 0;
}

s = input()
k = int(input())
k_str = [0 for i in range(k)]
for i in range(len(s)):
    for j in range(i,min(i+k,len(s))):
        for kk in range(k):
            if k_str[kk]==s[i:j+1]:
                break
            if k_str[kk]==0:
                k_str[kk]=s[i:j+1]
                break
            elif k_str[kk]>s[i:j+1]:
                k_str[kk+1:]=k_str[kk:-1]
                k_str[kk]=s[i:j+1]
                break
print(k_str[-1])

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
//#define mod 998244353
#define mod 1000000007
#define ll long long
using namespace std;
const int N=1e6+5;
const double ex=1e-8;
int n,m,k;
void solve(){
    set<string>st;
    string s;
    cin>>s>>k;
    n=s.size();
    for(int i=0;i<n;i++){
        string ss="";
        for(int j=i;j<n;j++){
            ss+=s[j];
            st.insert(ss);
            if(st.size()>k){
                st.erase(--st.end());
            }
        }
    }
    cout<<*(--st.end())<<'\n';
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    //cout<<fixed<<setprecision(10);
    //int t;
    //cin>>t;
    //while(t--){
        solve();
    //}
    return 0;
}

#include<iostream>
#include<set>

using namespace std;

string s;
int k;

int main()
{
    cin >> s;
    cin >> k;
    set<string>min_k;  //用于存储最小的k个子串，存储在set中的元素有序，--min_k.end()是指向容器中字典序最大字符串的指针
    int lenth = s.size();
    for (int i = 0; i < lenth; i++)
    {
        string tem;
        for (int j = i; j < lenth; j++)
        {
            tem += s[j];
            if (min_k.size() == k)
            {
                if (tem >= *(--min_k.end()))
                {
                    break;
                }
            }
            min_k.insert(tem);
            if (min_k.size() > k)
            {
                min_k.erase(--min_k.end());  //因为可能会存在重复的子串，所以在插入tem后清理超出k个的元素
            }
        }
    }
    cout << *(--min_k.end()) << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_set>
#include <cstring>
#include <algorithm>
using namespace std;

struct SuffixAutomaton{
	static constexpr int N=1e6+5;
	int fa[N],len[N],endpos[N];
	int ch[N][26];
	vector<int>ed[N];
	int root,last,sz;
	SuffixAutomaton(){
		root=last=sz=1;
	}

	void clear(){
		for(int i=0;i<=sz;i++)
		{
			fa[i]=len[i]=endpos[i]=0;
			memset(ch[i],0,sizeof(ch[i]));
		}
		root=last=sz=1;
	}

	void insert(int c){
	    int p=last,now=++sz;
	    endpos[now]++;
	    len[now]=len[p]+1;
	    for(;p&&!ch[p][c];p=fa[p])ch[p][c]=now;
	    if(!p)fa[now]=root;
	    else
	    {
	        int q=ch[p][c];
	        if(len[q]==len[p]+1)fa[now]=q;
	        else
	        {
	            int nq=++sz;
	            memcpy(ch[nq],ch[q],sizeof(ch[q]));
	            fa[nq]=fa[q];
	            len[nq]=len[p]+1;
	            fa[now]=fa[q]=nq;
	            for(;p&&ch[p][c]==q;p=fa[p])ch[p][c]=nq;
	        }
	    }
	    last=now;
	}

	int find(string&s){
		int rt=1;
		for(auto i:s)
		{
			if(ch[rt][i-'a'])rt=ch[rt][i-'a'];
			else return 0;
		}
		return 1;
	}

	void build(){
		for(int i=2;i<=sz;i++)
		{
			ed[fa[i]].push_back(i);
		}
	}

    void get(int x){
        for(auto y:ed[x])
        {
            get(y);
            endpos[x]+=endpos[y];
        }
    }

    string ans;
    int res;
	bool dfs(int x){
		for(int i=0,j;i<26;i++)
        {
            if(j=ch[x][i])
            {
                if(endpos[j])res--;
                if(!res||dfs(j))return ans+='a'+i,true;
            }
        }
        return false;
	}
}sam;

int main() {
    string s; cin>>s;
    int k; cin>>k;
    for(auto i:s)
    {
        sam.insert(i-'a');
    }

    sam.build(),sam.get(1);

    sam.res=k;
    sam.dfs(1);
    reverse(sam.ans.begin(),sam.ans.end());
    cout<<sam.ans<<"\n";
}

import java.io.BufferedInputStream;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(new BufferedInputStream(System.in));
        String s = in.nextLine();
        int k = in.nextInt();
        TreeSet<String> set = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                for (int i = 0; i < Math.min(o1.length(), o2.length()); i++) {
                    if (o1.charAt(i) != o2.charAt(i)) {
                        return o1.charAt(i) - o2.charAt(i);
                    }
                }
                return o1.length() - o2.length();
            }
        });
        for (int i = 0; i < s.length(); i++) {
            for (int j = i + 1; j <= i + k && j <= s.length(); j++) {
                set.add(s.substring(i, j));
            }
        }
        for (String str : set) {
            k--;
            if (k == 0) {
                System.out.println(str);
                return;
            }
        }
    }



}

import sys
from collections import defaultdict
s = sys.stdin.readline().strip()
k = int(sys.stdin.readline().strip())
ans = []
for i in range(len(s)):
    ans.append([ord(s[i]) - ord("a"), i])
ans.sort(key=lambda x: (x[0], s[x[1]:len(s)]))
 
def find():
    viewed = defaultdict(bool)
    count = 0
    for j in range(len(ans)):
        for h in range(len(s)-ans[j][1]):
            curr_s = s[ans[j][1]:ans[j][1]+h+1]
            if not viewed[curr_s]:
                viewed[curr_s] = True
                count += 1
                if count == k:
                    return curr_s
print(find())