Votre tâche consiste à générer un mot non-sens qui est raisonnablement prononçable avec le nombre spécifié de «syllabes». Chaque fois que le programme est exécuté, il peut en résulter un mot de non-sens différent.

Prononçabilité

Un mot prononçable est composé de syllabes, qui sont à leur tour constituées d'un groupe de voyelles qui est éventuellement pris en sandwich entre deux groupes de consonnes. Tous les sons ne peuvent pas être prononcés dans toutes les positions, et comme cela dépend de la langue, nous utiliserons des modèles compréhensibles par les anglophones

Début des groupes de consonnes:

b c d f g h j k l m n p r s t v w y 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 st th tr wh wr sch scr shm shr squ squ str thr

Groupes de voyelles:

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

Fin des groupes de consonnes:

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 rsh rst rst rth sch tch

Combinaison de syllabes

Les groupes de consonnes de début et de fin sont facultatifs en général, mais vous ne pouvez pas placer une syllabe se terminant par une voyelle juste avant une commençant par une voyelle.

Avertissement

Dans un souci de simplicité, certains mots anglais ne peuvent pas être générés de cette façon, tels que vide, xylophone, mnémonique, ptérodactyle, beau, bla, eux, wow et la plupart des pluriels.

Aperçu

Modèles de syllabes possibles à l'aide de cette touche:

(SC) = consonne de départ; (V) = groupe de voyelles; (EC) = consonne finale

Pour une syllabe:

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

Avec deux syllabes:

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

... etc

Exemples

1 syllabe

• charst
• serré
• shriegn
• eess
• shue
• oo
• cheezz

2 syllabes

• jazzcrap
• whylprog
• en mangeant
• umba
• ola
• avoir
• ingsoc
• greespheurz
• bleuspoo

3 syllabes

• brokiompic
• squirdshlicker
• Capitale
• opengtrass
• double pensée
• grand frère
• phoebliaptmoo
• skolfblauquent

4 syllabes

• paille
• patchworkzombie
• preearneajoomie
• slephotoschou
• doubleplusgood

Codage

Entrée: un entier pour le nombre de syllabes à générer

Sortie: un mot (probablement) absurde qui contient de nombreuses syllabes

Règles

• Une certaine forme d'aléa (pseudo) est requise. Toutes les combinaisons de syllabes devraient être (théoriquement) possibles à générer, bien que la distribution ne doive pas être uniforme.
  • Vous pouvez supposer que votre générateur est apériodique, il ne doit donc pas être mathématiquement possible de générer tous les mots possibles (il peut ne pas avoir une période suffisamment longue en réalité) et vous n'avez pas besoin de fournir une sorte de preuve que votre générateur peut, en fait, produire tous les mots possibles.
  • Votre générateur doit en fait être capable de produire au moins 255 valeurs distinctes, vous ne pouvez donc pas simplement retourner 4 à chaque appel du générateur.
  • Ce qui est finalement important, c'est que vous incluiez en quelque sorte tous les groupes de lettres ci-dessus dans votre code, que chaque groupe de lettres ait une probabilité non nulle d'être sélectionné, et que chaque motif de syllabe ait une probabilité non nulle de se produire (s'il est fourni avec un vrai caractère aléatoire).
• Vous devez prendre en charge jusqu'à 16 mots de syllabe
• En plus des règles de combinaison des syllabes, le mot de sortie ne doit pas avoir:
  • 3 voyelles consécutives ( a e i o u; cela peut arriver pour les qumots)
  • 3 consonnes correspondantes consécutives

Bonne chance!

Notez que ceci est distinct de Générer un mot prononçable pour plusieurs raisons:

• Nombre variable de syllabes spécifié par entrée plutôt qu'une exigence stricte de 10 lettres.
• Ce défi ajoute des groupes de lettres non exhaustifs qui doivent être (intelligemment) encodés et permet plus de variantes de syllabes, donc le code ne peut pas être simplement copié de l'autre défi
• Squirdshlicker. Dois-je en dire plus?

_{J'ai également oublié de duper le chèque, mais il s'avère que cela apporte suffisamment de nouveautés à la table pour que cela n'ait pas d'importance. Après tout, il existe des centaines de défis de variantes quine.}

JavaScript (ES6),  407  403 octets

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

Essayez-le en ligne!

05AB1E , 237 234 230 228 octets

.•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 octets grâce à @MagicOctopusUrn .

Essayez-le en ligne ou obtenez quelques sorties supplémentaires .

Explication:

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

Voir cette astuce 05AB1E de la mine (section Comment chaînes Compresser ne font pas partie du dictionnaire? , Comment compresser les grands entiers? , Et comment les listes entières Compresser? ) Pour comprendre le fonctionnement de pièces de compression.

Gelée , 231 octets

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ß¹Ñ?

Essayez-le en ligne!

Un programme complet qui prend un seul argument, le nombre de syllabes nécessaires.

Explication

Le cœur de ceci est une chaîne de dictionnaire compressée de 66 mots. Si les mots sont divisés en groupes de consonnes et de voyelles et que les 3 premiers groupes sont pris pour chaque mot, ils génèrent les groupes de départ, de voyelle et de fin souhaités à partir de la question. Les exceptions sont quet squparce qu'elles contiennent une voyelle, elles sont donc ajoutées manuellement. La liste de mots a été construite de manière algorithmique à partir du dictionnaire Jelly à l'aide d'un script Python. Notez que certains groupes de lettres sont répétés, mais la question permet aux sorties de ne pas représenter uniformément chaque combinaison possible. Si cela était préféré, il serait simple de rendre chaque groupe unique au prix de deux octets ( 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 octets

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

Essayez-le en ligne!

Pyth, 346 335 octets

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

Essayez-le en ligne ici .

Rubis , 381 379 375 octets

Utilise des correspondances d'expression rationnelle désordonnées pour obtenir les groupes de consonnes. Pourrait probablement être optimisé.

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

Essayez-le en ligne!