Aquí tienen 5 retos y la oportunidad de ayudarme.

[Tachikomaia]

Reto 1:
Genera una lista así:
1
2
3
4
5
6
1 1
1 2
1 3
1 4
1 5
1 6
2 1
etc
Es como contar pero sólo se usan los números del 1 al 6 y además van separados.


Reto 2:
Genera una lista así:
1
2
3 4
3
3 5
6 7 8
4
3 6
6 7 9
10 11 12 13
etc
La 1era combinación está compuesta de 1 número.
Luego hay otra de 1 número y otra de 2.
Luego otra de 1, de 2, y de 3.
Luego 1, 2, 3, 4.
etc.
En cuanto qué números van en cada una, depende de si el largo de la combinación ya existía o no. Si existía, simplemente se le suma 1 al número final. Si no existía, el 1er número será el mayor que se haya alcanzado hasta ahora, +1.


Reto 3:
Genera una lista así:
1
2
3 4
3
3 5
6 1 2
4
3 6
6 1 3
4 5 6 1
etc
Es como la anterior pero los números van del 1 al 6. Cuando alguno se pasa de 6 vuelve a 1. El considerado máximo número es el último de la combinación que tenga más largo (y se modifica también cuando se está creando una combinación más larga, claro).


Reto 4:
Genera una lista como la anterior pero en la que luego de hacer una combinacion con el método "clásico" (como la lista anterior) se pregunte al usuario si quiere una de un largo aún no alcanzado (método "creativo"). Ej:
1
¿Creativo? Sí. 2 3
2
¿Creativo? No.
2 4
¿Creativo? No.
3
¿Creativo? Sí. 5 6 1.
2 5
etc
El máximo largo del proceso clásico no aumenta porque se creen mayores largos con el proceso creativo, pero si están creados el proceso clásico usa sus números en vez de crearlos.


Reto 5:
Genera una lista como la anterior pero en la cual el máximo de números sea 100 y en los momentos de crear una combinación de nuevo largo no se use el máximo+1 sino... no sé explicarlo pero básicamente el más alejado considerando todos los usados y considerando que forman un circulo (1 está luego de 100, el más alejado de 1 es 50 aproximadamente). Ejemplo aproximado:
1
¿Creativo? Sí. 50 51
2
¿Creativo? Sí. 25 26
25 27
¿Creativo? Sí. 75 76 77
etc
O sea, inicialmente se usa 1 como siempre. Luego lo que esté en medio de 2 y 100, que aproximadamente es 50. Luego 2, clásico. Luego, si se pide creativo o cuando haya que crear, se usa de 3 a 49, o sino de 52 a 100, lo que tenga más cantidad de números. Así sucesivamente. La cantidad de "fragmentos" va aumentando, o sea, 1ero tenemos de 2 a 100. Luego aproximadamente de 2 a 49 y de 51 a 100. Luego de un par de veces tendremos aproximadamente de 1 a 24, de 26 a 49, de 51 a 74, y de 76 a 100.


Yo estoy haciendo algo un poquitito más complicado que el 4. Tengo otro tema creado al respecto, en esta misma sección. Ver cómo harían estas cosas uds me ayudaría. Gracias.

[Baphomet2204]

El primero lo hice en Java, muy rápido y se puede eficientizar mas pero por ahora lo deje así

Código [Seleccionar] Expandir


package contador;

public class Contador
{
    public static void main(String[] args)
    {
        int i,j;
        for(i=1;i<=6;i++)
        {
            System.out.println(i);
        }
        for(i=1;i<=6;i++)
        {
            for(j=1;j<=6;j++)
            {
                System.out.println(i+" "+j);
            }
        }
    }   
}


[Tachikomaia]

Nunca entendí cómo se lee for. A ver:

Código [Seleccionar] Expandir

       for(i=1;i<=6;i++)
        {
            System.out.println(i);
        }
