Su tarea es generar una palabra sin sentido que sea razonablemente pronunciable con el número especificado de 'sílabas'. Cada vez que se ejecuta el programa, posiblemente se obtenga una palabra diferente sin sentido.

Pronunciabilidad

Una palabra pronunciable se compone de sílabas, que a su vez están formadas por un grupo de vocales que posiblemente se intercala entre dos grupos de consonantes. No todos los sonidos son pronunciables en todas las posiciones, y dado que esto depende del idioma, utilizaremos patrones comprensibles para los hablantes de inglés

Grupos de consonantes iniciales:

b c d f g h j k l m n p r s t v wy z bl br ch cl cr dr fl fr gh gl gn gr kn ph pl pr qu sc sh sk sl sm sn sp th th tr wh wr sch scr shm shr squ str str

Grupos de vocales:

a e i o u ae ai ao au ea ee ei eu ia ie io oa oe oi oo ou ue ui

Finalización de los grupos de consonantes:

bcdfglmnprstxz bt ch ck ct ft gh gn lb ld lf lk ll lm ln lp lt mb mn mp nk ng nt ph pt rb rc rd rf rg rk rl rm rn rp rt rv rz sh sk sp ss st zz lch lsh lth rch rsh rs rth sch tch

Combinando sílabas

Los grupos de consonantes iniciales y finales son opcionales en general, sin embargo, no puede colocar una sílaba que termine con una vocal inmediatamente antes de que comience con una vocal.

Descargo de responsabilidad

En aras de la simplicidad, ciertas palabras en inglés no se pueden generar de esta manera, como vacío, xilófono, mnemotécnico, pterodáctilo, hermoso, bla, ellos, wow y la mayoría de los plurales.

Visión general

Posibles patrones de sílabas con esta clave:

(SC) = consonante inicial; (V) = grupo vocal; (CE) = consonante final

Para una sílaba:

• (SC) (V) (CE)
• (V) (CE)
• (SC) (V)
• (V)

Con dos sílabas:

• (SC) (V) (EC) (SC) (V) (EC)
• (SC) (V) (EC) (SC) (V)
• (SC) (V) (CE) (V) (CE)

• (SC) (V) (CE) (V)

• (SC) (V) (SC) (V) (CE)

• (SC) (V) (SC) (V)

• (V) (CE) (SC) (V) (CE)

• (V) (CE) (SC) (V)
• (V) (CE) (V) (CE)

• (V) (CE) (V)

• (V) (SC) (V) (CE)

• (V) (SC) (V)

... y así

Ejemplos

1 sílaba

• charst
• apretado
• chillido
• eess
• shue
• oo
• cheezz

2 sílabas

• jazzcrap
• whylprog
• comiendo
• umba
• ola
• tener
• ingsoc
• greespheurz
• bleuspoo

3 sílabas

• brokiompic
• Squirdshlicker
• capital
• opengtrass
• doble pensamiento
• hermano mayor
• phoebliaptmoo
• skolfblauquent

4 sílabas

• Strawishoepick
• patchworkzombie
• prearneajoomie
• slephotoschou
• doble plusgood

Codificación

Entrada: un número entero para la cantidad de sílabas a generar

Salida: una palabra (probablemente) sin sentido que tiene muchas sílabas

Reglas

• Se requiere alguna forma de aleatoriedad (psuedo). Todas las combinaciones de sílabas deberían ser (teóricamente) posibles de generar, aunque la distribución no tiene que ser uniforme.
  • Puede suponer que su generador es aperiódico, por lo que no tiene que ser matemáticamente posible generar todas las palabras posibles (puede que no tenga un período lo suficientemente largo en realidad) y no necesita proporcionar ningún tipo de prueba de que su generador puede, de hecho, producir todas las palabras posibles.
  • Su generador debe ser capaz de producir al menos 255 valores distintos, por lo que no puede devolver 4 cada vez que se llama al generador.
  • Lo que en última instancia es importante es que de alguna manera incluya todos los grupos de letras anteriores en su código, que cada grupo de letras tenga una probabilidad distinta de cero de ser elegido, y que cada patrón de sílabas tenga una probabilidad distinta de cero (si se proporciona con una aleatoriedad verdadera).
• Debes admitir hasta 16 palabras de sílaba
• Además de las reglas sobre la combinación de sílabas, la palabra de salida no debe tener:
  • 3 vocales consecutivas ( a e i o u; esto puede suceder para las qupalabras)
  • 3 consonantes coincidentes consecutivas

¡Buena suerte!

Tenga en cuenta que esto es distinto de Generar una palabra pronunciable por varias razones:

