java-competitive/archive/2019.02/2019.02.21 - unsorted/D.java

package chelper;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

import io.InputReader;
import io.OutputWriter;
import misc.SimpleSavingChelperSolution;


public class D extends SimpleSavingChelperSolution {

  public static final int N = 100000;
  public static final int TOTAL_TURNS = 100;
  public static final int PREP_TURNS = 45;

  static class Solver {
    List<Integer> history = new ArrayList<>();
    int minIndex = -1;
    int turn = 0;

    String decide(String s) {
      int x = -1;
      if (s != null) {
        x = strToInt(s);
      }

      int ans = decide(x, turn);
      turn++;
      return intToStr(ans);
    }

    int decide(int x, int turn) {
      if (turn == 0) {
        return 0;
      }

      history.add(x);

      if (turn < PREP_TURNS) {
        return x;
      }

      if (turn == PREP_TURNS) {
        findMinIndex();
        System.err.println("GUESS:");
        System.err.println("max: " + intToStr(history.get(minIndex - 1)));
        System.err.println("min: " + intToStr(history.get(minIndex)));
      }

      int maxValue = history.get(minIndex - 1);
      int minValue = history.get(minIndex);
      int randValue = history.get(minIndex + 1);

      if (x == maxValue) {
        return minValue;
      }
      if (x == minValue) {
        return randValue;
      }
      return maxValue;
    }

    void findMinIndex() {
      for (int i = 1; i < history.size() - 1; i++) {
        for (int j = i + 1; j < history.size() - 1; j++) {
          for (int k = j + 1; k < history.size() - 1; k++) {
            int a1 = history.get(i - 1);
            int a2 = history.get(i);
            int a3 = history.get(i + 1);
            int b1 = history.get(j - 1);
            int b2 = history.get(j);
            int b3 = history.get(j + 1);
            int c1 = history.get(k - 1);
            int c2 = history.get(k);
            int c3 = history.get(k + 1);

            if (a1 == b1 && b1 == c1
                && a2 == b2 && b2 == c2
                && a1 != a2
                && a3 != b3 && a3 != c3 && b3 != c3
            ) {
              minIndex = i;
              return;
            }
          }
        }
      }

      for (int i = 1; i < history.size() - 1; i++) {
        for (int j = i + 1; j < history.size() - 1; j++) {
          int a1 = history.get(i - 1);
          int a2 = history.get(i);
          int a3 = history.get(i + 1);
          int b1 = history.get(j - 1);
          int b2 = history.get(j);
          int b3 = history.get(j + 1);

          if (a1 == b1
              && a2 == b2
              && a1 != a2
              && a3 != b3
          ) {
            minIndex = i;
            return;
          }
        }
      }

      throw new IllegalArgumentException(":(");
    }
  }

  static class Checker {
    List<String> bank = new ArrayList<>();
    Map<String, Integer> bankPos = new HashMap<>();
    Random random = new Random();

    Checker() {
      for (int i = 0; i < N; i++) {
        bank.add(intToStr(i));
      }
      Collections.shuffle(bank, random);

      for (int i = 0; i < N; i++) {
        bankPos.put(bank.get(i), i);
      }
    }

    boolean greater(String a, String b) {
      if (a.equals(bank.get(0)) && b.equals(bank.get(N - 1))) {
        return true;
      }

      return bankPos.get(a) > bankPos.get(b);
    }

    String decide(String s) {
      int x = bankPos.get(s);

      if (x == N - 1) {
        return bank.get(0);
      }

      if (x == 0) {
        return bank.get(x + 1 + random.nextInt(N - x - 2));
      }

      return bank.get(x + 1 + random.nextInt(N - x - 1));
    }

    int run() {
      Solver solver = new Solver();
      int score = 0;

      String prev = null;
      for (int i = 0; i <= TOTAL_TURNS; i++) {
        String attempt = solver.decide(prev);

        if (prev != null && greater(attempt, prev)) {
          score++;
        }

        prev = decide(attempt);

        if (!greater(prev, attempt)) {
          System.err.println("WAHT");
        }
      }

      return score;
    }
  }


  public void solve(int testNumber, InputReader in, OutputWriter out) {
    wrapSolve(testNumber, in, out);
  }

  public void solve(int testNumber) {
    int T = in.nextInt();
    int N = in.nextInt();

    for (int i = 0; i < T; i++) {
      solveTestCase();
    }
  }

  static int strToInt(String s) {
    int result = 0;

    for (int i = 0; i < 5; i++) {
      result *= 10;
      result += s.charAt(i) - 'A';
    }

    return result;
  }

  static String intToStr(int x) {
    String result = "";

    for (int i = 0; i < 5; i++) {
      result = (char) (x % 10 + 'A') + result;
      x /= 10;
    }

    return result;
  }

  private void solveTestCase() {
//    Checker checker = new Checker();
//    System.err.println(checker.run());

    Solver solver = new Solver();
    String prev = null;
    for (int i = 0; i <= TOTAL_TURNS; i++) {
      String answer = solver.decide(prev);
      System.out.println(answer);
      System.out.flush();

      if (i < TOTAL_TURNS) {
        prev = in.nextString();
      }
    }
  }
}