แนวคิด

คุณสามารถปีนป่ายตัวอักษรภาษาอังกฤษเพื่อที่จะยังคงสามารถร้องเพลงท่วงทำนอง Twinkle Twinkle Little Star ได้โดยไม่ทำลายการแต่งเพลง?

กฎระเบียบ

แลกเปลี่ยน

สมมติว่าตัวอักษรที่มีอยู่ในแต่ละชุดต่อไปนี้สามารถเปลี่ยนได้อย่างอิสระโดยค่าเริ่มต้นโดยไม่ทำลายการปรับแต่ง:

• {A, J, K}
• {B, C, D, E, G, P, T, V, Z}
• {I, Y}
• {Q, U}
• {S, X, F}
• {M, N}
• ดังนั้น H, L, O, R และ W จึงถูกล็อคเข้าที่

เอาท์พุต

โปรแกรมจำเป็นต้องส่งออกสตริง RANDOM เส้นเดียว (หรือรายการของตัวอักษร) ที่มีตัวอักษรภาษาอังกฤษที่สมบูรณ์ในลำดับใดก็ได้หากคำสั่งนั้นตรงตามเงื่อนไขข้างต้น ไม่มีทางที่คุณจะคาดเดาว่าโปรแกรมของคุณจะส่งออกสตริงใด (ถ้าเราไม่สนใจการเพาะ) หมายความว่าคุณไม่สามารถ hardcode ได้

โปรแกรมของคุณต้องมีความน่าจะเป็นในเชิงบวก (ไม่จำเป็นต้องเหมือนกัน) ในการสร้าง$9! \cdot 3! \cdot 3! \cdot 2! \cdot 2! \cdot 2! = 104509440$แต่ละตัว! ⋅ 3 ! ⋅ 3 ! ⋅ 2 ! ⋅ 2 ! ⋅ 2 ! =เอาต์พุต104509440

ไม่มีข้อ จำกัด การจัดรูปแบบโดยเฉพาะเกี่ยวกับการเว้นวรรคตัวคั่นหรือตัวอักษรเพียงให้สอดคล้องกัน

เป้าหมาย

ไบต์ที่น้อยที่สุดจะชนะ!

ตัวอย่าง:

• KCDBPSVHIAJLMNOZQRXGUEWFYT
• A, G, Z, V, P, X, C, H, Y, K, J, L, N, M, O, T, U, R, S, D, Q, B, W, F, I, E
• KVTDCFBHIJALNMOPURSZQGWXYE
• jcdebxthikalnmogursvq pwfyz
• ABCDEFGHIJKLMNOPQRSTUVWXYZ

Nonexample:

• HLWROABCDEFZXYGIJKMNPQTSVU

พิสูจน์แนวคิด: (Python3, 529 ไบต์)

import random
g1 = ['A', 'J', 'K']
g2 = ['B', 'C', 'D', 'E', 'G', 'P', 'T', 'V', 'Z']
g3 = ['I', 'Y']
g4 = ['Q', 'U']
g5 = ['S', 'X', 'F']
g6 = ['M', 'N']
random.shuffle(g1)
random.shuffle(g2)
random.shuffle(g3)
random.shuffle(g4)
random.shuffle(g5)
random.shuffle(g6)
print(g1[0] + g2[0] + g2[1] + g2[2] + g2[3] + g5[0] + g2[4] + 'H' + g3[0] + g1[1] + g1[2] + 'L' + g6[0] + g6[1] + 'O' + g2[5] + g4[0] + 'R' + g5[1] + g2[6] + g4[1] + g2[7] + 'W' + g5[2] + g3[1] + g2[8])

05AB1E , 28 ไบต์

A.•¬=©ƶÓÄûkTVã”ØζÞ•Dás#€.rJ‡

ส่งออกเป็นสตริงตัวพิมพ์เล็กเดียว

$n$

คำอธิบาย:

