import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.StringTokenizer; 
import java.util.*;
 
public class Solution 
{ 
    
    public static int gcd(int a,int b){
        if(a==1 ||b==1)
        return 1;
        if(b==0)
        return a;
        return gcd(b, a%b);
    }
      public static HashMap<Integer,Integer> primeFactors(int n) 
    { 
      HashMap<Integer,Integer>  h=new  HashMap<>  ();
        while (n%2==0) 
        { 
            if(h.containsKey(2))
         h.put(2,h.get(2)+1);
    else
    h.put(2,1);
            n /= 2; 
        } 
  
        // n must be odd at this point.  So we can 
        // skip one element (Note i = i +2) 
        for (int i = 3; i <= Math.sqrt(n); i+= 2) 
        { 
            // While i divides n, print i and divide n 
            while (n%i == 0) 
            { 
                    if(h.containsKey(i))
         h.put(i,h.get(i)+1);
    else
    h.put(i,1);
                n /= i; 
            } 
        } 
  
        // This condition is to handle the case whien 
        // n is a prime number greater than 2 
        if (n > 2) {
               if(h.containsKey(n))
         h.put(n,h.get(n)+1);
    else
    h.put(n,1);
         
        }
        return h;
    } 
   public  static boolean isPowerOfTwo (int x) 
    { 
      /* First x in the below expression is  
        for the case when x is 0 */
        return x!=0 && ((x&(x-1)) == 0); 
          
    } 
    public static int good(String str, int s,int e,char ch){
        //System.out.println(s+"/"+e);
        if(s==e){
          if(str.charAt(s)==ch)
          return 0;
          else
          return 1;
      }
      int m=(s+e)/2;
      int first=0;
      for(int i=s;i<=m;i++){
          if(str.charAt(i)==ch)
          first++;
      }
      //System.out.println(first+"*");
      int sec=0;
      for(int i=m+1;i<=e;i++){
          if(str.charAt(i)==ch)
          sec++;
      }
      //System.out.println(sec+"**");
      int ans=0;
      if(first>=sec){
          ans=m-s+1-first;
          int l=(int)ch;
          l++;
          ans=ans+good(str,m+1,e,(char)l);
      }else{
           ans=e-(m+1)+1-sec;
          int l=(int)ch;
          l++;
          ans=ans+good(str,s,m,(char)l);
      }
      return ans;
    }
    public static void main(String[] args) throws IOException 
    { 
  
       BufferedReader br = new BufferedReader( 
                             new InputStreamReader(System.in));
        StringBuilder out=new StringBuilder(); 
        int t=Integer.parseInt(br.readLine());
        while(t-->0){
      
     int n=Integer.parseInt(br.readLine());
  // int arr[]=new int[n];
   //StringTokenizer st=new StringTokenizer(br.readLine());
   //    for(int i=0;i<n;i++){
    //     arr[i]=Integer.parseInt(st.nextToken());
   //    }
      String s=br.readLine();
     int ans=good(s,0,n-1,'a');
       out.append(ans+"\n");
        }
    //}
System.out.println(out);

}}
// class Graph 
// { 
//     private int V;   // No. of vertices 
  
//     // Array  of lists for Adjacency List Representation 
//      ArrayList<pair> adj[]; 
  
//     // Constructor 
//     Graph(int v) 
//     { 
//         V = v; 
//         adj = new ArrayList[v]; 
//         for (int i=0; i<v; ++i) 
//             adj[i] = new ArrayList(); 
//     } 
  
//     //Function to add an edge into the graph 
//     void addEdge(int v, int w,int x) 
//     { 
//         adj[v].add(new pair(w,x));
//         adj[w].add(new pair(v,x));// Add w to v's list. 
//     } 
  
//     // A function used by DFS 
// }
// class pair{
//     int x;
//     int y;
//     public pair(int xx,int yy){
//         x=xx;
//         y=yy;
        
//     }
// }
// class SortT implements Comparator<String> 
// { 
   
//     public int compare(String a, String b) 
//     { 
       
//         return a.length() - b.length(); 
//     } 
// } 