description: This is a simplified version of the problem B2. Perhaps you should read the problem B2 before you start solving B1.
  
  Paul and Mary have a favorite string s which consists of lowercase letters of the Latin alphabet. They want to paint it using pieces of chalk of two colors: red and green. Let's call a coloring of a string wonderful if the following conditions are met:
  
    1. each letter of the string is either painted in exactly one color (red or green) or isn't painted; 
    2. each two letters which are painted in the same color are different; 
    3. the number of letters painted in red is equal to the number of letters painted in green; 
    4. the number of painted letters of this coloring is maximum among all colorings of the string which meet the first three conditions. 
  
  
  
  E. g. consider a string s equal to "kzaaa". One of the wonderful colorings of the string is shown in the figure.
  
  <image> The example of a wonderful coloring of the string "kzaaa".
  
  Paul and Mary want to learn by themselves how to find a wonderful coloring of the string. But they are very young, so they need a hint. Help them find k — the number of red (or green, these numbers are equal) letters in a wonderful coloring.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
  
  Each test case consists of one non-empty string s which consists of lowercase letters of the Latin alphabet. The number of characters in the string doesn't exceed 50.
  
  Output
  
  For each test case, output a separate line containing one non-negative integer k — the number of letters which will be painted in red in a wonderful coloring.
  
  Example
  
  Input
  
  
  5
  kzaaa
  codeforces
  archive
  y
  xxxxxx
  
  
  Output
  
  
  2
  5
  3
  0
  1
  
  Note
  
  The first test case contains the string from the statement. One of the wonderful colorings is shown in the figure. There's no wonderful coloring containing 3 or more red letters because the total number of painted symbols will exceed the string's length.
  
  The string from the second test case can be painted as follows. Let's paint the first occurrence of each of the letters "c", "o", "e" in red and the second ones in green. Let's paint the letters "d", "f" in red and "r", "s" in green. So every letter will be painted in red or green, hence the answer better than 5 doesn't exist.
  
  The third test case contains the string of distinct letters, so you can paint any set of characters in red, as long as the size of this set doesn't exceed half of the size of the string and is the maximum possible.
  
  The fourth test case contains a single letter which cannot be painted in red because there will be no letter able to be painted in green.
  
  The fifth test case contains a string of identical letters, so there's no way to paint more than one letter in red.
