Twoim zadaniem jest wygenerowanie nonsensownego słowa, które można rozsądnie wymówić przy użyciu określonej liczby „sylab”. Każde uruchomienie programu może skutkować innym bezsensownym słowem.

Zdolność do wymawiania

Wymawiane słowo składa się z sylab, które z kolei składają się z grupy samogłoskowej, która prawdopodobnie jest umieszczona pomiędzy dwiema grupami spółgłoskowymi. Nie wszystkie dźwięki są wymawiane we wszystkich pozycjach, a ponieważ zależy to od języka, użyjemy wzorców zrozumiałych dla osób mówiących po angielsku

Początkowe grupy spółgłoskowe:

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 sm sp sp st th tr wh wr sch scr shm shr squ str thr thr

Grupy samogłoskowe:

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

Kończące grupy Consonant:

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 rk rl rl rm rn rp rt rv rz sh sk sp ss st zz lch lsh lth rch rsh rst rth sch tch

Łączenie sylab

Zarówno początkowa, jak i końcowa grupa spółgłoskowa są na ogół opcjonalne, jednak nie można umieszczać sylaby kończącej się samogłoską bezpośrednio przed tą rozpoczynającą się od samogłoski.

Zrzeczenie się

W trosce o prostotę, niektóre angielskie słowa nie mogą być generowane w ten sposób, takie jak próżnia, ksylofon, mnemonik, pterodaktyl, piękny, bla, one, wow, i większość liczby mnogiej.

Przegląd

Możliwe wzorce sylab przy użyciu tego klucza:

(SC) = początkowa spółgłoska; (V) = grupa samogłosek; (EC) = kończąca spółgłoska

Dla jednej sylaby:

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

Z dwiema sylabami:

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

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

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

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

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

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

• (V) (WE) (V)

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

• (V) (SC) (V)

... i tak dalej

Przykłady

1 sylaba

• charst
• uda
• shriegn
• eess
• shue
• z oo
• Cheezz

2 sylaby

• jazzcrap
• whylprog
• jedzenie
• umba
• ola
• mieć
• ingsoc
• greespheurz
• bleuspoo

3 sylaby

• brokiompic
• squirdshlicker
• kapitał
• opengtrass
• dwuznaczne
• duży brat
• phoebliaptmoo
• skolfblauquent

4 sylaby

• Strawishoepick
• patchworkzombie
• prearneajoomie
• slephotoschou
• doubleplusgood

Kodowanie

Dane wejściowe: liczba całkowita liczby sylab do wygenerowania

Wyjście: (prawdopodobnie) nonsensowne słowo, które ma wiele sylab

Zasady

• Wymagana jest jakaś forma losowości (psuedo). Wszystkie kombinacje sylab powinny być (teoretycznie) możliwe do wygenerowania, chociaż rozkład nie musi być jednolity.
  • Możesz założyć, że twój generator jest nieokresowy, więc nie musi być matematycznie możliwe wygenerowanie każdego możliwego słowa (w rzeczywistości może nie mieć wystarczająco długiego okresu) i nie musisz przedstawiać żadnego dowodu, że twój generator może w rzeczywistości wygenerować każde możliwe słowo.
  • Twój generator musi być w stanie wygenerować co najmniej 255 różnych wartości, więc nie możesz po prostu zwrócić 4 za każdym razem, gdy generator jest wywoływany.
  • Ostatecznie ważne jest to, że w jakiś sposób włączysz wszystkie powyższe grupy liter do swojego kodu, że każda grupa liter ma niezerowe prawdopodobieństwo, że zostanie wybrany, a każdy wzorzec sylaby ma niezerowe prawdopodobieństwo wystąpienia (jeśli zostanie podana prawdziwa losowość).
• Musisz obsłużyć do 16 sylab słów
• Oprócz zasad łączenia sylab słowo wyjściowe nie może mieć:
  • 3 kolejne samogłoski ( a e i o u; może się tak zdarzyć w przypadku qusłów)
  • 3 kolejne dopasowane spółgłoski

Powodzenia!

Zauważ, że różni się to od Wygeneruj wymawiane słowo z kilku powodów:

• Zmienna liczba sylab określona przez dane wejściowe zamiast ścisłego wymogu 10 liter.
• To wyzwanie dodaje niewyczerpujące grupy liter, które muszą być (sprytnie) zakodowane i pozwala na więcej wariantów sylab, więc kodu nie można po prostu skopiować z innego wyzwania
• Squirdshlicker. Czy muszę powiedzieć więcej?

_{Zapomniałem też oszukiwać, ale okazuje się, że przynosi to wystarczająco dużo nowego do stołu, że to nie ma znaczenia. W końcu istnieją setki różnych wariantów quine.}

JavaScript (ES6),  407  403 bajtów

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

Wypróbuj online!

05AB1E , 237 234 230 228 bajtów

.•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 bajty dzięki @MagicOctopusUrn .

Wypróbuj online lub uzyskaj kilka dodatkowych wyników .

Wyjaśnienie:

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

Zobacz tę końcówkę 05AB1E kopalni (sekcja Jak kompresować strun nie Część słownika? , Jak skompresować dużych liczb całkowitych? I jak skompresować list całkowitych? ) , Aby zrozumieć, jak działa zamienne kompresji.

Galaretka , 231 bajtów

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

Wypróbuj online!

Pełny program, który przyjmuje pojedynczy argument, wymaganą liczbę sylab.

Wyjaśnienie

Trzon tego stanowi 66-wyrazowy skompresowany ciąg słownika. Jeśli słowa są podzielone na grupy spółgłosek i samogłosek, a pierwsze 3 grupy są brane dla każdego słowa, generują pożądane grupy początkowe, samogłoski i końcowe z pytania. Wyjątkami są quisqu ponieważ mają one samogłoskę, więc są one dodawane ręcznie. Lista słów została zbudowana algorytmicznie ze słownika Jelly przy użyciu skryptu Python. Zauważ, że niektóre grupy liter są powtarzane, ale pytanie pozwala, aby dane wyjściowe nie reprezentowały w sposób jednolity każdej możliwej kombinacji. Gdyby to było preferowane, byłoby łatwo uczynić każdą grupę unikalną kosztem dwóch bajtów ( 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 bajtów

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

Wypróbuj online!

Pyth, 346 335 bajtów

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

Wypróbuj online tutaj .

Rubinowy , 381 379 375 bajtów

Używa niechlujnych dopasowań wyrażeń regularnych, aby uzyskać grupy spółgłoskowe. Prawdopodobnie można go zoptymalizować.

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

Wypróbuj online!