Problema

Você está preso em uma cabana no meio da floresta, com apenas uma velha brincadeira para se divertir. Após a inspeção, você vê que as letras do scrabble estão tão gastas que apenas os pontos de cada letra são visíveis.

No entanto, você decide jogar um jogo. Você puxa sete letras da sacola e as coloca em sua bandeja, seu desafio é determinar o que essas cartas podem ser.

Geralmente, dada uma lista de pontos, converta-a em qualquer sequência ou lista de letras possível.

Scrabble Tiles e Distribuições

• 2 peças em branco (marcando 0 pontos)
• 1 ponto: E × 12, A × 9, I × 9, O × 8, N × 6, R × 6, T × 6, L × 4, S × 4, U × 4
• 2 pontos: D × 4, G × 3
• 3 pontos: B × 2, C × 2, M × 2, P × 2
• 4 pontos: F × 2, H × 2, V × 2, W × 2, Y × 2
• 5 pontos: K × 1
• 8 pontos: J × 1, X × 1
• 10 pontos: Q × 1, Z × 1

Portanto, se você tiver uma lista de pontos [10,10,8,5,1,1,1], "QZJKEEE"seria válido, mas "QQJKEEE"não seria válido (pois há apenas 1 bloco Q na sacola)

Regras específicas de problemas

• Você pode assumir que todas as entradas são válidas e que sempre haverá 7 blocos (ou seja, não haverá uma lista de sete blocos de 10 pontos e não haverá 9 blocos)
• Você pode assumir que nenhum bloco foi retirado anteriormente da sacola (portanto, a distribuição é a distribuição padrão de blocos em inglês, conforme definido acima)
• Você não precisa gerar uma palavra válida, apenas uma sequência de letras válida.
• A ordem da sua string é irrelevante, desde que para cada bloco haja uma letra correspondente.
• Os pontos são baseados nos pontos padrão do scrabble em inglês, conforme definido acima.
• Você pode produzir em maiúsculas ou minúsculas; para um bloco em branco, você pode gerar um caractere de espaço ou um sublinhado '_'
• Sua resposta pode aparecer como qualquer representação razoável dos blocos, como Lista, String, Matriz ou Sequência

  ---

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta com as regras de E / S padrão , para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste

Obviamente, como você pode gerar qualquer valor possível, é difícil definir casos de teste estritos.

Alguns casos com um possível valor de retorno válido :

[10,0,10,5,8,8,0] -> "Q ZKJX "
[1,1,1,1,1,1,1] -> "EEEEEEE"
[1,2,3,4,5,8,0] -> "NDBHKJ "
[2,2,2,2,2,2,2] -> "DGDGDGD"

Alguns casos com um valor de retorno inválido :

[10,0,10,5,8,8,0] -> "Q QKJX "  - Too many Qs 
[1,1,1,1,1,1,1] -> "EEEEEE "  - Space is 0 points not 1
[1,2,3,4,5,8,0] -> "NDBH" - Too short
[1,2,3,4,5,8,0] -> "NDBHKJ  I" - Too long
[1,2,3,4,5,8,0] -> "ÉDBHKJ1" - Contains none scrabble characters
[2,2,2,2,2,2,2] -> "GDGDGDG" - Contains too many Gs (case for invalid cycling)

JavaScript (ES6), 72 bytes

Uma variante mais curta sugerida por @supercat

a=>a.map(o=n=>'?ED?BWQ?_EG?CFZ?_EDJMH?K?EGXPV'[n*9.4+(o[n]=7-~o[n])&31])

Experimente online!

JavaScript (ES6),  137 ... 84 78 77  76 bytes

Economizou 10 bytes usando o método de ciclagem de Neil

Retorna uma lista de blocos. Usa _para azulejos em branco.

a=>a.map(o=n=>"____FHVWGDGD_K__BCMPEEEE_ZQ__XJ"[n*20%44%32+(o[n]=-~o[n])%4])

Experimente online!

Quão?

Para cada número de pontos, percorremos um grupo de exatamente 4 blocos, começando com o segundo bloco de cada grupo (isso é importante para Gvs D):

 points | group | max. sequence