• Número variable de sílabas especificadas por entrada en lugar de un requisito estricto de 10 letras.
• Este desafío agrega grupos de letras no exhaustivos que deben estar codificados (inteligentemente) y permite más variantes de sílabas, por lo que el código no se puede copiar del otro desafío
• Squirdshlicker. ¿Necesito decir mas?

_{También olvidé engañar el cheque, pero resulta que esto trae suficientes novedades a la mesa que no importan. Después de todo, hay cientos de desafíos de quine variantes.}

Javascript (ES6),  407  403 bytes

f=n=>/[aeiou]{3}|(.)\1\1/.test(s=(h=k=>k?(g=s=>p=s.match(/.[a-z]*/g)[Math.random()*99|0]||(s>x&&p?'':g(s)))(x+'lBrClCrDrFlFrGlGrHJKKnPlPrQuScScrShmShrSlSmSnSquStrThThrTrVWWhWrY')+g('AAeAiAoAuEEaEeEiEuIIaIeIoOOaOeOiOoOuUUeUi')+g(x+'tCkCtFtLbLchLdLfLkLlLmLnLpLshLtLthMbMnMpNgNkNtPtRbRcRchRdRfRgRkRlRmRnRpRshRstRtRthRvRzSsTchXZz')+h(k-1):'')(n,p=x='BCChDFGGhGnLMNPPhRSSchShSkSpStTZB').toLowerCase())?f(n):s

Pruébalo en línea!

05AB1E , 237 234 230 228 bytes

.•O0¦"ÐD›ô:ΓF9—∊‘àÕGÌ•3LŽZв₂в×S£V[1U.µ\µTΩiY.•1θ₆Ω–¸‡ÊΔιÃмº³ô»ÝAïG3_@|å“₄bÒs₃l¬t©ïÙK:≠•3LŽII₂в×S£«Ω1U}XižM•·Áy&ŒGηΩ¼αŸKq•6вèJ•Λ1"•bS>£Ω¼0U}TΩiY.•E–æƵHl¨åñyBY±(ú,ā]JùË‚aEuŒ—[K³|C~ôÙŸ„#¼ÑûĀdš+¢zsÄΘä¹ÊÌ₅ôθ•3LŽAE₆в×S£«Ω1U}J}Dγ€g3‹P#

-2 bytes gracias a @MagicOctopusUrn .

Pruébelo en línea u obtenga algunos resultados más .

Explicación:

.•O0¦"ÐD›ô:ΓF9—∊‘àÕGÌ•
                  "# Push compressed string "bcdfglmnprstzchghgnphshskspstsch"
  3L               # Push list [1,2,3]
    ŽA;            # Push compressed integer 8997
       ₂в          # Converted to Base-26 as list: [13,8,1]
         ×         # Repeat the digits [1,2,3] that many times: ["1111111111111","22222222","3"]
          S        # Convert it to a list of flattened digits
           £       # Split the string into parts of that size
            V      # Pop and store this string-list in variable `Y`
[                  # Start an infinite loop:
 1U                #  Reset variable `X` to 1
 .µ                #  Reset the counter_variable to 0
 \                 #  Discard the top of the stack (if any)
 µ                 #  Loop while the counter_variable is not equal to the (implicit) input:
  TΩi              #   If a random boolean is truthy:
     Y             #    Push the string-list we stored in variable `Y`
     .•1θ₆Ω–¸‡ÊΔιÃмº³ô»ÝAïG3_@|å“₄bÒs₃l¬t©ïÙK:≠•
                   #    Push compressed string "hjkvwyblbrclcrdrflfrglgrknplprquscslsmsnthtrwhwrscrshmshrsqustrthr"
       3L          #    Push list [1,2,3]
         ŽII       #    Push compressed integer 4608
            ₂в     #    Converted to Base-26 as list: [6,21,6]
              ×    #    Repeat the digits [1,2,3] that many times: ["111111","222222222222222222222","333333"]
               S   #    Convert it to a list of flattened digits
                £  #    Split the string into parts of that size
     «             #    Merge it with list `Y`
      Ω            #    Pop and push a random starting consonant group from this list
     1U            #    And set variable `X` to 1
    }              #   Close the if-statement
  Xi               #   If variable `X` is 1:
    žM             #    Push builtin string "aeiou"
      •·Áy&ŒGηΩ¼αŸKq•
                   #    Push compressed integer 13814931869773709280202935082102
        6в         #    Converted to Base-6 as list: [1,0,1,1,1,2,1,4,0,1,0,2,0,3,0,4,2,0,2,1,2,3,3,0,3,1,3,2,3,3,3,4,4,1,4,2,0,1,2,3,4]
          èJ       #    Index each into the string "aeiou", and join together: "aeaiaoaueaeeeieuiaieiooaoeoiooouueuiaeiou"
      •Λ1"•       "#    Push compressed integer 8388576
           b       #    Converted to binary: "11111111111111111100000"
            S>     #    Split into a list of digits, and each increased by 1
              £    #    Split the string into parts of that size
               Ω   #    Pop and push a random vowel group from this list
    ¼              #    Increase the counter_variable by 1
    0U             #    And then set variable `X` to 0
   }               #   Close the if-statement
  TΩi              #   If a random boolean is truthy:
     Y             #    Push the string-list we stored in variable `Y`
     .•E–æƵHl¨åñyBY±(ú,ā]JùË‚aEuŒ—[K³|C~ôÙŸ„#¼ÑûĀdš+¢zsÄΘä¹ÊÌ₅ôθ•
                   #    Push compressed string "xbtckctftlbldlflklllmlnlpltmbmnmpnkngntptrbrcrdrfrgrkrlrmrnrprtrvrzsszzlchlshlthrchrshrstrthtch"
       3L          #    Push list [1,2,3]
         ŽAE       #    Push compressed integer 2564
            ₆в     #    Converted to Base-36 as list: [1,35,8]
              ×    #    Repeat the digits [1,2,3] that many times: ["1","222...222","33333333"]
               S   #    Convert it to a list of flattened digits
                £  #    Split the string into parts of that size
     «             #    Merge it with list `Y`
      Ω            #    Pop and push a random ending consonant group from this list
     1U            #    And set variable `X` to 1
    }              #   Close the if-statement
  J                #   Join all strings on the stack together
 }D                #  After the while-loop: duplicate the resulting string
   γ               #  Split the copy into chunks, with adjacent characters that are
                   #  the same grouped together
    €g             #  Get the length of each chunk
      3‹           #  Check for each length if it's smaller than 3
        P          #  Check if all are truthy by taking the product, and if it is:
         #         #   Stop the infinite loop
                   # (after which the string at the top of the stack is output implicitly)