"Para/por i que es 1, mientras sea menor que 6: Sumarle 1 y mostrar i en pantalla."
¿Es como esto?

Código [Seleccionar] Expandir

i = 1
si i<=6
   mostrar i en pantalla
   i++
repetir Eso muestra los números del 1 al 6, bien.

Luego dices:

Código [Seleccionar] Expandir

        for(i=1;i<=6;i++)
        {
            for(j=1;j<=6;j++)
            {
                System.out.println(i+" "+j);
            }
        }
Bien creo, eso muestra todos los números del 1 1 al 6 6.

Está bien, pero la idea era que muestre números hasta que el usuario lo detenga (dije "etc", pensé que se entendería), o sea, luego de 6 6 debe venir 1 1 1, luego 1 1 2, y así sucesivamente hasta que llega al 6 6 6 y luego pasa a 1 1 1 1 y así sucesivamente. Supongo que se entiende.

Yo lo haría así:
La parte1 es 1.
La combinación tiene 1 parte (partes=1).
El cursor está en la última parte, o sea 1 (cursor=partes).
Si la parte indicada por el cursor es < 6,
   aumentarla 1, concatenar las partes, mostrar eso en pantalla, y volver a "El cursor...".
Sino
   La parte indicada por el cursor es 1
   Si el cursor es mayor que 1,
      bajarlo 1 y volver "Si la parte...".
   sino
      La parte nro (cursor) es 1.
      Crear otra parte (partes+1), que sea 1.
      partes++
      Concatenar las partes y mostrar eso en pantalla
      Ir a "El cursor está..."

La concatenación la haría con un do while.

Código [Seleccionar] Expandir

En otras palabras:
Etapa 1:
La parte1 es 1.
La combinación tiene 1 parte (partes=1).
Etapa 2:
Poner el cursor en la última parte (partes)
Etapa 3:
Si la parte indicada por el cursor es aumentable,
   aumentarla, concatenar las partes, mostrar eso en pantalla, y volver a la etapa 2.
Etapa 4:
La parte indicada por el cursor es 1
Si el cursor puede bajar,
   bajarlo 1 y volver a la etapa 3
Etapa 5:
   Resetear la parte que indica el cursor.
   Crear parte (partes+1), que sea 1.
   Partes++
   Concatenar las partes y mostrar eso en pantalla
   Ir a etapa 2

Estaría bueno hacer una tabla o un gif o algo que vaya mostrando cómo se va ejecutando el código, porque por más que lo escriba de 3 formas distintas (aunque sin mucho esfuerzo), me cuesta entenderlo. De hecho no estoy seguro de que funcione (como comenté estoy con otra cosa, no tengo ganas de andar probando esto).

[Serapis]

Tu dí lo que quieras, pero no puedes poner un "etc..." como dando a entender que continúa sin fin. Hay que ser discreto, porque el tamaño de la memoria es discreto lo mismo que el tamaño en los discos.

Luego procede... esto es, es obligado señalar un punto final. Un límite razonablemente práctico. Luego...  al implementarlo cada uno puede modificarlo a su antojo y necesidades, haciendo los cambios que procedan derivados de las circunstancias.

No sé si te tomaste la molestia de leer el hilo al que te derivé... pero bueno, tu problema 1 te lo resumo, fácilmente en 3-4 funciones... Si resulta que fueras incapaz de entender y aplicar esto, no vale lapena seguir dando más explicaciones, aparte que tras esto, será conveniente que reescribas el resto, porque sigue sin entenderse adónde quieres llegar.


- SizeAlfabeto: Cantidad de caracteres distintos que entran en juego, en tu caso 1-6, luego =6
- Largo: Cómode largo han de ser las permutaciones, si 1, solo genera 1,2,3,4,5,6, si 2, genera desde 11 hasta 66, si 8 genera desde 11111111 hasta 66666666
- Evidentemente si pones valores grandes podría desbordar, así que usa el tipo de datos adecuado...
Esta función calcula el número de permutaciones para el caso específico que se invoque.
La llama la función bajo esta...

