How can I continue permutation/combination where I stopped the program?

Question

It's my second time asking here and straight to the point. I can't seem to find a solution and I know it's not impossible. I wrote a java program that can generate a set of combination of any length, when I stop the program I don't want to start from the beginning how can I pick up from where I stopped? Thanks.

Example (for length 3):

If I start from aaa ==> 9zI and I stop the program here, I don't want to start from aaa all over but start from 9zI and continue to 999. I just want to continue from where I left off.

public class Main {

public static void main(String[] args) {
    S_Permutation sp = new S_Permutation();
    String text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    FileClass.fileExist("new.txt", true);
    System.out.println("");

    sp.permutation(text, "", 7, "sha256.txt","Kaaaaaa");
  }
}  

=====================================================================

public class S_Permutation {

private List<String> permutation;

public S_Permutation() {
    permutation = new ArrayList<>();
}

public boolean saveThis(String words, char a, int limit) {
    int count = 0;
    limit++;
    for (char character : words.toCharArray()) {
        if (count == limit) {
            return false;
        }

        if (character == a) {
            count++;
        } else {
            count = 0;
        }
    }

    return count < limit;
}
private int counter = 0;
private boolean seen = false;
public void permutation(String str, String prefix, int lengthOfPermutationString, String filename, String startPoint) {
    if (prefix.equalsIgnoreCase(startPoint))
    {
        seen = true;
    }
    if (counter == 0) {
        if (startPoint.length() != lengthOfPermutationString) {
            for (int i = startPoint.length(); i < lengthOfPermutationString; i++) {
                startPoint += str.charAt(0);
            }
        }
        counter = -45;
    }
    if (prefix.length() == lengthOfPermutationString) {
        boolean savethis = true;

        for (int i = 0; i < prefix.length(); i++) {
            savethis = this.saveThis(prefix, prefix.charAt(i), 13);
            if (!savethis) {
                break;
            }
        }
        if (savethis && seen) {
            System.out.println(prefix);
            //permutation.add(prefix);
        }

    } else {
        for (int i = 0; i < str.length(); i++) {
            if (permutation.size() == 1000) {
                FileClass.WriteFile("new.txt", permutation);
                permutation.clear();
            }

            permutation(str, prefix + str.charAt(i), lengthOfPermutationString, filename, startPoint);
        }
        FileClass.WriteFile("new.txt", permutation);
        permutation.clear();

      }
  }
 }

=========================================================================

public class FileClass {

public static boolean WriteFile(String filename, List<String> doc) {

    try {
        if (!filename.contains(".txt")) {
            filename += ".txt";
        }

        RandomAccessFile raf = new RandomAccessFile(filename, "rw");
        String writer = "";

        writer = doc.stream().map((string) -> string + "\n").reduce(writer, String::concat);
        raf.seek(raf.length());
        raf.writeBytes(writer);
        raf.close();
    } catch (Exception e) {
        System.out.println(e.getMessage());
        System.out.println("Error");
        new Scanner(System.in).nextLine();

        return false;
    }

    return true;
}
static RandomAccessFile raf;
public static boolean fileExist(String filename, boolean delete){
    File file = new File(filename);
    if (file.exists() && delete)
    {
        return file.delete();
    }
    return file.exists();
}
public static void WriteFile(String filename, String text) {

    try {
        if (!filename.contains(".txt")) {
            filename += ".txt";
        }

        raf = new RandomAccessFile(filename, "rw");
        long length = raf.length();
        raf.setLength(length + 1);
        raf.seek(raf.length());
        raf.writeBytes(text + "\n");

    } catch (Exception e) {
    }

}

private static void write(List<String> records, Writer writer) throws IOException {
    for (String record : records) {
        writer.write(record);
    }
    writer.flush();
    writer.close();

}

public static void stringWriter(List<String> records, String filename) {

    try {
        File file = new File(filename);
        FileWriter writer = new FileWriter(file, true);
        write(records, writer);
    } catch (Exception ex) {
        System.out.println(ex.getMessage());
        new Scanner(System.in).nextLine();
    }
}

public static boolean CloseFile() {
    try {
        raf.close();
        return true;
    } catch (Exception e) {
        return false;
    }
  }
 }

Answer 1

In order to add a "Resume" mechanism, you need to make your program idempotent. One way to do it, is instead of saving the permutations - save to file the parameters that are sent to permutation on each iteration:

now each time that the program starts, it will check what were the last parameters that permutation was called with (the last line in the file), and start from there (when the program starts on the first time, nothing will be written in the file - so it will start from the beginning).

After that the recursion finished, we can call another method that will go over the lines of the file, and read only the permutations (ignoring the other parameters) and write them into a cleaner "final_result.txt" file.

Needless to say that this implementation is more costly (all the additional reads and write from disc) but that's the tradeoff for having it support "resume" operation.

Answer 2

To save/restore process in the middle of its work, you need something we can call a "state" and implement generating combinations in iterative way. In my implementation the "state" is pos object (I assume set and k will not change on "resume").

My implementation of the problem would be following:

public class RepeatComb {
    private int[] pos;
    private String set;
    public RepeatComb(String set, int k) {
        this.set = set;
        pos = new int[k];
    }
    public int[] getState() {return Arrays.copyOf(pos, pos.length);}
    public void resume(int[] a) {pos = Arrays.copyOf(a,a.length);}
    public boolean next() {
        int i = pos.length-1;
        for (int maxpos = set.length()-1; pos[i] >= maxpos; ) {
            if (i==0) return false;
            --i;
        }
        ++pos[i];
        while (++i < pos.length) pos[i]=0;
        return true;
    }
    public String getCur() {
        StringBuilder s = new StringBuilder(pos.length);
        for (int i=0; i < pos.length; ++i)
            s.append(set.charAt(pos[i]));
        return s.toString();
    }

    public static void main(String[] args) {
        int[] state;
        String text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        RepeatComb comb = new RepeatComb(text, 3);
        int stop = 10; //break after 10
        do {
            if (stop-- == 0) break;
            System.out.println(comb.getCur());
        } while (comb.next());
        //save state
        state = comb.getState();
        System.out.println("---------");

        //resume (with the same args: text,3)
        stop = 10; //break after 10
        comb = new RepeatComb(text, 3);
        comb.resume(state); // resume here
        do {
            if (stop-- == 0) break;
            System.out.println(comb.getCur());
        } while (comb.next());
    }
}

Update: I've added functions for getting state and resuming from it and example of use. state array can be saved in file, then restored.