Concetto

In che modo puoi mescolare l'alfabeto inglese in modo che possa ancora essere cantato sulla melodia Twinkle Twinkle Little Star senza rovinare la melodia?

Regole

Swapping

Supponiamo che le lettere contenute in ciascuno dei seguenti set possano essere scambiate liberamente per impostazione predefinita senza rovinare la melodia:

• {A, J, K}
• {B, C, D, E, G, P, T, V, Z}
• {I, Y}
• {Q, U}
• {S, X, F}
• {M, N}
• Pertanto H, L, O, R e W sono bloccati in posizione

Produzione

Il programma deve emettere una singola stringa RANDOM (o un elenco di caratteri) contenente l'alfabeto inglese completo in qualsiasi ordine a condizione che l'ordine soddisfi le condizioni sopra. Non dovresti avere modo di prevedere quale stringa verrà generata dal tuo programma (se ignoriamo il seeding), il che significa che non puoi semplicemente codificarlo.

Il tuo programma deve avere qualche probabilità positiva (non necessariamente uniforme) di generare ciascuno dei uscite.$9! \cdot 3! \cdot 3! \cdot 2! \cdot 2! \cdot 2! = 104509440$

Non ci sono particolari restrizioni di formattazione per quanto riguarda spaziatura, delimitatori o maiuscole, basta essere coerenti.

Obbiettivo

Vince il minor numero di byte!

Esempi:

• 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

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 byte

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

Emette come una singola stringa minuscola.

$n$

Spiegazione:

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)

Vedere questo 05AB1E punta del mio (sezione Come stringhe di comprimere che non fanno parte del dizionario? ) Per capire il motivo per cui .•¬=©ƶÓÄûkTVã”ØζÞ•è "ajk bcdegptvz iy qu sxf mn".

Python 3 , 140 133 124 123 byte

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

Provalo online!

_{-1 byte, grazie a Jo King}

Python 2 , 174 170 158 byte

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

Provalo online!

Rubino , 102 byte

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

Provalo online!

Pyth , 59 57 56 byte

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

Provalo online!

L'output è una matrice di lettere minuscole.

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 byte

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

Provalo online!

Perl 6 , 76 byte

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

Provalo online!

Blocco di codice anonimo che non accetta argomenti e restituisce un elenco di caratteri.

Spiegazione:

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

-77 byte - da solo

-18 byte - grazie a @tsh e @Geza Kerecsenyi che mi hanno fatto vedere cosa ha sottolineato anche @tsh inizialmente

-8 byte - grazie a @Geza Kerecsenyi

-14 byte - con l'aiuto di @Geza Kerecsenyi

- 28 byte - da solo

-3 byte - di nuovo con l'aiuto di @Geza Kerecsenyi

-1 byte - come è potuto accadere ...

...

-100 byte - @Kaiido l'ha ucciso e attraverso alcuni passaggi prima che tutto si rovinasse a 176 byte

golfed:

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

o provalo online !

Incantesimi runici , 210 byte

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

Provalo online!

La randomizzazione non è uniforme in quanto non esiste un buon modo per farlo in Runico. Invece ruota casualmente ogni raccolta di lettere (ad es. [BCDEGPTVZ]È un raggruppamento) di una certa quantità (ad es. Ruotando il set sopra di 4, dove la parte superiore della pila è a destra, il risultato sarebbe [BCDEGZPTV]) e quindi decide casualmente se invertire la pila. Esegue queste operazioni 15 volte. Di conseguenza, tutti gli ordini possibili sono possibili ma non altrettanto probabili. (Nel caso in cui ciò non bastasse, aumentarlo ulteriormente costa zero byte , fino a 15000 cicli shuffle).

Questa è la sezione del codice che gestisce lo shuffle:

  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

Il resto del codice si svolge in questo:

                     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

Se le lettere vengono lasciate in ordine casuale (ma una volta invertite) modificando due byte, l'alfabeto viene stampato normalmente , che può essere utilizzato per verificare che tutti i raggruppamenti di lettere vengano stampati nei punti corretti. Lo spazio bianco che sposta i Bcomandi fuori fase è in modo tale che tutti gli IP possano utilizzare il loop delle funzioni contemporaneamente senza scontrarsi e quindi riportarli nuovamente in fase.

