description: A string s of length n, consisting of lowercase letters of the English alphabet, is given.
  
  You must choose some number k between 0 and n. Then, you select k characters of s and permute them however you want. In this process, the positions of the other n-k characters remain unchanged. You have to perform this operation exactly once.
  
  For example, if s="andrea", you can choose the k=4 characters "a_d_ea" and permute them into "d_e_aa" so that after the operation the string becomes "dneraa".
  
  Determine the minimum k so that it is possible to sort s alphabetically (that is, after the operation its characters appear in alphabetical order).
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
  
  The first line of each test case contains one integer n (1 ≤ n ≤ 40) — the length of the string.
  
  The second line of each test case contains the string s. It is guaranteed that s contains only lowercase letters of the English alphabet.
  
  Output
  
  For each test case, output the minimum k that allows you to obtain a string sorted alphabetically, through the operation described above.
  
  Example
  
  Input
  
  
  4
  3
  lol
  10
  codeforces
  5
  aaaaa
  4
  dcba
  
  
  Output
  
  
  2
  6
  0
  4
  
  Note
  
  In the first test case, we can choose the k=2 characters "_ol" and rearrange them as "_lo" (so the resulting string is "llo"). It is not possible to sort the string choosing strictly less than 2 characters.
  
  In the second test case, one possible way to sort s is to consider the k=6 characters "_o__force_" and rearrange them as "_c__efoor_" (so the resulting string is "ccdeefoors"). One can show that it is not possible to sort the string choosing strictly less than 6 characters.
  
  In the third test case, string s is already sorted (so we can choose k=0 characters).
  
  In the fourth test case, we can choose all k=4 characters "dcba" and reverse the whole string (so the resulting string is "abcd").
