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.math.BigInteger;
  import java.util.Scanner;
  import java.io.DataInputStream;
  import java.io.FileInputStream;
  
  import java.io.IOException;
  
  public class cfContest1606 {
  
      static long ch(long a, long[] val) {
          long res = 0;
          for (int i = val.length - 1; i >= 0; i--) {
              res += (a / val[i]);
              a -= (a / val[i]) * val[i];
          }
          return res;
      }
  
      public static void main(String args[]) throws IOException {
          Reader scan = new Reader();
          int t = scan.nextInt();
          StringBuilder sb = new StringBuilder();
  
          while (t-- > 0) {
              int n = scan.nextInt();
              int k = scan.nextInt();
              long[] a = new long[n];
              for (int i = 0; i < n; i++) {
                  a[i] = scan.nextInt();
              }
              long[] val = new long[n];
              for (int i = 0; i < n; i++) {
                  val[i] = (long) Math.pow(10, a[i]);
              }
              for (int i = 1; i < 19; i++) {
                  long p = (long) Math.pow(10, i) - 1;
  
                  long res = ch(p, val);
                  if (res > k) {
                      long r = p;
                      long pe = res - k;
                      long mx = 0;
                      for (int j = val.length - 1; j >= 0; j--) {
                          if (p / val[j] >= 1) {
                              mx = Math.max(mx, val[j]);
                              p -= (p / val[j]) * val[j];
                          }
                      }
  
                      System.out.println(r - mx * (pe - 1));
  
                      break;
  
                  }
  
              }
  
          }
         
      }
  
  }
  
  class Reader {
  
      final private int BUFFER_SIZE = 1 << 16;
      private DataInputStream din;
      private byte[] buffer;
      private int bufferPointer, bytesRead;
  
      public Reader() {
          din = new DataInputStream(System.in);
          buffer = new byte[BUFFER_SIZE];
          bufferPointer = bytesRead = 0;
      }
  
      public Reader(String file_name) throws IOException {
          din = new DataInputStream(new FileInputStream(file_name));
          buffer = new byte[BUFFER_SIZE];
          bufferPointer = bytesRead = 0;
      }
  
      public String readLine() throws IOException {
          byte[] buf = new byte[64]; // line length 
          int cnt = 0, c;
          while ((c = read()) != -1) {
              if (c == '\n') {
                  break;
              }
              buf[cnt++] = (byte) c;
          }
          return new String(buf, 0, cnt);
      }
  
      public int nextInt() throws IOException {
          int ret = 0;
          byte c = read();
          while (c <= ' ') {
              c = read();
          }
          boolean neg = (c == '-');
          if (neg) {
              c = read();
          }
          do {
              ret = ret * 10 + c - '0';
          } while ((c = read()) >= '0' && c <= '9');
  
          if (neg) {
              return -ret;
          }
          return ret;
      }
  
      public long nextLong() throws IOException {
          long ret = 0;
          byte c = read();
          while (c <= ' ') {
              c = read();
          }
          boolean neg = (c == '-');
          if (neg) {
              c = read();
          }
          do {
              ret = ret * 10 + c - '0';
          } while ((c = read()) >= '0' && c <= '9');
          if (neg) {
              return -ret;
          }
          return ret;
      }
  
      public double nextDouble() throws IOException {
          double ret = 0, div = 1;
          byte c = read();
          while (c <= ' ') {
              c = read();
          }
          boolean neg = (c == '-');
          if (neg) {
              c = read();
          }
  
          do {
              ret = ret * 10 + c - '0';
          } while ((c = read()) >= '0' && c <= '9');
  
          if (c == '.') {
              while ((c = read()) >= '0' && c <= '9') {
                  ret += (c - '0') / (div *= 10);
              }
          }
  
          if (neg) {
              return -ret;
          }
          return ret;
      }
  
      private void fillBuffer() throws IOException {
          bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
          if (bytesRead == -1) {
              buffer[0] = -1;
          }
      }
  
      private byte read() throws IOException {
          if (bufferPointer == bytesRead) {
              fillBuffer();
          }
          return buffer[bufferPointer++];
      }
  
      public void close() throws IOException {
          if (din == null) {
              return;
          }
          din.close();
      }
  }
  