!636

!quickmain

!auto-import

!standard functions

!quicknew

!1000346 // use "case" as a variable name

!688 // buf.isEmpty

!class JavaTok

import java.lang.reflect.*;

interface Learner {

  public void processInOut(String in, String out);

  public String processIn(String in);

  public void toJava(Code code);

}

interface Function {

  public Object process(Object in);

  public void toJava_process(Code code);

}

interface ReversibleFunction extends Function {

  public Object unprocess(Object in);

  public void toJava_unprocess(Code code);

}

// generic learner (works on objects)

interface GLearner {

  public void processInOut(Object in, Object out);

  public Object processIn(Object in);

  public void toJava(Code code);

}

abstract class Base {

  void printVars() {

    new StringBuilder buf;

    Field[] fields = getClass().getDeclaredFields();

    for (Field field : fields) {

      if ((field.getModifiers() & Modifier.STATIC) != 0)

        continue;

      Object value;

      try {

        value = field.get(this);

      } catch (Exception e) {

        value = "?";

      }

      if (!buf.isEmpty()) buf.append(", ");

      buf.append(field.getName() + "=" + value);

    }

    System.out.println(buf.toString());

  }

}

abstract class LearnerImpl extends Base implements Learner {

}

abstract class GLearnerImpl extends Base implements GLearner {

}

class WrappedGLearner extends LearnerImpl {

  GLearner learner;

  WrappedGLearner(GLearner learner) {

    this.learner = learner;

  }

  public void processInOut(String in, String out) {

    learner.processInOut(in, out);

  }

  public String processIn(String in) {

    return (String) learner.processIn(in);

  }

  public void toJava(Code code) {

    learner.toJava(code);

  }

}

class Code {

  StringBuilder buf = new StringBuilder();

  String var = "in";

  String indent = "";

  void line(String line) {

    buf.append(indent).append(line).append('\n');

  }

  void indent() {

    indent += "  ";

  }

  void unindent() {

    indent = indent.substring(0, indent.length()-2);

  }

}

