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.util.function.Function;
  import java.util.stream.Collectors;
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.*;
  import java.math.*;
  
  
  
  
  public class Solution
  {
  	
  	static StringBuilder sb;
  	static dsu dsu;
  	static long fact[];
  	static long mod=(long)(1e9+7);
  	static ArrayList<Integer>l;
  	static long A[];
  	static long c[];
  	static long k;
  	
  	
  	static void solve()
      {
  		int n=i();
  		char c[]=s().toCharArray();
  		
  		
  		int cost=0;
  		for(int i=0;i<n;i++)
  		{
  			if((c[i]-'0')>0)
  			{
  				cost+=(c[i]-'0')+1;
  			}
  		}
  		
  		if(c[n-1]-'0'>0)
  			cost--;
  		System.out.println(cost);
  		
  		
  		
  	}
  	
  	public static void main(String[] args)
  	 {
  		 sb=new StringBuilder();
  	     l=new ArrayList<>();
  	     
  	     int test=i();
  	    for(int tt=1;tt<=test;tt++) 
  	    {
  	         solve();
  	    }
  	     System.out.println(sb);
  	 }
  	 
  //*******************************************NCR%P*******************************************************	 
  	 static long ncr(int n, int r)
  	 {
  		 if(r>n)
  			 return (long)0;
  		 
  		 long res=fact[n]%mod;
  		 //System.out.println(res);
  		 res=((long)(res%mod)*(long)(p(fact[r],mod-2)%mod))%mod;
  		 res=((long)(res%mod)*(long)(p(fact[n-r],mod-2)%mod))%mod;
  		 //System.out.println(res);
  		 return res;
  		
  		 
  	 }
  		static long p(long x, long y)//POWER FXN //
  		{
  			if(y==0)
  				return 1;
  			
  			long res=1;
  			while(y>0)
  			{
  				if(y%2==1)
  				{
  					res=(res*x)%mod;
  					y--;
  				}
  				
  				x=(x*x)%mod;
  				y=y/2;
  				
  				
  			}
  			return res;
  		}
  		
  
  //*******************************************END*******************************************************
  		 public static long[] sort(long[] a) {
  		        int n = a.length;
  		        ArrayList<Long> l = new ArrayList<>();
  		        for (long i : a)
  		            l.add(i);
  		        Collections.sort(l);
  		        for (int i = 0; i < l.size(); i++)
  		            a[i] = l.get(i);
  		        return a;
  		    }
  
  		
  	 
  	 
  	 //*********************************Disjoint set union*************************//
  	 static class dsu
  	 {
  		 int parent[];
  		 dsu(int n)
  		 {
  			 parent=new int[n];
  			 for(int i=0;i<n;i++)
  				 parent[i]=-1;
  		 }
  		 int find(int a)
  		 {
  			 if(parent[a]<0)
  				 return a;
  			 else
  			 {
  				 int x=find(parent[a]);
  				 parent[a]=x;
  				 return x;
  			 }
  		 }
  		 void merge(int a,int b)
  		 {
  			 a=find(a);
  			 b=find(b);
  			 if(a==b)
  				 return;
  			 parent[b]=a;
  		 }
  	 }
  	 
  	 
  	 
  //*******************************************PRIME FACTORIZE *****************************************************************************************************//
  	 static TreeMap<Integer,Integer> prime(long n)
  	 {
  		 TreeMap<Integer,Integer>h=new TreeMap<>();
  		 long num=n;
  		 for(int i=2;i<=Math.sqrt(num);i++)
  		 {
  			 if(n%i==0)
  			 {
  				 int nt=0;
  				 while(n%i==0) {
  					 n=n/i;
  					 nt++;
  				 }
  				 h.put(i, nt);
  			 }
  		 }
  		 if(n!=1)
  			 h.put((int)n, 1);
  		 return h;
  		 
  	 }
  	 
  	
  	
  //*************CLASS PAIR ***********************************************************************************************************************************************
  	    static class pair implements Comparable<pair>
  	    {
  	        int x;
  	        int  y;
  	       
  	        pair(int x, int y) {
  	            this.x = x;
  	            this.y = y;
  	          
  	        }
  	        public int compareTo(pair o)
  	        {
  	        	return(int) (y-o.y);
  	        	
  	        }
  	       /* public int hashCode() 
  	        { 
  	                final int temp = 14; 
  	                int ans = 1; 
  	                ans =x*31+y*13; 
  	                return (int)ans;
  	        }*/
  	        @Override
  	         public boolean equals(Object o) 
  	         { 
  	             if (this == o) { 
  	                 return true; 
  	             } 
  	             if (o == null) { 
  	                 return false; 
  	             } 
  	             if (this.getClass() != o.getClass()) { 
  	                 return false; 
  	             } 
  	             pair other = (pair)o; 
  	             if (this.x != other.x || this.y!=other.y) { 
  	                 return false; 
  	             } 
  	             return true; 
  	         }
  	    } 
  	        
  	        
  			
  	       
  	    
  //*************CLASS PAIR *****************************************************************************************************************************************************
  	
  	
  	
  
      static class InputReader {
          private InputStream stream;
          private byte[] buf = new byte[1024];
          private int curChar;
          private int numChars;
          private SpaceCharFilter filter;
  
          public InputReader(InputStream stream) {
              this.stream = stream;
          }
  
          public int read() {
              if (numChars == -1)
                  throw new InputMismatchException();
              if (curChar >= numChars) {
                  curChar = 0;
                  try {
                      numChars = stream.read(buf);
                  } catch (IOException e) {
                      throw new InputMismatchException();
                  }
                  if (numChars <= 0)
                      return -1;
              }
              return buf[curChar++];
          }
  
          public int Int() {
              int c = read();
              while (isSpaceChar(c))
                  c = read();
              int sgn = 1;
              if (c == '-') {
                  sgn = -1;
                  c = read();
              }
              int res = 0;
              do {
                  if (c < '0' || c > '9')
                      throw new InputMismatchException();
                  res *= 10;
                  res += c - '0';
                  c = read();
              } while (!isSpaceChar(c));
              return res * sgn;
          }
  
          public String String() {
              int c = read();
              while (isSpaceChar(c))
                  c = read();
              StringBuilder res = new StringBuilder();
              do {
                  res.appendCodePoint(c);
                  c = read();
              } while (!isSpaceChar(c));
              return res.toString();
          }
  
          public boolean isSpaceChar(int c) {
              if (filter != null)
                  return filter.isSpaceChar(c);
              return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
          }
  
          public String next() {
              return String();
          }
  
          public interface SpaceCharFilter {
              public boolean isSpaceChar(int ch);
          }
      }
  
      static class OutputWriter {
          private final PrintWriter writer;
  
          public OutputWriter(OutputStream outputStream) {
              writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
          }
  
          public OutputWriter(Writer writer) {
              this.writer = new PrintWriter(writer);
          }
  
          public void print(Object... objects) {
              for (int i = 0; i < objects.length; i++) {
                  if (i != 0)
                      writer.print(' ');
                  writer.print(objects[i]);
              }
          }
  
          public void printLine(Object... objects) {
              print(objects);
              writer.println();
          }
  
          public void close() {
              writer.close();
          }
  
          public void flush() {
              writer.flush();
          }
      }
  
      static InputReader in = new InputReader(System.in);
      static OutputWriter out = new OutputWriter(System.out);
     
  
      public static int[] sort(int[] a) {
          int n = a.length;
          ArrayList<Integer> l = new ArrayList<>();
          for (int i : a)
              l.add(i);
          Collections.sort(l);
          for (int i = 0; i < l.size(); i++)
              a[i] = l.get(i);
          return a;
      }
  
      public static long pow(long x, long y) {
          long res = 1;
          while (y > 0) {
              if (y % 2 != 0) {
                  res = (res * x);// % modulus;
                  y--;
  
              }
              x = (x * x);// % modulus;
              y = y / 2;
          }
          return res;
      }
  //GCD___+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      public static long gcd(long x, long y) {
          if (x == 0)
              return y;
          else
              return gcd(y % x, x);
      }
      //****************LOWEST COMMON MULTIPLE   *************************************************************************************************************************************
  
      public static long lcm(long x, long y) {
          return (x * (y / gcd(x, y)));
      }
  //INPUT PATTERN******************************************************************************************************************************************************************
      public static int i() {
          return in.Int();
      }
  
      public static long l() {
          String s = in.String();
          return Long.parseLong(s);
      }
  
      public static String s() {
          return in.String();
      }
  
      public static int[] readArray(int n) {
          int A[] = new int[n];
          for (int i = 0; i < n; i++) {
              A[i] = i();
          }
          return A;
      }
  
      public static long[] readArray(long n) {
          long A[] = new long[(int) n];
          for (int i = 0; i < n; i++) {
              A[i] = l();
          }
          return A;
      }
      public int[][] deepCopy(int[][] matrix) {
  		return java.util.Arrays.stream(matrix).map(el -> el.clone()).toArray($ -> matrix.clone());
  		}
   
  
  }
  
  
  
  
  
  
  	