description: Paprika loves permutations. She has an array a_1, a_2, ..., a_n. She wants to make the array a permutation of integers 1 to n.
  
  In order to achieve this goal, she can perform operations on the array. In each operation she can choose two integers i (1 ≤ i ≤ n) and x (x > 0), then perform a_i := a_i mod x (that is, replace a_i by the remainder of a_i divided by x). In different operations, the chosen i and x can be different.
  
  Determine the minimum number of operations needed to make the array a permutation of integers 1 to n. If it is impossible, output -1.
  
  A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
  
  Input
  
  Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. Description of the test cases follows.
  
  The first line of each test case contains an integer n (1 ≤ n ≤ 10^5).
  
  The second line of each test case contains n integers a_1, a_2, ..., a_n. (1 ≤ a_i ≤ 10^9).
  
  It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
  
  Output
  
  For each test case, output the minimum number of operations needed to make the array a permutation of integers 1 to n, or -1 if it is impossible.
  
  Example
  
  Input
  
  
  4
  2
  1 7
  3
  1 5 4
  4
  12345678 87654321 20211218 23571113
  9
  1 2 3 4 18 19 5 6 7
  
  
  Output
  
  
  1
  -1
  4
  2
  
  Note
  
  For the first test, the only possible sequence of operations which minimizes the number of operations is: 
  
    * Choose i=2, x=5. Perform a_2 := a_2 mod 5 = 2. 
  
  
  
  For the second test, it is impossible to obtain a permutation of integers from 1 to n.
