Konzept

Auf welche Weise können Sie das englische Alphabet verschlüsseln, damit es immer noch in der Melodie Twinkle Twinkle Little Star gesungen werden kann, ohne die Melodie zu ruinieren?

Regeln

Tauschen

Angenommen, die Buchstaben in den folgenden Sätzen können standardmäßig frei ausgetauscht werden, ohne die Melodie zu ruinieren:

• {A, J, K}
• {B, C, D, E, G, P, T, V, Z}
• {I, Y}
• {Q, U}
• {S, X, F}
• {M, N}
• Daher sind H, L, O, R und W an Ort und Stelle verriegelt

Ausgabe

Das Programm muss eine einzelne RANDOM-Zeichenfolge (oder eine Liste von Zeichen) ausgeben, die das vollständige englische Alphabet in einer beliebigen Reihenfolge enthält, sofern diese Reihenfolge die oben genannten Bedingungen erfüllt. Es sollte keine Möglichkeit für Sie geben, vorherzusagen, welche Zeichenfolge Ihr Programm ausgibt (wenn wir das Seeding ignorieren), was bedeutet, dass Sie es nicht einfach hart codieren können.

Ihr Programm muss eine positive Wahrscheinlichkeit (nicht unbedingt einheitlich) haben, jede der erzeugen Ausgänge.$9! \cdot 3! \cdot 3! \cdot 2! \cdot 2! \cdot 2! = 104509440$

Es gibt keine besonderen Formatierungsbeschränkungen in Bezug auf Abstand, Begrenzer oder Groß- / Kleinschreibung. Seien Sie einfach konsistent.

Tor

Wenigste Bytes gewinnt!

Beispiele:

• 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

Kein Beispiel:

• HLWROABCDEFZXYGIJKMNPQTSVU

Proof of Concept: (Python3, 529 Byte)

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 Bytes

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

Ausgabe als einzelne Zeichenfolge in Kleinbuchstaben.

$n$

Erläuterung:

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)

Sehen Sie diese 05AB1E Spitze Mine (Abschnitt Wie Kompresse Strings nicht Teil des Wörterbuchs? ) Zu verstehen , warum .•¬=©ƶÓÄûkTVã”ØζÞ•ist "ajk bcdegptvz iy qu sxf mn".

Python 3 , 140 133 124 123 Bytes

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

Probieren Sie es online!

_{-1 Byte, danke an Jo King}

Python 2 , 174 170 158 Bytes

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

Probieren Sie es online!

Ruby , 102 Bytes

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

Probieren Sie es online!

Pyth , 59 57 56 Bytes

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

Probieren Sie es online!

Die Ausgabe ist ein Array von Kleinbuchstaben.

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 Bytes

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

Probieren Sie es online!

Perl 6 , 76 Bytes

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

Probieren Sie es online!

Anonymer Codeblock, der keine Argumente verwendet und eine Liste von Zeichen zurückgibt.

Erläuterung:

{                                                                          } # 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 Bytes

-77 Bytes - alleine

-18 Bytes - danke an @tsh und @Geza Kerecsenyi , die mir gezeigt haben, worauf @tsh ursprünglich hingewiesen hat

-8 Bytes - danke an @Geza Kerecsenyi

-14 Bytes - mit Hilfe von @Geza Kerecsenyi

- 28 Bytes - alleine

-3 Bytes - wieder mit Hilfe von @Geza Kerecsenyi

-1 Bytes - wie konnte das passieren ...

...

-100 Bytes - @Kaiido hat es getötet und über ein paar Schritte, bevor das Ganze zusammenbrach bis 176 Bytes

Golf gespielt:

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),""))

oder online ausprobieren !

Runenverzauberungen , 210 Bytes

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

Probieren Sie es online!

Die Randomisierung ist nicht einheitlich, da es in Runic keinen guten Weg gibt, dies zu tun. Stattdessen dreht es zufällig jede Sammlung von Buchstaben (z. B. [BCDEGPTVZ]eine Gruppierung) um einen bestimmten Betrag (z. B. wenn das oben gesetzte um 4 gedreht wird, wobei sich die Oberseite des Stapels rechts befindet, ist das Ergebnis [BCDEGZPTV]) und entscheidet dann zufällig, ob dies der Fall ist oder nicht kehre den Stapel um. Diese Operationen werden 15 Mal ausgeführt. Infolgedessen sind alle möglichen Bestellungen möglich, aber nicht gleich wahrscheinlich. (Für den Fall, dass dies nicht ausreicht, kostet eine weitere Erhöhung 0 Byte , bis zu 15000 Shuffle-Schleifen).

Dies ist der Abschnitt des Codes, der das Mischen behandelt:

  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

Der Rest des Codes entfaltet sich darin:

                     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

Wenn die Buchstaben durch Ändern von zwei Bytes nicht gemischt (aber einmal umgekehrt) werden, wird das Alphabet normal gedruckt. Dies kann verwendet werden, um sicherzustellen , dass alle Buchstabengruppierungen an den richtigen Stellen gedruckt werden. Durch das Leerzeichen werden die BBefehle phasenverschoben, sodass alle IPs die Funktionsschleife gleichzeitig verwenden können, ohne zu kollidieren, und sie dann wieder in die Phase zurückbringen können.

