Nhiệm vụ của bạn là tạo ra một từ vô nghĩa có thể phát âm hợp lý với số lượng 'âm tiết' được chỉ định. Mỗi lần chương trình được chạy có thể dẫn đến một từ vô nghĩa khác nhau.

Tính linh hoạt

Một từ có thể phát âm được tạo thành từ các âm tiết, lần lượt được tạo thành từ một nhóm nguyên âm có thể được kẹp giữa hai nhóm phụ âm. Không phải tất cả âm thanh đều có thể phát âm được ở tất cả các vị trí và vì điều này phụ thuộc vào ngôn ngữ, chúng tôi sẽ sử dụng các mẫu dễ hiểu cho người nói tiếng Anh

Nhóm phụ âm bắt đầu:

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 sh sc sl sl sn sn st st

Nhóm nguyên âm:

a e i o u ae ai ao au ee ei eu ia tức là io oa oe oi oo ou ue ui

Kết thúc nhóm Phụ âm:

bcdfglmnprstxz bt ch ck ct ft gh gn lb ld lf ll k l l l l rth sch tch

Kết hợp các âm tiết

Cả hai nhóm phụ âm bắt đầu và kết thúc đều là tùy chọn nói chung, tuy nhiên bạn không thể đặt một kết thúc âm tiết bằng nguyên âm ngay trước khi bắt đầu bằng một nguyên âm.

Khước từ

Vì lợi ích của sự đơn giản, một số từ tiếng Anh thực sự không thể được tạo ra theo cách này, chẳng hạn như chân không, xylophone, mnemonic, pterodactyl, beautiful, blah, they, wow, và hầu hết số nhiều.

Tổng quat

Các mẫu âm tiết có thể sử dụng phím này:

(SC) = phụ âm bắt đầu; (V) = nhóm nguyên âm; (EC) = phụ âm kết thúc

Đối với một âm tiết:

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

Với hai âm tiết:

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

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

• (V) (EC) (V)

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

• (V) (SC) (V)

... và như thế

Ví dụ

1 âm tiết

• xe ngựa
• kéo dài
• tiếng hét
• ê
• shue
• oo
• má

2 âm tiết

• nhạc jazz
• whylprog
• Ăn
• rốn
• ola
• có
• ingsoc
• greespheurz
• bleuspoo

3 âm tiết

• môi giới
• hình vuông
• thủ đô
• opengtrass
• nhân đôi
• anh cả
• phoebliaptmoo
• skolfblauquent

4 âm tiết

• rơm rạ
• chắp vá
• prearneajoomie
• slephotoschou
• doubleplusgood

Mã hóa

Input: một số nguyên cho số lượng âm tiết cần tạo

Kết quả: một từ vô nghĩa (có thể) dài mà nhiều âm tiết dài

Quy tắc

• Một số hình thức ngẫu nhiên (psuedo) là bắt buộc. Tất cả các kết hợp của các âm tiết nên (về mặt lý thuyết) có thể tạo ra, mặc dù phân phối không phải là thống nhất.
  • Bạn có thể cho rằng trình tạo của bạn là một chu kỳ, do đó không nhất thiết phải tạo ra mọi từ có thể về mặt toán học (Nó có thể không có một khoảng thời gian đủ dài trong thực tế) và bạn không cần cung cấp bất kỳ loại bằng chứng nào cho thấy trong thực tế, máy phát điện có thể tạo ra mọi từ có thể.
  • Trình tạo của bạn thực sự phải có khả năng tạo ra ít nhất 255 giá trị riêng biệt, vì vậy bạn không thể trả về 4 mỗi khi trình tạo được gọi.
  • Điều quan trọng cuối cùng là bạn bằng cách nào đó bao gồm tất cả các nhóm chữ cái trong mã của bạn, rằng mỗi nhóm chữ cái có xác suất được chọn khác nhau và mỗi mẫu âm tiết có xác suất xuất hiện khác nhau (nếu được cung cấp ngẫu nhiên thực sự).
• Bạn phải hỗ trợ tối đa 16 từ.
• Ngoài các quy tắc về kết hợp các âm tiết, từ đầu ra không được có:
  • 3 nguyên âm liên tiếp ( a e i o u; điều này có thể xảy ra đối với các qutừ)
  • 3 phụ âm phù hợp liên tiếp

Chúc may mắn!

Lưu ý rằng điều này khác với Tạo một từ có thể phát âm được vì một vài lý do:

• Số lượng âm tiết được chỉ định bởi đầu vào thay vì yêu cầu 10 chữ cái nghiêm ngặt.
• Thử thách này thêm các nhóm chữ không đầy đủ phải được mã hóa (một cách khéo léo) và cho phép nhiều biến thể của âm tiết hơn, vì vậy mã không thể được sao chép từ thử thách khác
• Hình vuông. Tôi cần nói nhiều hơn?

_{Tôi cũng quên kiểm tra bản sao, nhưng hóa ra điều này mang lại đủ mới cho bảng mà nó không quan trọng. Rốt cuộc, có hàng trăm thử thách biến thể quine.}

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

Hãy thử trực tuyến!

05AB1E , 237 234 230 228 byte

.•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 nhờ @MagicOctopusUrn .

Hãy thử trực tuyến hoặc nhận thêm một vài kết quả đầu ra .

Giải trình:

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

Xem mẹo 05AB1E này của tôi (phần Làm thế nào để chuỗi nén không nằm trong từ điển? , Làm thế nào để nén các số nguyên lớn? Và Làm thế nào để liệt kê số nguyên nén? ) Để hiểu làm thế nào các phần nén công trình.

Thạch , 231 byte

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

Hãy thử trực tuyến!

Một chương trình đầy đủ có một đối số duy nhất, số lượng âm tiết cần thiết.

Giải trình

Cốt lõi của điều này là một chuỗi từ điển nén 66 từ. Nếu các từ được chia thành các nhóm phụ âm và nguyên âm và 3 nhóm đầu tiên được sử dụng cho mỗi từ, chúng sẽ tạo ra các nhóm bắt đầu, nguyên âm và kết thúc mong muốn từ câu hỏi. Các ngoại lệ là quvàsqu bởi vì họ có một nguyên âm trong, vì vậy chúng được bổ sung bằng tay. Danh sách từ được xây dựng theo thuật toán từ từ điển Jelly sử dụng tập lệnh Python. Lưu ý một số nhóm chữ cái được lặp lại, nhưng câu hỏi cho phép các đầu ra không thể hiện thống nhất từng kết hợp có thể. Nếu điều này được ưa thích, sẽ đơn giản để làm cho mỗi nhóm trở nên duy nhất với chi phí là hai byte ( 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 byte

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

Hãy thử trực tuyến!

Pyth, 346 335 byte

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

Hãy thử trực tuyến tại đây .

Ruby , 381 379 375 byte

Sử dụng các kết hợp regex lộn xộn để có được các nhóm phụ âm. Có lẽ có thể được tối ưu hóa.

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

Hãy thử trực tuyến!