import os
import sys
from io import BytesIO, IOBase
# from collections import defaultdict as dd
# from collections import deque as dq
# import itertools as it
# from math import sqrt, log, log2
# from fractions import Fraction
def recurse(s, c, n):
    if n == 1:
        if s == c:
            return 0
        else:
            return 1
    
    # how many incorrect in left string and right string
    lstr, rstr = s[:n//2], s[n//2:]
    l, r = 0, 0
    for i in lstr:
        if i != c: l += 1
    
    for i in rstr:
        if i !=c : r += 1

    # next character
    nxt = chr(ord(c) + 1)

    # assuming the left half is c-good
    left = recurse(rstr, nxt, n//2)

    # assuming the right half is c-good
    right = recurse(lstr, nxt, n//2)

    return min(l + left, r + right)

# def recurse2(s, freq, c, i, j):
#     n = j - i
#     nby2 = n//2
#     ordc = ord(c)

#     if n == 1:
#         if s[i] == c:
#             return 0
#         else:
#             return 1
    
#     l = nby2 - (freq[ordc - 97][i + nby2 - 1] - (freq[ordc - 97][i-1] if i>0 else 0))
#     r = nby2 - (freq[ordc - 97][j-1] - freq[ordc - 97][i + nby2 - 1])

#     nxt = chr(ordc + 1)
#     left = recurse(s, freq, nxt, nby2 + i, j)
#     right = recurse(s , freq, nxt, i, i + nby2)

#     return min(l + left, r + right)

def main():
    t = int(input())
    for _ in range(t):
        n = int(input())
        s = input()
        
        freq = [[0]*n for _ in range(26)]
        for ind, char in enumerate(s):
            freq[ord(char) - 97][ind] = 1
        
        for i in range(26):
            for j in range(1, n):
                freq[i][j] += freq[i][j-1]

        # print(freq)
        # print(recurse(s, freq, 'a', 0, n))
        print(recurse(s, 'a', n))



        




































# region fastio
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()