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.security.SecureRandom;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.InputMismatchException;
  import java.util.List;
  import java.util.Optional;
  import java.util.Random;
  import java.util.stream.*;
  
  
  public class A {
  
      // 420 remainder: use long everywhere
  
      private final static boolean MULTIPLE_TESTS = true;
  
      private void solve() {
          int n = in.readInt();
          out.println((n + 1) / 10);
      }
  
      private void run() throws Exception {
          in = new FastReader("input.txt");
          out = new FastWriter();
  
          int t = MULTIPLE_TESTS ? in.readInt() : 1;
  
          for (int testNum = 0; testNum < t; testNum++) {
              solve();
          }
  
          out.close();
          in.close();
      }
  
      public static void main(String[] args) throws Exception {
          new A().run();
      }
  
      private FastReader in;
      private FastWriter out;
  
      private final static boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
  
      private static class FastWriter implements AutoCloseable {
          @SuppressWarnings(value="all")
          private final static Optional<String> OUTPUT_FILENAME = Optional.empty();
  
          private final PrintWriter out;
  
          public FastWriter() throws FileNotFoundException {
              this.out = OUTPUT_FILENAME.isEmpty() ? new PrintWriter(System.out) : new PrintWriter(new File(OUTPUT_FILENAME.get()));
          }
  
          public void println() {
              out.println();
          }
  
          public <T> void print(T value) {
              out.print(value);
          }
  
          public <T> void println(T value) {
              out.println(value);
          }
  
          public <T> void print(List<? extends T> list) {
              for (var it = list.listIterator(); it.hasNext(); ) {
                  out.print(it.next());
                  if (it.hasNext()) {
                      out.print(' ');
                  }
              }
          }
  
          public <T> void println(List<? extends T> list) {
              print(list);
              out.println();
          }
  
          public <T> void print(T[] array) {
              for (int i = 0; i < array.length; i++) {
                  out.print(array[i]);
                  if (i + 1 < array.length) {
                      out.print(' ');
                  }
              }
          }
  
          public <T> void println(T[] array) {
              print(array);
              out.println();
          }
  
          public void print(int[] array) {
              for (int i = 0; i < array.length; i++) {
                  out.print(array[i]);
                  if (i + 1 < array.length) {
                      out.print(' ');
                  }
              }
          }
  
          public void println(int[] array) {
              print(array);
              out.println();
          }
  
          public void print(long[] array) {
              for (int i = 0; i < array.length; i++) {
                  out.print(array[i]);
                  if (i + 1 < array.length) {
                      out.print(' ');
                  }
              }
          }
  
          public void println(long[] array) {
              print(array);
              out.println();
          }
  
          public void print(double[] array) {
              for (int i = 0; i < array.length; i++) {
                  out.print(array[i]);
                  if (i + 1 < array.length) {
                      out.print(' ');
                  }
              }
          }
  
          public void println(double[] array) {
              print(array);
              out.println();
          }
  
          @Override
          public void close() {
              out.close();
          }
      }
  
      private static class FastReader implements AutoCloseable {
          private final InputStream inputStream;
          private final byte[] buffer = new byte[1024];
  
          private int bufferLen = 0;
          private int bufferPtr = 0;
  
          public FastReader(String fileName) throws FileNotFoundException {
              this.inputStream = ONLINE_JUDGE ? System.in : new FileInputStream(fileName);
          }
  
          public int[] readIntArray(int size) {
              int[] array = new int[size];
              for (int i = 0; i < size; i++) {
                  array[i] = readInt();
              }
              return array;
          }
  
          public long[] readLongArray(int size) {
              long[] array = new long[size];
              for (int i = 0; i < size; i++) {
                  array[i] = readLong();
              }
              return array;
          }
  
          public double[] readDoubleArray(int size) {
              double[] array = new double[size];
              for (int i = 0; i < size; i++) {
                  array[i] = readLong();
              }
              return array;
          }
  
          public double readDouble() {
              return Double.parseDouble(readToken());
          }
  
          public String readToken() {
              int b = skip();
              StringBuilder sb = new StringBuilder();
              while (!(isSpaceChar(b))) {
                  sb.appendCodePoint(b);
                  b = readByte();
              }
              return sb.toString();
          }
  
          public int readInt() {
              int num = 0, b;
              boolean minus = false;
  
              while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
  
              if (b == '-') {
                  minus = true;
                  b = readByte();
              }
  
              while (true) {
                  if (b >= '0' && b <= '9') {
                      num = num * 10 + (b - '0');
                  } else {
                      return minus ? -num : num;
                  }
                  b = readByte();
              }
          }
  
          public long readLong() {
              long num = 0;
              int b;
              boolean minus = false;
  
              while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
  
              if (b == '-') {
                  minus = true;
                  b = readByte();
              }
  
              while (true) {
                  if (b >= '0' && b <= '9') {
                      num = num * 10 + (b - '0');
                  } else {
                      return minus ? -num : num;
                  }
                  b = readByte();
              }
          }
  
          public int readByte() {
              if (bufferLen == -1) {
                  throw new InputMismatchException();
              }
              if (bufferPtr >= bufferLen) {
                  bufferPtr = 0;
                  try {
                      bufferLen = inputStream.read(buffer);
                  } catch (IOException e) {
                      throw new InputMismatchException();
                  }
                  if (bufferLen <= 0) {
                      return -1;
                  }
              }
              return buffer[bufferPtr++];
          }
  
          public char readChar() {
              return (char) skip();
          }
  
          private int skip() {
              int b;
              while ((b = readByte()) != -1 && isSpaceChar(b));
              return b;
          }
  
          private static boolean isSpaceChar(int c) {
              return !(c >= 33 && c <= 126);
          }
  
          @Override
          public void close() throws Exception {
              inputStream.close();
              bufferPtr = bufferLen;
          }
      }
  
      private static class Tuple {
          public static <A, B> Tuple2<A, B> of(A first, B second) {
              return new Tuple2<>(first, second);
          }
  
          public static <A, B> List<Tuple2<A, B>> array(A[] first, B[] second) {
              if (first.length != second.length) {
                  throw new RuntimeException(
                          String.format("Can't create tuples array from arrays with different length (%d != %d)",
                                  first.length, second.length));
              }
              return IntStream.range(0, first.length)
                      .mapToObj(i -> Tuple.of(first[i], second[i]))
                      .collect(Collectors.toList());
          }
  
          public static <A, B, C> Tuple3<A, B, C> of(A first, B second, C third) {
              return new Tuple3<>(first, second, third);
          }
  
          public static <A, B, C> List<Tuple3<A, B, C>> array(A[] first, B[] second, C[] third) {
              if (first.length != second.length || second.length != third.length) {
                  throw new RuntimeException(
                          String.format("Can't create tuples array from arrays with different length (%d, %d, %d)",
                                  first.length, second.length, third.length));
              }
              return IntStream.range(0, first.length)
                      .mapToObj(i -> Tuple.of(first[i], second[i], third[i]))
                      .collect(Collectors.toList());
          }
  
          public static <A extends Comparable<A>, B extends Comparable<B>> Comparator<Tuple2<A, B>> tuple2Comparator() {
              return Comparator.comparing((Tuple2<A, B> t) -> t.first).thenComparing(t -> t.second);
          }
  
          public static <A extends Comparable<A>, B extends Comparable<B>, C extends Comparable<C>> Comparator<Tuple3<A, B, C>> tuple3Comparator() {
              return Comparator.comparing((Tuple3<A, B, C> t) -> t.first).thenComparing(t -> t.second).thenComparing(t -> t.third);
          }
  
          private static class Tuple2<A, B> extends Tuple {
              public final A first;
              public final B second;
  
              private Tuple2(A first, B second) {
                  this.first = first;
                  this.second = second;
              }
  
              @Override
              public String toString() {
                  return "(" + first + ", " + second + ")";
              }
          }
  
          private static class Tuple3<A, B, C> extends Tuple2<A, B> {
              public final C third;
  
              private Tuple3(A first, B second, C third) {
                  super(first, second);
                  this.third = third;
              }
  
              @Override
              public String toString() {
                  return "(" + first + ", " + second + ", " + third + ")";
              }
          }
      }
  
      private static class Utils {
          private static final Random RANDOM = new SecureRandom();
  
          public static <T extends Comparable<T>> void sort(T[] array) {
              shuffle(array);
              Arrays.sort(array);
          }
  
          public static void sort(int[] array) {
              shuffle(array);
              Arrays.sort(array);
          }
  
          public static void sort(long[] array) {
              shuffle(array);
              Arrays.sort(array);
          }
  
          public static void sort(double[] array) {
              shuffle(array);
              Arrays.sort(array);
          }
  
          public static <T> void sort(T[] array, Comparator<T> comparator) {
              shuffle(array);
              Arrays.sort(array, comparator);
          }
  
          public static <T> void shuffle(T[] array) {
              for (int i = array.length - 1; i > 0; i--) {
                  int index = RANDOM.nextInt(i + 1);
                  T a = array[index];
                  array[index] = array[i];
                  array[i] = a;
              }
          }
  
          public static void shuffle(int[] array) {
              for (int i = array.length - 1; i > 0; i--) {
                  int index = RANDOM.nextInt(i + 1);
                  int a = array[index];
                  array[index] = array[i];
                  array[i] = a;
              }
          }
  
          public static void shuffle(long[] array) {
              for (int i = array.length - 1; i > 0; i--) {
                  int index = RANDOM.nextInt(i + 1);
                  long a = array[index];
                  array[index] = array[i];
                  array[i] = a;
              }
          }
  
          public static void shuffle(double[] array) {
              for (int i = array.length - 1; i > 0; i--) {
                  int index = RANDOM.nextInt(i + 1);
                  double a = array[index];
                  array[index] = array[i];
                  array[i] = a;
              }
          }
  
          public static <T extends Comparable<T>> void sort(List<T> list) {
              Collections.shuffle(list);
              Collections.sort(list);
          }
  
          public static <T> void sort(List<T> list, Comparator<T> comparator) {
              Collections.shuffle(list);
              list.sort(comparator);
          }
  
          public static int randomInt(int fromIncluded, int toExcluded) {
              return fromIncluded + RANDOM.nextInt(toExcluded - fromIncluded);
          }
  
          public static Integer[] box(int[] a) {
              return IntStream.of(a).boxed().toArray(Integer[]::new);
          }
  
          public static Long[] box(long[] a) {
              return LongStream.of(a).boxed().toArray(Long[]::new);
          }
  
          public static Double[] box(double[] a) {
              return DoubleStream.of(a).boxed().toArray(Double[]::new);
          }
      }
  }
  