A                    # (a) Push the lowercase alphabet
 .•¬=©ƶÓÄûkTVã”ØζÞ•  # Push compressed string "ajk bcdegptvz iy qu sxf mn"
  Dá                 # (b) Duplicate it, and only keep the letters (removing the spaces)
    s#               # Swap to get the string again, and split it by spaces
      €.r            # Shuffle each substring randomly
         J           # (c) Join it back together to a single string
          ‡          # Transliterate all characters from (b) to (c) in string (a)
                     # (and output the result implicitly)

ดู 05AB1E นี้เคล็ดลับของฉัน (ส่วนวิธีการบีบอัดสตริงไม่ใช่ส่วนหนึ่งของพจนานุกรม? )จะเข้าใจว่าทำไมเป็น.•¬=©ƶÓÄûkTVã”ØζÞ•"ajk bcdegptvz iy qu sxf mn"

Python 3 , 140 133 124 123 ไบต์

d=*map(set,'AJK BCDEGPTVZ IY QU SXF MN H L O R W'.split()),
print([d[int(c,16)].pop()for c in'0111141620075581394131a421'])

ลองออนไลน์!

_{-1 ไบต์ขอบคุณ Jo King}

Python 2 , 174 170 158 ไบต์

from random import*
s=''
for c in'abbbbebHcaaLffObdRebdbWecb':s+=choice(list(set(('AJK BCDEGPTVZ IY QU SXF MN '+c).split()['abcdef'.find(c)])-set(s)))
print s

ลองออนไลน์!

Ruby , 102 ไบต์