--------+-------+---------------
    0   | ____  | __
    1   | EEEE  | EEEEEEE
    2   | GDGD  | DGDGDGD
    3   | BCMP  | CMPBCMP
    4   | FHVW  | HVWFHVW
    5   | _K__  | K         \
    8   | _XJ_  | XJ         }--- these letters may only appear once each
   10   | _ZQ_  | ZQ        /

Todos esses grupos são armazenados como uma única sequência de 31 caracteres:

____FHVWGDGD_K__BCMPEEEE_ZQ__XJ
^   ^   ^   ^   ^   ^   ^   ^
0   4   8  12  16  20  24  28

NB : Nós não precisa armazenar a final "_"em "_XJ_", como ele nunca será acessado de qualquer maneira.

O número de pontos $n$ é convertido no índice correto $i_n$ nessa cadeia de caracteres com:

  n | *20 | mod 44 | mod 32 | group
----+-----+--------+--------+-------
  0 |   0 |    0   |    0   | ____
  1 |  20 |   20   |   20   | EEEE
  2 |  40 |   40   |    8   | GDGD
  3 |  60 |   16   |   16   | BCMP
  4 |  80 |   36   |    4   | FHVW
  5 | 100 |   12   |   12   | _K__
  8 | 160 |   28   |   28   | _XJ_
 10 | 200 |   24   |   24   | _ZQ_

$o$

Carvão , 33 bytes

⭆觧⪪”＆↖“Ｖh_z↶∕¡⌈∨₂χ¹‖◨⌊″”¶ι№…θκι

Experimente online! Link é a versão detalhada do código. Explicação:

 θ                  Input array
⭆                   Map over elements and join
     ”...”          Literal string " \nE\nDG\nBCMP\nFHVW\nK\n\n\nJX\n\nQZ"
    ⪪     ¶         Split on newlines
   §       ι        Indexed by current element
  §                 Cyclically indexed by
            №…θκι   Number of times current element has already appeared
                    Implcitly print

Geléia ,  31 30 27  26 bytes