solution: import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.*;
  
  public class Solution{
  static long mod=(long)1e9+7;
  static FastScanner sc = new FastScanner();
  public static void solve()
  {
          int n=sc.nextInt();
          int[] a=sc.readArray(n);
          PriorityQueue<Integer> pq=new PriorityQueue<>();
          boolean[] vis=new boolean[n+1];
          for (int i=0;i<n;i++) {
            if (a[i]>n || vis[a[i]]) {
              pq.add(a[i]);
            }else
            vis[a[i]]=true;
          }
          int ans=pq.size();
          for (int i=1;i<=n;i++) {
            if (!vis[i] && pq.poll()<=2*i) {
              System.out.println("-1");
              return ;
            }
          }
          System.out.println(ans);
  
          } 
      
   public static void main(String[] args) {
    int t = sc.nextInt();
    // int t=1;
    outer: for (int tt = 0; tt < t; tt++) {
      solve();
    }
  
  }
  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 log2(long n){
    return (long)((double)Math.log((double)n)/Math.log((double)2));
  }
  static boolean isPrime(int n)
      {
          if (n <= 1)
              return false;
          if (n <= 3)
              return true;
    
          if (n % 2 == 0 || n % 3 == 0)
              return false;
    
          for (int i = 5; i * i <= n; i = i + 6)
              if (n % i == 0 || n % (i + 2) == 0)
                  return false;
    
          return true;
      }
  public static int[] LPS(String s){
    int[] lps=new int[s.length()];
    int i=0,j=1;
    while (j<s.length()) {
      if(s.charAt(i)==s.charAt(j)){
        lps[j]=i+1;
        i++;
        j++;
        continue;
      }else{
        if (i==0) {
          j++;
          continue;
        }
        i=lps[i-1];
        while(s.charAt(i)!=s.charAt(j) && i!=0) {
          i=lps[i-1];
        }
        if(s.charAt(i)==s.charAt(j)){
        lps[j]=i+1;
        i++;
        }
        j++;
      }
    }
    return lps;
  }
  static long getPairsCount(int n, double sum,int[] arr)
      {
          HashMap<Double, Integer> hm = new HashMap<>();
          for (int i = 0; i < n; i++) {
              if (!hm.containsKey((double)arr[i]))
                  hm.put((double)arr[i], 0);
              hm.put((double)arr[i], hm.get((double)arr[i]) + 1);
          }
          long twice_count = 0;
          for (int i = 0; i < n; i++) {
              if (hm.get(sum - arr[i]) != null)
                  twice_count += hm.get(sum - arr[i]);
              if (sum - (double)arr[i] == (double)arr[i])
                  twice_count--;
          }
          return twice_count / 2l;
      }
  static boolean[] sieveOfEratosthenes(int n)
      {
          boolean prime[] = new boolean[n + 1];
          for (int i = 0; i <= n; i++)
              prime[i] = true;
   
          for (int p = 2; p * p <= n; p++)
          {
              if (prime[p] == true)
              {
                  for (int i = p * p; i <= n; i += p)
                      prime[i] = false;
              }
          }
          prime[1]=false;
          return prime;
   }
  static long power(long x, long y, long p)
    {
      long res = 1l; 
      x = x % p;
      if (x == 0)
        return 0;
      while (y > 0)
      {
  
        if ((y & 1) != 0)
          res = (res * x) % p;
        y>>=1;
        x = (x * x) % p;
      }
      return res;
    }
  
  public static int log2(int N)
      {
          int result = (int)(Math.log(N) / Math.log(2));
    
          return result;
      }
  
  ////////////////////////////////////////////////////////////////////////////////////
  ////////////////////DO NOT READ AFTER THIS LINE //////////////////////////////////
  ////////////////////////////////////////////////////////////////////////////////////
  static long modFact(int n, 
                         int p) 
      { 
          if (n >= p) 
              return 0; 
        
          long result = 1l; 
          for (int i = 3; i <= n; i++) 
              result = (result * i) % p; 
        
          return result; 
      } 
        
  static boolean isPalindrom(char[] arr, int i, int j) {
    boolean ok = true;
    while (i <= j) {
      if (arr[i] != arr[j]) {
        ok = false;
        break;
      }
      i++;
      j--;
    }
    return ok;
  }
  
  static int max(int a, int b) {
    return Math.max(a, b);
  }
  
  static int min(int a, int b) {
    return Math.min(a, b);
  }
  
  static long max(long a, long b) {
    return Math.max(a, b);
  }
  
  static long min(long a, long b) {
    return Math.min(a, b);
  }
  
  static int abs(int a) {
    return Math.abs(a);
  }
  
  static long abs(long a) {
    return Math.abs(a);
  }
  
  static void swap(long arr[], int i, int j) {
    long temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  }
  
  static void swap(int arr[], int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  }
  
  static int maxArr(int arr[]) {
    int maxi = Integer.MIN_VALUE;
    for (int x : arr)
      maxi = max(maxi, x);
    return maxi;
  }
  
  static int minArr(int arr[]) {
    int mini = Integer.MAX_VALUE;
    for (int x : arr)
      mini = min(mini, x);
    return mini;
  }
  
  static long maxArr(long arr[]) {
    long maxi = Long.MIN_VALUE;
    for (long x : arr)
      maxi = max(maxi, x);
    return maxi;
  }
  
  static long minArr(long arr[]) {
    long mini = Long.MAX_VALUE;
    for (long x : arr)
      mini = min(mini, x);
    return mini;
  }
  static int lcm(int a,int b){
    return (int)(((long)a*b)/(long)gcd(a,b));
  }
  static int gcd(int a, int b) {
    if (b == 0)
      return a;
    return gcd(b, a % b);
  }
  
  static long gcd(long a, long b) {
    if (b == 0)
      return a;
    return gcd(b, a % b);
  }
  
  static void ruffleSort(int[] a) {
    int n = a.length;
    Random r = new Random();
    for (int i = 0; i < a.length; i++) {
      int oi = r.nextInt(n);
      int temp = a[i];
      a[i] = a[oi];
      a[oi] = temp;
    }
    Arrays.sort(a);
  }
  
  public static int binarySearch(int a[], int target) {
    int left = 0;
    int right = a.length - 1;
    int mid = (left + right) / 2;
    int i = 0;
    while (left <= right) {
      if (a[mid] <= target) {
        i = mid + 1;
        left = mid + 1;
      } else {
        right = mid - 1;
      }
      mid = (left + right) / 2;
    }
    return i-1;
  }
  
  
  static class FastScanner {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer("");
  
    String next() {
      while (!st.hasMoreTokens())
        try {
          st = new StringTokenizer(br.readLine());
        } catch (IOException e) {
          e.printStackTrace();
        }
      return st.nextToken();
    }
  
    int nextInt() {
      return Integer.parseInt(next());
    }
  
    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;
    }
  
    int[][] read2dArray(int n, int m) {
      int arr[][] = new int[n][m];
      for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
          arr[i][j] = nextInt();
        }
      }
      return arr;
    }
  
    ArrayList<Integer> readArrayList(int n) {
      ArrayList<Integer> arr = new ArrayList<Integer>();
      for (int i = 0; i < n; i++) {
        int a = nextInt();
        arr.add(a);
      }
      return arr;
    }
  
    long nextLong() {
      return Long.parseLong(next());
    }
  }
   static class Pair {
    int val, ind;
  
    Pair(int fr, int sc) {
      this.val = fr;
      this.ind = sc;
    }
  }
  }