Consulte esta sugerencia mía 05AB1E (sección ¿Cómo comprimir cadenas que no forman parte del diccionario ? , ¿Cómo comprimir enteros grandes? Y ¿Cómo comprimir listas enteras? ) Para comprender cómo funcionan las partes de compresión.

Jalea , 231 bytes

e€ØẹŒrḢƇ,ŒɠF>2Ẹ
“yŒʠT¬ḅɼṬɦṀUżGv¶æɲCĊQ>ṙȦẇɼṄ0IḤhDẋDċṀĊṪɗĖƇẊ;1JƒṾỊżỵhṖ8>Ȯ⁶]¦Qṭ|Ṛṇẹm⁵ØKƈBNɦÇȯ¢ṣḟPṇMʠ¬YėĊÇẒỊĿXJÑḷÞeȮȮɼ$ỴœeṂṠɲẓḊ⁺ċŻ⁽⁶Ẓ⁹<>#nẇṬ⁴\¤ÐṡḞF5ƙẇwḶȤYḍ¡¢~ṚⱮ-ṃƲ⁻Ṙ6ɱṬ?İẆḌỊþEØ»Ḳµe€ØẹIkḣ3)Z;€“squ“qu”$1¦
“ئµ£‘ḃ3$Xµ³Ð¡ḊFµ⁺wØ2$¿ịÇX€Fß¹Ñ?

Pruébalo en línea!

Un programa completo que toma un solo argumento, la cantidad de sílabas requeridas.

Explicación

El núcleo de esto es una cadena de diccionario comprimido de 66 palabras. Si las palabras se dividen en grupos de consonantes y vocales y los primeros 3 grupos tomados para cada palabra, generan los grupos iniciales, vocales y finales deseados a partir de la pregunta. Las excepciones son quy squporque tienen una vocal, por lo que se agregan manualmente. La lista de palabras fue construida algorítmicamente a partir del diccionario Jelly usando un script Python. Tenga en cuenta que algunos grupos de letras se repiten, pero la pregunta permite que las salidas no representen uniformemente cada combinación posible. Si se prefiere, sería sencillo hacer que cada grupo sea único a costa de dos bytes ( Q€).

                | Sample input: branggag
