¿Conoces tus 'KVZ's?

23

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!⋅3!⋅3!⋅2!⋅2!⋅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])
code-golf string random señor del pan
fuente
55
No debería Zestar "encerrado en su lugar", ¿no rima con los demás?
Shaggy
3
Depende de dónde eres, supongo. Si dices 'zed', entonces tendría sentido sacarlo, pero de lo contrario, si dices 'zee', déjalo adentro. En última instancia, depende de ti, al igual que el resto de los sets. Se supone que son pautas y puntos de partida opuestos a reglas estrictas :)
breadlord
3
¿Uniformemente al azar o cada posibilidad que tiene una probabilidad distinta de cero, o algo más?
jimmy23013
8
@PeterTaylor Creo que la intención es que los miembros de los grupos puedan intercambiarse fácilmente en el medio de la canción mientras se mantiene la melodía y el ritmo del original, por lo que mientras riman, W tiene 3 sílabas mientras que U es solo 1, lo que cambiaría el ritmo de la canción.
Sok
2
Para aquellos que (como yo) no tenían idea de qué estaba hablando la pregunta: en.wikipedia.org/wiki/Alphabet_song
anatolyg

Respuestas:

6

05AB1E , 28 bytes

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

Salidas como una sola cadena en minúsculas.

norte

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

Kevin Cruijssen
fuente
7

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!

TFeld
fuente
4

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!

Tinta de valor
fuente
3

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
Sok
fuente
3

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!

digEmAll
fuente
3

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
Jo King
fuente
3

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

o pruébalo en línea !

pixma140
fuente
1
Al menos podría reemplazar ['B', 'C', 'D', 'E', 'G', 'P', 'T', 'V', 'Z'] por 'BCDEGPTVZ'.split' ' guardar algunos bytes
tsh
1
Intenta en 'BCDEGPTVZ'.split``lugar de .split('')por -2.
Geza Kerecsenyi
1
Además, se puede definir y=q=>q.split``en la parte superior de su código, y hacer todas las cadenas de matrices que se pasa en y()- por ejemplo, a=['A','J','K']se convierte ena=y("AJK")
Geza Kerecsenyi
1
Y reemplazar 'BCDEGPTVZ'.split('')cony('BCDEGPTVZ')
Geza Kerecsenyi
1
'abcdef'.includes(s)?r(eval(s)):l[i]
Geza Kerecsenyi
2

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

Draco18s
fuente
2

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.

Xcali
fuente
Excepto que la producción de claves hash de Perl no es aleatoria en absoluto. Es completamente determinista, solo influenciado por las teclas mismas de una manera que hace que sea difícil de predecir. Es por eso que este código produce la misma salida en cada ejecución. No sé si eso descalifica este enfoque o no.
John Bollinger
@JohnBollinger Eso solo es cierto dentro de una ejecución de un programa. Dentro de una sola ejecución, el orden de hash será el mismo si el hash no se modifica. En dos ejecuciones o con una modificación, se crea una semilla aleatoria durante cada invocación de perl. Referencia
Xcali
Ok, @Xcali, estoy corregido. Sin embargo, he sido engañado al menos parcialmente por su "¡Pruébelo en línea!" enlace, que genera repetidamente la misma salida para mí. Debe ser el almacenamiento en caché, o algo así.
John Bollinger
keysDefinitivamente, usar es un buen enfoque, pero puedes guardar 6 bytes usando sort rand 2,...:( ¡ Pruébalo en línea!
Dom Hastings
1

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

Jitse
fuente
1

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

Adán
fuente
1

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.

Neil
fuente
0

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.

lolad
fuente