Ihre Aufgabe ist es, ein unsinniges Wort zu generieren, das mit der angegebenen Anzahl von 'Silben' einigermaßen aussprechbar ist. Jedes Mal, wenn das Programm ausgeführt wird, ergibt sich möglicherweise ein anderes Unsinnwort.

Aussprechbarkeit

Ein aussprechbares Wort besteht aus Silben, die wiederum aus einer Vokalgruppe bestehen, die möglicherweise zwischen zwei Konsonantengruppen eingeschlossen ist. Nicht alle Töne können in allen Positionen ausgesprochen werden, und da dies von der Sprache abhängt, verwenden wir Muster, die für Englischsprachige verständlich sind

Konsonantengruppen starten:

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 g n gr k p pl pr sc sh sk sl sm sn sp st th tr wr wr sh shm shr squ str thr thr

Vokalgruppen:

a e i o u ai ao au ee ei eu ia dh io oa oi oo ou ue ui

Konsonanten-Endgruppen:

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

Silben kombinieren

Sowohl Anfangs- als auch Endkonsonantengruppen sind im Allgemeinen optional. Sie können jedoch keine Silbe, die mit einem Vokal endet, unmittelbar vor eine Silbe setzen, die mit einem Vokal beginnt.

Haftungsausschluss

Der Einfachheit halber können bestimmte englische Wörter, wie Vakuum, Xylophon, Mnemonik, Pterodaktylus, Schön, Bla, Sie, Wow und die meisten Pluralformen, nicht auf diese Weise generiert werden.

Überblick

Mögliche Silbenmuster mit diesem Schlüssel:

(SC) = Startkonsonant; (V) = Vokalgruppe; (EC) = Endkonsonant

Für eine Silbe:

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

Mit zwei Silben:

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

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

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

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

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

• (V) (EC) (SC) (V)
• (V) (EG) (V) (EG)

• (V) (EG) (V)

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

• (V) (SC) (V)

... und so weiter

Beispiele

1 Silbe

• charst
• fest
• geschrumpft
• eess
• shue
• oo
• cheezz

2 Silben

• Jazzcrap
• Whylprog
• Essen
• umba
• ola
• haben
• ingsoc
• greespheurz
• bleuspoo

3 Silben

• brokiompic
• squirdshlicker
• Hauptstadt
• opengtrass
• Doppeltes Denken
• Großer Bruder
• phoebliaptmoo
• skolfblauquent

4 Silben

• strawishoepick
• Patchworkzombie
• prearneajoomie
• slephotoschou
• doubleplusgood

Codierung

Eingabe: Eine Ganzzahl für die Anzahl der zu generierenden Silben

Ausgabe: ein (wahrscheinlich) unsinniges Wort, das viele Silben lang ist

Regeln

• Irgendeine Form von (pseudo) Zufälligkeit ist erforderlich. Alle Silbenkombinationen sollten (theoretisch) erzeugbar sein, wobei die Verteilung nicht einheitlich sein muss.
  • Sie können davon ausgehen, dass Ihr Generator aperiodisch ist, daher muss es nicht mathematisch möglich sein, jedes mögliche Wort zu generieren (in der Realität hat es möglicherweise nicht genügend Zeit), und Sie müssen keinen Beweis dafür vorlegen, dass Ihr Wort aperiodisch ist Generator kann in der Tat jedes mögliche Wort produzieren.
  • Ihr Generator muss in der Lage sein, mindestens 255 verschiedene Werte zu erzeugen, damit Sie nicht einfach 4 zurückgeben können jedes Mal können, wenn der Generator aufgerufen wird.
  • Was letztendlich wichtig ist, ist, dass Sie alle oben genannten Buchstabengruppen irgendwie in Ihren Code aufnehmen, dass jede Buchstabengruppe eine Wahrscheinlichkeit von ungleich Null hat, ausgewählt zu werden, und dass jedes Silbenmuster eine Wahrscheinlichkeit ungleich Null hat, aufzutreten (wenn es mit wahrer Zufälligkeit versehen ist).
• Sie müssen bis zu 16 Silbenwörter unterstützen
• Zusätzlich zu den Regeln zum Kombinieren von Silben darf das Ausgabewort nicht haben:
  • 3 aufeinanderfolgende Vokale ( a e i o udies kann für quWörter passieren )
  • 3 aufeinanderfolgende übereinstimmende Konsonanten

Viel Glück!

Beachten Sie, dass dies aus folgenden Gründen anders ist als Generieren Sie ein aussprechbares Wort :

• Variable Anzahl von Silben, die durch Eingabe angegeben werden und keine strengen 10-Buchstaben-Anforderungen sind.
• Diese Herausforderung fügt nicht erschöpfende Buchstabengruppen hinzu, die (geschickt) codiert werden müssen, und ermöglicht mehr Varianten von Silben, sodass Code nicht einfach von der anderen Herausforderung kopiert werden kann
• Squirdshlicker. Muss ich mehr sagen?

_{Ich habe auch vergessen, zu täuschen, aber es stellt sich heraus, dass dies genug Neues auf den Tisch bringt, dass es keine Rolle spielt. Immerhin gibt es Hunderte von Quine-Varianten-Herausforderungen.}

JavaScript (ES6),  407 -  403 Byte

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

Probieren Sie es 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 Byte dank @MagicOctopusUrn .

Probieren Sie es online aus oder holen Sie sich noch ein paar Ausgaben .

Erläuterung:

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

Sehen Sie sich meinen Tipp 05AB1E an (Abschnitt So komprimieren Sie Zeichenfolgen, die nicht Teil des Wörterbuchs sind , So komprimieren Sie große Ganzzahlen und So komprimieren Sie Ganzzahllisten ), um zu verstehen, wie die Komprimierungselemente funktionieren.

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

Probieren Sie es online!

Ein vollständiges Programm, das ein einziges Argument benötigt, die Anzahl der benötigten Silben.

Erläuterung

Das Herzstück ist eine komprimierte Wörterbuchzeichenfolge mit 66 Wörtern. Wenn die Wörter in Gruppen von Konsonanten und Vokalen aufgeteilt werden und die ersten drei Gruppen für jedes Wort genommen werden, erzeugen sie die gewünschten Start-, Vokal- und Endgruppen aus der Frage. Die Ausnahmen sind quundsqu weil sie einen Vokal haben, werden diese manuell hinzugefügt. Die Wortliste wurde algorithmisch aus dem Jelly-Wörterbuch mit einem Python-Skript erstellt. Beachten Sie, dass einige Buchstabengruppen wiederholt werden, aber die Frage ermöglicht, dass die Ausgaben nicht jede mögliche Kombination einheitlich darstellen. Wenn dies bevorzugt würde, wäre es einfach, jede Gruppe auf Kosten von zwei Bytes ( Q€) eindeutig zu machen .

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

Probieren Sie es online!

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

Probieren Sie es hier online aus .

Rubin , 381 379 375 Bytes

Verwendet chaotische Regex-Übereinstimmungen, um die Konsonantengruppen zu erhalten. Könnte wohl optimiert werden.

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

Probieren Sie es online!