solution: import java.io.*;
  import java.util.*;
  import static java.lang.System.*;
  import static java.lang.Math.*;
  import static java.util.Collections.*;
  import static java.util.Arrays.*;
  public class B {
      public static int swap(int... args) {
          return args[0];
      } static   ArrayList<Integer> primes = new ArrayList<>();
      //static Scanner sc = new Scanner(System.in);
      static FastReader sc = new FastReader();
      public static void main(String[] args) throws IOException {
          do {
              startTime = currentTimeMillis();
              //setOut(new PrintStream("output"));
              //setIn(new FileInputStream("input"));
              int T = sc.nextInt();while (T-- != 0)
              {
                  solve();
  
              }
              endTime = currentTimeMillis();
              long duration = endTime - startTime;
              //out.println(duration);
              if (false) {
                  out.println(max(3, 2));
                  Integer[] ARRAY = new Integer[2];
                  ArrayList<Integer> LIST = new ArrayList<>();
                  LIST.add(2);
                  // sort(LIST, reverseOrder());
                  LIST.sort(reverseOrder());
                  sort(ARRAY, reverseOrder());
                  out.println(LIST + " " + Arrays.toString(ARRAY));
              }
          } while (LOCAL);
      }
      public static void solve() throws IOException {
  /////////////////////////////////////////////////////////////////////
              String str = sc.next();
              int [] freq = new int[200];
          for (int i = 0; i < str.length(); i++) {
                  freq[str.charAt(i)]++;
          }
          int odd=0,even=0;
          for (int i = 0; i < freq.length; i++) {
                  if(freq[i]==1)odd++;
                  else if(freq[i]==3)odd+=2;
                  else if(freq[i]!=0)even+=2;
          }
          out.println((even+odd)/2);
  ///////////////////////////////////////////////////////////////////////
  
      }
      public static final boolean LOCAL = System.getProperty("ONLINE_JUDGE")==null;
      // public static final boolean LOCAL = System.getProperty("LOCAL")!=null;
      public static final String ANSI_RED = "\u001B[31m";
      public static final String ANSI_RESET = "\u001B[0m";
      static long startTime;
      static long endTime;
      static boolean[] prime;
      static final int M = (int) 1e9 + 7;
      static final long MM = (long) M * M;
      static final int MAX = Integer.MAX_VALUE;
      static final int MIN = Integer.MIN_VALUE;
      static final int SIZE = (int) 1e9 * 2;
      static int [] visited;
      static ArrayList<ArrayList<Integer>> graph;
      static ArrayList<Integer> dfs;
      static  boolean isCyclic = false;
      static void dfs(int src){
          visited[src] = 1;
          for(Integer integer : graph.get(src) ){
              if(visited[integer]!=1){
                  dfs(integer);
              }
          }
          dfs.add(src);
  
      }
      static void detectCycle(int src){
          visited[src] =2;
          for(Integer integer : graph.get(src)){
              if(visited[integer]==0){
                  detectCycle(integer);
              }
              else if(visited[integer]==2) {
                  isCyclic = true;
                  return;
              }
  
          }
          visited[src] = 1;
      }
      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;
          }
      }
      static class Pair implements Comparable< Pair> {
          private int key;
          private int value;
          public Pair(int key, int value) {
              this.key = key;
              this.value = value;
          }
          public int second() {
              return value;
          }
          @Override
          public int compareTo(Pair o) {
              return -Integer.compare(key, o.key);
          }
          @Override
          public String toString() {
              return "Pair{" + "x=" + key + ", y=" + value + '}';
          }
      }
      static <Array, Target> int count(Array[] array, Target target){
          int cn=0;
          for (Array value : array) {
              if (value.equals(target)) cn++;
          }
          return cn;
      }
      static int count (String string , char target){
          int cn=0;
          for (int i = 0; i < string.length(); i++) {
              if(string.charAt(i)==target)cn++;
          }
          return cn;
      }
      static  <Array> void revArray(Array [] arr) {
          int n = arr.length;
          for (int i = 0; i < n / 2; i++) {
              Array temp = arr[i];
              arr[i] = arr[n - i - 1];
              arr[n - i - 1] = temp;
          }
  
      }
      static <Array> void printArray(Array [] arr) {
          int n = arr.length;
          for (Array array : arr)out.print(array + " ");
          out.println();
      }
      static void yes() {out.println("YES");}
      static void no() {out.println("NO");}
      public static boolean isPal(String s)
      {
          StringBuilder stringBuilder = new StringBuilder(s);
          return s.equals(stringBuilder.reverse().toString());
      }
      public static int lowerBound(Integer[] array, int length, int value) {
          int low = -1;
          int hi = length;
          while (low + 1 < hi) {
              int mid = (low + hi) / 2;
              if (array[mid] <= value) {
                  low = mid;
              } else {
                  hi = mid;
              }
          }
          return low;
      }
      public static int upperBound(Integer[] array, int length, int value) {
          int low = -1;
          int hi = length;
          while (low + 1 < hi) {
              int mid = (low + hi) >> 1;
              if (array[mid] >= value) {
                  hi = mid;
              } else low = mid;
          }
          return hi;
      }
      public static int binarySearch(Integer[] arr, int length, int value) {
          int low = 0;
          int hi = length - 1;
          int ans = -1;
          while (low <= hi) {
              int mid = (low + hi) >> 1;
              if (arr[mid] > value) {
                  hi = mid - 1;
              } else if (arr[mid] < value) {
                  low = mid + 1;
              } else {
                  ans = mid;
                  break;
              }
          }
          return ans;
      }
      public static int gcd(int a, int b) {
          return b==0?a:gcd(b, a % b);
      }
      public static int lcm(int a, int b) {
          return a / gcd(a, b) * b;
      }
      public static int countDivs(int n) {
          int cn = 0;
          int sqr = (int) Math.sqrt(n);
          for (int i = 1; i <= sqr; ++i) {
              if (n % i == 0) {
                  ++cn;
              }
          }
          cn *= 2;
          if (sqr * sqr == n) cn--;
          return cn;
      }
  
      static void prime(int x) {
          //sieve algorithm. nlog(log(n)).
          prime = new boolean[(x + 1)];
          Arrays.fill(prime, true);
          prime[0] = prime[1] = false;
          for (int i = 2; i * i <= x; i++)
              if (prime[i])
                  for (int j = i * i; j <= x; j += i)
                      prime[j] = false;
      }
      static boolean isEven(long x) {
          return x % 2 == 0;
      }
      static boolean isPrime(long x) {
          boolean flag = true;
          int sqr = (int) Math.sqrt(x);
          if (x < 2) return false;
          for (int i = 2; i <= sqr; i++) {
              if (x % i == 0) {
                  flag = false;
                  break;
              }
          }
          return flag;
      }
  
      static long factorial(long x) {
          long total = 1;
          for (int i = 2; i <= x; i++)
              total = (total * i) % M;
          return total;
      }
  
      static long power(long x, long n) {
          if (n == 0) {
              return 1;
          }
          long pow = power(x, n / 2L);
          if ((n & 1) == 1) {
              return (x * (pow) * (pow));
          }
          return (pow * pow);
      }
      private static <T> String ts(T t) {
          if(t==null) {
              return "null";
          }
          try {
              return ts((Iterable) t);
          }catch(ClassCastException e) {
              if(t instanceof int[]) {
                  String s = Arrays.toString((int[]) t);
                  return "{"+s.substring(1, s.length()-1)+"}";
              }else if(t instanceof long[]) {
                  String s = Arrays.toString((long[]) t);
                  return "{"+s.substring(1, s.length()-1)+"}";
              }else if(t instanceof char[]) {
                  String s = Arrays.toString((char[]) t);
                  return "{"+s.substring(1, s.length()-1)+"}";
              }else if(t instanceof double[]) {
                  String s = Arrays.toString((double[]) t);
                  return "{"+s.substring(1, s.length()-1)+"}";
              }else if(t instanceof boolean[]) {
                  String s = Arrays.toString((boolean[]) t);
                  return "{"+s.substring(1, s.length()-1)+"}";
              }
              try {
                  return ts((Object[]) t);
              }catch(ClassCastException e1) {
                  return t.toString();
              }
          }
      }
      private static <T> String ts(T[] arr) {
          StringBuilder ret = new StringBuilder();
          ret.append("{");
          boolean first = true;
          for(T t: arr) {
              if(!first) {
                  ret.append(", ");
              }
              first = false;
              ret.append(ts(t));
          }
          ret.append("}");
          return ret.toString();
      }
      private static <T> String ts(Iterable<T> iter) {
          StringBuilder ret = new StringBuilder();
          ret.append("{");
          boolean first = true;
          for(T t: iter) {
              if(!first) {
                  ret.append(", ");
              }
              first = false;
              ret.append(ts(t));
          }
          ret.append("}");
          return ret.toString();
      }
      public static void dbg(Object... o) {
          if(LOCAL) {
              System.err.print("Line #"+Thread.currentThread().getStackTrace()[2].getLineNumber()+": [");
              for(int i = 0; i<o.length; i++) {
                  if(i!=0) {
                      System.err.print(", ");
                  }
                  System.err.print(ts(o[i]));
              }
              System.err.println("]");
          }
      }
  
  }
  