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.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.PrintWriter;
  import java.util.*;
  
   
   
  public class Codeforces {
  	
  	static int mod=1000000007 ;
  
  	public static void main(String[] args) throws Exception {
  		// TODO Auto-generated method stub
  		PrintWriter out=new PrintWriter(System.out);
  	    FastScanner fs=new FastScanner();
  	    int t=fs.nextInt();
  	    outer:for(int time=1;time<=t;time++) {
  	    	int n=fs.nextInt();
  	    	char arr[]=fs.next().toCharArray();
  	    	int ans=0;
  	    	for(int i=0;i<arr.length;i++) {
  	    		int cur=(arr[i]-'0');
  	    		if(cur!=0) {
  	    			ans+=cur;
  	    			if(i!=n-1) ans++;
  	    		}
  	    	}
  	    	System.out.println(ans);
  	    }
  	    
  	    
  	    out.close();
  	}
  	static double dis(double a,double b,double c,double d) {
  		return Math.sqrt((a-c)*(a-c)+(b-d)*(b-d));
  	}
  	static double area(double x1, double y1, double x2, double y2,
  			double x3, double y3)
  	{
  	return Math.abs((x1*(y2-y3) + x2*(y3-y1)+
  	        x3*(y1-y2))/2.0);
  	}
  	
  	/* A function to check whether point P(x, y) lies
  	inside the triangle formed by A(x1, y1),
  	B(x2, y2) and C(x3, y3) */
  	static boolean isInside(int x1, int y1, int x2,
  	int y2, int x3, int y3, int x, int y)
  	{  
  	/* Calculate area of triangle ABC */
  	double A = area (x1, y1, x2, y2, x3, y3);
  	
  	double z=0.0;
  	/* Calculate area of triangle PBC */ 
  	double A1 = area (x, y, x2, y2, x3, y3);
  	
  	/* Calculate area of triangle PAC */ 
  	double A2 = area (x1, y1, x, y, x3, y3);
  	
  	/* Calculate area of triangle PAB */  
  	double A3 = area (x1, y1, x2, y2, x, y);
  	
  	/* Check if sum of A1, A2 and A3 is same as A */
  	if(A1==z||A2==z||A3==z) return false;
  	return (A == A1 + A2 + A3);
  	}
  	static boolean s(int x1, int y1, int x2,
  			int y2, int x3, int y3,int x4,int y4, int x, int y)
  			{  
  			/* Calculate area of triangle ABC */
  			double A = area (x1, y1, x2, y2, x3, y3);
  			
  			double z=0.0;
  			/* Calculate area of triangle PBC */ 
  			double A1 = area (x, y, x2, y2, x3, y3);
  			
  			/* Calculate area of triangle PAC */ 
  			double A2 = area (x1, y1, x, y, x3, y3);
  			
  			/* Calculate area of triangle PAB */  
  			double A3 = area (x1, y1, x2, y2, x, y);
  			double A4 = area (x1, y1, x2, y2, x, y);
  			
  			/* Check if sum of A1, A2 and A3 is same as A */
  			if(A1==z||A2==z||A3==z) return false;
  			return (A == A1 + A2 + A3);
  			}
  	static long pow(long a,long b) {
  		if(b<0) return 1;
  		long res=1;
  		while(b!=0) {
  			if((b&1)!=0) {
  				res*=a;
  				res%=mod;
  			}
  			a*=a;
  			a%=mod;
  			b=b>>1;
  		}
  		return res;
  	}
  	static long gcd(long  a,long  b) {
  		if(b==0) return a;
  		return gcd(b,a%b);
  	}
  	static long nck(int n,int k) {
  		if(k>n) return 0;
  		long res=1;
  		res*=fact(n);
  		res%=mod;
  		res*=modInv(fact(k));
  		res%=mod;
  		res*=modInv(fact(n-k)); 
  		res%=mod;
  		return res;
  	}
  	static long fact(long n) {
  		long res=1;
  		for(int i=2;i<=n;i++) {
  			res*=i;
  			res%=mod;
  		}
  		return res;
  	}
  	
  	static long modInv(long n) {
  		return pow(n,mod-2);
  	}
  	
  	static void sort(int[] a) {
  		//suffle
  		int n=a.length;
  		Random r=new Random();
  		for (int i=0; i<a.length; i++) {
  			int oi=r.nextInt(n);
  			int temp=a[i];
  			a[i]=a[oi];
  			a[oi]=temp;
  		}
  		
  		//then sort
  		Arrays.sort(a);
  	}
  	
  	// Use this to input code since it is faster than a Scanner
  	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());
  		}
  		long[] lreadArray(int n) {
  			long a[]=new long[n];
  			for(int i=0;i<n;i++) a[i]=nextLong();
  			return a;
  		}
  		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());
  		}
  	}
   
  }