Conceito

De que maneira você pode embaralhar o alfabeto inglês para que ele ainda possa ser cantado na música Twinkle Twinkle Little Star sem estragar a música?

Regras

Troca

Vamos supor que as letras contidas em cada um dos seguintes conjuntos possam ser trocadas livremente por padrão, sem estragar a música:

• {A, J, K}
• {B, C, D, E, G, P, T, V, Z}
• {I, Y}
• {Q, U}
• {S, X, F}
• {M, N}
• Portanto, H, L, O, R e W estão travados no lugar

Saída

O programa precisa gerar uma única sequência RANDOM (ou lista de caracteres) contendo o alfabeto inglês completo em qualquer ordem, desde que a ordem atenda às condições acima. Não deve haver maneira de você prever qual string seu programa produzirá (se ignorarmos a propagação), o que significa que você não pode simplesmente codificá-lo.

Seu programa deve ter alguma probabilidade positiva (não necessariamente uniforme) de gerar cada um dos saídas.$9! \cdot 3! \cdot 3! \cdot 2! \cdot 2! \cdot 2! = 104509440$

Não há restrições de formatação específicas em relação ao espaçamento, delimitadores ou maiúsculas e minúsculas, apenas seja consistente.

Objetivo

Menos bytes ganha!

Exemplos:

• 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
• A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Nenhum exemplo:

• HLWROABCDEFZXYGIJKMNPQTSVU

Prova de conceito: (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‡

Saídas como uma única sequência minúscula.

Experimente online ou verifique saídas aleatórias de uma só vez$n$ .

Explicação:

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)

Veja este 05AB1E ponta do meu (seção Como cordas compressa não fazem parte do dicionário? ) Para entender por que .•¬=©ƶÓÄûkTVã”ØζÞ•é "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'])

Experimente online!

