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: //package CodeforcesContests;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.*;
  
  public class C {
      
      public static void main (String[] Z) throws IOException {
          
          BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
          StringBuilder op = new StringBuilder();
          StringTokenizer stz;
          
          int T = Integer.parseInt(br.readLine());
          
          
          while(T-- > 0) {
      
              stz = new StringTokenizer(br.readLine());
              long n = Long.parseLong(stz.nextToken());
              long k = Long.parseLong(stz.nextToken());
              
              long[] arr = new long[(int)n];
              long ten = 10;
              stz = new StringTokenizer(br.readLine());
              for (int i = 0; i < n; i++) {
                  long pow = Long.parseLong(stz.nextToken());
                  long num = 1;
                  for (int j = 0; j < pow; j++) {
                      num *= ten;
                  }
                  arr[i] = num;
              }
              
              long[] diffs = new long[(int)n];
              diffs[0] = 0;
      
              Arrays.sort(arr);
              for (int i = 1 ; i < n; i++) {
                  long now = arr[i];
                  long prev = arr[i-1];
                  
                  long tadd = now/prev;
                  --tadd;
                  diffs[i] = diffs[i-1] + tadd;
              }
      
  //            System.out.println(Arrays.toString(arr));
  //            System.out.println(Arrays.toString(diffs));
              long ans = 1;
              
              if(arr[0] > k) {
                  op.append("1\n");
                  continue;
              }
              
              for (int i = 0; i < n; i++) {
  
                  if(k < diffs[i]) {
                      if(i == 0) {
                          ans = 1;
                          break;
                      }
                      
                      long rem = k - diffs[i-1] + 2 ;
                      rem *= arr[i-1];
                      rem -= 1;
                      ans = rem;
                      break;
                      
                  }
                  else if(i == n-1) {
                      long rem = k - diffs[i] + 2 ;
                      rem *= arr[i];
                      rem -= 1;
                      ans = rem;
                      break;
                  }
              }
              
              op.append(ans + "\n");
              
              
              
              
          }
          
          System.out.println(op);
          
          
          // END OF CODE
      }
  }
  