Connaissez-vous vos «KVZ»?

23

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!3!3!2!2!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])
seigneur
la source
5
Ne doit pas Zêtre «enfermé», ça ne rime pas avec les autres?
Shaggy
3
Cela dépend d'où vous venez, je suppose. Si vous dites «zed», il serait logique de le retirer, mais sinon, si vous dites «zee», laissez-le. En fin de compte, c'est à vous de décider, comme le reste des ensembles. Ils sont censés être des lignes directrices et des points de départ opposés à des règles strictes :)
breadlord
3
Uniformément aléatoire ou toute possibilité ayant une probabilité non nulle, ou autre chose?
jimmy23013
8
@PeterTaylor Je pense que l'intention est que les membres des groupes puissent être facilement échangés au milieu de la chanson tout en conservant la mélodie et le rythme de l'original - donc pendant qu'ils riment, W est de 3 syllabes tandis que U n'est que de 1, ce qui changerait le rythme de la chanson.
Sok
2
Pour ceux qui (comme moi) n'avaient aucune idée de quoi parlait la question: en.wikipedia.org/wiki/Alphabet_song
anatolyg

Réponses:

6

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".

Kevin Cruijssen
la source
7

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!

TFeld
la source
4

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!

Encre de valeur
la source
3

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
Sok
la source
3

R , 93 91 octets

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

Essayez-le en ligne!

digEmAll
la source
3

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
Jo King
la source
3

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 !

pixma140
la source
1
Vous pouvez au moins remplacer ['B', 'C', 'D', 'E', 'G', 'P', 'T', 'V', 'Z'] par 'BCDEGPTVZ'.split' ' pour économiser quelques octets
tsh
1
Essayez 'BCDEGPTVZ'.split``au lieu de .split('')-2.
Geza Kerecsenyi
1
En outre, vous pouvez définir y=q=>q.split``en haut de votre code et créer toutes les chaînes de tableaux dans lesquelles vous passez y()- par exemple a=['A','J','K']devienta=y("AJK")
Geza Kerecsenyi
1
Et remplacez 'BCDEGPTVZ'.split('')pary('BCDEGPTVZ')
Geza Kerecsenyi
1
'abcdef'.includes(s)?r(eval(s)):l[i]
Geza Kerecsenyi
2

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

Draco18s
la source
2

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.

Xcali
la source
Sauf que la sortie de Perl des clés de hachage n'est pas aléatoire du tout. C'est complètement déterministe, juste influencé par les touches elles-mêmes d'une manière qui le rend difficile à prévoir. C'est pourquoi ce code produit la même sortie à chaque exécution. Je ne sais pas si cela disqualifie cette approche ou non.
John Bollinger
@JohnBollinger Cela n'est vrai que dans le cadre d'un programme. Au cours d'une même exécution, l'ordre de hachage sera le même si le hachage n'est pas modifié. Sur deux séries ou avec une modification, une graine aléatoire est créée lors de chaque invocation de perl. Référence
Xcali
Ok, @Xcali, je suis corrigé. J'ai été au moins partiellement induit en erreur, cependant, par votre "Essayez-le en ligne!" lien, qui génère à plusieurs reprises la même sortie pour moi. Ce doit être la mise en cache, ou quelque chose.
John Bollinger
L'utilisation keysest certainement une bonne approche, mais vous pouvez économiser 6 octets en utilisant à la sort rand 2,...place :( Essayez-le en ligne!
Dom Hastings
2

Gelée , 34 octets

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

Essayez-le en ligne!

Erik le Outgolfer
la source
1

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

Jitse
la source
1

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

Adam
la source
1

Fusain , 43 octets

FαF⪪”&↖(vJf#S»↖ιηa↷N↖⪪νP´↑x‖υ” F№κι‽Φκ¬№KAμ

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:

Fα

Faites une boucle sur chaque lettre de l'alphabet.

F⪪”&↖(vJf#S»↖ιηa↷N↖⪪νP´↑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.

F№κι

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

‽Φκ¬№KAμ

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

Neil
la source
0

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.

lolade
la source