_{-1 byte, graças 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

Experimente online!

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

Experimente online!

Pitão , 59 57 56 bytes

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

Experimente online!

Saída é uma 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

Experimente online!

Perl 6 , 76 bytes

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

Experimente online!

Bloco de código anônimo sem argumentos e retornando uma lista de caracteres.

Explicação:

{                                                                          } # 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 conta própria

-18 Byte - graças a @tsh e @Geza Kerecsenyi, que me fizeram ver o que @tsh inicialmente apontou também

-8 Bytes - graças a @Geza Kerecsenyi

-14 Bytes - com a ajuda de @Geza Kerecsenyi

- 28 Bytes - On my Own

-3 Bytes - novamente com a ajuda de @Geza Kerecsenyi

-1 Bytes - como isso poderia acontecer ...

...

-100 Bytes - @Kaiido matou-o e através de alguns passos antes essa coisa toda desceu para 176 bytes

Golfe:

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 experimente online !

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

Experimente online!

A randomização não é uniforme, pois não há uma boa maneira de fazer isso em Runic. Em vez disso, ele gira aleatoriamente cada coleção de letras (por exemplo, [BCDEGPTVZ]um agrupamento) em alguma quantidade (por exemplo, girando o conjunto acima por 4, onde a parte superior da pilha está à direita, o resultado seria [BCDEGZPTV]) e então decide aleatoriamente se deve ou não inverta a pilha. Ele realiza essas operações 15 vezes. Como resultado, todos os pedidos possíveis são possíveis, mas não são igualmente prováveis. (Caso isso não seja suficiente, aumentá-lo custa zero bytes , até 15000 loops aleatórios).

Esta é a seção do código que lida com o embaralhamento:

  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

O restante do código se desenrola nisso:

                     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 as letras não forem embaralhadas (mas revertidas uma vez), alterando dois bytes, o alfabeto será impresso normalmente , o que pode ser usado para verificar se todos os agrupamentos de letras são impressos nos locais corretos. O espaço em branco que desloca os Bcomandos para fora da fase é para que todos os IPs possam usar o loop de função ao mesmo tempo sem colidir e, em seguida, colocá-los novamente em fase.

Para o golfe, primeiro qualquer espaço que pudesse ser removido em todas as linhas era aparado; depois, cada um dos dois espaços era convertido em a y, e cada sequência yyyyera convertida em ̤porque ̤e yyyytem a mesma quantidade de atraso, mas 2 bytes mais barato. A saída do loop também foi combinada com o HLORWsegmento principal do programa para economizar nos bytes de espaçamento (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

Experimente online!

Este código (ab) usa o fato de que a saída de chaves hash ( %l) do Perl é aleatória para criar um mapeamento ( %k) de todas as letras modificáveis ​​para uma de suas possíveis contrapartes. No momento da saída, qualquer chave que não exista é assumida como inalterada.

Geléia , 34 bytes

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

Experimente online!

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

Experimente online!

Randomização usando pop () para o conjunto de letras

APL (Dyalog Extended) , 55 bytes

Programa completo. Imprime maiúsculas com um espaço à esquerda e à direita, mas sem espaços intermediários.

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

Experimente online!

⎕A o alfabeto maiúsculo

'AjkBcdegptvzIyQuSxfMn'(… ) Aplique a seguinte função tácita anônima com isso como argumento da direita e a sequência indicada como argumento da esquerda:

⊣ para o argumento esquerdo,

⊂ particioná-lo, iniciando um novo segmento onde

∊ os caracteres de argumentos à esquerda são membros do argumento à direita (ou seja, em letras maiúsculas)

,⍨ acrescentar

⊂ coloque (para tratá-lo como um único elemento)
⍤ o
⊢ argumento correto

⌈ tudo em maiúsculas

{… }/ Reduza pela seguinte lambda anônima, fornecendo… "QU"λ("SXF"λ("MN"λ"A-Z")):

 ⊢⍵ no argumento certo (o alfabeto em andamento)

 (… )@(∊∘⍺) Aplique a seguinte função tácita anônima ao subconjunto que é membro do argumento esquerdo (um grupo de rimas)

  ⊢ nesse subconjunto

  ⊇ reordenar

  ?⍨ uma permutação aleatória
  ∘ do
  ≢ registro de tamanho das letras no subconjunto

Carvão , 43 bytes

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

Experimente online! Link é a versão detalhada do código. O carvão vegetal não possui operadores de embaralhamento, mas criei um método de amostragem sem substituição. Explicação:

Ｆα

Faça um loop sobre cada letra do alfabeto.

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

Divida a sequência AJK BCDEGPTVZ IY QU SXF MN H L O R Wem espaços e faça um loop sobre as substrings.

Ｆ№κι

Repita o número de vezes que a letra atual aparece na substring. (Eu uso um loop porque um condicional precisaria de uma elsecaluse. Como alternativa, eu poderia ter filtrado a substring que contém a letra atual para a mesma contagem de bytes.)

‽Φκ¬№ＫＡμ

Imprima um caractere aleatório, mas exclua aqueles que já foram impressos.

Retina , 80 bytes

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

Experimente online!

Provavelmente não é o método mais praticado, mas vou enviá-lo de qualquer maneira.

Explicação:

K`1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z

Defina a sequência de trabalho para 1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z. Há um número antes de cada letra em um grupo, por exemplo A, Je Ktodos têm 1antes deles.

~(

Marque uma seção do código que produzirá algum código de retina e execute-o posteriormente.

K`123456

Defina a cadeia de trabalho como 123456

.
?O`$&.¶

Substitua cada caractere por ?O`{character}.¶

)`¶$
[blank line]

Remova a nova linha à direita e termine o grupo para gerar o código. O grupo irá gerar o código:

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

{n}.corresponde a todas as instâncias do número n seguido por um caractere. ?Oclassifica cada instância aleatoriamente, e isso é feito para todos os conjuntos de caracteres.

\d
[blank line]

Por fim, remova todos os números e produza implicitamente a sequência gerada.