“ñẒẎYñ(“Nut¦hß’ṃØA;€⁶ɓṢĖœị

Um link monádico que aceita uma lista de números inteiros que gera uma lista de caracteres.
- uma confusão do meu anterior, abaixo, e minha melhoria do Nick Kennedy

Experimente online!

A saída não é fornecida na mesma ordem que a entrada (isso é permitido).

Usar duas de minhas próprias adições ao idioma em uma resposta não acontece com frequência! ( ṃe ɓaqui).

Quão?

“...“...’ṃØA;€⁶ɓṢĖœị - Link: list of integers, V     e.g. [10,1,0,3,2,1,10]
“...“...’            - list of base 250 integers          [28089224382041, 77611203526272]
          ØA         - 'ABC...XYZ'
         ṃ           - base decompress (vectorises)       ["EDMFKZZJZQ", "NGPYKZZXZZ"]
            ;€       - for €ach: concatenate:
              ⁶      -   a space                          ["EDMFKZZJZQ ", "NGPYKZZXZZ "]
               ɓ     - start a new dyadic chain with swapped arguments - i.e. f(V,that)
                Ṣ    - sort                               [0,1,1,2,3,10,10]
                 Ė   - enumerate                          [[1,0],[2,1],[3,1],[4,2],[5,3],[6,10],[7,10]]
                  œị - multi-dimensional index into       " NEGMZQ"
                       (1-based and modular)

anterior @ 30

“²rṛʂṂø5=Ɓṇ^N¥Y»⁾tky;⁶s2ɓṢĖUœị

Um link monádico que aceita uma lista de números inteiros que gera uma lista de caracteres.

Experimente online!

A saída dessa pessoa também é mista (isso é permitido).

Quão?

“...»⁾tky;⁶s2ɓṢĖUœị - Link: list of integers, V          e.g. [10,1,0,3,2,1,10]
“...»               - compression of dictionary entries:
                    -   "end", "GMP", "fyttes", "adj", and "xci" and the string "qz"
                    -                                         "endGMPfyttesadjxciqz"
        y           - translate with:
     ⁾tk            -   ['t', 'k']                            "endGMPfykkesadjxciqz"
         ;⁶s2ɓṢĖUœị - ...
                    - ...then like the above method (except U reverses each pair of indices)
                                                              " neGMzq"

Pitão - 92 86 83 81 80 75 60 52 49 42 36 bytes

Passa pela entrada, exibindo as letras disponíveis. Eu só tenho um de cada letra que juntos dá 7 para essa categoria de pontos. Agora, usando a codificação de string compactada.

K[M*L7c."B_êº çÑOÒ
7âCkÑ"\Lm.)@K

K                       Assign to K       
 [M                     Map list(for popping). Uses a quirk of M to splat each first
  *L7                   Map repeating each string by 7
   c      \L            Split on occurrences of 'L'
    ."..."              Packed string encoding of the needed letters
m              (Q)      Map on input (input is taken implicitly)
 .)                     Pop. This returns the first element after removing it
  @K                    Index into K
   (d)                  The loop variable is given implicitly

Aliás, esta é a string carta original antes da codificação: "_ E DG BCMP FHVW K JX QZ".

Experimente online .

Perl 5 , 71 bytes

@a=(__,'E'x7,DDDDGGG,BBCCMMP,FFHHVVW,K,1,1,JX,1,QZ);say chop$a[$_]for<>

Experimente online!

05AB1E , 70 52 39 38 29 26 25 bytes

{ε.•3Oû}α›ηö‡.ÝŽ{•2ôÁyèNè?

-18 bytes graças a @ExpiredData .
-13 bytes, utilizando o mesmo estender ao tamanho a partir de 7 @Maltysen resposta Pyth 's .
-9 bytes criando uma porta da resposta de @JonathanAllan Jelly , por isso não deixe de votar nele!
-3 bytes graças a @Emigna .

Resulta em uma lista de caracteres e usa letras minúsculas e um espaço para espaços em branco.

Experimente online ou verifique mais alguns casos de teste .

Explicação:

{                      # Sort the (implicit) input-list
 ε                     # Map each character `y` in this list to:
  .•3Oû}α›ηö‡.ÝŽ{•     #  Push compressed string "endgmpfykkzzzzjxzzqz "
                  2ô   #  Split into parts of size 2
                    Á  #  Rotate it once towards the left so the space is leading
  yè                   #  Use integer `y` to index into the string-pairs
    Nè                 #  Then get the `N`'th character of the string-pair (with automatic
                       #   wraparound), where `N` is the index of the loop

Veja este 05AB1E ponta do meu (seção Como cordas compressa não fazem parte do dicionário? ) Para entender por que .•3Oû}α›ηö‡.ÝŽ{•é"endgmpfykkzzzzjxzzqz " .

Resposta anterior de 38 bytes:

.•Mñ&Àû«ì{₆v*Å+µ-•#ðšε7∍}IvDyèн©?ε®õ.;

Experimente online ou verifique mais alguns casos de teste .

Explicação:

.•Mñ&Àû«ì{₆v*Å+µ-•    # Push compressed string "e dg bcmp fhvw k   jx  qz"
                  #   # Split on spaces: ["e","dg","bcmp","fhvw","k","","","jx","","qz"]
                   ðš # Prepend a space to this list
 ε7∍}                 # Extend each string to size 7:
                      #  ["       ","eeeeeee","dgdgdgd","bcmpbcm","fhvwfhv","kkkkkkk","","","jxjxjxj","","qzqzqzq"]
     Iv               # Loop `y` over the input-list:
       Dyè            #  Get the `y`'th string from a copy of the list
          н           #  Get it's first character
           ©?         #  Store it in the register, and print it without trailing newline
        ε             #  Then map each string in the list to:
         ®õ.;         #   Remove the first occurrence of the character from the register

Veja este 05AB1E ponta do meu (seção Como cordas compressa não fazem parte do dicionário? ) Para entender por que .•Mñ&Àû«ì{₆v*Å+µ-•é"e dg bcmp fhvw k jx qz" .

C (gcc) , 110 bytes

_[]={0,7,14,21,0,0,22,0,24};f(char*s){for(;*s+1;s++)*s=*s?*s-1?"DDDDGGGBBCCMMPFFHHVVWKJXQZ"[_[*s-2]++]:69:32;}

Experimente online!

Usa a _matriz como um índice na cadeia estática "DDDDGGGBBCCMMPFFHHVVWKJXQZ"dinamicamente, com exceções para 0 e 1.

O argumento é uma -1matriz de pontuações terminada que é transformada no local em uma -1sequência terminada.

C # (compilador interativo do Visual C #) , 104 90 bytes

a=>a.OrderBy(x=>x).Select((x,i)=>(x="_ E DG BCMP FHVW K   JX  QZ".Split()[x])[i%x.Length])

Experimente online!

Geléia , 34 32 bytes

“¿RÇĊƈ⁸⁾%ỵṆþœsṀṂ’ṃØAṣ”A;⁶ẋ€7⁸ịḢ€

Experimente online!

Eu não tinha visto uma resposta Jelly mais curta quando escrevi isso, e isso usa uma abordagem diferente, então pensei que valeria a pena postar também.

Obrigado a @ JonathanAllan por salvar 2 bytes!

Python 3 , 178 142 135 127 112 117 bytes

def f(l):
 d=list(map(list,"  _EEEEEEE_DDDDGGG_BBCCMMP_FFHHVVW_K___JX__QZ".split('_')))
 return[d[i].pop()for i in l]

Experimente online!

-1 byte graças a cdlane

correto graças a mathmandan

Python 2 , 102 bytes (ou talvez 95?)

(Também é bom para o Python 3.)

lambda a:''.join([r*7for r in'_ E DG BCMP FHVW K * * JX * QZ'.split()][x][:a.count(x)]for x in set(a))

Experimente online!

Eu não acho que o seguinte seria aceitável:

lambda a:[[r*7for r in'_ E DG BCMP FHVW K * * JX * QZ'.split()][x][:a.count(x)]for x in set(a)]

Esta segunda versão daria saída como ['__', 'JX', 'QZ', 'K']. Portanto, as letras estariam corretas, mas seriam coletadas pelo valor do ponto. (Se isso fosse aceitável, economizaria 7 bytes.)

PHP , 101 bytes

$b=[_,E,DG,BCMP,FHVW,K,8=>JX,0,QZ];foreach($argv as$t){echo$c=($d=$b[$t])[0];$b[$t]=substr($d,1).$c;}

Como um programa independente, insira via linha de comando:

$ php s.php 10 0 10 5 8 8 0
"Q_ZKJX_"

Experimente online!

Ou 112 bytes como uma função

function($a){$b=[_,E,DG,BCMP,FHVW,K,8=>JX,0,QZ];foreach($a as$t)$b[$t]=substr($d=$b[$t],1).$c[]=$d[0];return$c;}

Experimente online!

Saída

[10,0,10,5,8,8,0]   "Q_ZKJX_"
[1,1,1,1,1,1,1]     "EEEEEEE"
[1,2,3,4,5,8,0]     "EDBFKJ_"
[2,2,2,2,2,2,2]     "DGDGDGD"

Ruby , 77 76 bytes

->a{r=%w{_ E DG BCMP FHVW K . . JX . QZ};a.map{|i|(r[i]<<r[i][0]).slice! 0}}

Experimente online!

Perl 6 , 63 bytes

*>>.&{(<_ E DG BCMP FHVW K _ _ JX _ QZ>[$_]x 7).comb[%.{$_}++]}

Experimente online!

<_ E DG BCMP FHVW K _ _ JX _ QZ> # array indexed on tile value
(<...>[$_] x 7)     # pull letters for this value, repeat 7 times to catch E
          %         # anonymous stateful hash
           .{$_}    # element for this tile value
                ++  # post increment value to move position
       .comb[...]   # characters to array, pull this incrementing index

Portanto, basicamente ele mantém uma pesquisa de compensações para cada valor de bloco e as incrementa conforme necessário, usando o deslocamento para extrair um caractere do conjunto disponível.