ottieni tutta la combinazione di un dato insieme di numeri [duplicato]

-2

Sto cercando di ottenere le possibili combinazioni di un dato insieme di numeri, ad esempio 123

Le possibili combinazioni potrebbero essere

123 132 213 231 312 321

Per questo ho scritto un codice come sotto -

import java.util.ArrayList;

/* Name of the class has to be "Main" only if the class is public. */
public class Main {

/**
 * @param args the command line arguments
 */
static ArrayList list;

public static void main(String[] args) {
    // TODO code application logic here
    Main nm = new Main();
    nm.list = new ArrayList();
    /*
    for(int i=1; i<= 4; i++) {
        list.add(i);
    }

    list.remove(list.indexOf(1));

    for(int i=0; i<= 2; i++) {
        System.out.print(list.get(i));
    }
    */
    nm.test1();        
}

public void test1() {        
    for(int i=1; i<= 4; i++) {
        if(!list.contains(i)) {
            list.add(i);
            test1();
            list.remove(list.indexOf(i));
        }
    }           
    if(list.size() == 4) 
    {
        for(int i=0; i< 4; i++) {
            System.out.print(list.get(i));
        }
        System.out.println("");
    }
}

}

Fornisce l'output corretto come mostrato qui nel link

Stavo pensando se questo è l'approccio giusto o se possono esserci ottimizzazioni in modo che questo codice possa essere usato per ottenere combinazioni di numeri da 10 a 20 cifre o più.

Saluti

    
posta Pradyut Bhattacharya 27.06.2014 - 20:53
fonte

1 risposta

0

Ero dopo che la stessa cosa è arrivata alla conclusione che sono le permutazioni che volevo e questo " l'algoritmo per generare le permutazioni spiegate " ha fatto ciò che volevo. L'esempio è in Ruby ma è abbastanza facile da capire (e abbastanza semplice).

Modifica:

Dal sito web indicato sopra:

First things first, the basics: Permutations are how many times a set of items you have can be ordered. For example, there are 24 permutations of 1234: 1234, 1243, 1324, 1342, 1423, 1432, 2134, 2143, 2314, 2341, 2413, 2431, 3124, 3142, 3214, 3241, 3412, 3421, 4123, 4132, 4213, 4231, 4312, 4321. If some of the items are the same, then there are fewer permutations of sets of 4. For example, there are only 4 permutations of 1112: 1112, 1121, 1211, 2111

The algorithm to generate all of the permutations requires a way of comparing and ordering the items. The first permutation in the series is the one with all of the permutations in ascending order, for example, 12345 or ABCDE. It then uses this permutation to generate the next permutation in the series until the last one which has all of the items in descending order: 54321 or EDCBA.

In words, the algorithm goes as follows:

  1. Starting from the right hand side of the list, go backwards and find the first item which is less than the item immediately after it and let that be i. list[i] < list[i+1]. If none of the items satisfy the criteria (i.e. the whole list is in descending order, then you’ve finished).
  2. Starting from the right hand side of the list, go backwards and find the first item which is larger than item i. Mark this as j.
  3. Swap the items at i and j.
  4. Reverse the items from i+1 to the end of the list.
    
risposta data 27.06.2014 - 21:14
fonte

Leggi altre domande sui tag