Scribd
Cargar
284 vistas3 páginas

Combinatoria Sin Repetir en Java

Este documento describe un programa Java que genera combinaciones de elementos tomados de una lista. Primero crea una lista con números del 1 al 45 y define una función para generar combinaciones de 6 elementos de la lista. Luego implementa un iterador para recorrer todas las combinaciones posibles y las imprime por pantalla junto con la fecha de inicio y finalización del proceso.

Cargado por

Carlos Villamizar
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
284 vistas3 páginas

Combinatoria Sin Repetir en Java

Este documento describe un programa Java que genera combinaciones de elementos tomados de una lista. Primero crea una lista con números del 1 al 45 y define una función para generar combinaciones de 6 elementos de la lista. Luego implementa un iterador para recorrer todas las combinaciones posibles y las imprime por pantalla junto con la fecha de inicio y finalización del proceso.

Cargado por

Carlos Villamizar
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 3

import java.util.

ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
*
* @author jarivera
*/

public class baMain {

public static void main(String[] args) {


List<String> aa = new ArrayList<String>();

for (int i = 1; i < 46; i++) {


aa.add("" + i);
}

combinar(aa, 6);
}

/**
* Realiza el Proceso de Combinatoria
*
* @param a lista de objetos a combinar
* @param m cantidad de posiciones
*/
public static void combinar(List<String> a, int m) {

IteradorCombinacion it = new IteradorCombinacion(a, m);


Iterator s = it.iterator();

System.out.println("Iniciado " + new Date().toLocaleString());

int contador = 1;
List t;
while (s.hasNext()) {
t = ((List) (s.next()));
System.out.print("" + contador + "," + t.get(5).toString() +
"," + t.get(4).toString() + "," + t.get(3).toString() + "," +
t.get(2).toString() + "," + t.get(1).toString() + "," +
t.get(0).toString() + "\n");
contador++;
}
System.out.println("FInalizado " + new Date().toLocaleString());
}
}

class IteradorCombinacion implements Iterable<List<String>> {

private List<String> lista;


private Integer k;

public IteradorCombinacion(List<String> s, Integer k) {


lista = s;
this.k = k;
}

@Override
public Iterator<List<String>> iterator() {
return new IteradorCombn(lista, k);
}

private class IteradorCombn implements Iterator<List<String>> {

private int actualSize, maxresult;


private Integer curIndex;
private String[] result;
private int[] indices;
private String[] arrayList;
private List<String> elem = null;

public IteradorCombn(List<String> s, Integer k) {


actualSize = k;// desde dónde
curIndex = 0;
maxresult = k;
arrayList = new String[s.size()];
for (int i = 0; i < arrayList.length; i++) { // la lista s la
vuelca en arrayList
arrayList[i] = s.get(i);
}
this.result = new String[actualSize < s.size() ? actualSize :
s.size()];
//el tamaño de result va a ser el valor menor entre
actualSize y el tamaño de s
indices = new int[result.length];

for (int i = 0; i < result.length; i++) {


indices[i] = result.length - 2 - i;
}
}

public boolean hasNext() {


elem = null;
while ((elem == null && curIndex != -1)) {

indices[curIndex]++;
if (indices[curIndex] == (curIndex == 0 ?
arrayList.length : indices[curIndex - 1])) {

indices[curIndex] = indices.length - curIndex - 2;


curIndex--;
} else {

result[curIndex] = arrayList[indices[curIndex]];

if (curIndex < indices.length - 1) {


curIndex++;
} else {
elem = new LinkedList<String>();
for (String s : result) {
elem.add(s);

}
}
}
}

if (elem == null) {
if (actualSize < maxresult) {
actualSize++;
this.result = new String[actualSize <
arrayList.length ? actualSize : arrayList.length];
indices = new int[result.length];

for (int i = 0; i < result.length; i++) {

indices[i] = result.length - 2 - i;
}
curIndex = 0;

return this.hasNext();
} else {
return false;
}
} else {
return true;
}
}

@Override
public List<String> next() {
return elem;
}

@Override
public void remove() {
}
}
}

También podría gustarte