Concepto

¿De qué maneras puedes mezclar el alfabeto inglés para que aún se pueda cantar con la melodía Twinkle Twinkle Little Star sin arruinar la melodía?

Reglas

Intercambiando

Supongamos que las letras contenidas en cada uno de los siguientes conjuntos se pueden intercambiar libremente de forma predeterminada sin arruinar la melodía:

• {A, J, K}
• {B, C, D, E, G, P, T, V, Z}
• {I, Y}
• {Q, U}
• {S, X, F}
• {M, N}
• Por lo tanto, H, L, O, R y W están bloqueados en su lugar

Salida

El programa debe generar una única cadena ALEATORIA (o lista de caracteres) que contenga el alfabeto inglés completo en cualquier orden, siempre que ese orden cumpla las condiciones anteriores. No debería haber forma de predecir qué cadena generará su programa (si ignoramos la siembra), lo que significa que no puede simplemente codificarlo.

¡Su programa debe tener alguna probabilidad positiva (no necesariamente uniforme) de generar cada uno de los $9! \cdot 3! \cdot 3! \cdot 2! \cdot 2! \cdot 2! = 104509440$ salidas.

No existen restricciones de formato particulares con respecto al espaciado, delimitadores o mayúsculas y minúsculas, solo sea consistente.

Gol

¡Pocos bytes ganan!

Ejemplos:

• 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, mi
• KVTDCFBHIJALNMOPURSZQGWXYE
• jcdebxthikalnmogursvq pwfyz
• ABCDEFGHIJKLMNOPQRSTU VWXYZ

No ejemplo:

• HLWROABCDEFZXYGIJKMNPQTSVU

Prueba de concepto: (Python3, 529 bytes)

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‡

Salidas como una sola cadena en minúsculas.

$n$

Explicació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)

Ver este consejo 05AB1E mío (sección Cómo comprimir cadenas que no forman parte del diccionario? ) Para entender por qué .•¬=©ƶÓÄûkTVã”ØζÞ•es "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'])

Pruébalo en línea!