main {

  static List<Case> cases = new ArrayList<Case>();

  psvm {

    String snippetID = null;

    for (int i = 0; i < args.length; i++) {

      String arg = args[i];

      if (arg.equals("debug"))

        debugOn(args[++i]);

      else if (isSnippetID(arg))

        snippetID = arg;

      else

        System.err.println("Unknown argument: " + arg + ", ignoring");

    }

    parse(snippetID);

    int solved = 0, n = cases.size();

    for (int i = 0; i < n; i++) {

      calculate(cases.get(i));

      if (cases.get(i).winner != null)

        ++solved;

      System.out.println((i+1) + " case(s) processed, " + solved + " solved.");

    }

    print ""    

    print "----"

    boolean allSolved = solved == n;

    if (!allSolved) {

      System.out.println();

      System.out.print("Unsolved: ");

      for (Case case : cases)

        if (case.winner == null)

          System.out.print(case.id + " ");

      System.out.println();

    }

    if (solved != 0) {

      System.out.println();

      System.out.print("Solved: ");

      for (Case case : cases)

        if (case.winner != null)

          System.out.print(case.id + " ");

      System.out.println();

    }

    System.out.println();

    System.out.println(allSolved ? "ALL SOLVED (" + solved + ")" : "Solved " + solved + " out of " + n + ".");

    print ""

  }

  static class Case {

    String id;

    List<String[]> fullExamples = new ArrayList<String[]>();

    List<String> halfExamples = new ArrayList<String>();

    List<String[]> examples1, examples2;

    Learner winner;

  }

  static void parse(String arg) tex {

    Case case = new Case();

    String text;

    if (arg != null) {

      case.id = arg;

      text = loadSnippet(arg);

    } else {

      case.id = "input.txt";

      text = loadTextFile("input/input.txt", null);

      if (text == null) {

        //case.id = "#2000455";  // example input

        case.id = "#681"; // a collection of "all cases"!

        text = loadSnippet(case.id);

      }

    }

    // it's a collection of cases!

    if (text.trim().startsWith("#")) {

      for (String line : toLines(text))

        parse(line);

      return;

    }

    System.out.println(text);

    String in = null, out = null;

    for (String line : toLines(text)) {

      if (line.startsWith("I")) { // "In: " or "I: "

        if (in != null)

          case.halfExamples.add(in);

        in = unquote(line.substring(line.indexOf(':')+1).trim());

        out = null;

      } else if (line.startsWith("O")) { // "Out: " or "O: "

        out = unquote(line.substring(line.indexOf(':')+1).trim());

        System.out.println(quote(in) + " => " + quote(out));

        case.fullExamples.add(new String[] {in, out});

        in = out = null;

      }

    }

    if (in != null)

      case.halfExamples.add(in);

    cases.add(case);

  }

  static void calculate(Case case) tex {

    if (case.fullExamples.size() < 2)

      throw new RuntimeException("Too few examples (" + case.fullExamples.size() + ")");

    int splitPoint = case.fullExamples.size()-1;

    System.out.println("Full examples: " + case.fullExamples.size() + ", splitPoint: " + splitPoint);

    case.examples1 = case.fullExamples.subList(0, splitPoint);

    case.examples2 = case.fullExamples.subList(splitPoint, case.fullExamples.size());

    Learner learner = findOKLearner(case);

    if (learner == null)

      print "\nProblem not solved"

    else {

      print "\nSolved!\n"

      case.winner = learner;

      Code code = new Code();

      learner.toJava(code);

      System.out.println("Java:");

      System.out.println(indent("  ", code.buf.toString()));

      for (String in : case.halfExamples) {

        String out = learner.processIn(in);

        System.out.println(quote(in) + " =>! " + quote(out));

      }

    }

  }

  static Learner findOKLearner(Case case) {

    for (Learner learner : makeLearners()) try {

      if (learnerOK(learner, case))

        return learner;

    } catch (Throwable e) {

      e.printStackTrace();

    }

    return null;

  }

  static boolean learnerOK(Learner learner, Case case) {

    String[] _e = null;

    try {

      for (String[] e : case.examples1) {

        _e = e;

        learner.processInOut(e[0], e[1]);

      }

      // full validation against all examples

      for (String[] e : case.fullExamples) {

        _e = e;

        String out = learner.processIn(e[0]);

        if (!e[1].equals(out)) {

          System.out.println("[fail] " + learner + " on " + quote(e[0]) + " - got: " + quote(out) + " rather than: " + quote(e[1]));

          return false;

        }

      }

      return true; // all test examples passed

    } catch (Throwable e) {

        System.out.println("[fail] " + learner + " on " + (_e == null ? "?" : quote(_e[0])) + " - " + e);

      silentException(e);

      return false;

    }

  }

  static void silentException(Throwable e) {

  }

  static Iterable<Learner> makeLearners() {

    List<Learner> list = new ArrayList<Learner>();

    //list.add(new LId()); // subsumed by trivial case of PrefixSuffix

    list.add(new LPrefixSuffix());

    list.add(new LSplitInput(new LOutPattern()));

    list.add(new LInputPattern());

    list.add(wrap(new LFixed()));

    list.add(wrap(new LBoth(new RFJavaTok(), new LEach(new LFixedFunction(new EscapeCase())))));

    return list;

  }

  public static String unquote(String s) {

    if (s.startsWith("\"") && s.endsWith("\"") && s.length() > 1)

      return s.substring(1, s.length()-1).replace("\\\"", "\"").replace("\\\\", "\\"); // SHOULD work...

    else

      return s; // Return SOMETHING

  }

  public static String quote(String s) {

    if (s == null) return "null";

    return "\"" + s.replace("\\", "\\\\").replace("\"", "\\\"") + "\"";

  }

  static String indent(String indent, String s) {

    return indent + s.replace("\n", "\n" + indent);

  }

  static void debugOn(String name) {

    try {

      Class c = Class.forName("main$" + name);

      Field field;

      while (true)

        try {

          field = c.getDeclaredField("debug");

          break;

        } catch  (NoSuchFieldException e) {

          c = c.getSuperclass();

        }

      field.setBoolean(null, true);

    } catch (Exception e) {

      e.printStackTrace();

      System.err.println("Cannot debug class " + name);

    }

  }

  static Learner wrap(GLearner learner) {

    return new WrappedGLearner(learner);

  }

  // splits the input at some point, takes only one part

  static class LSplitInput implements Learner {

    int splitIdx = 1; // split after first character

    Learner baseLearner;

    LSplitInput(Learner baseLearner) {

      this.baseLearner = baseLearner;

    }

    public void processInOut(String in, String out) {

      in = in.substring(splitIdx);

      baseLearner.processInOut(in, out);

    }

    public String processIn(String in) {

      in = in.substring(splitIdx);

      return baseLearner.processIn(in);

    }

    public void toJava(Code code) {

      code.line(code.var + " = ((String) " + code.var + ").substring(" + splitIdx + ");");

      baseLearner.toJava(code);

    }

  }

  // if input appears in output in fixed pattern

  static class LOutPattern implements Learner {

    String pattern = "%!%";

    public void processInOut(String in, String out) {

      pattern = out.replace(in, "%!%");

    }

    public String processIn(String in) {

      return pattern.replace("%!%", in);

    }

    public void toJava(Code code) {

      code.line(code.var + " = " + quote(pattern) + ".replace(" + quote("%!%") + ", (String) " + code.var + ");");

    }

  }

  // learns to exchange common prefixes and suffixes

  static class LPrefixSuffix extends LearnerImpl {

    static boolean debug;

    String prefixIn, suffixIn, prefixOut, suffixOut;

    public void processInOut(String in, String out) {

      updateIn(in);

      prefixOut = prefixOut == null ? out : commonPrefix(prefixOut, out);

      suffixOut = suffixOut == null ? out : commonSuffix(suffixOut, out);

      if (debug)

        printState("processInOut(" + quote(in) + ", " + quote(out) + ")");

    }

    void updateIn(String in) {

      prefixIn = prefixIn == null ? in : commonPrefix(prefixIn, in);

      suffixIn = suffixIn == null ? in : commonSuffix(suffixIn, in);

      if (debug)

        printState("updateIn(" + quote(in) + ")");

    }

    public String processIn(String in) {

      //System.out.println("[before last info] " + quote(prefixIn) + " " + quote(suffixIn) + " " + quote(prefixOut) + " " + quote(suffixOut));

      //System.out.println("[last info] " + quote(in));

      // use latest information

      String p = prefixIn, s = suffixIn;

      updateIn(in);

      prefixOut = prefixOut.substring(0, prefixOut.length()-(p.length()-prefixIn.length()));

      suffixOut = suffixOut.substring(s.length()-suffixIn.length());

      //System.out.println("[after last info] " + quote(prefixIn) + " " + quote(suffixIn) + " " + quote(prefixOut) + " " + quote(suffixOut));

      String core = in.substring(prefixIn.length(), in.length()-suffixIn.length());

      return prefixOut + core + suffixOut;

    }

    public void toJava(Code code) {

      code.line(code.var + " = ((String) " + code.var + ").substring(" + prefixIn.length() + ", in.length()-" + suffixIn.length() + ");");

      code.line(code.var + " = " + quote(prefixOut) + " + " + code.var + " + " + quote(suffixOut) + ";");

    }

    void printState(String text) {

      System.out.println(text);

      printVars();

    }

  }

  // for "find" tasks (e.g. "abcde" to "[[abc]]de")

  static class LInputPattern implements Learner {

    String regexp = "";

    public void processInOut(String in, String out) {

      int i = out.indexOf("[["), j = out.indexOf("]]", i+1);

      if (j < 0) return;

      String s = out.substring(i+2, j);

      regexp = s.replaceAll("\\d+", Matcher.quoteReplacement("\\d+"));

      System.out.println("regexp: " + regexp);

    }

    public String processIn(String in) {

      if (regexp.length() == 0)

        return in;

      else

        return in.replaceAll("(" + regexp + ")", "[[$1]]");

    }

    public void toJava(Code code) {

      code.line(code.var + " = ((String) " + code.var + ").replaceAll(" + quote("(" + regexp + ")") + ", \"[[$1]]\");");

    }

  }

  static class LFixed extends GLearnerImpl {

    static boolean debug;

    Object value;

    public void processInOut(Object in, Object out) {

      value = out;

      if (debug)

        printVars();

    }

    public Object processIn(Object in) {

      return value;

    }

    public void toJava(Code code) {

      code.line(code.var + " = " + quote((String) value) + ";");

    }

  }

  static void fail(String msg) {

    throw new RuntimeException(msg);

  }

  static void assertSameSize(List a, List b) {

    if (a.size() != b.size())

      fail("wrong list sizes");

  }

  // process lists in parallel

  // (in and out must be a list of same length)

  static class LEach extends GLearnerImpl {

    static boolean debug;

    GLearner base;

    LEach(GLearner base) {

      this.base = base;

    }

    public void processInOut(Object _in, Object _out) {

      List in = (List) _in, out = (List) _out;

      assertSameSize(in, out);

      for (int i = 0; i < in.size(); i++)

        base.processInOut(in.get(i), out.get(i));

      if (debug)

        printVars();

    }

    public Object processIn(Object _in) {

      List in = (List) _in;

      List out = new ArrayList();

      for (Object x : in)

        out.add(base.processIn(x));

      return out;

    }

    public void toJava(Code code) {

      code.line("List out = new ArrayList();");

      code.line("for (Object x : (List) in) {");

      code.indent();

      code.line("in = x;");

      base.toJava(code);

      code.line("out.add(in);");

      code.unindent();

      code.line("}");

      code.line("in = out;");

    }

  }

  static class LBoth extends GLearnerImpl {

    ReversibleFunction f;

    GLearner base;

    LBoth(ReversibleFunction f, GLearner base) {

      this.f = f;

      this.base = base;

    }

    public void processInOut(Object in, Object out) {

      in = f.process(in);

      out = f.process(out);

      base.processInOut(in, out);

    }

    public Object processIn(Object in) {

      in = f.process(in);

      in = base.processIn(in);

      in = f.unprocess(in);

      return in;

    }

    public void toJava(Code code) {

      f.toJava_process(code);

      base.toJava(code);

      f.toJava_unprocess(code);

    }

  }

  static class RFJavaTok implements ReversibleFunction {

    public Object process(Object in) {

      return JavaTok.split((String) in);

    }

    public Object unprocess(Object in) {

      return JavaTok.join((List) in);

    }

    public void toJava_process(Code code) {

      code.line(code.var + " = JavaTok.split((String) " + code.var + ");");

    }

    public void toJava_unprocess(Code code) {

      code.line(code.var + " = JavaTok.join((List) " + code.var + ");");

    }

  }

  static class LFixedFunction extends GLearnerImpl {

    Function f;

    LFixedFunction(Function f) {

      this.f = f;

    }

    public void processInOut(Object in, Object out) {

    }

    public Object processIn(Object in) {

      return f.process(in);

    }

    public void toJava(Code code) {

      f.toJava_process(code);

    }

  }

  static class EscapeCase implements Function {

    static boolean debug;

    public Object process(Object _in) {

      if (debug)

        System.out.println("EscapeCase: " + _in);

      String in = (String) _in;

      return in.equals("case") ? "_case" : in;

    }

    public void toJava_process(Code code) {

      code.line("if (\"case\".equals(" + code.var + ")) " + code.var + " = " + quote("_case") + ";");

    }

  }

}