Código [Seleccionar] Expandir

entero = funcion NumPermutaciones(byte SizeAlfabeto, byte Largo)
   entero j, k

   j = 1
   bucle para k desde 1 hasta Largo
       j = (j * Sizealfabeto)
   siguiente en bucle

   devolver j
fin funcion

Ahora generamos las permutaciones para dicho alfabeto:

Código [Seleccionar] Expandir

funcion Permutar(String Alfabeto, byte LargoPalabra)
   entero i, j, k
   string palabra
   entero SizeAlfabeto = Alfabeto.Length  // vamos, la cantidad de caracteres del string,

   i= NumPermutaciones(sizealfabeto, LargoPalabra)

   bucle para k desde 0 hasta i-1
       palabra = PermutacionKaesima(Alfabeto, LargoPalabra, k)
       imprimir palabra
   siguiente en bucle
fin funcion

Ahora obtenemos la permutación enésima ordenada, aplicando el alfabeto de entrada.
Esta función puede en realidad ponerse como un bucle interno en el lugar desde donde se la llama. Sería más eficiente, pero lo dejo así por claridad...

Código [Seleccionar] Expandir


string = Funcion PermutacionKaesima(string Alfabeto, byte LargoP, entero Permutacion)
   entero  k    
   entero SizeAlfa = Alfabeto.Length  // vamos, la cantidad de caracteres del string,
   string Permuta = espacios(LargoP)  // esto es creamos una cadena de texto del largo del alfabeto.
   byte j
   char c

   Bucle para k desde 0 hata LargoP-1
      j = (permutacion modulo Sizealfa)   //modulo es el resto de una división. Algo que tú horrorosamente llamas
                                                          // 'resetearse' y te cito: ("Si le aumentamos 1 a 9, queda en 0, eso es resetearse."
      c = alfabeto.Getchar(j)  // Esto es, obtener el carácter en la posición 'j' del alfabeto que se quiere usar.
                                        // Alfabeto: en tu caso, creo que sería = "123456", o quizás "654321", o quizás "012345", o los caracteres que se te antojen...
      permuta.SetChar( c, k)  // esto es, colocar el carácter 'c' en la posición 'k' del string permuta... Cada lenguaje tiene su propia función para el caso....
                                       // también puede usarse un array de chars, y al devolverlo convertirlo en string... etc, etc...
                                       // Igualmente el alfabeto puede ser un array de chars, se gana en velocidad usando arrays...
      permutacion = (permutacion \ sizealfa)  // es una división entera, si el lenguaje usado no tiene un operador, habrá que usar división y luego una función que elimine los decimales.
   Siguiente en bucle
   
   devolver Permuta
Fin funcion


El código para usar las funciones, vendría a ser:

Código [Seleccionar] Expandir


Funcion Main
   string Alfabeto = "654321"
   byte SizeAlFa = Alfabeto.Size // .Length, etc...
   byte LargoPalabrasAGenerar = 6   // esto es por ejemplo: "555436"  = 6 caracteres.

   entero k  
   string SubAlfa =""
   // como no quieres generar una sola lista sino  diferentes listas cada una con su largo, este  bucle es preciso, si no sería suficiente la última iteración...
   bucle para k desde 1 hasta  LargoPalabrasAGenerar
       imprimir "Permutaciones para un largo de " + k + " símbolos/caracteres de largo, con el alfabeto: " + Alfabeto   //simbolos=caracteres
       SubAlfa = Alfabeto.Substring(0, k)  // Esto es, toma los 'k' caracteres de la izquierda del string 'Alfabeto'...
       Permutar(subAlfa, k)
   siguiente en bucle  
   
   imprimeir "Fin de todas las permutaciones:"
Fin funcion