Per giocare a golf, prima è stato tagliato qualsiasi spazio che potesse essere rimosso su tutte le linee, quindi ogni due spazi sono stati convertiti in a y, e ogni sequenza di è yyyystata convertita in ̤perché ̤e yyyyhanno la stessa quantità di ritardo, ma 2 byte in meno. L'uscita del loop è stata anche combinata con il HLORWsegmento principale del programma per risparmiare sui byte di spaziatura (12 byte).

Perl 5 , 103 91 85 byte

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

Provalo online!

Questo codice (ab) usa il fatto che l'output di Perl delle chiavi hash ( %l) è casuale per creare una mappatura ( %k) di tutte le lettere modificabili a una delle loro possibili controparti. Al momento dell'uscita, si presume che qualsiasi chiave inesistente sia invariata.

Gelatina , 34 byte

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

Provalo online!

Python 3 , 149 byte

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

Provalo online!

Randomizzazione usando pop () per il set di lettere

APL (Dyalog Extended) , 55 byte

Programma completo. Stampa in maiuscolo con uno spazio iniziale e finale, ma senza spazi intermedi.

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

Provalo online!

⎕A l'alfabeto maiuscolo

'AjkBcdegptvzIyQuSxfMn'(... ) applica la seguente funzione tacita anonima con quella come argomento giusto e la stringa indicata come argomento sinistro:

⊣ per l'argomento sinistro,

⊂ partizionalo, iniziando un nuovo segmento dove

∊ i caratteri degli argomenti di sinistra sono membri dell'argomento di destra (cioè su lettere maiuscole)

,⍨ aggiungere

⊂ racchiudere (per trattarlo come un singolo elemento)
⍤ l'
⊢ argomento giusto

⌈ tutto in maiuscolo

{... }/ riduci con la seguente lambda anonima, dando ... "QU"λ("SXF"λ("MN"λ"A-Z")):

 ⊢⍵ sull'argomentazione giusta (l'alfabeto scrambling in progress)

 (... )@(∊∘⍺) applica la seguente funzione tacita anonima al sottoinsieme che è un membro dell'argomento sinistro (un gruppo di rime)

  ⊢ su quel sottoinsieme

  ⊇ riordinare per essere

  ?⍨ una permutazione casuale
  ∘ della lunghezza
  ≢ delle lettere nel sottoinsieme

Carbone , 43 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Il carbone non ha operatori di mescolamento, ma ho ideato un metodo di campionamento senza sostituzione. Spiegazione:

Ｆα

Scorri ogni lettera dell'alfabeto.

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

Dividi la stringa AJK BCDEGPTVZ IY QU SXF MN H L O R Wnegli spazi e avvolgi le sottostringhe.

Ｆ№κι

Scorri il numero di volte in cui la lettera corrente appare nella sottostringa. (Uso un ciclo perché un condizionale avrebbe bisogno di un elsecaluse. In alternativa avrei potuto filtrare sulla sottostringa contenente la lettera corrente per lo stesso conteggio dei byte.)

‽Φκ¬№ＫＡμ

Stampa un carattere casuale ma escludi quelli che sono già stati stampati.

Retina , 80 byte

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

Provalo online!

Probabilmente non è il metodo più golfato, ma lo inoltrerò comunque.

Spiegazione:

K`1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z

Impostare la stringa di lavoro su 1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z. C'è un numero prima di ogni lettera in un gruppo, per esempio A, Je Ktutti hanno 1prima di loro.

~(

Contrassegna una sezione di codice che produrrà del codice retina, quindi eseguilo in seguito.

K`123456

Impostare la stringa di lavoro su 123456

.
?O`$&.¶

Sostituisci ogni personaggio con ?O`{character}.¶

)`¶$
[blank line]

Rimuovere la nuova riga finale e terminare il gruppo per generare il codice. Il gruppo genererà il codice:

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

{n}.corrisponde a tutte le istanze del numero n seguito da un carattere. ?Oordina ogni istanza in modo casuale, e questo viene fatto per tutti i set di caratteri.

\d
[blank line]

Infine, rimuovi tutti i numeri e genera implicitamente la stringa generata.