Paste Search Dynamic
Recent pastes
DataInput
  1.  
  2. import java.io.*;
  3. import java.util.*;
  4.  
  5. public class Main {
  6.         static class reader {
  7.                 final private int BUFFER_SIZE = 1 << 16;
  8.                 private datainputstream din;
  9.                 private byte[] buffer;
  10.                 private int bufferPointer, bytesRead;
  11.  
  12.                 public reader()
  13.                 {
  14.                         din = new datainputstream(system.in);
  15.                         buffer = new byte[BUFFER_SIZE];
  16.                         bufferPointer = bytesRead = 0;
  17.                 }
  18.  
  19.                 public reader(string file_name) throws ioexception
  20.                 {
  21.                         din = new datainputstream(
  22.                                 new fileinputstream(file_name));
  23.                         buffer = new byte[BUFFER_SIZE];
  24.                         bufferPointer = bytesRead = 0;
  25.                 }
  26.  
  27.                 public string readLine() throws ioexception
  28.                 {
  29.                         byte[] buf = new byte[64]; // line length
  30.                         int cnt = 0, c;
  31.                         while ((c = read()) != -1) {
  32.                                 if (c == 'n') {
  33.                                         if (cnt != 0) {
  34.                                                 break;
  35.                                         }
  36.                                         else {
  37.                                                 continue;
  38.                                         }
  39.                                 }
  40.                                 buf[cnt++] = (byte)c;
  41.                         }
  42.                         return new string(buf, 0, cnt);
  43.                 }
  44.  
  45.                 public int nextInt() throws ioexception
  46.                 {
  47.                         int ret = 0;
  48.                         byte c = read();
  49.                         while (c <= ' ') {
  50.                                 c = read();
  51.                         }
  52.                         boolean neg = (c == '-');
  53.                         if (neg)
  54.                                 c = read();
  55.                         do {
  56.                                 ret = ret * 10 + c - '0';
  57.                         } while ((c = read()) >= '0' && c <= '9');
  58.  
  59.                         if (neg)
  60.                                 return -ret;
  61.                         return ret;
  62.                 }
  63.  
  64.                 public long nextLong() throws ioexception
  65.                 {
  66.                         long ret = 0;
  67.                         byte c = read();
  68.                         while (c <= ' ')
  69.                                 c = read();
  70.                         boolean neg = (c == '-');
  71.                         if (neg)
  72.                                 c = read();
  73.                         do {
  74.                                 ret = ret * 10 + c - '0';
  75.                         } while ((c = read()) >= '0' && c <= '9');
  76.                         if (neg)
  77.                                 return -ret;
  78.                         return ret;
  79.                 }
  80.  
  81.                 public double nextDouble() throws ioexception
  82.                 {
  83.                         double ret = 0, div = 1;
  84.                         byte c = read();
  85.                         while (c <= ' ')
  86.                                 c = read();
  87.                         boolean neg = (c == '-');
  88.                         if (neg)
  89.                                 c = read();
  90.  
  91.                         do {
  92.                                 ret = ret * 10 + c - '0';
  93.                         } while ((c = read()) >= '0' && c <= '9');
  94.  
  95.                         if (c == '.') {
  96.                                 while ((c = read()) >= '0' && c <= '9') {
  97.                                         ret += (c - '0') / (div *= 10);
  98.                                 }
  99.                         }
  100.  
  101.                         if (neg)
  102.                                 return -ret;
  103.                         return ret;
  104.                 }
  105.  
  106.                 private void fillBuffer() throws ioexception
  107.                 {
  108.                         bytesRead = din.read(buffer, bufferPointer = 0,
  109.                                                                 BUFFER_SIZE);
  110.                         if (bytesRead == -1)
  111.                                 buffer[0] = -1;
  112.                 }
  113.  
  114.                 private byte read() throws ioexception
  115.                 {
  116.                         if (bufferPointer == bytesRead)
  117.                                 fillBuffer();
  118.                         return buffer[bufferPointer++];
  119.                 }
  120.  
  121.                 public void close() throws ioexception
  122.                 {
  123.                         if (din == null)
  124.                                 return;
  125.                         din.close();
  126.                 }
  127.         }
  128.  
  129.         public static void main(string[] args)
  130.                 throws ioexception
  131.         {
  132.                 reader s = new reader();
  133.                 int t=s.nextInt();
  134.                 while(t-->0){
  135.                     int x=s.nextInt();
  136.                     int y=s.nextInt();
  137.                     int n=x-y;
  138.                     if(n>=y)system.out.println(y);
  139.                         else    system.out.println(n);
  140.                    
  141.                 }
  142.  
  143.         }
  144. }
  145.  
Parsed in 0.070 seconds