Zum Golfen wurde zuerst jegliches Leerzeichen, das in allen Zeilen entfernt werden konnte, abgeschnitten, dann wurden jeweils zwei Leerzeichen in ein konvertiert y, und jede Sequenz von yyyywurde in ̤weil konvertiert ̤und yyyyist genauso verzögert, aber 2 Byte billiger. Der Loop-Exit wurde ebenfalls mit dem HLORWHauptprogramm-Segment kombiniert , um die Abstandsbytes (12 Bytes) einzusparen.

Perl 5 , 103 91 85 Bytes

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

Probieren Sie es online!

Dieser Code (ab) verwendet die Tatsache, dass Perls Ausgabe von Hash-Schlüsseln ( %l) zufällig ist, um eine Zuordnung ( %k) aller veränderbaren Buchstaben zu einem ihrer möglichen Gegenstücke zu erstellen . Zum Zeitpunkt der Ausgabe wird angenommen, dass ein nicht vorhandener Schlüssel unverändert ist.

Jelly , 34 Bytes

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

Probieren Sie es online!

Python 3 , 149 Bytes

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

Probieren Sie es online!

Randomisierung mit pop () als Buchstabensatz

APL (Dyalog Extended) , 55 Byte

Volles Programm. Druckt Großbuchstaben mit einem führenden und einem nachgestellten Leerzeichen, jedoch ohne Zwischenräume.

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

Probieren Sie es online!

⎕A das Großbuchstaben

'AjkBcdegptvzIyQuSxfMn'(… ) Wende die folgende anonyme implizite Funktion als rechtes Argument und die angegebene Zeichenfolge als linkes Argument an:

⊣ für das linke argument,

⊂ partitionieren Sie es und beginnen Sie ein neues Segment, in dem

∊ Die Zeichen für die linken Argumente sind Mitglieder des rechten Arguments (dh in Großbuchstaben).

,⍨ anhängen

⊂ Füge
⍤ das
⊢ richtige Argument ein (um es als ein einzelnes Element zu behandeln)

⌈ alles in Großbuchstaben

{… }/ Reduzieren sich um das folgende anonyme Lambda, was… ergibt "QU"λ("SXF"λ("MN"λ"A-Z")):

 ⊢⍵ auf das richtige Argument (das Scrambling-in-Progress-Alphabet)

 (... )@(∊∘⍺) die folgende anonymous stillschweigende Funktion der Untergruppe gelten , die ein Mitglied des linken Argument ist (ein Reim Gruppe)

  ⊢ auf dieser Untermenge

  ⊇ nachbestellen

  ?⍨ eine zufällige Permutation
  ∘ der Länge
  ≢ der Buchstaben in der Untermenge

Holzkohle , 43 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Charcoal hat keine Mischoperatoren, aber ich habe eine Methode für die ersatzlose Probenahme entwickelt. Erläuterung:

Ｆα

Schleife über jeden Buchstaben des Alphabets.

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

Teilen Sie die Zeichenfolge AJK BCDEGPTVZ IY QU SXF MN H L O R Wauf Leerzeichen und ziehen Sie eine Schleife über die Teilzeichenfolgen.

Ｆ№κι

Wiederholen Sie, wie oft der aktuelle Buchstabe in der Teilzeichenfolge angezeigt wird. (Ich verwende eine Schleife, da eine Bedingung eine elseKlausel erfordern würde . Alternativ hätte ich nach der Teilzeichenfolge filtern können, die den aktuellen Buchstaben für dieselbe Bytezahl enthält.)

‽Φκ¬№ＫＡμ

Drucken Sie ein zufälliges Zeichen, schließen Sie jedoch bereits gedruckte Zeichen aus.

Netzhaut , 80 Bytes

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

Probieren Sie es online!

Wahrscheinlich nicht die am meisten Golf spielende Methode, aber ich werde sie trotzdem einreichen.

Erläuterung:

K`1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z

Setzen Sie die Arbeitszeichenfolge auf 1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z. Beispielsweise steht vor jedem Buchstaben in einer Gruppe eine Zahl A, Jund Kalle haben eine 1vor sich.

~(

Markieren Sie einen Codeabschnitt, der Retina-Code erzeugt, und führen Sie ihn anschließend aus.

K`123456

Setzen Sie die Arbeitszeichenfolge auf 123456

.
?O`$&.¶

Ersetzen Sie jedes Zeichen durch ?O`{character}.¶

)`¶$
[blank line]

Entfernen Sie die nachgestellte Zeile und beenden Sie die Gruppe, um den Code zu generieren. Die Gruppe generiert den Code:

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

{n}.stimmt mit allen Instanzen der Nummer n überein gefolgt von einem Zeichen. ?Osortiert jede Instanz nach dem Zufallsprinzip, und dies erfolgt für alle Zeichensätze.

\d
[blank line]

Entfernen Sie abschließend alle Zahlen und geben Sie den generierten String implizit aus.