description: In Berland, n different types of banknotes are used. Banknotes of the i-th type have denomination 10^{a_i} burles (burles are the currency used in Berland); the denomination of banknotes of the first type is exactly 1.
  
  Let's denote f(s) as the minimum number of banknotes required to represent exactly s burles. For example, if the denominations of banknotes used in Berland are 1, 10 and 100, then f(59) = 14: 9 banknotes with denomination of 1 burle and 5 banknotes with denomination of 10 burles can be used to represent exactly 9 ⋅ 1 + 5 ⋅ 10 = 59 burles, and there's no way to do it with fewer banknotes.
  
  For a given integer k, find the minimum positive number of burles s that cannot be represented with k or fewer banknotes (that is, f(s) > k).
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
  
  The first line of each test case contains two integers n and k (1 ≤ n ≤ 10; 1 ≤ k ≤ 10^9).
  
  The next line contains n integers a_1, a_2, ..., a_n (0 = a_1 < a_2 < ... < a_n ≤ 9).
  
  Output
  
  For each test case, print one integer — the minimum positive number of burles s that cannot be represented with k or fewer banknotes.
  
  Example
  
  Input
  
  
  4
  3 13
  0 1 2
  2 777
  0 4
  3 255
  0 1 3
  10 1000000000
  0 1 2 3 4 5 6 7 8 9
  
  
  Output
  
  
  59
  778
  148999
  999999920999999999
solution: 	import java.util.*;
  	import java.io.*;
  	public class C1606{
  		static FastScanner fs = null;
  		public static void main(String[] args) {
  			fs = new FastScanner();
  			PrintWriter out = new PrintWriter(System.out);
  			int t = fs.nextInt();
  			while(t-->0){
  				int n = fs.nextInt();
  				long k = fs.nextLong();
  				int count[] = new int[12];
  				int max = 0;
  				for(int i=0;i<n;i++){
  					int num = fs.nextInt();
  					count[num]+=1;
  					max = Math.max(num,num);
  				}
  				long ans = 0;
  				int prev = 0;
  				int c = 0;
  				for(int i=0;i<12;i++){
  					if(count[i]==0){
  						if(i>max){
  							ans+=((k+1)*(long)Math.pow(10,i-1));
  							break;
  						}
  						else{
  						long mul = (long)9*(long)Math.pow(10,c);
  						if(mul>=(k+(long)1)){
  							ans+=((k+(long)1)*(long)Math.pow(10,i-c));
  							break;
  						}
  						else{
  							ans+=((mul)*(long)Math.pow(10,i-c));
  							k-=mul;
  						}
  						}
  						c+=1;
  					}
  					else{
  					long ci = (long)9;
  					if((k+(long)1)<=ci){
  						ans+=((k+(long)1)*(long)Math.pow(10,i));
  						break;
  					}
  					k-=(long)9;
  					ans+=(ci*(long)Math.pow(10,i));
  					prev = i;
  					c = 1;
  					}
  				}
  				out.println(ans);
  			}
  			out.println();
  			out.close();
  		}
  		static void sort(int[] a) {
  			ArrayList<Integer> l=new ArrayList<>();
  			for (int i:a) l.add(i);
  			Collections.sort(l);
  			for (int i=0; i<a.length; i++) a[i]=l.get(i);
  		}
  		static class FastScanner {
  			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  			StringTokenizer st=new StringTokenizer("");
  			String next() {
  				while (!st.hasMoreTokens())
  					try {
  						st=new StringTokenizer(br.readLine());
  					} catch (IOException e) {
  						e.printStackTrace();
  					}
  				return st.nextToken();
  			}
  			
  			int nextInt() {
  				return Integer.parseInt(next());
  			}
  			int[] readArray(int n) {
  				int[] a=new int[n];
  				for (int i=0; i<n; i++) a[i]=nextInt();
  				return a;
  			}
  			long nextLong() {
  				return Long.parseLong(next());
  			}
  		}
  	}