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() {
}
}
}