Concept

De quelles manières pouvez-vous brouiller l'alphabet anglais pour qu'il puisse toujours être chanté sur l'air Twinkle Twinkle Little Star sans ruiner l'air?

Règles

Échange

Supposons simplement que les lettres contenues dans chacun des ensembles suivants puissent être échangées librement par défaut sans ruiner la mélodie:

• {A, J, K}
• {B, C, D, E, G, P, T, V, Z}
• {I, Y}
• {Q, U}
• {S, X, F}
• {M, N}
• Par conséquent, H, L, O, R et W sont verrouillés en place

Sortie

Le programme doit sortir une seule chaîne RANDOM (ou liste de caractères) contenant l'alphabet anglais complet dans n'importe quel ordre à condition que cet ordre satisfasse aux conditions ci-dessus. Il ne devrait y avoir aucun moyen de prédire quelle chaîne votre programme générera (si nous ignorons l'amorçage), ce qui signifie que vous ne pouvez pas simplement le coder en dur.

Votre programme doit avoir une probabilité positive (pas nécessairement uniforme) de générer chacun des sorties.$9! \cdot 3! \cdot 3! \cdot 2! \cdot 2! \cdot 2! = 104509440$

Il n'y a pas de restrictions de formatage particulières concernant l'espacement, les délimiteurs ou la casse, soyez juste cohérent.

Objectif

Le moins d'octets gagne!

Exemples:

• 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

Non exemple:

• HLWROABCDEFZXYGIJKMNPQTSVU

Preuve de concept: (Python3, 529 octets)

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 octets

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

Sorties sous forme d'une seule chaîne en minuscules.

$n$

Explication:

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)

Voir cette astuce de mes 05AB1E (section Comment chaînes Compresser ne font pas partie du dictionnaire? ) Pour comprendre pourquoi .•¬=©ƶÓÄûkTVã”ØζÞ•est "ajk bcdegptvz iy qu sxf mn".

Python 3 , 140 133 124 123 octets

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

Essayez-le en ligne!

_{-1 octet, merci à Jo King}

Python 2 , 174 170 158 octets

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

Essayez-le en ligne!

Rubis , 102 octets

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

Essayez-le en ligne!

Pyth , 59 57 56 octets

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

Essayez-le en ligne!

La sortie est un tableau de lettres minuscules.

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 octets

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

Essayez-le en ligne!

Perl 6 , 76 octets

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

Essayez-le en ligne!

Bloc de code anonyme ne prenant aucun argument et renvoyant une liste de caractères.

Explication:

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

-77 octets - à moi seul

-18 octets - merci à @tsh et @Geza Kerecsenyi qui m'ont fait voir ce que @tsh avait initialement signalé aussi

-8 octets - grâce à @Geza Kerecsenyi

-14 octets - avec l'aide de @Geza Kerecsenyi

- 28 octets - à moi seul

-3 octets - encore une fois avec l'aide de @Geza Kerecsenyi

-1 octets - comment cela a-t-il pu arriver ...

...

-100 octets - @Kaiido l'a tué et via quelques étapes avant que tout cela ne tombe en panne à 176 octets

Golfé:

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

ou essayez-le en ligne !

Enchantements runiques , 210 octets

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

Essayez-le en ligne!

La randomisation n'est pas uniforme car il n'y a pas de bon moyen de le faire dans Runic. Au lieu de cela, il fait tourner aléatoirement chaque collection de lettres (par exemple, [BCDEGPTVZ]un groupe) d'une certaine quantité (par exemple, en faisant tourner l'ensemble ci-dessus de 4, où le haut de la pile est à droite, le résultat serait [BCDEGZPTV]), puis décide au hasard s'il doit ou non inverser la pile. Il effectue ces opérations 15 fois. En conséquence, toutes les commandes possibles sont possibles mais pas aussi probables. (Dans le cas où cela ne suffirait pas, son augmentation coûte encore zéro octet , jusqu'à 15 000 boucles de lecture aléatoire).

C'est la section du code qui gère le brassage:

  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

Le reste du code se déroule dans ceci:

                     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

Si les lettres ne sont pas mélangées (mais inversées une fois) en modifiant deux octets, l'alphabet est imprimé normalement , ce qui peut être utilisé pour vérifier que tous les groupes de lettres s'impriment aux bons endroits. L'espace blanc décalant les Bcommandes hors phase est de sorte que toutes les adresses IP puissent utiliser la boucle de fonction en même temps sans entrer en collision, puis les remettre à nouveau en phase.

