1. import java.io.IOException;
  2. import java.io.DataInputStream;
  3. import java.util.*;
  4. class TestClass {
  5.     
  6.     public static void main(String args[] ) throws Exception {
  7.         FastReader reader = new FastReader();
  8.         StringBuilder sb = new StringBuilder();
  9.         int n = reader.nextInt();
  10.         int[] arr = new int[n];
  11.         int sum = 0;
  12.  
  13.         for(int i = 0; i < n; i++){
  14.             arr[i] = reader.nextInt();
  15.             sum += arr[i];
  16.         }
  17.  
  18.         int[] subL = new int[n * n];
  19.         int[] subR = new int[n * n];
  20.         int p = 0;
  21.         for(int i = 0; i < n; i++){
  22.             int len = 0;
  23.             int remLen = n;
  24.             int sumArr = 0;
  25.             int sumRem = sum;
  26.             for(int j = i; j < n; j++){
  27.                 sumArr += arr[j];
  28.                 sumRem -= arr[j];
  29.                 len++;
  30.                 remLen--;
  31.                 double avgArr = (double)sumArr / len;
  32.                 double avgRem = 0;
  33.                 if(remLen > 0) avgRem = (double)sumRem / remLen;
  34.                 if(avgArr > avgRem){
  35.                     subL[p] = i + 1;
  36.                     subR[p++] = j + 1;
  37.                 }
  38.             }
  39.         }
  40.         sb.append(p).append("\n");
  41.         for(int i = 0; i < p; i++){
  42.             sb.append(subL[i]).append(" ");
  43.             sb.append(subR[i]).append("\n");
  44.         }
  45.         System.out.print(sb); 
  46.         reader.close();
  47.     }
  48.     
  49.     private static class FastReader{
  50.         final private int BUFFER_SIZE = 1 << 16;
  51.         private byte[] buffer;
  52.         private DataInputStream din;
  53.         private int bufferPointer, bytesRead;
  54.         
  55.         public FastReader(){
  56.             buffer = new byte[BUFFER_SIZE];
  57.             din = new DataInputStream(System.in);
  58.             bufferPointer = bytesRead = 0;
  59.         }
  60.         
  61.         private String nextLine() throws IOException{
  62.             StringBuilder sb = new StringBuilder();
  63.             byte c;
  64.             while((c = read()) != -1 && c != '\n'){
  65.                 sb.appendCodePoint(c);
  66.             }
  67.             return sb.toString();
  68.         }
  69.         
  70.         private int nextInt() throws IOException{
  71.             int ret = 0;
  72.             byte c = read();
  73.             while(c <= ' '){
  74.                 c = read();
  75.             }
  76.             boolean neg = c == '-';
  77.             if(neg){
  78.                 c = read();
  79.             }
  80.             while(c >= '0' && c <= '9'){
  81.                 ret = ret * 10 + c - '0';
  82.                 c = read();
  83.             }
  84.             return (neg) ? -ret : ret;
  85.         }
  86.         
  87.         private long nextLong() throws IOException{
  88.             long ret = 0;
  89.             byte c = read();
  90.             while(c <= ' '){
  91.                 c = read();
  92.             }
  93.             boolean neg = c == '-';
  94.             if(neg){
  95.                 c = read();
  96.             }
  97.             while(c >= '0' && c <= '9'){
  98.                 ret = ret * 10 + c - '0';
  99.                 c = read();
  100.             }
  101.             return (neg) ? -ret : ret;
  102.         }
  103.         
  104.         private double nextDouble() throws IOException{
  105.             double ret = 0, div = 1;
  106.             byte c = read();
  107.             while(c <= ' '){
  108.                 c = read();
  109.             }
  110.             boolean neg = c == '-';
  111.             if(neg){
  112.                 c = read();
  113.             }
  114.             while(c >= '0' && c <= '9'){
  115.                 ret = ret * 10 + (c - '0');
  116.                 c = read();
  117.             }
  118.             if(c == '.'){
  119.                 while((c = read()) >= '0' && c <= '9'){
  120.                     ret += (c - '0') / (div *= 10);
  121.                 }
  122.             }
  123.             return (neg) ? -ret : ret;
  124.         }
  125.         
  126.         private void fillBuffer() throws IOException{
  127.             bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
  128.             if(bytesRead == -1){
  129.                 buffer[0] = -1;
  130.             }
  131.         }
  132.         
  133.         private byte read() throws IOException{
  134.             if(bufferPointer == bytesRead){
  135.                 fillBuffer();
  136.             }
  137.             return buffer[bufferPointer++];
  138.         }
  139.         
  140.         private void close() throws IOException{
  141.             if(din != null){
  142.                 din.close();
  143.             }
  144.         }
  145.         
  146.     }
  147. }
Language: Java 8