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 Main {
      private static final fast sc = new fast();
      private static final BufferedWriter sout = new BufferedWriter(new OutputStreamWriter(System.out));
      private static final int OO = 1000000007;
      private static final double PI = Math.acos(-1);
      //right,down,left,up
      private static final int[] dx4 = {0, 1, 0, -1}, dx = {0, 0, 1, -1, 1, -1, 1, -1};
      private static final int[] dy4 = {1, 0, -1, 0}, dy = {1, -1, 0, 0, 1, -1, -1, 1};
      //static void print6P{ System.out.printf("%8.6f\n"); }
  
      public static void main(String[] args) throws IOException {
          //Start from here.
          int t = sc.nextInt();
          while (t-- > 0) {
              int n = sc.nextInt();
              String s = String.valueOf(n);
              int res = (n / 10);
              if (s.charAt(s.length() - 1) == '9') {
                  res += 1;
              }
              sout.write(res + "\n");
  
          }
          //end here
          sout.close();
      }
  
      static class fast {
          BufferedReader br;
          StringTokenizer st;
  
          fast() {
              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();
          }
  
          boolean hasNext() {
              if (st != null && st.hasMoreTokens()) {
                  return true;
              }
              String tmp;
              try {
                  br.mark(1000);
                  tmp = br.readLine();
                  if (tmp == null) {
                      return false;
                  }
                  br.reset();
              } catch (IOException e) {
                  return false;
              }
              return true;
          }
  
          int nextInt() {
              return Integer.parseInt(next());
          }
  
          long nextLong() {
              return Long.parseLong(next());
          }
  
          double nextDouble() {
              return Double.parseDouble(next());
          }
  
          double nextFloat() {
              return Float.parseFloat(next());
          }
  
          String nextLine() {
              String str = "";
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
  
      static class Pair implements Comparable<Pair> {
          Integer first;
          Integer second;
  
          Pair(Integer first, Integer second) {
              this.first = first;
              this.second = second;
          }
  
          @Override
          public int compareTo(Pair o) {
              if (first.equals(o.first)) {
                  return Double.compare(second, o.second);
              }
              return Double.compare(first, o.first);
          }
  
          @Override
          public boolean equals(Object o) {
              if (o instanceof Pair) {
                  Pair p = (Pair) o;
                  return p.first.equals(first) && p.second.equals(second);
              }
              return false;
          }
  
          @Override
          public int hashCode() {
              return first.hashCode() * 31 + second.hashCode();
          }
      }
  
      static class Triple implements Comparable<Triple> {
          Integer f;
          Integer s;
          Integer t;
  
  
          Triple(Integer first, Integer second, Integer third) {
              this.f = first;
              this.s = second;
              this.t = third;
          }
  
          @Override
          public int compareTo(Triple o) {
              return Long.compare(o.f, f);
          }
      }
  
  }