En realidad todo el código de estas 4 funciones es mucho más breve, la 'verbosidad' añadida para dejar claridad, es lo que lo abulta, solo porque comparten la misma ventana... y conviene para dejar el comentario oportuno, en el sitio requerido.

...Y tendrías las salidas, siguientes... las meto en una cita, para que se vea más claro... losp untos suspensivos, imagino que sabrás entenderlos como que ahí encajan todas las que no comparecen entre la secuencia previa y posterior...

Para el primer ciclo:
Permutaciones para un largo de 1 símbolos/caracteres de largo, con el alfabeto: 123456"
1
2
3
4
5
6

Para el 2º ciclo:
Permutaciones para un largo de 2 símbolos/caracteres de largo, con el alfabeto: 123456"
11
12
13
...
21
22
23
...
...
...
64
65
65

............................
............................
............................


Para el 6º ciclo:
Permutaciones para un largo de 6 símbolos/caracteres de largo, con el alfabeto: 123456"
111111
111112
111113
...
111116
....
611111
611112
611113
...
611116
...
...
...
666664
666665
666666
Fin de todas las permutaciones:

El pecado de esto, es que como cuento al hilo al que te derivé, es el algoritmo más sencillo de implementar para mostrar todas las permutaciones posibles dados un alfabeto específico, y de una 'palabra' de salida de largo específico... pero no es el algoritmo más óptimo cara a la velocidad. Pero si no lo entiendes allí, tendrás que apañarte con esto...
Otro pecado, es en realidad te basta ejecutar el ´último ciclo, el de 6, pués todos los anteriores se entienden subsumidos en el siguyiente. Esto es... 'todas la permutaciones de 4 elementos', existen en 'todas las permutaciones de 5 elementos', y todas las permutaciones de 5 elementos', existen en 'todas las permutaciones de 6 elementos'.
Y es fácil entenderlo, pués el número 1, 2, 3 , 4 ,5 ,6  son lo mismo que 00º1, 002, 003, 004, 004, 006 si la cuenta la llevas hasta el 999... pero allá tú...

[Tachikomaia]

Tu dí lo que quieras, pero no puedes poner un "etc..." como dando a entender que continúa sin fin. Hay que ser discreto, porque el tamaño de la memoria es discreto lo mismo que el tamaño en los discos.

Vale, pero en estos casos nunca tuve necesidad de poner un límite.

Digamos que el límite es largo 30.

No sé si te tomaste la molestia de leer el hilo al que te derivé...

No le vi suficiente relación y me pareció muy largo.

aparte que tras esto, será conveniente que reescribas el resto, porque sigue sin entenderse adónde quieres llegar.

¿No entiendes el por qué planteo los retos o no entiendes alguno de ellos? Si por el final, te acabo de decir uno como pediste: Largo 30.

Esta función calcula el número de permutaciones para el caso específico que se invoque.
La llama la función bajo esta...

Código [Seleccionar] Expandir

entero = funcion NumPermutaciones(byte SizeAlfabeto, byte Largo)
   entero j, k

   j = 1
   bucle para k desde 1 hasta Largo
       j = (j * Sizealfabeto)
   siguiente en bucle

   devolver j
fin funcion

¿k es Largo? ¿el cálculo no es alfabeto^Largo? Por ejemplo si alfabeto fuese 4 y lago 3:
111
112
113
114
121
122
123
124
131
132
133
134
141
142
143
144
Y eso (16) se multiplica por 4.
Es lo mismo que 4*4*4, o 4^3. Pareces calcularlo de otro modo, no entiendo.

Bueno otro día continuaré intentando entender pero la verdad me cuesta mucho entender las funciones, estoy acostumbrado a flujos.

Ahora generamos las permutaciones para dicho alfabeto:

Código [Seleccionar] Expandir

