Sé libre de compartir nuestros post y códigos en tus redes, danos de tu ayuda para aumentar esta comunidad.
Solución:
La palabra clave a buscar es permutación. Hay una gran cantidad de código fuente disponible gratuitamente que los realiza.
En cuanto a mantenerlo libre de repeticiones, sugiero un enfoque recursivo simple: para cada dígito, tiene la opción de incluirlo en su variación o no, por lo que su recursión cuenta a través de los dígitos y se bifurca en dos llamadas recursivas, una en la que se incluye el dígito , aquella en la que se excluye. Luego, después de llegar al último dígito, cada recursión esencialmente le brinda una lista (única, ordenada) de dígitos sin repetición. Luego puede crear todas las permutaciones posibles de esta lista y combinar todas esas permutaciones para lograr su resultado final.
(Lo mismo que dijo duffymo: no proporcionaré código para eso)
Nota avanzada: la recurrencia se basa en 0/1 (exclusión, inclusión) que se puede traducir directamente a bits, por lo tanto, a números enteros. Por lo tanto, para obtener todas las combinaciones de dígitos posibles sin realizar la recursión en sí, simplemente puede usar todos los números enteros de 10 bits e iterar a través de ellos. Luego interprete los números de tal manera que un bit establecido corresponda a incluir el dígito en la lista que necesita ser permutado.
Aquí está mi código Java. Siéntete libre de preguntar si no entiendes. El punto principal aquí es:
- ordenar de nuevo el personaje array. por ejemplo: a1 a2 a3 b1 b2 b3 …. (a1 = a2 = a3)
- generar permutación y mantener siempre la condición: índice de a1 <índice de a2 <índice de a3...
import java.util.Arrays;
public class PermutationDup
public void permutation(String s)
char[] original = s.toCharArray();
Arrays.sort(original);
char[] clone = new char[s.length()];
boolean[] mark = new boolean[s.length()];
Arrays.fill(mark, false);
permute(original, clone, mark, 0, s.length());
private void permute(char[] original, char[] clone, boolean[] mark, int length, int n)
if (length == n)
System.out.println(clone);
return;
for (int i = 0; i < n; i++)
if (mark[i] == true) continue;
// dont use this state. to keep order of duplicate character
if (i > 0 && original[i] == original[i-1] && mark[i-1] == false) continue;
mark[i] = true;
clone[length] = original[i];
permute(original, clone, mark, length+1, n);
mark[i] = false;
public static void main(String[] args)
PermutationDup p = new PermutationDup();
p.permutation("abcab");
Creé el siguiente código para generar permutaciones donde el orden es importante y sin repetición. Hace uso de genéricos para permutar cualquier tipo de objeto:
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class Permutations
public static Collection> generatePermutationsNoRepetition(Set availableNumbers)
Collection> permutations = new HashSet<>();
for (T number : availableNumbers)
Set numbers = new HashSet<>(availableNumbers);
numbers.remove(number);
if (!numbers.isEmpty())
Collection> childPermutations = generatePermutationsNoRepetition(numbers);
for (List childPermutation : childPermutations)
List permutation = new ArrayList<>();
permutation.add(number);
permutation.addAll(childPermutation);
permutations.add(permutation);
else
List permutation = new ArrayList<>();
permutation.add(number);
permutations.add(permutation);
return permutations;