Trabajo de Anlisis de Algoritmo

-Permutacin
package combi5; // Se utiliza esta clase cuando se requiere que limite de //almacenamiento sea mayor a utilizar datos muy grandes import java.math.BigInteger; public class permutaciones { private int[] a; private BigInteger numLeft; private BigInteger total; public permutaciones(int n) { if (n < 1) { // Este algoritmo solo admite que el numero de caracteres sea mayores que 1 throw new IllegalArgumentException("Min 1"); // } a = new int[n]; total = getFactorial(n); // Entra la cantidad de elementos y calccula la permutacion del numero; reset(); // se llama a la funcion reset que inicializa el el vector de 1 hasta su largo } public void reset() { // metodo reset que se explico anteriormente for (int i = 0; i < a.length; i++) { a[i] = i; } numLeft = new BigInteger(total.toString()); } // Retorna todas las permutaciones que no han sido generadas aun public BigInteger getNumLeft() { return numLeft; } // Retorna el numero total de las permutaciones public BigInteger getTotal() { return total; } // Consulta si ahi mas permutaciones que realizar public boolean hasMore() { return numLeft.compareTo(BigInteger.ZERO) == 1; } // Funcion que entrega el valor de computo de un factorial private static BigInteger getFactorial(int n) { BigInteger fact = BigInteger.ONE; for (int i = n; i > 1; i--) { fact = fact.multiply(new BigInteger(Integer.toString(i))); } return fact; } ///algoritmo de Rosen public int[] getNext() { if (numLeft.equals(total)) { numLeft = numLeft.subtract(BigInteger.ONE); return a; } int temp; // Encuentra el indice mas grande j con a[j] < a[j+1] int j = a.length - 2; while (a[j] > a[j + 1]) { j--; } // Encontrar ndice k de manera que una[k] es el entero menor // Mayor que un [j] a la derecha de un[j] int k = a.length - 1; while (a[j] > a[k]) { k--; } //Intercambio un[j] y un [k] temp = a[k];

a[k] = a[j]; a[j] = temp; //Ponga extremo de la cola de permutacin despus de la posicin j en orden creciente int r = a.length - 1; int s = j + 1; while (r > s) { temp = a[s]; a[s] = a[r]; a[r] = temp; r--; s++; } numLeft = numLeft.subtract(BigInteger.ONE); return a; } }

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;

Combinatoria
package combinatoria; import java.util.*; public class Combinatoria { public static void main(String[] args) { List<String> aa = new ArrayList<>(); for (int i = 1; i < 46; i++) { aa.add("" + i); } combinar(aa, 6); } 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;

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 dnde 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 tamao de result va a ser el valor menor entre actualSize y el tamao de s indices = new int[result.length]; for (int i = 0; i < result.length; i++) { indices[i] = result.length - 2 - i; } } @Override 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 {

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

result[curIndex] = arrayList[indices[curIndex]]; } if (curIndex < indices.length - 1) { curIndex++; } else { elem = new LinkedList<>(); elem.addAll(Arrays.asList(result)); } } } if (elem == null) { if (actualSize < maxresult) { actualSize++;