solution: 
  /*
  
      /$$$$$  /$$$$$$  /$$    /$$  /$$$$$$                                                                  
     |__  $$ /$$__  $$ |$$    |$$ /$$__  $$                                                                 
            | $$| $$  \ $$|    $$|$$| $$  \ $$                                                                 
            | $$| $$$$$$$$|  $$ / $$/| $$$$$$$$                                                                 
  / $$  | $$| $$__  $$ \  $$ $$/ | $$__  $$                                                                 
  | $$  | $$| $$  | $$  \  $$$/  | $$  | $$                                                                 
  |  $$$$$$/| $$  | $$   \  $/   | $$  | $$                                                                 
   \______/ |__/  |__/    \_/    |__/  |__/                                                                 
  /$$$$$$$  /$$$$$$$   /$$$$$$   /$$$$$$  /$$$$$$$   /$$$$$$  /$$      /$$ /$$      /$$ /$$$$$$$$ /$$$$$$$ 
  | $$__  $$| $$__  $$ /$$__  $$ /$$__  $$| $$__  $$ /$$__  $$| $$$    /$$$| $$$    /$$$| $$_____/| $$__  $$
  | $$  \ $$| $$  \ $$| $$  \ $$| $$  \__/| $$  \ $$| $$  \ $$| $$$$  /$$$$| $$$$  /$$$$| $$      | $$  \ $$
  | $$$$$$$/| $$$$$$$/| $$  | $$| $$ /$$$$| $$$$$$$/| $$$$$$$$| $$ $$/$$ $$| $$ $$/$$ $$| $$$$$   | $$$$$$$/
  | $$____/ | $$__  $$| $$  | $$| $$|_  $$| $$__  $$| $$__  $$| $$  $$$| $$| $$  $$$| $$| $$__/   | $$__  $$
  | $$      | $$  \ $$| $$  | $$| $$  \ $$| $$  \ $$| $$  | $$| $$\  $ | $$| $$\  $ | $$| $$      | $$  \ $$
  | $$      | $$  | $$|  $$$$$$/|  $$$$$$/| $$  | $$| $$  | $$| $$ \/  | $$| $$ \/  | $$| $$$$$$$$| $$  | $$
  |__/      |__/  |__/ \______/  \______/ |__/  |__/|__/  |__/|__/     |__/|__/     |__/|________/|__/  |__/
  																																																				
  																																																				
  
  */
  
  import java.io.BufferedReader;
  import java.text.DecimalFormat;
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.math.BigInteger;
  import java.util.*;
  import java.io.*;
  
  public class abc {
  	static PrintWriter pw;
  
  	/*
  	 * static long inv[]=new long[1000001]; static long dp[]=new long[1000001];
  	 */
  	/// MAIN FUNCTION///
  	public static void main(String[] args) throws Exception {
  
  		FastReader sc = new FastReader();
  		pw = new PrintWriter(System.out);
  		// use arraylist as it use the concept of dynamic table(amortized analysis)
  		// Arrays.stream(array).forEach(a -> Arrays.fill(a, 0));
  		/* List<Integer> l1 = new ArrayList<Integer>(); */
  		int tst = sc.nextInt();
  		while (tst-- > 0) {
  			int n=sc.nextInt();
  			String s=sc.nextLine();
  			char arr[]=s.toCharArray();
  			Arrays.sort(arr);
  			int c=0;
  			for(int i=0;i<s.length();i++)
  			{
  				if(s.charAt(i)!=arr[i])
  					c++;
  				
  			}
  			pw.println(c);
  		}
  		pw.flush();
  	}
  
  	public static int helper(int b[][], int k, int m, int n) {
  		int res = 0, f = 0;
  		for (int i = 0; i < m; i++) {
  			for (int j = 0; j < n; j++) {
  				if (k == b[i][j]) {
  					res = j;
  					f = -1;
  					break;
  				}
  			}
  			if (f == -1)
  				break;
  		}
  		return res;
  	}
  
  	public static void debugger() {
  		Random rand = new Random();
  		int tst = (int) (Math.abs(rand.nextInt()) % 2 + 1);
  		pw.println(tst);
  		while (tst-- > 0) {
  			int n = (int) (Math.abs(rand.nextInt()) % 5 + 1);
  			pw.println(n);
  			for (int i = 0; i < n; i++) {
  				pw.print((int) (Math.abs(rand.nextInt()) % 6 + 1) + " ");
  			}
  			pw.println();
  		}
  	}
  
  	static void recursion(int n) {
  		if (n == 1) {
  			pw.print(n + " ");
  			return;
  		}
  		// pw.print(n+" "); gives us n to 1
  		recursion(n - 1);
  		// pw.print(n+" "); gives us 1 to n
  	}
  
  	// ch.charAt(i)+"" converts into a char sequence
  	static 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;
  		}
  
  		/* CREATED BY ME */
  		int[] readArray(int n) {
  			int[] a = new int[n];
  			for (int i = 0; i < n; i++)
  				a[i] = nextInt();
  			return a;
  		}
  
  		long[] readLongArray(int n) {
  			long[] a = new long[n];
  			for (int i = 0; i < n; i++)
  				a[i] = nextLong();
  			return a;
  		}
  	}
  
  	public static long gcd(long a, long b) {
  		return b == 0 ? a : gcd(b, a % b);
  	}
  
  	public static boolean isPrime(long n) {
  		if (n == 2)
  			return true;
  		long i = 2;
  		while (i * i <= n) {
  			if (n % i == 0)
  				return false;
  			i++;
  		}
  		return true;
  	}
  
  	static int ceil(int x, int y) {
  		return (x % y == 0 ? x / y : (x / y + 1));
  	}
  
  	static long ceil(long x, long y) {
  		return (x % y == 0 ? x / y : (x / y + 1));
  	}
  
  	static double max(double x, double y) {
  		return Math.max(x, y);
  	}
  
  	static int min(int x, int y) {
  		return Math.min(x, y);
  	}
  
  	static int abs(int x) {
  		return Math.abs(x);
  	}
  
  	static long abs(long x) {
  		return Math.abs(x);
  	}
  
  	static int log2(int N) {
  		int result = (int) (Math.log(N) / Math.log(2));
  		return result;
  	}
  
  	static long max(long x, long y) {
  		return Math.max(x, y);
  	}
  
  	static long min(long x, long y) {
  		return Math.min(x, y);
  	}
  
  	public static class pair {
  		long x;
  		long y;
  
  		public pair(long a, long b) {
  			x = a;
  			y = b;
  		}
  	}
  
  	public static class Comp implements Comparator<pair> {
  		public int compare(pair a, pair b) {
  			long ans = a.x - b.x;
  			if (ans > 0)
  				return 1;
  			if (ans < 0)
  				return -1;
  			return 0;
  		}
  	}
  
  	// modular exponentiation
  	public static long fastExpo(long a, int n, int mod) {
  		if (n == 0)
  			return 1;
  		else {
  			if ((n & 1) == 1) {
  				long x = fastExpo(a, n / 2, mod);
  				return (((a * x) % mod) * x) % mod;
  			} else {
  				long x = fastExpo(a, n / 2, mod);
  				return (((x % mod) * (x % mod)) % mod) % mod;
  			}
  		}
  	}
  
  	public static long modInverse(long n, int p) {
  		return fastExpo(n, p - 2, p);
  	}
  
  	/*
  	 * public static void extract(ArrayList<Integer> ar, int k, int d) { int c = 0;
  	 * for (int i = 1; i < k; i++) { int x = 0; boolean dm = false; while (x > 0) {
  	 * long dig = x % 10; x = x / 10; if (dig == d) { dm = true; break; } } if (dm)
  	 * ar.add(i); } }
  	 */
  
  	public static int[] prefixfuntion(String s) {
  		int n = s.length();
  		int z[] = new int[n];
  		for (int i = 1; i < n; i++) {
  			int j = z[i - 1];
  			while (j > 0 && s.charAt(i) != s.charAt(j))
  				j = z[j - 1];
  			if (s.charAt(i) == s.charAt(j))
  				j++;
  			z[i] = j;
  		}
  		return z;
  	}
  
  	public static void dfs(int index, boolean vis[], int a[], int b[], int n) {
  		vis[index] = true;
  		for (int i = 0; i < n; i++) {
  			if (!vis[i] && (a[i] == a[index] || b[i] == b[index]))
  				dfs(i, vis, a, b, n);
  		}
  	}
  
  // counts the set(1) bit of a number
  	public static long countSetBitsUtil(long x) {
  		if (x <= 0)
  			return 0;
  		return (x % 2 == 0 ? 0 : 1) + countSetBitsUtil(x / 2);
  	}
  
  //tells whether a particular index has which bit of a number	
  	public static int getIthBitsUtil(int x, int y) {
  		return (x & (1 << y)) != 0 ? 1 : 0;
  	}
  
  	public static void swap(long x, long y) {
  		x = x ^ y;
  		y = y ^ x;
  		x = x ^ y;
  	}
  
  	/*
  	 * static long mod_inverse(long a, long b) { long mod=(long) (1000000007); long
  	 * ans=1; while(b>0) { if((b%2)==0) ans=(ans*a) %mod; b/=2; a=(a*a) % mod;
  	 * 
  	 * } return ans; }
  	 */
  
  	public static double decimalPlaces(double sum) {
  		DecimalFormat df = new DecimalFormat("#.00");
  		String angleFormated = df.format(sum);
  		double fin = Double.parseDouble(angleFormated);
  		return fin;
  	}
  
  //use collections.swap for swapping 
  	static boolean isSubSequence(String str1, String str2, int m, int n) {
  		int j = 0;
  
  		for (int i = 0; i < n && j < m; i++)
  			if (str1.charAt(j) == str2.charAt(i))
  				j++;
  
  		return (j == m);
  	}
  
  	static long sum(long n) {
  		long s2 = 0, max = -1, min = 10;
  		while (n > 0) {
  			s2 = (n % 10);
  			min = min(s2, min);
  			max = max(s2, max);
  			n = n / 10;
  		}
  		return max * min;
  	}
  
  	static long pow(long base, long power) {
  		if (power == 0) {
  			return 1;
  		}
  		long result = pow(base, power / 2);
  		if (power % 2 == 1) {
  			return result * result * base;
  		}
  		return result * result;
  	}
  
  	// return the hash value of a string
  	static long compute_hash(String s) {
  		long val = 0;
  		long p = 31;
  		long mod = (long) (1000000007);
  		long pow = 1;
  		for (int i = 0; i < s.length(); i++) {
  			char ch = s.charAt(i);
  			val = (val + (int) (ch - 'a' + 1) * pow) % mod;
  			pow = (pow * p) % mod;
  		}
  		return val;
  	}
  
  	// return a prefix sum array of hash values
  	/*
  	 * static void prefix_array_value(String s) { long p=31; long mod=(long)
  	 * (1000000007); long pow=1; inv[0]=1; dp[0]=(long)(s.charAt(0)-'a'+1);
  	 * 
  	 * for(int i=1;i<s.length();i++) { char ch=s.charAt(i); pow= ( pow*p ) % mod;
  	 * inv[i]=mod_inverse(pow, mod-2); dp[i]=(dp[i-1]+ (long)(ch- 'a' +1)*pow)%mod;
  	 * } }
  	 */
  
  	/*
  	 * static long substringHash(int L , int R ) { long result = dp[R]; long
  	 * mod=(long) (1000000007); if(L > 0) result = (result - dp[L-1] + mod) % mod;
  	 * result= (result * inv[L]) % mod; return result; }
  	 */
  }
  