Java非重复序列算法

Question

Hey everyone So I am making an application that with loop through an array of 1625 words & create a 12 word string. The problem is that a single word can't show up twice in the string.

(Numbered) ex.  
0, 1, 2,  3, 4, 5, 6, 7, 8, 9, 10, 11  
0, 1, 2,  3, 4, 5, 6, 7, 8, 9, 10, 12  
0, 1, 2,  3, 4, 5, 6, 7, 8, 9, 10, ...  
0, 1, 2,  3, 4, 5, 6, 7, 8, 9, 10, 1625  
then   
0, 1, 2,  3, 4, 5, 6, 7, 8, 9, 11, 10  
0, 1, 2,  3, 4, 5, 6, 7, 8, 9, 11, 12  
0, 1, 2,  3, 4, 5, 6, 7, 8, 9, 11, ...  
0, 1, 2,  3, 4, 5, 6, 7, 8, 9, 11, 1625  
0, 1, 2,  3, 4, 5, 6, 7, 8, 9, ..., ...  
0, 1, 2,  3, 4, 5, 6, 7, 8, 9, 1625, 1624  
then   
0, 1, 2,  3, 4, 5, 6, 7, 8, 10, 9, 11  
0, 1, 2,  3, 4, 5, 6, 7, 8, 10, 9, 12  
0, 1, 2,  3, 4, 5, 6, 7, 8, 10, 9, ...  
0, 1, 2,  3, 4, 5, 6, 7, 8, 10, 9, 1625  
0, 1, 2,  3, 4, 5, 6, 7, 8, 10, 9, 12    
And so on......  

I am having a very hard time figuring out the math behind this algorithm as I would prefer to avoid "if" statements. If someone would be able to help me that would be great.

(Note the numbers above are the indexes in the array that holds words)

EDIT: SIMPLE OUTPUT:
0, 1, 2
0, 1, 3
0, 1, 4
0, 1, 5
0, 1, 6
0, 1, ...
0, 1, 9
0, 2, 1
0, 2, 3
0, 2, 4
0, 2, 5
0, 2, ...
0, 9, ...
0, 9, 1
0, 9, 2
0, 9, 3
0, 9, ...
1, 0, 2
1, 0, 3
1, 0, 4
1, 0, ...
1, 2, 3
And so on

Answer 1

Its not a very optional solution as I feel its brute force way of doing it.
Would this work for you? You can replace the TOTAL_SIZE variable to 1626 (as you want 1625 to get printed as well.) and CHUNK_SIZE to 12.

public class TestClass {
    static int TOTAL_SIZE = 5;
    static int CHUNK_SIZE = 3;
    static int[] wordArray = new int[TOTAL_SIZE];

    public static void main(String args[]) {
        for(int i = 0; i < TOTAL_SIZE; i++) {
            wordArray[i] = i;
        }

        List<Integer> newList = new ArrayList<>();
        int[] visitedIndexes = new int[TOTAL_SIZE];
        printAllValues(newList, visitedIndexes);
    }


    private static void printAllValues(List<Integer> newList, int[] visitedIndexes) {
        if(newList.size() == CHUNK_SIZE) {
            newList.stream().forEach(System.out::print);
            System.out.println(""); // new line
            return;
        }

        for (int i = 0; i < TOTAL_SIZE; i++) {
            if (visitedIndexes[i] != 1) {
                visitedIndexes[i] = 1;
                newList.add(wordArray[i]);
                printAllValues(newList, visitedIndexes);
                newList.remove((Integer) wordArray[i]);
                visitedIndexes[i] = 0;
            }
        }
    }
}

Output : For array size of 5 and word size of 3.

012
013
014
021
023
024
031
032
034
041
042
043
102
103
104
120
123
124
130
132
134
140
142
143
201
203
204
210
213
214
230
231
234
240
241
243
301
302
304
310
312
314
320
321
324
340
341
342
401
402
403
410
412
413
420
421
423
430
431
432

Description :

1. Take each value from the original list.
2. For each character appended, populate every combination of remaining characters.
3. Retry this logic, by removing the skipping this appended character and trying out every possible combination.

This logic can be optimized:

1. by checking up front as to how many values are left in for(int i = 0; i < TOTAL_SIZE; i++) loop and break out if there aren't enough values to go ahead (ie, if((list.size() + (TOTAL_SIZE-i)) < CHUNK_SIZE) break;

Also, for a huge data the recursion might just blow up.

Answer 2

This code can run on small set. But I am not sure how long it take in huge data in your case. Hope it help!

static int STRING_SIZE = 3; //12 in your  case
static int MAX_VAL = 10; //1625 in your case
static Set<Integer> set = new LinkedHashSet<Integer>();

public static void main(String[] args) {
    fillSet();
}

static void fillSet() {
    if (set.size() == STRING_SIZE) {
        System.out.println(set);
        return;
    }
    for (int i = 0; i < MAX_VAL; i++) {
        if (set.contains(i))
            continue;
        set.add(i);

        fillSet();

        set.remove(i);
    }

}