funcion Permutar(String Alfabeto, byte LargoPalabra)
   entero i, j, k
   string palabra
   entero SizeAlfabeto = Alfabeto.Length  // vamos, la cantidad de caracteres del string,

   i= NumPermutaciones(sizealfabeto, LargoPalabra)

   bucle para k desde 0 hasta i-1
       palabra = PermutacionKaesima(Alfabeto, LargoPalabra, k)
       imprimir palabra
   siguiente en bucle
fin funcion Calculas el nro de permutaciones.
Comienzas un bucle.
Llamas a una función que aún no has definido (o sea no entiendo cómo uds leen esto, van más adelante en el texto, y luego vuelven, y luego se saltean lo antes leído que está después).
Creo que entendí lo que puede entenderse, lo que no no está explicado/definido aún.

Ahora obtenemos la permutación enésima ordenada, aplicando el alfabeto de entrada.

¿Qué es eso de "enésima ordenada"? ¿es lo que antes llamaste Kaesima? Pero no entiendo lo de ordenada. Es la última del Largo ¿no?

Esta función puede en realidad ponerse como un bucle interno en el lugar desde donde se la llama. Sería más eficiente, pero lo dejo así por claridad...

Para mí creo que sería más claro si estaba definida antes xD

j = (permutacion modulo Sizealfa)   //modulo es el resto de una división. Algo que tú horrorosamente llamas
                                                          // 'resetearse' y te cito: ("Si le aumentamos 1 a 9, queda en 0, eso es resetearse."

Bien por aclararme lo de modulo ¿"permutacion" es algo nuevo, definido como k también?

En cuanto a lo que me citas, recordaba haberlo escrito pero no el contexto, eso de 0 no me sonaba, olvidé que había hecho eso, está en otro tema, me autocito:

Código [Seleccionar] Expandir

actions for fotograma 4
      // El char no es aumentable, ergo Se resetea.
      set ("Char"+Cursor, 0);
      if (0<Cursor) {
         // Si Cursor puede bajar, baja.
         Cursor = Cursor-1;
      } else {
         // Sino (el cursor no puede bajar), se agrega un char.
         set ("Char"+Chars, 0);
         Chars = Chars+1;
         Concatenarytrace();
         gotoAndPlay (2);
      }
"Si le aumentamos 1 a 9, queda en 0, eso es resetearse." (...)

Yo ahí no estoy calculando el resto de una división (tampoco en la función que se llama), quizá te has confundido. Y resetearse significa volver al valor común, inicial, no sé qué tiene de malo esa expresión.

Código [Seleccionar] Expandir


string = Funcion PermutacionKaesima(string Alfabeto, byte LargoP, entero Permutacion)
   entero  k    
   entero SizeAlfa = Alfabeto.Length  // vamos, la cantidad de caracteres del string,
   string Permuta = espacios(LargoP)  // esto es creamos una cadena de texto del largo del alfabeto.
   byte j
   char c

   Bucle para k desde 0 hata LargoP-1
      j = (permutacion modulo Sizealfa)   //modulo es el resto de una división. Algo que tú horrorosamente llamas
                                                          // 'resetearse' y te cito: ("Si le aumentamos 1 a 9, queda en 0, eso es resetearse."
      c = alfabeto.Getchar(j)  // Esto es, obtener el carácter en la posición 'j' del alfabeto que se quiere usar.
                                        // Alfabeto: en tu caso, creo que sería = "123456", o quizás "654321", o quizás "012345", o los caracteres que se te antojen...
      permuta.SetChar( c, k)  // esto es, colocar el carácter 'c' en la posición 'k' del string permuta... Cada lenguaje tiene su propia función para el caso....
                                       // también puede usarse un array de chars, y al devolverlo convertirlo en string... etc, etc...
                                       // Igualmente el alfabeto puede ser un array de chars, se gana en velocidad usando arrays...
      permutacion = (permutacion \ sizealfa)  // es una división entera, si el lenguaje usado no tiene un operador, habrá que usar división y luego una función que elimine los decimales.
   Siguiente en bucle
   
   devolver Permuta
