Diccionario de Fuerza Bruta Tipo v2

[RJuegos]

Lo que estás haciendo no es generar sílabas en todo caso serían dígrafos.
En realidad, lo de menos es el nombre, sino la funcionalidad, y desde luegro, de ese modo no podrás inscribir sílabas muy específicas pero también muy presentes como por ejemplo las que aparecen en la palabra 'constructor', sus sílabas son 'cons-truc-tor', pero t código no generaría los digrafos 'ns' y 'tr' porque solo une silabas con consonantes y viceversa, además eso tolera ciertas construcciones que muy probablemente no se den en palabras (ciñéndonos al caso tu premisa del uso de palabras), o aunque se den su frecuencia sea realmente escasa.

En realidad tu algoritmo de sílabas debiera generar las sílabas que toleran las reglas de silabeo de la gramática española, es decir tu algoritmo debiera considerar dichas reglas e implementarlas en un algoritmo, para poder reconocerlas.
Luego generalas todas supone elegir una entre (al menos) dos estrategias...
- Alimentar el algortimo con pseudosílabas generadas a partir de un algoritmo de bucles (el anterior que te dí vale a condición de que el array contenga los caracteres a-z, y el largo vaya pasando por 1, 2, 3 ,4, 5 y 6 (en español es imposible generar sílabas más largas de 6 y cuesta encontrar ejemplos de estas, incluso de 5)). Cada pseudosílaba es una proposición que el algoritmo de silabeo demuestra si pertenece o no a la gramática española, si el resultado es favorable se añade a la lista.
En este caso, el algoritmo recibe pues un string que es una posible sílaba y el algoritmo debe demostrar si lo es o no.

- Alimentar el algoritmo con textos procedentes de obras en español.
En este caso el algoritmo lo que recibe es un texto que se compone de palabras  y el algoritmo, lo que hace es la partición silábica. Luego con cada sílaba hallada se localiza si ya se tiene almacenada, en caso negativo se añade a la lista.

Ambos algoritmos difieren muy poco. En el primero recibe un string y verifica si al completo es o no una silaba, en el segundo se recibe una palabra y va tomando caracteres formando así sílabas (saltando espacios y caracteres de puntuación cuando aparezcan), con cada una encontrada devuelve la posición alcanzada en la palabra (o devuelve la sílaba), para seguir en una nueva llamada a continuación del punto previo.
La mayor diferencia no reside en el algoritmo de silabeo (que es el mismo en ambos casos), si no en el que alimenta a dicho algoritmo.

Desde luego el algoritmo de silabeo tiene su trabajillo (no es complicado peor lleva su tiempo), primero hay que empaparse (ponerse al día y refrescar lo olvidado) de las reglas de silabeo de la gramática española (desde mis tiempos de estudiante, ignoro si alguna de estas reglas ha cambiado, como sí han ido cambiando las reglas de ortografía (las 'reglas' de cualquier índole, tienen un carácter de 'constante, en el tiempo', pero con tantos y tan frecuentes cambios, más bien dichas reglas ya, parecen 'variables, cada pocos años'))... y luego para hacerlo eficiente en velocidad lo adecuado sería diseñar el automáta para reconocer las sílabas en base a dichas reglas. Esto también puede resultar complicado si las capacidades como programador son limitadas...

...en el pseudocódigo anterior te había dejado una 'tarea' a tu esfuerzo, cuando lo vieras. Debe haber dos condiciones de salida, una cuando acaba el análisis y no se encontró nada (esa salida está), y la otra cuando la contraseña coincide que también debe acabar, que es la que omití... pero viendo tu código y leyendo tus explicaciones, entiendo que tu nivel de programación es el que es, luego ve a tu ritmo, a tu manera si no logras entender más allá.

conozco bien pascal a un nivel intermedio conociendo muy bien las cosas basicas y otras pocas cosas mas o menos complejas,
pero sigo aprendiendo, ya quiero aprender el lenguaje C pero se me hace muy pronto porque aun no llegue a ser avanzado con pascal,
para luego poder hacer lo mismo con lenguaje C, supongo que sera casi lo mismo aunque un poco mas complejo.

mi idea es hacer, teniendo una lista de silabas directas, indirectas y trabadas apartir de esas listas probar todas las combinaciones posibles y tratar de formar palabras rapidamente reduciendo combinaciones seguro que no esten como claves (ej: qlkholaz, clave que seguramente nadie pondra). Se que hay palabras que lleven ns(mo-ns-tr-uo), nd(mu-nd-os), ct(vi-ct-or-ia), rt(ma-rt-in), etc. esas se van añadir tambien porque son probables que tambien usen otras palabras.

lo que me dices es como una tecnica de aprendizaje supervisado para predecir una función a partir de datos de entrenamiento.

