Problema

Estás atrapado en una cabaña en medio del bosque, con solo un viejo juego de scrabble para entretenerte. Tras la inspección, verá que las letras de Scrabble están tan gastadas que solo los puntos de cada letra son visibles.

No obstante, decides jugar un juego. Sacas siete letras de la bolsa y las colocas en tu bandeja, tu desafío es determinar cuáles podrían ser esas letras.

Entonces, generalmente, dada una lista de puntos, conviértalo en cualquier posible cadena o lista de letras.

Scrabble Tiles y Distribuciones

• 2 fichas en blanco (puntuación de 0 puntos)
• 1 punto: E × 12, A × 9, I × 9, O × 8, N × 6, R × 6, T × 6, L × 4, S × 4, U × 4
• 2 puntos: D × 4, G × 3
• 3 puntos: B × 2, C × 2, M × 2, P × 2
• 4 puntos: F × 2, H × 2, V × 2, W × 2, Y × 2
• 5 puntos: K × 1
• 8 puntos: J × 1, X × 1
• 10 puntos: Q × 1, Z × 1

Entonces, si tiene una lista de puntos, [10,10,8,5,1,1,1]entonces "QZJKEEE"sería válido pero "QQJKEEE"no sería válido (ya que solo hay 1 Q mosaico en la bolsa)

Reglas específicas del problema

• Puede suponer que todas las entradas son válidas y que siempre habrá 7 mosaicos (es decir, no será una lista de siete mosaicos de 10 puntos y no serán 9 mosaicos)
• Puede suponer que no se han extraído previamente fichas de la bolsa (por lo que la distribución es la distribución estándar de las fichas en inglés como se definió anteriormente)
• No tiene que generar una palabra válida, solo una cadena de letras válida.
• El orden de su cadena es irrelevante siempre que para cada mosaico haya una letra correspondiente.
• Los puntos se basan en los puntos de mosaico de Scrabble en inglés estándar como se definió anteriormente.
• Puede mostrar en mayúsculas o minúsculas, para un mosaico en blanco puede mostrar un carácter de espacio o un guión bajo '_'
• Su respuesta puede aparecer como cualquier representación razonable de los mosaicos, como una lista, cadena, matriz o secuencia

  ---

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba

Obviamente, dado que puede generar cualquier valor posible, es difícil definir casos de prueba estrictos.

Algunos casos con un posible 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"

Algunos casos con un valor de retorno no vá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

Una variante más corta sugerida por @supercat

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

Pruébalo en línea!

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

Ahorró 10 bytes usando el método de ciclismo de Neil

Devuelve una lista de mosaicos. Usos _para azulejos en blanco.

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

Pruébalo en línea!

¿Cómo?

Para cada número de puntos, recorremos un grupo de exactamente 4 mosaicos, comenzando con el segundo mosaico de cada grupo (esto es 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 estos grupos se almacenan como una sola cadena de 31 caracteres:

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

NB : No necesitamos para almacenar la final "_"en "_XJ_", ya que nunca se tendrá acceso de todos modos.

El número de puntos se convierte al índice correcto en esta cadena con:$n$$i_n$

  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_

La posición actual en cada grupo se almacena en el objeto .$o$

Carbón , 33 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 θ                  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

Gelatina ,  31 30 27  26 bytes

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

Un enlace monádico que acepta una lista de enteros que produce una lista de caracteres.
- una mezcla de mis anteriores, a continuación, y mi mejora de Nick Kennedy

Pruébalo en línea!

La salida no se da en el mismo orden que la entrada (esto está permitido).

¡Usar 2 de mis propias adiciones al idioma en una respuesta no sucede a menudo! ( ṃy ɓaquí)

¿Cómo?

“...“...’ṃØ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œị

Un enlace monádico que acepta una lista de enteros que produce una lista de caracteres.

Pruébalo en línea!

La salida de este también es mixta (esto está permitido).

¿Cómo?

“...»⁾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"

Pyth - 92 86 83 81 80 75 60 52 49 42 36 bytes

Recorre la entrada, sacando las letras disponibles. Solo tengo una de cada letra que juntas da 7 para esa categoría de puntos. Ahora usando la codificación de cadena empaquetada.

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

Por cierto, esta es la cadena original de la carta antes de la codificación: "_ E DG BCMP FHVW K JX QZ".

Pruébalo en línea .

Perl 5 , 71 bytes

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

Pruébalo en línea!

05AB1E , 70 52 39 38 29 26 25 bytes

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

-18 bytes gracias a @ExpiredData .
-13 bytes mediante el uso de la misma se extienden a tamaño 7 de @Maltysen Pyth respuesta 's .
-9 bytes creando un puerto de la respuesta Jelly de @JonathanAllan , ¡así que asegúrate de votarlo!
-3 bytes gracias a @Emigna .

Da como resultado una lista de caracteres y utiliza letras minúsculas y un espacio para espacios en blanco.

Pruébelo en línea o verifique algunos casos de prueba más .

Explicación:

{                      # 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

Ver este consejo 05AB1E mío (sección Cómo comprimir cadenas que no forman parte del diccionario? ) Para entender por qué .•3Oû}α›ηö‡.ÝŽ{•es "endgmpfykkzzzzjxzzqz ".

Respuesta anterior de 38 bytes:

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

Pruébelo en línea o verifique algunos casos de prueba más .

Explicación:

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

Ver este consejo 05AB1E mío (sección Cómo comprimir cadenas que no forman parte del diccionario? ) Para entender por qué .•Mñ&Àû«ì{₆v*Å+µ-•es "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;}

Pruébalo en línea!

Utiliza la _matriz como un índice en la cadena estática "DDDDGGGBBCCMMPFFHHVVWKJXQZ"dinámicamente con excepciones para 0 y 1.

El argumento es una -1matriz de puntuaciones terminada que se transforma en el lugar en una -1cadena terminada.

C # (compilador interactivo de 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])

Pruébalo en línea!

Jalea , 34 32 bytes

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

Pruébalo en línea!

No había visto una respuesta Jelly más corta cuando escribí esto, y esto usa un enfoque diferente, así que pensé que valía la pena publicarlo también.

¡Gracias a @JonathanAllan por guardar 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]

Pruébalo en línea!

-1 byte gracias a cdlane

correcto gracias a Mathmandan

Python 2 , 102 bytes (¿o quizás 95?)

(También está bien para 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))

Pruébalo en línea!

No creo que lo siguiente sea aceptable:

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 versión daría salida como ['__', 'JX', 'QZ', 'K']. Entonces las letras serían correctas, pero se recogerían por valor de punto. (Si esto fuera aceptable, ahorraría 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 un programa independiente, ingrese a través de la línea de comando:

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

Pruébalo en línea!

O 112 bytes como una función

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;}

Pruébalo en línea!

Salida

[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}}

Pruébalo en línea!

Perl 6 , 63 bytes

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

Pruébalo en línea!

<_ 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

Por lo tanto, esencialmente mantiene una búsqueda de desplazamientos para cada valor de mosaico y los incrementa según sea necesario, utilizando el desplazamiento para extraer un carácter del conjunto disponible.