Fin funcion
En el bucle obtienes el resto de dividir permutación ¿k? entre Sizealfa, o viceversa, no sé cómo se interpreta.
Obtienes un caracter usando eso. No entiendo cómo haces ¿qué es permutación? ¿cómo es que el resto de una división está relacionada siempre con el caracter que necesitas?
Colocas el caracter en la cadena permuta.
Haces una división que elimina los decimales del resultado.

Lo reeleré otro día pero ya te digo que no entendí. Considerando que esto funciona a partir de otra cosa (si mal no recuerdo), a lo mejor es por eso. Sigo.

Código [Seleccionar] Expandir

   bucle para k desde 1 hasta  LargoPalabrasAGenerar
       imprimir "Permutaciones para un largo de " + k + " símbolos/caracteres de largo, con el alfabeto: " + Alfabeto   //simbolos=caracteres
       SubAlfa = Alfabeto.Substring(0, k)  // Esto es, toma los 'k' caracteres de la izquierda del string 'Alfabeto'...
       Permutar(subAlfa, k)
   siguiente en bucle No entiendo lo de
"SubAlfa = Alfabeto.Substring(0, k)  // Esto es, toma los 'k' caracteres de la izquierda del string 'Alfabeto'..."
Por ejemplo la 1er vuelta (creo que le llaman iteración) ¿toma 1 caracter de la izquierda? 6 izquierda-derecha ¿no? Por las dudas. ...ya entendí, pero en tu impresión has definido los caracteres al revés, por eso no entendía.

Bueno, otro día releo qué hace la función Permuta.

El pecado de esto, es que como cuento al hilo al que te derivé, es el algoritmo más sencillo de implementar para mostrar todas las permutaciones posibles dados un alfabeto específico, y de una 'palabra' de salida de largo específico... pero no es el algoritmo más óptimo cara a la velocidad. Pero si no lo entiendes allí, tendrás que apañarte con esto...

No te preocupes, soy ateo, jajaja. Hablando en serio, si este el más sencillo me resulta tan complicado, el otro prefiero ni verlo, sigamos con este.

Otro pecado, es en realidad te basta ejecutar el ´último ciclo, el de 6, pués todos los anteriores se entienden subsumidos en el siguyiente. Esto es... 'todas la permutaciones de 4 elementos', existen en 'todas las permutaciones de 5 elementos', y todas las permutaciones de 5 elementos', existen en 'todas las permutaciones de 6 elementos'.

Entiendo, bastaría con mantener guardadas las permutaciones hechas y para generar un largo mayor simplemente agregarle por separado los diferentes caracteres. Pero creo que es más complicado de programar.

Y es fácil entenderlo, pués el número 1, 2, 3 , 4 ,5 ,6  son lo mismo que 00º1, 002, 003, 004, 004, 006 si la cuenta la llevas hasta el 999... pero allá tú...

Esto no lo entendí.


Lo que más me gustó (de lo que entendí) es calcular el total de permutaciones. Yo en este caso no lo necesito, porque cuando el 1er caracter es 6 y debe aumentar entonces ya se sabe que se hizo todas. Pero cuando las quiero en un orden raro, como en el Reto 2, lo que hago es grabar cómo será la última, y "predecirla" da ciertos problemas (ya estoy medio oxidado, pero creo que el principal problema que tengo es precisamente ese de "predecir"). Pero si sé cuántas permutaciones son y las voy contando, no tengo que predecir.
El pecado de eso, como tú dirías, es que se tiene una variable cambiando a cada rato, y que puede ser alto... pero yo tengo una variable más larga, de texto, dudo mucho que sea mejor.
Me va a servir tu idea, creo. La voy a probar.

Lo demás me da curiosidad de cómo lo haces, aunque bueno, ahora me voy a descansar un rato, estas cosas me cuestan.