[RJuegos]

Despues de terminar de desarrollar el programa para generar diccionario, dejare de publicar diccionario y traere el programa, me voy a poner mas tiempo a desarrollar el programa mejor.

Diccionario FB v2 (claves be 20303346)

Por Mega Link : https://mega.nz/folder/DNg2GaLR#hxFt7sm6ipl2wYj--ipBsg

Tamaño real: 176MB
Tamaño Comprimido: 21,2MB
Total de Claves: 20.303.346

Claves que empiezen con be****** y 8 letras lo desifra.

Claves que empiezen con biba**** bibe**** bibi**** bibo**** bibu**** y 8 letras lo desifra.

+Nueva combinacion agregada

ly my

apareceran en cualquier posicion de combinacion
-------------------------------------------
+Nuevos numeros en la ultima 2 letras

96 94 93 92 91 21

para que ser compatible con palabra + años 2 ultimos digitos

Claves de ejemplo: franco96, miauto91, mimapa93, etc.
-------------------------------------------
+Ahora los numeros...

19 20

apareceran en cualquier posicion para formar los años pero no apareceran al final de la dos ultimas letras.

Claves de ejemplo: wifi2021, andy2021, sofi1991, mayo2021, etc.

[Serapis]

Pascal es un muy buen lenguaje sobretodo de cara al aprendizaje, de hecho Wirth lo diseñó precisamente para eso, y se convirtió (en su momento) en el lenguaje de facto usado en las universidades.
Uno de los mayores aportes que supuso (que pasa desapercibido para usuarios 'normales') es que el código conduce al compilador, es decir la especificación del lenguaje no difiere demasiado entre el código escrito y el compilado, lo que lo une más íntimamente al hardware y sobretodo ayuda a encarrilar más acertadamente a los algoritmos a ser más exactos y eficientes, de lo que hasta ese momento suponían ser otros lenguajes de programación de alto nivel. O dicho de un modo simplificado, es el primer lenguaje de alto nivel que no dista tanto de un lenguaje de bajo nivel. Todo ello se debe a que es un lenguaje estructurado... hasta entonces los lenguajes eran muy complejos (y a menudo muy extensos) y los compiladores aún mucho más.
Ahora, tiene serias limitaciones (respecto de lenguajes modernos).
C es un lenguaje muy complejo, básicamente es el Frankestein de la programación, cada idea nueva que aparece y sale 'rentable' se endosa en una nueva versión sin apenas tocar nada del resto del lenguaje y con una curva de aprendizaje largo. Aunque cuando uno conoce a fondo un lenguaje, aprender otro es más sencillo que partir de cero (conocimientos), para C esto no se aplica al 100%, pero si uno tiene suficientes conocimientos de  ensamblador, hardware y sistemas operativos, resulta más asequible. Viniendo de Pascal, yo te recomendaría quizás Delphi (sigue activo), sería una actualización, un punto intermedio que te acercaría más a C pero sin salir de Pascal.

lo que me dices es como una tecnica de aprendizaje supervisado para predecir una función a partir de datos de entrenamiento.

No. No se trata de aprendizaje supervisado... No te dejes arrastrar por eso de 'alimentar'... pues en el sentido de entrada de datos, de suministrar los datos.
El algoritmo de silabación todo lo que debe hacer es una de dos opciones (pueden diseñarse para que sea uniforme y proporcione la misma respuesta).
- Pasado un string señalar si todo el string recibido representa una sílaba o no.
- Pasado un string (por ejemplo una palabra), reconocer una sílaba hasta donde logre reconocerla como tal (y lo más larga posible*) e indicar en que punto del string ha terminado esa sílaba.

