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.*;
      import java.util.*;
  
  
      public class speed {
          static class Kattio extends PrintWriter {
              private BufferedReader r;
              private StringTokenizer st;
  
              // standard input
              public Kattio() {
                  this(System.in, System.out);
              }
  
              public Kattio(InputStream i, OutputStream o) {
                  super(o);
                  r = new BufferedReader(new InputStreamReader(i));
              }
  
              // USACO-style file input
              public Kattio(String problemName) throws IOException {
                  super(new FileWriter(problemName + ".out"));
                  r = new BufferedReader(new FileReader(problemName + ".in"));
              }
  
              // returns null if no more input
              public String next() {
                  try {
                      while (st == null || !st.hasMoreTokens())
                          st = new StringTokenizer(r.readLine());
                      return st.nextToken();
                  } catch (Exception e) {
                  }
                  return null;
              }
  
              public int nextInt() {
                  return Integer.parseInt(next());
              }
  
              public double nextDouble() {
                  return Double.parseDouble(next());
              }
  
              public long nextLong() {
                  return Long.parseLong(next());
              }
          }
  
          static int n, t;
  
          public static void main(String[] args) throws IOException {
              Kattio io = new Kattio();
              t = io.nextInt();
  
              for (int i = 0; i < t; i++) {
                  int n = io.nextInt();
                  String str = Integer.toString(n);
                  long ans = 0;
                  for (int j = 0; j < str.length() - 1; j++) {
                      ans += (long) (Integer.parseInt(String.valueOf(str.charAt(j))) * Math.pow(10, (str.length() - j) - 2));
                  }
                  if(str.charAt(str.length()  - 1) == '9')
                      ans++;
                  io.println(ans);
              }
              io.close();
          }
  
          class pair implements Comparable<pair> {
              private final int x;
              private final int y;
  
              public pair(final int x, final int y) {
                  this.x = x;
                  this.y = y;
              }
  
              @Override
              public int compareTo(pair o) {
                  return Integer.compare(this.x, o.x);
              }
          }
      }
  