s=[*?A..?Z]*''
%w(AJK BCDEGPTVZ IY QU SXF MN).map{|e|a=e.chars.shuffle;s.gsub!(/[#{e}]/){a.pop}}
$><<s

ลองออนไลน์!

Pyth , 59 57 56 ไบต์

hMeD,Vs.SMJc"ajk bcdegptvz iy qu fsx mn h l o r w"dxLGsJ

ลองออนไลน์!

เอาต์พุตคืออาร์เรย์ของตัวอักษรตัวพิมพ์เล็ก

hMeD,Vs.SMJc"ajk bcdegptvz iy qu fsx mn h l o r w"dxLGsJ   Implicit: d=" ", G=<lowercase alphabet>
          Jc"ajk bcdegptvz iy qu fsx mn h l o r w"d        Chop the grouping string on spaces, store in J
                                                      sJ   Concatenate J into single string
                                                   xLG     Find the index of each letter in grouping string in the unaltered alphabet
       .SMJ                                                Shuffle each group in J
      s                                                    Concatenate into a single string
    ,V                                                     Pair the shuffled string with their 'correct' positions in the alphabet
  eD                                                       Order the pairs by the derived positions (last element of each pair)
hM                                                         Keep the letter from each pair (the first element)
                                                           Implicit print

R , 93 91 ไบต์

`^`=strsplit
L=LETTERS
for(s in el('AJK7BCDEGPTVZ7IY7QU7FSX7MN'^7)^'')L[L%in%s]=sample(s)
L

ลองออนไลน์!

Perl 6 , 76 ไบต์

{my@a='A'..'Z';<AJK BCDEGPTVZ IY QU SXF MN>>>.&{@a[.ords X-65].=pick(*)};@a}

ลองออนไลน์!

การบล็อกโค้ดแบบไม่ระบุชื่อโดยไม่มีข้อโต้แย้งและส่งคืนรายการของอักขระ

คำอธิบาย:

{                                                                          } # Anonymous code block
 my@a='A'..'Z';      # Initialise @a as a list of the alphabet
               <AJK BCDEGPTVZ IY QU SXF MN>   # For each of the sets of letters
                                           >>.&{@a[.ords X-65].=       }  # Set those indexes
                                                                pick(*)   # To a random order
                                                                        ;@a  # And return

JavaScript - 421 344 328 320 306 280 277 276 ... 176 ไบต์

-77 Bytes - ด้วยตัวเอง

-18 Byte - ขอบคุณ@tshและ@Geza Kerecsenyiที่ทำให้ฉันเห็นสิ่งที่@tshเริ่มต้นชี้ไปที่

-8 Bytes - ขอบคุณ@Geza Kerecsenyi

-14 Bytes - ด้วยความช่วยเหลือของ@Geza Kerecsenyi

- 28 Bytes - บนตัวฉันเอง

-3 Bytes - อีกครั้งด้วยความช่วยเหลือของ@Geza Kerecsenyi

-1 Bytes - จะเกิดอะไรขึ้น ...

...

-100 Bytes - @Kaiidoฆ่ามันและผ่านบางขั้นตอนก่อนที่สิ่งนี้จะลง ถึง176 ไบต์

แข็งแรงเล่นกอล์ฟ:

c=[,'AJK','BCDEGPTVZ','IY','QU','SXF','MN'].map(s=>[...s]);alert([...'1222252H311L66O24R5242W532'].reduce((o,v)=>o+(+v?(p=>p.splice((Math.random()*p.length)|0,1))(c[v]):v),""))

หรือลองออนไลน์ !

เวทมนตร์รูน 210 ไบต์

>yy `AJK`06B$̤$@
>`BCDEGPTVZ`06B$$$$ $̤$y $ $y @
>̤`IY`06Byyy$yyy̤ @
> ̤`QU`06Byy̤ $y @
> ̤`FSX`06B $yy̤$yy@
>y̤ `MN`06Byyy $@
}}f}l3-[r\
3-[2'RA?rR1Kl'RAs]{1-:0)?\}l
> ̤`HLORW`06Bo$y $y$y$yy@ \~{{B͍

ลองออนไลน์!

การสุ่มนั้นไม่เหมือนกันเนื่องจากไม่มีวิธีที่ดีในการทำใน Runic แต่จะสุ่มหมุนตัวอักษรแต่ละชุด (เช่น[BCDEGPTVZ]การจัดกลุ่มเดียว) ด้วยจำนวนเงินบางส่วน (เช่นการหมุนด้านบนที่กำหนดด้วย 4 โดยที่ด้านบนสุดของสแต็คอยู่ทางขวาผลลัพธ์จะเป็น[BCDEGZPTV]) จากนั้นจะสุ่มเลือกว่าจะ ย้อนกลับกองซ้อน ทำการดำเนินการเหล่านี้ 15 ครั้ง ดังนั้นการสั่งซื้อที่เป็นไปได้ทั้งหมดอาจเป็นไปได้แต่ไม่เท่ากัน (ในกรณีที่สิ่งนี้ไม่เพียงพอการเพิ่มจะทำให้มีค่าใช้จ่ายเพิ่มขึ้นเป็นศูนย์ไบต์สูงถึง 15000 สลับแบบสุ่ม)

นี่คือส่วนของรหัสที่จัดการการสับ:

  v              vvvv           Loop counter

}}f}l3-[r\                      < Loop entry
[2'RA?r1KRl'RAs]{1-:0)?\}l3-
                       \~{{B͍    < loop exit

 ^^^^^^                         Randomly reverse
          ^^^^^                 Rotate by a random an amount

ส่วนที่เหลือของรหัส unrolls เป็น:

                     ABCDEFGHIJKLMNOPQRSTUVWXYZ
>      `AJK`08B      $        $$;
> `BCDEGPTVZ`08B      $$$$ $        $   $ $   $;
>         `IY`08B            $               $;
>          `QU`08B                   $   $;
>          `FSX`08B       $            $    $;
>            `MN`08B             $$;
>          `HLORW`08Bo      $   $  $  $    $;

^                                                   Create IPs
 ^^^^^^^^^^^^^^^^                                   Set letter groupings
                  ^^^                               Call shuffle function
                      ^^^^^^^^^^^^^^^^^^^^^^^^^^    Print letters
                     ^                              Last letter group needs to be sorted

หากตัวอักษรถูกปล่อยทิ้งไว้ (แต่กลับด้านหนึ่งครั้ง) โดยการเปลี่ยนสองไบต์ตัวอักษรจะถูกพิมพ์ตามปกติซึ่งสามารถใช้เพื่อตรวจสอบว่าการจัดกลุ่มตัวอักษรทั้งหมดพิมพ์ในสถานที่ที่ถูกต้อง ช่องว่างที่เปลี่ยนBคำสั่งออกจากเฟสคือเพื่อให้ IP ทั้งหมดสามารถใช้ฟังก์ชันลูปในเวลาเดียวกันโดยไม่เกิดการชนจากนั้นนำพวกมันกลับเข้าสู่เฟสอีกครั้ง

สำหรับกอล์ฟพื้นที่แรกที่สามารถลบได้ในทุกบรรทัดถูกตัดออกจากนั้นแต่ละช่องว่างจะถูกแปลงเป็น a yและทุกลำดับของyyyyการแปลงเป็น̤เพราะ̤และyyyyมีความล่าช้าเท่ากัน แต่มีราคาถูกกว่า 2 ไบต์ การออกจากลูปถูกรวมเข้ากับHLORWส่วนโปรแกรมหลักเพื่อบันทึกในระยะห่างไบต์ (12 ไบต์)

Perl 5 , 103 91 85 ไบต์

map{my%l;@l{/./g}++;@k{/./g}=keys%l}AJK,BCDEGPTVZ,SXF,IY,QU,MN;say map$k{$_}||$_,A..Z

ลองออนไลน์!

รหัสนี้ (ab) ใช้ข้อเท็จจริงที่ว่าเอาต์พุตของแฮชคีย์ ( %l) ของ Perl เป็นการสุ่มเพื่อสร้างการแมป ( %k) ของตัวอักษรที่แก้ไขได้ทั้งหมดให้กับหนึ่งในคู่หูที่เป็นไปได้ของพวกเขา ณ เวลาที่ส่งออกคีย์ใด ๆ ที่ไม่มีอยู่จะถือว่าไม่มีการเปลี่ยนแปลง

เยลลี่ 34 ไบต์

ØA“wẸXWỵḲ⁻ȦƙṄṇ’œ?µ“ĠQ’ḃ3ÄœṖ⁸Ẋ€Ẏị@Ụ

ลองออนไลน์!

Python 3 , 149 ไบต์

a,b,i,q,s,m,h,l,o,r,w=(set(s)for s in["AJK","BCDEGPTVZ","IY","QU","SXF","MN",*"HLORW"])
print([eval(c).pop()for c in[*"abbbbsbhiaalmmobqrsbqbwsib"]])

ลองออนไลน์!

การสุ่มโดยใช้ป๊อป () สำหรับชุดจดหมาย

APL (ขยาย Dyalog) , 55 ไบต์

โปรแกรมเต็มรูปแบบ พิมพ์ตัวพิมพ์ใหญ่ด้วยช่องว่างนำหน้าและต่อท้าย แต่ไม่มีช่องว่างตัวกลาง

{(?⍨∘≢⊇⊢)@(∊∘⍺)⊢⍵}/⌈'AjkBcdegptvzIyQuSxfMn'(⊂⍤⊢,⍨∊⊂⊣)⎕A

ลองออนไลน์!

⎕A ตัวอักษรตัวพิมพ์ใหญ่

'AjkBcdegptvzIyQuSxfMn'(… ) ใช้ฟังก์ชัน tacit แบบไม่ระบุชื่อต่อไปนี้โดยใช้เป็นอาร์กิวเมนต์ขวาและสตริงที่ระบุเป็นอาร์กิวเมนต์ซ้าย:

⊣ สำหรับอาร์กิวเมนต์ซ้าย

⊂ แบ่งพาร์ติชันดังกล่าวแล้วเริ่มกลุ่มใหม่ที่

∊ อักขระอาร์กิวเมนต์ทางซ้ายคือสมาชิกของอาร์กิวเมนต์ที่ถูกต้อง (เช่นตัวอักษรตัวพิมพ์ใหญ่)

,⍨ ผนวก

⊂ แนบ (ที่จะรักษามันเป็นองค์ประกอบเดียว)  โต้แย้งสิทธิ
⍤
⊢

⌈ พิมพ์ใหญ่ทุกอย่าง

{... }/ ลดจำนวนแลมบ์ดานิรนามโดยให้ ... "QU"λ("SXF"λ("MN"λ"A-Z")):

 ⊢⍵ ในอาร์กิวเมนต์ที่ถูกต้อง (ตัวอักษรที่กำลังดิ้นรนอยู่ระหว่างดำเนินการ)

 (… )@(∊∘⍺) ใช้ฟังก์ชัน tacit แบบไม่ระบุชื่อต่อไปนี้กับชุดย่อยที่เป็นสมาชิกของอาร์กิวเมนต์ด้านซ้าย (กลุ่มสัมผัส)

  ⊢ บนเซ็ตย่อยนั้น

  ⊇ จัดลำดับใหม่ให้เป็น

  ?⍨ การเรียงสับเปลี่ยนแบบสุ่ม
  ∘ ของความยาว
  ≢ นับของตัวอักษรในชุดย่อย

ถ่าน 43 ไบต์

ＦαＦ⪪”＆↖(vＪf#Ｓ»↖ιηa↷Ｎ↖⪪νＰ´↑x‖υ” Ｆ№κι‽Φκ¬№ＫＡμ

ลองออนไลน์! การเชื่อมโยงคือการสร้างรหัสเวอร์ชัน ถ่านไม่มีตัวดำเนินการสับ แต่ฉันมาด้วยวิธีการสุ่มตัวอย่างโดยไม่มีการแทนที่ คำอธิบาย:

Ｆα

คล้องตัวอักษรแต่ละตัว

Ｆ⪪”＆↖(vＪf#Ｓ»↖ιηa↷Ｎ↖⪪νＰ´↑x‖υ” 

แยกสตริงAJK BCDEGPTVZ IY QU SXF MN H L O R Wบนช่องว่างและวนรอบสตริงย่อย

Ｆ№κι

วนซ้ำตามจำนวนครั้งที่ตัวอักษรปัจจุบันปรากฏในสตริงย่อย (ฉันใช้การวนซ้ำเนื่องจากเงื่อนไขจะต้องมีelsecaluse หรือฉันสามารถกรองบนสายอักขระย่อยที่มีตัวอักษรปัจจุบันสำหรับจำนวนไบต์เดียวกัน)

‽Φκ¬№ＫＡμ

พิมพ์ตัวอักษรแบบสุ่ม แต่ไม่รวมตัวอักษรที่ถูกพิมพ์ไปแล้ว

เรติน่า , 80 ไบต์

K`1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z
~(K`123456
.
?O`$&.¶
)`¶$
[blank line]
\d
[blank line]

ลองออนไลน์!

อาจไม่ใช่วิธีที่เล่นกอล์ฟมากที่สุด แต่ฉันจะส่งต่อไป

คำอธิบาย:

K`1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z

1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Zการตั้งค่าการทำงานเพื่อสตริง มีตัวเลขอยู่หน้าตัวอักษรแต่ละตัวในกลุ่มเช่นAกันJและKทุกตัวมีอยู่1ก่อนตัวอักษร

~(

ทำเครื่องหมายส่วนของรหัสที่จะสร้างรหัสเรตินาจากนั้นเรียกใช้ในภายหลัง

K`123456

ตั้งค่าสตริงการทำงานเป็น 123456

.
?O`$&.¶

แทนที่ตัวละครแต่ละตัวด้วย ?O`{character}.¶

)`¶$
[blank line]

ลบ newline ที่ต่อท้ายและเสร็จสิ้นกลุ่มเพื่อสร้างรหัส กลุ่มจะสร้างรหัส:

?O`1.
?O`2.
?O`3.
?O`4.
?O`5.
?O`6.

{n}.ตรงกับอินสแตนซ์ทั้งหมดของหมายเลขnตามด้วยอักขระ ?Oเรียงลำดับตัวอย่างแต่ละแบบสุ่มและจะทำสำหรับชุดอักขระทั้งหมด

\d
[blank line]

สุดท้ายลบตัวเลขทั้งหมดและเอาท์พุทสายที่สร้าง