e€Øẹ            | For each letter, is it a vowel? [0, 0, 1, 0, 0, 0, 1, 0]
    Œr          | Run-length encode [[0, 2], [1, 1], [0, 3], [1, 1], [0, 1]]
      ḢƇ        | Filter only those with true first value, popping first value [[1], [1]]
        ,       | Pair with
         Œɠ     | Run lengths of input [[[1], [1]], [1, 1, 1, 1, 2, 1, 1]
           F    | Flatten [1, 1, 1, 1, 1, 1, 2, 1, 1]
            >2  | Greater than 2 [0, 0, 0, 0, 0, 0, 0, 0, 0]
              Ẹ | Any 0

“yŒʠ...þEØ»                          | Compressed string: shmooze gaolbird hailshot shriech waeful furze ghaut cruelness stealthier gneiss shoeshine wheelchair wring build priorship knosp spoilfive karst through coalpit teschenite schoolkid theurgic zabtieh skiamachies yirth snazzier slimnastics scripted smirch droskies strift blepharism chaulmoogra glegness scarf fratch clerk brank jarvey flourless vorpal grex nard plumb larn philter sorbo tractabilities parcel mart damp rearm back bast bag bant baba boll bad bap becap basal ban bail bare
           Ḳ                         | Split at spaces
            µ        )               | For each word: e.g. hailshot
             e€Øẹ                    |   Check whether each character is a vowel [0, 1, 1, 0, 0, 0, 1, 0]
                 I                   | Increments of this [1, 0, -1, 0, 0, 1, -1]
                  k                  |   Split word at truthy values of this [h, ai, lsh, o, t]
                   ḣ3                |   Take the first three [h, ai, lsh]
                      Z              | Transpose (so now have three lists, start consonants, vowels, end consonants)
                        €        $1¦ | For the first group
                       ; “squ“qu”    | Append squ and qu

          µ³Ð¡                     | Repeat the following the input number of times, collecting results:
“ئµ£‘                             |   18, 5, 9, 2
      ḃ3$                          |   bijective base 3: [1,2,3],[1,2],[2,3],[2]
         X                         |   Take one at random
              Ḋ                    | Remove first item (which will be the input to the link because if the way С works
               F                   | Flatten; we now have e.g. [1,2,3,2,3,1,2,3,2]. This corresponds to SC V EC V EC AC V EC V
                µ⁺    ¿            | Do everything so far once and then repeat while:
                  wØ2$             |   The output contains two twos (i.e. vowel-vowel)
                       ịÇ          | Look these up in the previous link, so we now have a group of letter groups for each position
                         X€F       | Pick a random letter group for each position
                            ß¹Ñ?   | If helper link 1 is true, retry the whole of this link again. Otherwise implicitly output

Python 2 , 522 510 bytes

from random import*
import re
c=choice
S,V,E=[map(str.lower,re.findall('[A-Z][a-z]*',x))for x in'BCDFGHJKLMNPRSTVWYZBlBrChClCrDrFlFrGhGlGnGrKnPhPlPrQuScShSkSlSmSnSpStThTrWhWrSchScrShmShrSquStrThr','AeAiAoAuEaEeEiEuIaIeIoOaOeOiOoOuUeUiAEIOU','BCDFGLMNPRSTXZBtChCkCtFtGhGnLbLdLfLkLlLmLnLpLtMbMnMpNkNgNtPhPtRbRcRdRfRgRkRlRmRnRpRtRvRzShSkSpSsStZzLchLshLthRchRshRstRthSchTch']
def f(n):w=c(['',c(S)]);exec"e=c(E);w+=c(V)[-(w[-1:]in V):]+c([c(S),e,e+c([x for x in S if x[0]*2!=e])])*(n>1);n-=1;"*n;return w+c(['',e])

Pruébalo en línea!

Pyth, 346 335 bytes

McG.u+NYr9,VHSlH1smjOgs@L"eaiou"jC" ¤E̽]¢¨¦l#"5,4 17*Vd,Og"bcdfghjklmnprstvwyzblbrchclcrdrflfrghglgngrknphplprquscshskslsmsnspstthtrwhwrschscrshmshrsqustrthr"[18 29 6)Og"bcdfglmnprstxzbtchckctftghgnlbldlflklllmlnlpltmbmnmpnkngntphptrbrcrdrfrgrkrlrmrnrprtrvrzshskspssstzzlchlshlthrchrshrstrthschtch"[13 43 8)tuaGO<W!eeG^,1Z2 2Q]1

Pruébelo en línea aquí .

Rubí , 381 379 375 bytes

Utiliza combinaciones de expresiones regulares desordenadas para obtener los grupos de consonantes. Probablemente podría optimizarse.

->n,w=?a..s='zzz',a=[1]{s=(1..n).map{a=[w.grep(/^([^aeiouq]|[bcfgp][lr]|s?ch|dr|gn|kn|ph|s?qu|s[ct]r?|sh[mr]?|th?r?|s[klmnp]|wh|wr|gh)$/)+(a[-1]?[p]:[]),w.grep(/^[aeiou]{,2}$/),w.grep(/^([^aeiouqhjkvwy]|[bcflnprs]t|ck|gh|gn|l[bdfk-np]|m[bnp]|nk|ng|ph|r[bcdfgk-npvz]|[lr]?[stc]h|s[kps]|zz|rst|[st]ch)$/)<<p].map(&:sample)}*''while s=~/[aeiou]{3}|(.)\1\1|aa|eo|ii|iu|u[aou]/;s}

Pruébalo en línea!