import sys
import os
from io import BytesIO, IOBase

# credits of fastio to PyRival project in Github(https://github.com/cheran-senthil/PyRival)
# 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


import math
import random
import re
import heapq



t = int(input())
while t:
    t -= 1
    n = int(input())
    arr = list(map(ord, list(input().strip())))
    _a = ord('a')
    if len(arr) == 1:
        if arr[0] == _a:
            print(0)
        else:
            print(1)
        continue
    depth = 1
    while 2**depth < len(arr):
        depth += 1
    _a += depth
    dp = [1] * len(arr)
    for a in range(len(arr)):
        if arr[a] == _a:
            dp[a] = 0
    _a -= 1
    p = 1
    while _a >= ord('a'):
        i = 0
        while i < len(arr):
            st = i
            mid = i + (2**p)//2
            res1 = dp[st]
            for j in range(mid, mid+(2**p)//2):
                if arr[j] != _a:
                    res1 += 1
            res2 = dp[mid]
            for j in range(st, st + (2 ** p) // 2):
                if arr[j] != _a:
                    res2 += 1
            dp[st] = min(res1, res2)
            i += 2**p
        _a -= 1
        p += 1
    print(dp[0])
