description: Let's define S(x) to be the sum of digits of number x written in decimal system. For example, S(5) = 5, S(10) = 1, S(322) = 7.
  
  We will call an integer x interesting if S(x + 1) < S(x). In each test you will be given one integer n. Your task is to calculate the number of integers x such that 1 ≤ x ≤ n and x is interesting.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 1000) — number of test cases.
  
  Then t lines follow, the i-th line contains one integer n (1 ≤ n ≤ 10^9) for the i-th test case.
  
  Output
  
  Print t integers, the i-th should be the answer for the i-th test case.
  
  Example
  
  Input
  
  
  5
  1
  9
  10
  34
  880055535
  
  
  Output
  
  
  0
  1
  1
  3
  88005553
  
  Note
  
  The first interesting number is equal to 9.
solution: 
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.io.PrintWriter;
  import java.util.StringTokenizer;
  import java.util.*;
  import java.lang.*;
  import java.io.*;
  public class FG {
  
    static BufferedReader br;
    static PrintWriter out;
    static StringTokenizer st;
    
  
    public static void main(String[] args) throws IOException {
      br = new BufferedReader(new InputStreamReader(System.in));
      out = new PrintWriter(new OutputStreamWriter(System.out));
    
      int t= nextInt();
      while(t-->0){
      
      long n= nextLong();
     
      out.println((n+1)/10);
      
      
      }
     
      out.close();
    }
     static int nthFibonacci(int n){
          //int n= (int)m;
          int dp[]= new int[n];
          dp[0]=1;
          if(n<3)return 1;
          dp[1]=1;
          
          for(int i=2;i<n;i++){
              dp[i]=(dp[i-1]%1000000007+dp[i-2]%1000000007)%1000000007;
          }
          
          //System.out.println((int)dp[n-1]);
          return dp[n-1]%1000000007;
         
          
      }
  
    static String next() throws IOException {
      while (st == null || !st.hasMoreTokens())
        st = new StringTokenizer(br.readLine().trim());
      return st.nextToken();
    }
  
    static long nextLong() throws IOException {
      return Long.parseLong(next());
    }
  
    static int nextInt() throws IOException {
      return Integer.parseInt(next());
    }
  
    static double nextDouble() throws IOException {
      return Double.parseDouble(next());
    }
  
    static char nextCharacter() throws IOException {
      return next().charAt(0);
    }
  
    static String nextLine() throws IOException {
      return br.readLine().trim();
    }
  }