Cómo escribir un algoritmo para continuar esta secuencia: x, y, xx, xy, yx, yy, xxx

Una posible solución es implementar una cola.
Empuje los caracteres a – z – 1 – 0 en el orden en que desea que aparezca en el resultado final; a la cola
Entonces la cola inicial tiene, [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v , w, x, z, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
Ahora, en cada movimiento, elija la cadena superior de la cola, sáquela, agregue todos los caracteres uno por uno en el orden hasta el final y finalmente empuje eso al final de la cola.
Entonces cuando tienes ‘a’. Empujas ‘a’ + ‘a’ = ‘aa’ a la cola, luego ‘ab’, ‘ac’ ….. ‘a0’ de la misma manera.

Un código C ++ no probado:
vacío hacer algo ()
{
cola Q;
string alphabet = “abcde… .567890”;
for (int i = 0; i Q.push (alfabeto [i]); // puedes omitir esta inicialización con alguna bandera más o menos.
}
while (! Q.empty ()) {// tenga en cuenta poner alguna restricción, de lo contrario se ejecutará antes de que se aplaste.
cadena str = Q.front ();
Q.pop ();
cout << str << endl;
for (int i = 0; i Q.push (str + alfabeto [i]);
}
}
}

Espero que esta solución funcione 🙂

La siguiente función de Haskell generará la secuencia infinita de cadenas de un alfabeto:

import Control.Applicative allStrings alphabet = strings
where
strings = [] : (strings <**> prepends)
prepends = map (:) alphabet


import Control.Applicative allStrings alphabet = strings
where
strings = [] : (strings <**> prepends)
prepends = map (:) alphabet
Hay algunas cosas a tener en cuenta:
1) el primer elemento de la secuencia es la cadena vacía
2) el orden de las cadenas no es el que sugirió
3) la secuencia es infinita, por lo que no puede consumirlo todo, debe usar algo como tomar para decidir cuántos elementos desea usar / imprimir.
4) el código es polimórfico, por lo tanto, no está restringido a cadenas de caracteres.

Aquí hay algunos ejemplos de uso de la respuesta interactiva (ghci):

* Principal> tomar 15 (allStrings “xy”)
[“”, “x”, “y”, “xx”, “yx”, “xy”, “yy”, “xxx”, “yxx”, “xyx”, “yyx”, “xxy”, “yxy “,” xyy “,” aaa “]
* Principal> tomar 50 (allStrings “0123456789”)
[“”, “0”, “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “00”, “10 “,” 20 “,” 30 “,” 40 “,” 50 “,” 60 “,” 70 “,” 80 “,” 90 “,” 01 “,” 11 “,” 21 “,” 31 “, “41”, “51”, “61”, “71”, “81”, “91”, “02”, “12”, “22”, “32”, “42”, “52”, “62 “,” 72 “,” 82 “,” 92 “,” 03 “,” 13 “,” 23 “,” 33 “,” 43 “,” 53 “,” 63 “,” 73 “,” 83 “]
* Principal> tomar 20 (allStrings [1,2,3])
[[], [1], [2], [3], [1,1], [2,1], [3,1], [1,2], [2,2], [3,2 ], [1,3], [2,3], [3,3], [1,1,1], [2,1,1], [3,1,1], [1,2,1 ], [2,2,1], [3,2,1], [1,3,1]]
* Principal> tomar 15 (allStrings [True, False])
[[], [True], [False], [True, True], [False, True], [True, False], [False, False], [True, True, True], [False, True, True ], [Verdadero, Falso, Verdadero], [Falso, Falso, Verdadero], [Verdadero, Verdadero, Falso], [Falso, Verdadero, Falso], [Verdadero, Falso, Falso], [Falso, Falso, Falso]]

Algunas observaciones básicas
1) No. de observaciones de una longitud particular (l) = 2 ^ l
2) Para obtener observaciones con longitud (l + 1), primero agregue x antes de todas las observaciones con longitud (l) y luego agregue y antes de todas las observaciones con longitud (l) por ejemplo, las observaciones con longitud 1 son x & y. Entonces, las observaciones con longitud 2 son x + x, x + y, y + x, y + y donde + denota la concentración