#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
import threading 
from bisect import bisect_right
from math import gcd,log
from collections import Counter 



def main():
    for _ in range(int(input())):
        
            

        n=int(input())
        s=input()
        cnt=[[0]*26 for i in range(n+1)]
        for i in range(n):
            for j in range(26):
                cnt[i+1][j]=cnt[i][j]
            ch=ord(s[i])-97
            cnt[i+1][ch]+=1
        # print(cnt)

        def recur(l,r,s,cc):
            # print(l,r)
            if (l>r):
                return 

            mid=l+(r-l)//2
            # print(l,r)
            if l==r:
                return 1-cnt[mid][cc]+cnt[l-1][cc]
            c1=cnt[r][cc]-cnt[mid][cc]
            c2=cnt[mid][cc]-cnt[l-1][cc]
            r1=r2=float('inf')
            # if c1>=c2 :
                # ans+=s-c1
            r1=recur(l,mid,max(s//2,1),cc+1)
            # if (c2>=c1):
            r2=recur(mid+1,r,max(1,s//2),cc+1)

            a=min(r1+s-c1 ,r2+s-c2 )
            # print(l,r,mid,c1,c2,a,s)

            return a
        

        l=1
        r=n
        cc=0
        s=max(n//2,1)
        ans=recur(l,r,s,cc)
        print(ans)



        # while (l<=r):
        #     mid=l+(r-l)//2
        #     c1=cnt[r][cc]-cnt[mid][cc]
        #     c2=cnt[mid][cc]-cnt[l-1][cc]
            
        #     if c1>c2 or (c1==c2 and ):
        #         ans+=s-c1
        #         r=mid
        #     else:
        #         ans+=s-c2
        #         l=mid+1
        #     print(l,r,mid,c1,c2,ans)
        #     s//=2
        #     s=max(s,1)
        #     cc+=1

        # print(ans)    



        

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

if __name__ == "__main__":
    main()