Sua tarefa é gerar uma palavra sem sentido razoavelmente pronunciável com o número especificado de 'sílabas'. Cada vez que o programa é executado, possivelmente resulta em uma palavra sem sentido diferente.

Pronounceability

Uma palavra pronunciável é composta de sílabas, que por sua vez são constituídas por um grupo de vogais que possivelmente está imprensado entre dois grupos consoantes. Nem todos os sons são pronunciáveis ​​em todas as posições e, como isso depende do idioma, usaremos padrões compreensíveis para os falantes de inglês

Iniciando grupos consoantes:

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

Grupos de vogais:

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

Grupos consoantes finais:

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 r r r r r r r r r r r r r r r r sh sh sp sp st zz lch lsh lth rch rsh rst rth sch tch

Combinando sílabas

Os grupos consoante inicial e final são opcionais em geral, no entanto, você não pode colocar uma sílaba final com uma vogal imediatamente antes de iniciar uma vogal.

aviso Legal

No interesse da simplicidade, certas palavras em inglês não podem ser geradas dessa maneira, como vácuo, xilofone, mnemônico, pterodátilo, bonito, blá, eles, uau e o plural.

Visão geral

Possíveis padrões de sílabas usando esta chave:

(SC) = consoante inicial; (V) = grupo de vogais; (CE) = consoante final

Para uma sílaba:

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

Com duas sílabas:

• (SC) (V) (CE) (SC) (V) (CE)
• (SC) (V) (CE) (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)

... e assim por diante

Exemplos

1 sílaba

• charst
• apertado
• shriegn
• eess
• shue
• oo
• cheezz

2 sílabas

• jazzcrap
• whylprog
• comendo
• umba
• ola
• ter
• ingsoc
• greespheurz
• bleuspoo

3 sílabas

• brokiompic
• squirdshlicker
• capital
• opengtrass
• repensar
• grande irmão
• phoebliaptmoo
• skolfblauquent

4 sílabas

• strawishoepick
• patchworkzombie
• prearneajoomie
• slephotoschou
• doubleplusgood

Codificação

Entrada: um número inteiro para o número de sílabas a serem geradas

Saída: uma palavra (provavelmente) sem sentido, com muitas sílabas

Regras

• É necessária alguma forma de aleatoriedade (psuedo). Todas as combinações de sílabas devem ser (teoricamente) possíveis de gerar, embora a distribuição não precise ser uniforme.
  • Você pode supor que seu gerador é aperiódico, portanto, não precisa ser matematicamente possível gerar todas as palavras possíveis (pode não ter um período suficientemente longo na realidade) e você não precisa fornecer nenhum tipo de prova de que seu gerador pode, de fato, produzir todas as palavras possíveis.
  • Seu gerador deve ser capaz de produzir pelo menos 255 valores distintos; portanto, você não pode simplesmente retornar 4 toda vez que o gerador for chamado.
  • O mais importante é que, de alguma forma, você inclua todos os grupos de letras acima em seu código, que cada grupo de letras tenha uma probabilidade diferente de zero de ser escolhido e cada padrão de sílaba tenha uma probabilidade diferente de zero (se fornecida com verdadeira aleatoriedade).
• Você deve suportar até 16 palavras de sílaba
• Além das regras de combinação de sílabas, a palavra de saída não deve conter:
  • 3 vogais consecutivas (a e i o u ; isso pode acontecer por qupalavras)
  • 3 consoantes correspondentes consecutivas

Boa sorte!

Observe que isso é diferente de Gerar uma palavra pronunciável por alguns motivos:

• Número variável de sílabas especificadas por entrada, em vez de um requisito estrito de 10 letras.
• Esse desafio adiciona grupos de letras não exaustivos que devem ser (habilmente) codificados e permitem mais variantes de sílabas, para que o código não possa ser copiado apenas do outro desafio
• Squirdshlicker. Preciso dizer mais?

_{Também esqueci de enganar o cheque, mas acontece que isso traz bastante novidade para a mesa que não importa. Afinal, existem centenas de desafios de variantes de quine.}

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

Experimente online!

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 graças a @MagicOctopusUrn .

Experimente online ou obtenha mais algumas saídas .

Explicação:

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

Veja esta dica 05AB1E meu (seção Como cordas compressa não fazem parte do dicionário? , Como comprimir grandes inteiros? E Como listas inteiras compressa? ) Para entender como as obras de peças de compressão.

Geléia , 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ß¹Ñ?

Experimente online!

Um programa completo que usa um único argumento, o número de sílabas necessárias.

Explicação

O núcleo disso é uma string de dicionário compactada de 66 palavras. Se as palavras forem divididas em grupos de consoantes e vogais e os 3 primeiros grupos usados ​​para cada palavra, eles gerarão os grupos inicial, vogal e final desejados a partir da pergunta. As exceções são que, squcomo possuem uma vogal, elas são adicionadas manualmente. A lista de palavras foi construída algoritmicamente a partir do dicionário Jelly usando um script Python. Observe que alguns grupos de letras são repetidos, mas a pergunta permite que as saídas não representem uniformemente cada combinação possível. Se isso fosse preferido, seria fácil tornar cada grupo exclusivo ao custo de dois 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])

Experimente online!

Pitão, 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

Experimente online aqui .

Ruby , 381 379 375 bytes

Usa correspondências desarrumadas de regex para obter os grupos consoantes. Provavelmente poderia ser otimizado.

->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}

Experimente online!