_{-1 byte, gracias a 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

Pruébalo en línea!

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

Pruébalo en línea!

Pyth , 59 57 56 bytes

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

Pruébalo en línea!

La salida es una matriz de letras minúsculas.

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

Pruébalo en línea!

Perl 6 , 76 bytes

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

Pruébalo en línea!

El bloque de código anónimo no toma argumentos y devuelve una lista de caracteres.

Explicación:

{                                                                          } # 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 - por mi cuenta

-18 Byte - gracias a @tsh y @Geza Kerecsenyi que me hicieron ver lo que @tsh señaló inicialmente también

-8 Bytes - gracias a @Geza Kerecsenyi

-14 Bytes - con la ayuda de @Geza Kerecsenyi

- 28 bytes - por mi cuenta

-3 - Bytes de nuevo con la ayuda de @Geza Kerecsenyi

-1 Bytes - ¿cómo podría suceder esto ...

...

-100 Bytes - @Kaiido mató a ella y a través de algunos pasos antes de que todo esto se bajó a 176 bytes

Golfizado:

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 pruébalo en línea !

Encantamientos rúnicos , 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͍

Pruébalo en línea!

La aleatorización no es uniforme ya que no hay una buena manera de hacerlo en Runic. En cambio, rota aleatoriamente cada colección de letras (por ejemplo, [BCDEGPTVZ]es una agrupación) en cierta cantidad (por ejemplo, girando el conjunto anterior por 4, donde la parte superior de la pila está a la derecha, el resultado sería [BCDEGZPTV]) y luego decide aleatoriamente si invertir la pila. Realiza estas operaciones 15 veces. Como resultado, todos los posibles pedidos son posibles pero no igualmente probables. (En el caso de que esto no sea suficiente, aumentarlo aún cuesta cero bytes , hasta 15000 bucles aleatorios).

Esta es la sección del código que maneja el barajado:

  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

El resto del código se desenvuelve en esto:

                     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 las letras se dejan sin mezclar (pero una vez invertidas) al cambiar dos bytes, el alfabeto se imprime normalmente , lo que se puede utilizar para verificar que todos los grupos de letras se impriman en los lugares correctos. El espacio en blanco que desplaza los Bcomandos fuera de fase es para que todas las IP puedan usar el bucle de funciones al mismo tiempo sin colisionar, y luego volver a ponerlos en fase.

Para jugar al golf, primero se recortó cualquier espacio que pudiera eliminarse en todas las líneas, luego cada dos espacios se convirtieron en a y, y cada secuencia de yyyyse convirtió en ̤porque ̤y yyyytienen la misma cantidad de retraso, pero 2 bytes más baratos. La salida del bucle también se combinó con el HLORWsegmento principal del programa para ahorrar en los bytes de espaciado (12 bytes).

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

Pruébalo en línea!

Este código (ab) utiliza el hecho de que la salida de las claves hash ( %l) de Perl es aleatoria para crear una asignación ( %k) de todas las letras modificables a una de sus posibles contrapartes. En el momento de la salida, se supone que cualquier clave que no existe no se modifica.

Jalea , 34 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Aleatorización mediante el uso de pop () para el conjunto de letras

APL (Dyalog Extendido) , 55 bytes

Programa completo Imprime en mayúsculas con un espacio inicial y final, pero sin espacios intermedios.

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

Pruébalo en línea!

⎕A el alfabeto en mayúscula

'AjkBcdegptvzIyQuSxfMn'(...)  aplique la siguiente función tácita anónima con eso como argumento derecho y la cadena indicada como argumento izquierdo:

⊣ para el argumento de la izquierda,

⊂ particionarlo, comenzando un nuevo segmento donde

∊ los caracteres de los argumentos de la izquierda son miembros del argumento de la derecha (es decir, en letras mayúsculas)

,⍨ adjuntar

⊂ adjuntar (para tratarlo como un solo elemento)
⍤ el
⊢  argumento correcto

⌈ todo en mayúscula

{... }/ reducir por la siguiente lambda anónima, dando ..."QU"λ("SXF"λ("MN"λ"A-Z")) :

 ⊢⍵ en el argumento correcto (el alfabeto de codificación en progreso)

 (... )@(∊∘⍺) aplique la siguiente función tácita anónima al subconjunto que es miembro del argumento izquierdo (un grupo de rimas)

  ⊢ en ese subconjunto

  ⊇ reordenar para que sea

  ?⍨ Una permutación aleatoria
  ∘ de la longitud
  ≢ de las letras en el subconjunto

Carbón , 43 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. El carbón no tiene operadores de barajado, pero se me ocurrió un método de muestreo sin reemplazo. Explicación:

Ｆα

Pase sobre cada letra del alfabeto.

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

Divida la cadena AJK BCDEGPTVZ IY QU SXF MN H L O R Wen espacios y repita sobre las subcadenas.

Ｆ№κι

Recorre el número de veces que aparece la letra actual en la subcadena. (Uso un bucle porque un condicional necesitaría un elsecaluse. Alternativamente, podría haber filtrado en la subcadena que contiene la letra actual para el mismo recuento de bytes).

‽Φκ¬№ＫＡμ

Imprima un carácter aleatorio pero excluya los que ya se han impreso.

Retina , 80 bytes

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

Pruébalo en línea!

Probablemente no sea el método más golfizado, pero lo enviaré de todos modos.

Explicación:

K`1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z

Establezca la cadena de trabajo en 1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z. Hay un número antes de cada letra en un grupo, por ejemplo A, Jy Ktodos tienen 1antes.

~(

Marque una sección de código que produzca algún código de retina y luego ejecútelo.

K`123456

Establecer la cadena de trabajo a 123456

.
?O`$&.¶

Reemplace cada personaje con ?O`{character}.¶

)`¶$
[blank line]

Elimine la nueva línea final y finalice el grupo para generar el código. El grupo generará el código:

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

{n}.coincide con todas las instancias del número n seguido de un carácter. ?Oordena cada instancia al azar, y esto se hace para todos los conjuntos de caracteres.

\d
[blank line]

Finalmente, elimine todos los números y genere implícitamente la cadena generada.