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.

Nunca entendí cómo se lee for. A ver:
"Para/por i que es 1, mientras sea menor que 6: Sumarle 1 y mostrar i en pantalla."
¿Es como esto?
Eso muestra los números del 1 al 6, bien.

Luego dices:
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.




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).

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

Digamos que el límite es largo 30.

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

¿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.

¿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:
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.

¿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?

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

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:
"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.

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.

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.

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.

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.

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.