Pour jouer au golf, tout espace pouvant être supprimé sur toutes les lignes a d'abord été coupé, puis chacun des deux espaces a été converti en a y, et chaque séquence de a yyyyété convertie en ̤car ̤et yyyyreprésente le même délai, mais 2 octets moins cher. La sortie de boucle a également été combinée avec le HLORWsegment de programme principal afin d'économiser sur les octets d'espacement (12 octets).

Perl 5 , 103 91 85 octets

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

Essayez-le en ligne!

Ce code (ab) utilise le fait que la sortie de Perl des clés de hachage ( %l) est aléatoire pour créer un mappage ( %k) de toutes les lettres modifiables à l'un de leurs homologues possibles. Au moment de la sortie, toute clé qui n'existe pas est supposée être inchangée.

Gelée , 34 octets

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

Essayez-le en ligne!

Python 3 , 149 octets

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

Essayez-le en ligne!

Randomisation en utilisant pop () pour le jeu de lettres

APL (Dyalog Extended) , 55 octets

Programme complet. Imprime en majuscules avec un espace de début et de fin, mais pas d'espaces intermédiaires.

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

Essayez-le en ligne!

⎕A l'alphabet majuscule

'AjkBcdegptvzIyQuSxfMn'(… ) Appliquez la fonction tacite anonyme suivante avec cela comme argument de droite et la chaîne indiquée comme argument de gauche:

⊣ pour l'argument de gauche,

⊂ le partitionner, en commençant un nouveau segment où

∊ les caractères des arguments de gauche sont membres de l'argument de droite (c'est-à-dire sur les lettres majuscules)

,⍨ ajouter

⊂ joindre (pour le traiter comme un seul élément)
⍤ le
⊢ bon argument

⌈ tout en majuscules

{… }/ Réduire par le lambda anonyme suivant, en donnant… "QU"λ("SXF"λ("MN"λ"A-Z")):

 ⊢⍵ sur le bon argument (l'alphabet de brouillage en cours)

 (… )@(∊∘⍺) Appliquer la fonction tacite anonyme suivante au sous-ensemble qui est membre de l'argument de gauche (un groupe de rimes)

  ⊢ sur ce sous-ensemble

  ⊇ réorganiser pour être

  ?⍨ une permutation aléatoire
  ∘ de la longueur
  ≢ des lettres dans le sous-ensemble

Fusain , 43 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Le charbon de bois n'a pas d'opérateurs de brassage, mais j'ai trouvé une méthode d'échantillonnage sans remplacement. Explication:

Ｆα

Faites une boucle sur chaque lettre de l'alphabet.

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

Fractionnez la chaîne AJK BCDEGPTVZ IY QU SXF MN H L O R Wsur les espaces et bouclez sur les sous-chaînes.

Ｆ№κι

Faites une boucle sur le nombre de fois où la lettre actuelle apparaît dans la sous-chaîne. (J'utilise une boucle parce qu'un conditionnel aurait besoin d'un elsecaluse. Sinon, j'aurais pu filtrer sur la sous-chaîne contenant la lettre actuelle pour le même nombre d'octets.)

‽Φκ¬№ＫＡμ

Imprimez un caractère aléatoire mais excluez ceux qui ont déjà été imprimés.

Rétine , 80 octets

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

Essayez-le en ligne!

Ce n'est probablement pas la méthode la plus utilisée, mais je la soumettrai quand même.

Explication:

K`1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z

Définissez la chaîne de travail sur 1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z. Il y a un numéro avant chaque lettre dans un groupe, par exemple A, Jet Ktous ont 1devant eux.

~(

Marquez une section de code qui produira du code rétine, puis exécutez-la ensuite.

K`123456

Définissez la chaîne de travail sur 123456

.
?O`$&.¶

Remplacez chaque caractère par ?O`{character}.¶

)`¶$
[blank line]

Supprimez la nouvelle ligne de fin et terminez le groupe pour générer le code. Le groupe va générer le code:

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

{n}.correspond à toutes les instances du numéro n suivi d'un caractère. ?Otrie chaque instance de façon aléatoire, ce qui est fait pour tous les jeux de caractères.

\d
[blank line]

Enfin, supprimez tous les nombres et affichez implicitement la chaîne générée.