description: You are given a digital clock with n digits. Each digit shows an integer from 0 to 9, so the whole clock shows an integer from 0 to 10^n-1. The clock will show leading zeroes if the number is smaller than 10^{n-1}.
  
  You want the clock to show 0 with as few operations as possible. In an operation, you can do one of the following: 
  
    * decrease the number on the clock by 1, or 
    * swap two digits (you can choose which digits to swap, and they don't have to be adjacent). 
  
  
  
  Your task is to determine the minimum number of operations needed to make the clock show 0.
  
  Input
  
  Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3).
  
  The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — number of digits on the clock.
  
  The second line of each test case contains a string of n digits s_1, s_2, …, s_n (0 ≤ s_1, s_2, …, s_n ≤ 9) — the number on the clock.
  
  Note: If the number is smaller than 10^{n-1} the clock will show leading zeroes.
  
  Output
  
  For each test case, print one integer: the minimum number of operations needed to make the clock show 0.
  
  Example
  
  Input
  
  
  7
  3
  007
  4
  1000
  5
  00000
  3
  103
  4
  2020
  9
  123456789
  30
  001678294039710047203946100020
  
  
  Output
  
  
  7
  2
  0
  5
  6
  53
  115
  
  Note
  
  In the first example, it's optimal to just decrease the number 7 times.
  
  In the second example, we can first swap the first and last position and then decrease the number by 1.
  
  In the third example, the clock already shows 0, so we don't have to perform any operations.
solution: import java.util.*;
  import java.io.*;
  import java.lang.*;
  
  public class Main {
      //input
      static out op = new out();
      static inp ip = new inp();
      static FastReader sc = new FastReader();
      static BufferedWriter output = new BufferedWriter( 
          new OutputStreamWriter(System.out));
      static long inf = (long)1e9+7;
     
     static long mod = (long)1e18+7;
     static long z = 0;
  
     static void sol() throws Exception{
        
        int n = ip.in();
        char[] s = ip.cain();
        int cnt = s[n-1]-'0';
        for(int i=0;i<n-1;i++){
           if(s[i] > '0')
              cnt += (s[i] - '0') + 1;
          
        }
        
        op.sbln(cnt);
     }
     
     
     static long gcd(long a,long b){
       if(b==0)
       return a;
       return gcd(b,a%b);
     }
     
     public static void main(String[] args) throws Exception { 
         
        int t = ip.in();
        while(t-- > 0){
           sol();
        }
        op.output.flush();
      }
      static class Node implements Comparable<Node>{
         int data;
         int ind;
        //  Node left,right;
        //  Node(){
        //       left = null;
        //       right = null;
        //  }
         Node(int ind,int data){
              this.data = data;
              this.ind = ind;
         }
      
           @Override
           public int compareTo(Node o) {
               if(this.data == o.data)
               return o.ind - this.ind;
               // TODO Auto-generated method stub
               return this.data - o.data;
           }
      }
  }
  
  
  class FastReader 
  { 
      BufferedReader br; 
      StringTokenizer st; 
  
      public FastReader() 
      { 
          br = new BufferedReader(new
                   InputStreamReader(System.in)); 
      } 
  
      String next() 
      { 
          while (st == null || !st.hasMoreElements()) 
          { 
              try
              { 
                  st = new StringTokenizer(br.readLine()); 
              } 
              catch (IOException  e) 
              { 
                  e.printStackTrace(); 
              } 
          } 
          return st.nextToken(); 
      } 
  
      int nextInt() 
      { 
          return Integer.parseInt(next()); 
      } 
  
      long nextLong() 
      { 
          return Long.parseLong(next()); 
      } 
  
      double nextDouble() 
      { 
          return Double.parseDouble(next()); 
      } 
  
      String nextLine() 
      { 
          String str = ""; 
          try
          { 
              str = br.readLine(); 
          } 
          catch (IOException e) 
          { 
              e.printStackTrace(); 
          } 
          return str; 
      }
  
  }
  class inp{
      FastReader sc = new FastReader();
      int in(){
          int a = sc.nextInt();
          return a;
      }
      long lin(){
          long a = sc.nextLong();
          return a;
      }
      char cin(){
          char c = sc.next().charAt(0);
          return c;
      }
      char[] cain(){
          char[] a = sc.nextLine().toCharArray();
          return a;
      }
      int[] arrin(int n){
          int [] arr = new int[n];
          for(int i=0;i<n;i++)
              arr[i] = in();
  
          return arr;
      }
      int[] mm_arr(int[] arr){
          int max = Integer.MIN_VALUE;
          int min = Integer.MAX_VALUE;
          for(int i=0;i<arr.length;i++){
              max = Math.max(max,arr[i]);
              min = Math.min(min,arr[i]);
          }
          int ans[] = {max,min};
          return ans;
      }
      int[] srt(int[] arr){
          Arrays.sort(arr);
          return arr;
      }
      long pow(long a,long b){
          if(b == 0)return 1;
          long res = pow(a,b/2);
          //System.out.println(res + " " + b + " " + (b&1));
          if((b&1) == 0)return res*res;
          return a*res*res; 
      }
  
     //  boolean[] prime(){
     //     boolean prime[] = new boolean[100000001];
     //     Arrays.fill(prime,true);
     //     for (int p = 2; p * p <= 10000000; p++)
     //     {
     //          // If prime[p] is not changed,
     //          // then it is a prime
     //          if (prime[p] == true)
     //          {
     //              // Update all multiples
     //              // of p greater than or
     //              // equal to the square of it
     //              // numbers which are multiple
     //              // of p and are less than p^2
     //              // are already been marked.
     //              for (int i = p * p; i <= 10000000; i += p)
     //                 prime[i] = false;
     //          }
     //     }
     //     return prime;
     //  }
  }
  class out{
      BufferedWriter output = new BufferedWriter( 
          new OutputStreamWriter(System.out)); 
  
      void sb(String s) throws IOException {
          output.write(s);
      }
      void sbln(Object s) throws IOException {
          output.write(s+"\n");
      }
      void yes() throws IOException{
          output.write("YES\n");
      }
      void no() throws IOException{
          output.write("NO\n");
      }
  }