backtracking

package ch.fhnw.claudemartin;

import java.util.Arrays;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

import javax.script.ScriptException;

public class SomeClass {

  final static class BinStr implements Comparable<BinStr> {
    final private boolean[] data;

    public BinStr(final int n) {
      this.data = new boolean[n];
    }

    public BinStr(final boolean... data) {
      this.data = Arrays.copyOf(data, data.length);
    }

    char getChar(final int i) {
      return this.data[i] ? '1' : '0';
    }

    boolean get(final int i) {
      return this.data[i];
    }

    void set(final int i, final boolean value) {
      this.data[i] = value;
    }

    int getN() {
      return this.data.length;
    }

    @Override
    public String toString() {
      final StringBuffer s = new StringBuffer(this.data.length);
      for (int i = 0; i < this.data.length; i++) {
        s.append(this.getChar(i));
        if (i > 1 && i % 100 == 0)
          s.append("\n\t");
      }
      return s.toString();
    }

    @Override
    public int compareTo(final BinStr o) {
      if (this.data.length != o.data.length)
        return this.data.length - o.data.length;

      for (int i = 0; i < this.data.length; i++) {
        if (this.data[i] != o.data[i])
          return this.data[i] ? 1 : -1;
      }
      return 0;
    }
  }

  public static void main(final String[] args) throws ScriptException {
    final TreeSet<BinStr> input = new TreeSet<>();
    final int N = 20;
    final boolean[] data = new boolean[N];
    input.add(new BinStr(data));// all 0

    final Random r = new Random();
    while (input.size() < N) {
      for (int i = 0; i < data.length; i += r.nextInt(5)) {
        data[i] = r.nextBoolean();
      }
      input.add(new BinStr(data));
    }

    System.out.println("input is ready...");
    if (N <= 20)
      System.out.println(input);
    // Find multiple strings by adding each result and staring over:
    for (int i = 0; i < N; i++) {
      final BinStr str = new BinStr(N);
      final boolean found = find(0, str, input);
      if (!found) {
        System.out.println("not found");
      } else {
        System.out.println(str.toString());
        input.add(str);
      }
      System.out.flush();
    }
  }

  public static boolean find(final int i, final BinStr str,
      final Set<BinStr> input) {

    if (i == str.getN())
      return !input.contains(str);

    str.set(i, false);
    if (find(i + 1, str, input))
      return true;

    str.set(i, true);
    if (find(i + 1, str, input))
      return true;

    return false;
  }

}