Esa diferencia en el diseño de la respuesta del algoritmo, puede enfocarse como decía en función de la entrada que se le pretenda proporcionar.
El primero se presta a la combinatoria (A-ZZZZZZ, esto es A-Z, AA-ZZ, AAA-ZZZ,AAAA-ZZZZ, AAAAA-ZZZZZ, AAAAAA-ZZZZZZ). Este modo garantiza obtener absolutamente todas las sílabas que reconoce el idioma español (así sean raramente usadas (por ejemplo 'lex' como en 'sílex' o 'xi' como en 'léxico').
El segundo se presta a pasar como entrada un texto muy largo indicando un índice desde el que mirar y devolviendo el funto final reconocido, así el tramo intermedio entre ambos es la sílaba reconocida (si devuelve true, claro dada una entrada (que contiene la palabra) como  'ZZZZZZZZZZZZ', avanzaraía hasta el final sin descubrir ninguna sílaba.

Es decir hay dos algoritmos uno que determina si un string entrado es una sílaba o que avanza hasta reconocer una sílaba (o saltar si no lo es) y el algoritmo que le entrega esos strings al algoritmo de silabación y que cuando le devuelve una sílaba 'formada' que aún no contiene la añade a la lista de sílabas del español...
Esto, una vez completo el diccionario de sílabas, ya está no se necesita más... de hecho hasta e sprobable que buscando se encuentre algún fichero con todas las sílabas dle español (o casi todas). El primer método (descrito en este mensaje, es decir el de combinatoria) recogerá todas, e tanto el que recibe textos, recogerá solo las sílabas que consten en ese texto, luego para asegurarse que tengan una cantidad lo más amplía posible conviene que reciba muchos textos... las que finalmente no aparecieren es claro que son poco probables.
El mayor problema del alimentador por combinatoria, es que serán enormemente más las combinaciones (de hasta 6 letras) que no son sílabas que las que sí lo son. s

* Sea la palabra 'constructor': lógicamente el reconocedor podría aceptar 'co' como sílaba, pero la idea es dar la sílaba lo más larga que sea posible, luego 'con' también es una sílaba, peor ¿puede ser aún más larga?. Si la sílaba finalmente es 'cons'.

Veré si el fin de semana hecho una ojeada a las reglas vigentes de silabación de la gramática española para sugerir un pseudocódigo del algoritmo preciso...

mi idea es hacer, teniendo una lista de silabas directas, indirectas y trabadas apartir de esas listas probar todas las combinaciones posibles y tratar de formar palabras rapidamente ...

Precisamente por eso te digo, que obtener una lista lo más exaustiva de la sílabas reales, es algo que se hace de una vez y ya, no hay que ir retocando cada cierto tiempo nada. Es una cantidad finita. Un diccionario sin necesidad de crecer...

Finalmente a la hora de aplicar contraseñas, se aplica como te indicaba unos mensajes más arriba, concatenado sílabas de modo recursivo, que es si cabe más eficiente que leer una contraseña de fichero. Esto hace innecesario almacenar diccionarios de Gigabytes o Terabytes, basta ese pequeño diccionario de sílabas.
Es luego en este algoritmo donde uno puede operar para condicionar de formas más complejas... yo sugería (por ejemplo) la inclusión de dígitos (delante, en medio o detrás de una sílaba)...

Despues de terminar de desarrollar el programa para generar diccionario, dejare de publicar diccionario y traere el programa, me voy a poner mas tiempo a desarrollar el programa mejor.

Es lo mejor...
Esas variaciones a base de poner prefijos o sufijos, solo sirve para generar diccionarios interminables en ficheros y que jamás serán 'completos' al gusto de uno...

El diccionarios de sílabas lo creas una vez (con el programa para desarrollarlas que si funciona bien también se ejecutará una única vez), el tiempo entonces lo gastarás a futuro en simplemente filtrar el modo en que las sílabas se combinan para producir (en tiempo real, generar y usar), combinaciones específicamente acotadas...

[Serapis]

Estuve el sábado revisando si haya cambiado algo al respecto en la gramática y francamente es complicado de un vistazo rápido hacerse eco de ello... Básicamente obliga a leerse un tocho de cientos de páginas (siempre se puede acudir al índice para reducir al mínimo la lectura, pero es seguro que entonces se pierden ciertos detalles)...
http://aplica.rae.es/grweb/cgi-bin/v.cgi?i=feRKWpxYQmpczbvb

Consultando el último libro que compré de gramática ("La gramática descomplicada" de Alex Grijelmo, 2009 7ªEd.), que a fin de cuentas data del mismo año que "La nueva Gramática Española" del link citado, sobre las sílabas no dice nada especial que uno no sepa, de hecho hasta pasa de largo por su 'anatomía'.

Es habitual considerar que las sílabas se componen de letras y luego saltar a los diptongos, triptongos e hiato, previo conocimiento de las vocales y consonantes.
Lo cierto es que yo tengo en mi recuerdo que la sílaba se compone de 3 partes que es lo que expondré y de lo que he partido... el domingo me tomó algo más de una hora elaborar el esquema de la formación del que sin detallar a fondo, doy una simples pinceladas.

Código [Seleccionar] Expandir

silaba= [ataque] nucleo [coda]
Sí, estos son los componente de la sílaba en base a su estudio, a la especificdad con la que se forman.
Las palabras entre corchetes indica que son opcionales, pueden o no llevarlo, en cambio el núcleo es obligatorio.

Código [Seleccionar] Expandir


ataque= C[C]
nucleo= V[ [V|H]V]
coda= C[C]

C refiere a consonantes y V a vocales... esto de modo genérico, las reglas exactas las pondré más abajo.
Que puede resumirse:
- El ataque (cuando la sílaba lo lleva), se compone de 1 ó 2 consonantes. Otra forma de decirlo, puesto que puede o no llevar ataque es decir que hay 0, 1 o 2 consonantes.
- El núcleo, viene a decir que siempre existe como mínimo una vocal, a veces lleva dos (diptongo) y a veces 3 (triptongo), la vocal del medio puede no existir o dicho de otro modo, estar remplazada por una 'H' que en ese caso es muda y por tanto se comporta como si fuera un vocal (so pena de insistir en considerarla consonante y complicar la estructura, que al final ofrece el mismo resultado, pero más complejo).
- La coda cuando la lleva se compone de 1 u 2 consonantes, y como con el ataque considerando de forma absoluta que siempre se tiene, podemos asumir que entonces se compone de 0, 1 o 2 consonantes.

Resumiendo:

Código [Seleccionar] Expandir

Silaba= CCVVVCC
Esto es lo que recuerdo, sin embargo ayer (el domingo) mientras hacía todo el esquema se me vino a la cabeza algunas palabras (ejemplos de cada situación), donde la coda está formada por 3 consonantes, y cito los ejemplos que se me vinieron a la cabeza (es posible que existan más, pero basta que exista una para indicar que la 'teoría' no es correcta).
Films, gángster, tungsteno, tests, nietzschismo, seltz, watts

Hay que aclarar que originalmente ninguna de estas palabras es nativo-española, se puede asumir que las 'rarezas' en sílabas son casi en su totalidad de origen foráneo, es decir importadas del extranjero y al caso, si éstas dadas se hubiera importado siglos atrás, a buen seguro se escribirían distinto, posiblemente hubieran acabado mutando a: filmes, gánster, tunsteno, teses, nieschismo, selz, etc... Y que en mi opinión es hacia donde debiera haber mutado por indicación o regla gramatical a la sazón (que no existe, que yo sepa). Así como nos ha tocado vivir una época de empecinamiento purista absurdo, las palabras importadas tienden a mantenerse 'fieles al original en su idioma'...

No son el único caso por el que la procedencia extranjera aporte nuevas sílabas (sin uso o apenas uso en el español, previamente):  wagneriano, hamster, troll, etc...
Hay que recordar que la letra 'w' es una letra importada, su sonido en español al final cae siempre en (v|b|gü), luego es realmente innecesaria y es un aborto propio de ese purismo absurdo (a ver si en esas otras lenguas han adoptado la 'ñ').
También hay codas extrañas procedentes de las lenguas precolombinas como 'tl' que se ve en 'náhuatl'.

Quien sabe, a la vuelta de 100 años quizás hayan terminado su fase de mutación y todo lo que precisan es un rodaje y desgaste en el tiempo, que limen sus aristas y acaben como cantos rodados... como pasó con los términos procedentes del griego, latín,etc... que ya lo vemos con las perspectiva del tiempo.

Claramente la cosa se complica cuando pasamos al detalle intrincado, los diptongos lo son con la combinación de ciertas vocales, de lo contrario forman un hiato que separa la sílaba y forma dos sonidos... para rematar el caso, las vocales tildadas se encargan en buena medida de definir diptongos: 'hay' es un diptongo, pero no 'ahí', que forma un hiato 'a-hí', incluso en triptongos, como en 'bahía' que ni es triptogo, ni diptongo 'ba-hí-a'. No solo tenemos la 'h' intercalada (que se puede resumir que actúa como una vocal muda), también tenemos que la 'y' puede comportarse como la vocal 'i', como en 'rey', pero mantiene su origen en cambio en 'reyezuelo' como consonante aún procediendo de la misma raíz.

También podemos hablar de las consonantes:
- Si tomamos por ejemplo el ataque, no detrás de cualquier consonante aparece otra, por ejemplo: "'tp'-nucleo" es impronunciable en español, en cambio "'ps'-núcleo" se pronuncia obviando la 'p', como en psique, psicología... (sí una p muda se podría decir... que la gramática no señala por parte alguna, esto sucede básicamente con palabras importadas, incluso en la coda), muchas consonantes en cambio admiten como segunda consonante en el ataque la 'r' y la 'b', pero de nuevo una 'h' puede comparecer como segunda consonante (o tal vez considerada como primera vocal al ser muda), excepto que esa consonante sea precisamente la 'c' como 'cho-colate'. O la 'q' que no admite detrás de ella ninguna otra consonante.
- La coda en cambio parece ser más restrictiva, algunas de ellas no se dan, aunque opcionalmente podrían añadirse, so pena de alargar la cantidad de sílabas generadas a cambio de no hallar palabras donde se den (luego aclaro esta diferencia), como la 'ñ', 'v' o 'w'. Algunas de ellas, en cambio aceptan la pronunciación, aún cuando procedan de otro idioma. No es fácil encontrar palabras en español acabadas en k y ciertas otras consonantes como: rock, crómlech, surf, tuareg, tuaregs, etc...   e incluso no siendo algunas de nuestro idioma, si son pronunciables como: watts, Maxwell, saint

Para finalizar estas pinceladas, considerando el tamaño de las sílabas, hay que decir que es difícil encontrar sílabas de más de 5 letras, pero ahí está 'truhán', una sola sílaba y palabra de 6 letras, dado que la coda (como se ha demostrado) admite hasta 3 consonantes, quien me quita que yo no inventare la palabra: 'truhángs-ter' (mezcla de truhán y gángster), como se ve 'truhángs' es de 8 letras y es perfectamente pronunciable incluso algo como 'ñhehizz' forma una sola sílaba, es pronunciable y tiene 2 'h'.

Resumiendo. Limitarse a buscar solo las sílabas que contienen las palabras de nuestro diccionario, no reporta todas las sílabas posibles, es decir cualquiera puede crear una nueva palabra inexistente con cualquiera de la sílabas que aquí he generado. ...además el diccionario, aun conteniendo todas las palabras, no contiene las palabras de las conjugaciones de los verbos, que ofrecen muchas sílabas distintas que seguramente no constan en otras palabras (y que por tanto se perderían).

Veo por tanto más útil generar una lista con todas las sílabas que sean pronunciables (considerando además, la posibilidad de coda de 3 consonantes, precisamente por ser pronunciables), de las que luego uno pueda filtrar para eliminar las que quiera, que crear una lista con las sílabas que contienen x palabras a las que puedan añadirse otras, pués esto siempre será más complicado que lo previo. Por ejemplo, aunque no es fácil encontrar sílabas que acaben con la coda 'zz', surge facilmente 'jazz', si esto es pronunciable, también lo será 'jozz' y 'pazz' u 'pezz' y tazz', etc... luego en la lista si uno quiere, puede filtrar las sílabas que acaben en 'zz', por considerar que realmente existen muy pocas, del mismo modo uno puede querer considerar eliminar las sílabas de 8 o 7 letras, dado que es complicado encontrar sílabas incluso de 6 letras que existan en palabras de nuestra lengua. Igualmente las sílabas tildadas, puede uno asimilarlas o hacerlas equivalente a la misma sílaba con la vocal sin tilde, especialmente si la idea de uno es usar (no crear) diccionarios para tirar de fuerza bruta y un sitio no admite letras tildadas como parte de sus contraseñas.

Como digo que es más fácil eliminar ciertas sílabas existentes (en el fichero) que añadirlas si no estuvieran presentes, he considerado pués crear mejor una lista así. Ciertas condiciones me han parecido innecesarias, como añadir codas que empiecen por las consonantes :'ñ', 'v' y 'w', pero en cambio he dejado la posibilidad de acabar en 'q' y 'qs', por la simple razón de que puede pronunciarse como una 'c'... la infame: 'FAQS' (no la otra fucks), atestigua que es pronunciable aún cuando, sean siglas... Por supuesto cada cual puede tener su opinión al respecto y filtrar lo que desee o crear su propia lista desde cero si resulta que no se incluye cierta combinación que le parezca de interés... en ese caso esta explicación y la lista, pueden servirle de apoyo.

Esto reporta algo más de 400.000 sílabas, cuando no creo que en entre las palabras existentes haya más de 5.000 sílabas. El resultado se obtiene en menos de 1 minuto.

Nota que no me he metido a realizar una algoritmo expresamente para esto, pués ya tengo un programa de grafos para realizar análisis sintáctico basado en un conjunto de reglas, y opciones que puedo personalizar, y con ello puedo generar permutaciones con reglas muy dispares, simplemente programando el 'lenguaje' que suponen dichas reglas...
Este es el conjunto de reglas finalmente en juego:
1 - Máximo número de caracteres = 8
2 - Peso minimo = 4
3 - Reglas de producción:

Código [Seleccionar] Expandir


#nucleoIni = a3:4|e3:4|y3:4|o3:4|u3:4
#nucleo = #nucleoIni|á3:1|é3:1|i3:1|í3:1|ó3:1|ú3:1|ü3:1
#hNucleo = h2:1|#nucleo
#hrl= r2:1|l2:1|#hNucleo
#diptongo= i4:1|u4:1|y4:1|h4:1
#triptongo= a4:1|á4:1|e4:1|é4:1|o4:1|ó4:1
#coda = b6:1|c6:1|d6:1|f6:1|g6:1|h6:1|j6:1|k6:1|l6:1|m6:1|n6:1|p6:1|q6:1|r6:1|s6:1|t6:1|x6:1|y6:1|z6:1

ataque = b1:1|c1:1|d1:1|f1:1|g1:1|h1:1|j1:1|k1:1|l1:1|m1:1|n1:1|ñ1:1|p1:1|q1:1|r1:1|s1:1|t1:1|v1:1|w1:1|x1:1|y1:1|z1:1|#nucleoIni
b1= #hrl
c1= #hrl
d1= #hrl
f1= #hrl
g1= #hrl
h1= #nucleo
j1= #hNucleo
k1= #hrl
l1= l2:1|#hNucleo
m1= #hNucleo
n1= #hNucleo
ñ1= #hNucleo
p1= s2:1|#hrl
q1= u3:4
r1= r2:1|#hNucleo
s1= #hNucleo
t1= #hrl
v1= #hNucleo
w1= #hNucleo
x1= #hNucleo
y1= #hNucleo
z1= #hNucleo

c2= #nucleo
h2= #nucleo
l2= #nucleo
r2= #nucleo
s2= #nucleo

a3= #diptongo|#coda
á3= #diptongo|#coda
e3= #diptongo|#coda
é3= #diptongo|#coda
i3= #triptongo|u4:1|ú4:1|h5:1|#coda
í3= #coda
o3= #diptongo|#coda
ó3= #diptongo|#coda
u3= #triptongo|i4:1|í4:1|h5:1|#coda
ú3= #coda
ü3= e4:1|é4:1|i4:1|í4:1
y3= #triptongo|#coda

a4= #coda
á4= #coda
e4= y5:1|#coda
é4= #coda
i4= #coda
í4= #coda
o4= #coda
ó4= #coda
u4= #coda
ú4= #coda
h4= i5:1|í5:1|u5:1|ú5:1
y4=

a5= #coda
á5= #coda
e5= #coda
é5= #coda
i5= #coda
í5= #coda
o5= #coda
ó5= #coda
u5= #coda
ú5= #coda
h5= a5:1|á5:1|e5:1|é5:1|o5:1|ó5:1
y5=

b6= s7:1
c6= h7:1|k7:1|s7:1
d6= s7:1
f6= t8:1
g6= s7:1
h6= m7:1
j6=
k6= h7:1
l6= f7:1|l7:1|m7:1|s7:1|t7:1
m6= p7:1|s7:1
n6= d7:1|c7:1|g7:1|s7:1|t7:1|z8:1
p6= s7:1
q6= s7:1
r6= d7:1|f7:1|s7:1
s6= h8:1|s7:1|t7:1
t6= c7:1|l8:1|s7:1|t7:1|z7:1
v6= s7:1
w6= s7:1
x6=
y6= s7:1
z6= s7:1|z8:1

c7= h8:1
d7= s7:1
f7=
g7= s7:1
h7= s7:1
k7= s7:1
l7= s7:1
m7= s7:1
p7= s7:1
s7=
t7= s7:1|z8:1
z7= s7:1

h8=
l8=
t8=
z8=

Las primeras reglas, se tratan como directivas, es decir cada otra regla de producción que la contiene en la parte derecha es remplaza por la equivalencia de aquella que aparece en la izquierda (el nombre de la regla). Esto es para 3 cosas, primero claridad, luego sencillez de revisión y tercero evitar errores al transcribir 40 veces los mismos valores. El programa por tanto preprocesa (también elimina las líneas en blanco) tales entradas de directiva y las convierte en:... bueno no veo necesario ponerlo todo, baste un ejemplo, para el ataque de 'r', 's' y 't':

Código [Seleccionar] Expandir

r1= r2:1|h2:1|a3:4|e3:4|y3:4|o3:4|u3:4|á3:1|é3:1|i3:1|í3:1|ó3:1|ú3:1|ü3:1
s1= h2:1|a3:4|e3:4|y3:4|o3:4|u3:4|á3:1|é3:1|i3:1|í3:1|ó3:1|ú3:1|ü3:1
t1= r2:1|l2:1|h2:1|a3:4|e3:4|y3:4|o3:4|u3:4|á3:1|é3:1|i3:1|í3:1|ó3:1|ú3:1|ü3:1

El texto a la izquierda es el nombre de la regla-nodo, lo que está a la derecha son cada una de las opciones que pueden seguir a ese nombre (exactamente como sucede en la descripción de las reglas de un lenguaje de programación). Es decir sus opciones son iteraciones que sustituyen al 'actual', y el tamaño del 'sustrato' (el stack.ToString), es la concatenación que se resuelve por recursión.
Cada una de esas opciones son a su vez una regla, pero se adjunta con el 'peso' que supone añadir esa regla.
Un nombre-regla, sin parte derecha equivale a un terminal.
El límite de una silaba (condición de finales de los bucles), vienen dados por unas reglas simples:
1 - La regla es en sí misma un terminal (no admite que nada más se concatene detrás, acaba la recursión).
2 - La cantidad de caracteres máximos. También limita el final de la recursión, en este caso para no incurrir en desbordamiento.
3 - Final de iteración. La cantidad de 'hijo-nodos-opciones' que tiene la regla.
4 - De peso (en este caso condicionado a mínimo: (>= que) 4)... No es una sílaba si no reúne el peso mínimo.
Esta última regla en realidad define la salida de datos, siempre que el peso sea 4 o mayor se ha obtenido una sílaba. Nota como al núcleo (a las vocales grupo3) se le ha dado un peso de 4. Esto impide que cuando se tome la una o dos consonantes del ataque lo interprete como una sílaba, es decir hasta que no sume el valor de una vocal no se garantiza que sea tomada como sílaba...

El orden de las reglas, en esa lista previa, determina el orden en que saldrán la silabas, así por ejemplo la primera sílaba que sale es 'bra', porque 'b1' es la primera regla, y la primera opción de 'b1' es 'r1' y la primera opción de 'r1' es 'a3'. Si antepusiera las vocales a las consonantes en la regla 'ataque= vocales|consonantes' , pués entonces la primera sílaba sería la 'a', pués su peso por sí sola ya suma 4.


Las últimas sílabas son:

Código [Seleccionar] Expandir

1 ---> u3t6c7h8 7
1 ---> u3t6l8 6
1 ---> u3t6s7 6
1 ---> u3t6t7 6
1 ---> u3t6t7s7 7
1 ---> u3t6t7z8 7
1 ---> u3t6z7 6
1 ---> u3t6z7s7 7
1 ---> u3x6 5
1 ---> u3y6 5
1 ---> u3y6s7 6
1 ---> u3z6 5
1 ---> u3z6s7 6
1 ---> u3z6z8 6

Número de nodos: 101
Total de caminos: 408694
Total de Salidas: 405294

Esta es la salida en la interfaz del programa, en el volcado a fichero se guarda solo las 'silabas' (el nombre completo con sus dígitos).
Como se ve a cada sílaba le sucede un dígito, ello obedece a que ese es el nombre para la regla, por debajo hay una pila que verifica si ya consta esa regla, en el stack, si es preciso añadir dos 'z', entonces no sería posible (como en 'zuz', 'jazz'), además si la constante 'r' tiene una regla cuando es la primera letra del ataque (la regla indica que otras letras pueden seguirle), cómo distinguimos entonces la regla si la 'r' aparece en otra posición, un ejemplo de sílaba con 3 'r': 'ahorrarse'?...
Podría, al tomar el nombre para entregarlo a la salida, ser filtrado, pero me interesa mantenerlo así, resulta más sencillo de este modo comprobar que se comporta como se espera y si no es así, hacer ajustes, después de todo filtrarlo al término del programa es bastante sencillo y asequible. Nota sin embargo que esto duplica el tamaño del fichero de salida.

El número de 'nodos' es la cantidad de reglas, una vez procesadas las directivas, es decir el tamaño del array...
La diferencia entre el número de salidas y el de nodos visitados, responde a las consonantes del ataque que por la regla del peso, no logran formar sílaba. Con cada iteración se suma un nodo visitado y con cada sílaba hallada se suma una sílaba de salida.

Te dejo enlace a un fichero para descargar, 2 txts, uno tal como sale (más el conjunto de reglas) y otro tras filtrar los dígitos (el primero es para tu análisis si merece (a ti o cualquier otro interesado) el tiempo dedicado en indagar sobre la cuestión y proponer sus propias reglas para crear su variante de reglas para su propio algoritmo:
https://workupload.com/file/HbqAsXLsrES (1'94Mb. Aprox. decomprimido son de 5'37Mb. y 3'07Mb.)

Y con esto salvo alguna duda al respecto dejo el tema zanjado.
Debe quedar claro que un diccionario de 400.000 sílabas es manejable frente a uno de millones, decenas o miles de millones, pués no es más que concatenar x sílabas... o incluso variaciones, donde (por ejemplo) se solicita intercalar 1,2 o 3 dígitos en un punto concreto (nonecesariamente al inicio o final de sílaba), o determinado carácter que se admite como contraseña pero que no es parte del alfabeto A-Z. también hay que tener en cuenta que se dan en minúsculas, una palabra como: 'orden', tiene 120 variaciones (contraseñas distintas) considerando para cada letra si es mayúscula o minúscula (1*2*3*4*5), etc... sobre otras opciones de interés. Ahí en esos detalles es donde uno puede darle juego y esmerarse en programar y no perdiendo tiempo en crear diccionarios gigantes que no aportan nada interesante, de hecho hasta cuesta a uno elegir que conjunto quiere aplicar, por que las reglas son 'el conjunto de palabras que consta en el diccionario', e inntentar filtrarlo por tus propias reglas siendo tan enormes conlleva igualmente mucho tiempo y al caso es preferible perder ese tiempo programando tus propias reglas en tu propio algoritmo.

Al final los diccionarios de tamaño medio (pongamos superiores a x Mb. solo tienen utilidad para personas que por no saber programar, tienen que conformarse con algún programa que sea capaz de cargar diferentes diccionarios, si el propio programa no dispone de reglas adecuadas que poder aplicar...

[RJuegos]

G FUERZA BRUTA V2 (fase prueba).jpg

https://mega.nz/file/KVolRAoL#iOjrI8wZh7-brrKqoeXBZGD1YM8dpcgRa-vtHXkG9o4

No se como puedo enviar la imagen directamente.

Solo captura para ver mas o menos su aspecto visual y su contenido que traería, el programa se llamaría G Fuerza Bruta v2, y no solo hice su menú, sino que hay ya cosas funcionado atras de su apariencia, ya he desarrollado el algoritmo para generar listas de digrafos que forman silabas directas (Consonantes+Vocal), indirectas (Vocal+Consonantes) trabadas (Consonantes+Consonantes para ser seguidas de una vocal ej: fran pero no cumple siempre ese patrón por ej: frna) para almacenarlas todo en array, tambien he sacado q+vocal pero deje qu solamente, y saque vocal+ñ del último digrafo de una clave generada, y también he añadido un filtro de búsqueda en array para las letras que hallan elegido claves que empiecen con la letra inicial lo que me faltaría ahora de ese array unir esos elementos y combinarlos para formar claves y almacenarlas en fichero, y también actualizar el algoritmo de generar lista de dígrafos con el nuevo que he hecho.

Si quieren el programa G Fuerza Bruta v2 que todavía no hay mucha utilidad y es mas propenso a dar errores por entrada de datos incorrectos pero si ingresa todo bien o mal no pasa nada grave por ahora, avisen si quieren el link de descarga aunque no creo, pero si solo quieren probar como por ahora funciona y sugerir cambiar algo que no se entienda o mejorarlo me interesa saberlo, aunque creo que la captura es suficiente.

[Danielㅤ]

Hola, aquí dejo visible la imagen que ha compartido el compañero RJuegos:




Saludos

[RJuegos]

Limitarse a buscar solo las sílabas que contienen las palabras de nuestro diccionario, no reporta todas las sílabas posibles, es decir cualquiera puede crear una nueva palabra inexistente con cualquiera de la sílabas que aquí he generado. ...además el diccionario, aun conteniendo todas las palabras, no contiene las palabras de las conjugaciones de los verbos, que ofrecen muchas sílabas distintas que seguramente no constan en otras palabras (y que por tanto se perderían).

Veo por tanto más útil generar una lista con todas las sílabas que sean pronunciables

Eso podría reducir combinaciónes y tratar de acercarse a formar rápido alguna palabra o parecidas a algunas palabras y inexistente, podría aplicarlo a la hora de generar combinaciones y filtrar esas combinaciones para que formen silabas pronunciables, pero serían difícil de aplicar tal vez le busque la vuelta. No estaría mal ya que sería compatibles a palabras inexistente, aunque también pienso que se podría formar con el patrón que hago, pero seria un poco mas largo llegar algunas palabras sin aplicar algoritmo que reconozca silabas con posibles salidas al punto anterior, se me haría mas difícil.

[RJuegos]

Hola, aquí dejo visible la imagen que ha compartido el compañero RJuegos:




Saludos

El link de la imagen Lo he puesto entre img y no aparece la imagen en previsualizar, y aun sigo sin ver la imagen que has puesto, no hay nada en el espacio que hay talvez tenga que esperar que carge la imagen no me agarra bien el internet.

[Danielㅤ]

El link de la imagen Lo he puesto entre img y no aparece la imagen en previsualizar, y aun sigo sin ver la imagen que has puesto, no hay nada en el espacio que hay talvez tenga que esperar que carge la imagen no me agarra bien el internet.

Así es no se visualizaba porque estaba tratando de usar el link de Mega que has dejado pero no he podido lograrlo por lo que he descargado la imagen y la he subido a otro servidor de imágenes y ahora sí se visualiza perfectamente 


Saludos

[RJuegos]

Así es no se visualizaba porque estaba tratando de usar el link de Mega que has dejado pero no he podido lograrlo por lo que he descargado la imagen y la he subido a otro servidor de imágenes y ahora sí se visualiza perfectamente 


Saludos

Ahora si, Gracias.
Creo que era muy grande la imagen  pero bueno algo se ve, talvez me falto recortar mas la imagen.