Problème

Vous êtes coincé dans une cabane au milieu des bois, avec seulement un vieux jeu de scrabble pour vous divertir. Lors de l'inspection, vous constatez que les lettres de scrabble sont tellement usées que seuls les points de chaque lettre sont visibles.

Néanmoins, vous décidez de jouer à un jeu. Vous sortez sept lettres du sac et les placez sur votre plateau. Votre défi consiste à déterminer ce que ces lettres pourraient être.

Donc, généralement, étant donné une liste de points, convertissez-le en une chaîne ou une liste de lettres possible.

Tuiles de Scrabble et Distributions

• 2 tuiles vierges (marquant 0 points)
• 1 point: E × 12, A × 9, I × 9, O × 8, N × 6, R × 6, T × 6, L × 4, S × 4, U × 4
• 2 points: D × 4, G × 3
• 3 points: B × 2, C × 2, M × 2, P × 2
• 4 points: F × 2, H × 2, V × 2, W × 2, Y × 2
• 5 points: K × 1
• 8 points: J × 1, X × 1
• 10 points: Q × 1, Z × 1

Donc, si vous avez une liste de points [10,10,8,5,1,1,1]alors alors "QZJKEEE"serait valide mais "QQJKEEE"ne serait pas valide (puisqu'il y a seulement 1 tuile Q dans le sac)

Règles spécifiques aux problèmes

• Vous pouvez supposer que toutes les entrées sont valides et qu'il y aura toujours 7 tuiles (c'est-à-dire qu'il n'y aura pas de liste de sept tuiles à 10 points et ne sera pas 9 tuiles)
• Vous pouvez supposer qu'aucune tuile n'a été précédemment retirée du sac (la distribution est donc la distribution standard des tuiles anglais telle que définie ci-dessus)
• Vous n'avez pas à générer un mot valide, mais uniquement une chaîne de lettres valide.
• L'ordre de votre chaîne n'a pas d'importance tant qu'il y a une lettre pour chaque mosaïque.
• Les points sont basés sur les points de mosaïque de scrabble anglais standard définis ci-dessus.
• Vous pouvez sortir en majuscules ou en minuscules, pour une tuile vierge, vous pouvez écrire un caractère d'espacement ou un trait de soulignement '_'
• Votre réponse peut générer une représentation raisonnable des mosaïques telle qu'une liste, une chaîne, un tableau ou une séquence.

  ---

Règles générales:

• C'est du code-golf , donc la réponse la plus courte en octets est gagnante.
  Ne laissez pas les langues de code-golf vous décourager de poster des réponses avec des langues autres que le code de golf. Essayez de trouver une réponse aussi courte que possible à n'importe quel langage de programmation.
• Les règles standard s'appliquent à votre réponse avec les règles d'E / S par défaut . Vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type de retour, de type renvoyé. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (c.-à-d. TIO ).
• En outre, l'ajout d'une explication de votre réponse est fortement recommandé.

Cas de test

De toute évidence, étant donné que vous pouvez générer toute valeur possible, il est difficile de définir des cas de test stricts.

Quelques cas avec une valeur de retour valide possible :

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

Quelques cas avec une valeur de retour invalide :

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

Une variante plus courte proposée par @supercat

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

Essayez-le en ligne!

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

Sauvegardé 10 octets en utilisant la méthode de cycle de Neil

Retourne une liste de tuiles. Utilisations _pour les carreaux vierges.

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

Essayez-le en ligne!

Comment?

Pour chaque nombre de points, nous parcourons un groupe d’exactement 4 tuiles, en commençant par la deuxième tuile de chaque groupe (ceci est important pour 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        /

Tous ces groupes sont stockés en une seule chaîne de 31 caractères:

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

NB : On n'a pas besoin de stocker la finale "_"en "_XJ_", car il ne sera jamais accessible de toute façon.

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

$o$

Charbon de bois , 33 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

 θ                  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

Jelly ,  31 30 27  26 octets

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

Un lien monadique acceptant une liste d'entiers qui donne une liste de caractères.
- un méli-mélo de mon précédent, ci-dessous, et mon amélioration de Nick Kennedy

Essayez-le en ligne!

La sortie n'est pas donnée dans le même ordre que l'entrée (ceci est autorisé).

Utiliser 2 de mes propres ajouts au langage dans une réponse n'arrive pas souvent! ( ṃet ɓici).

Comment?

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

précédent @ 30

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

Un lien monadique acceptant une liste d'entiers qui donne une liste de caractères.

Essayez-le en ligne!

La sortie de celui-ci est également une affaire mixte (ceci est autorisé).

Comment?

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

Boucle par saisie, en supprimant les lettres disponibles. J'ai juste une de chaque lettre qui ensemble donne 7 pour cette catégorie de point. Maintenant, en utilisant l'encodage de chaîne condensée.

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

Btw, c'est la lettre originale avant l'encodage: "_ E DG BCMP FHVW K JX QZ" .

Essayez-le en ligne .

Perl 5 , 71 octets

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

Essayez-le en ligne!

05AB1E , 70 52 39 38 29 26 25 octets

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

-18 octets grâce à @ExpiredData .
-13 octets en utilisant le même étendre la taille de 7 @Maltysen réponse Pyth s » .
-9 octets en créant un portage de la réponse Jelly de @JonathanAllan , alors assurez-vous de le réévaluer!
-3 octets grâce à @Emigna .

Résultats dans une liste de caractères et utilise des lettres minuscules et un espace pour les blancs.

Essayez-le en ligne ou vérifiez quelques autres cas de test .

Explication:

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

Voir cette astuce de mes 05AB1E (section Comment chaînes Compresser ne font pas partie du dictionnaire? ) Pour comprendre pourquoi .•3Oû}α›ηö‡.ÝŽ{•est "endgmpfykkzzzzjxzzqz ".

Réponse précédente de 38 octets:

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

Essayez-le en ligne ou vérifiez quelques autres cas de test .

Explication:

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

Voir cette astuce de mes 05AB1E (section Comment chaînes Compresser ne font pas partie du dictionnaire? ) Pour comprendre pourquoi .•Mñ&Àû«ì{₆v*Å+µ-•est "e dg bcmp fhvw k jx qz".

C (gcc) , 110 octets

_[]={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;}

Essayez-le en ligne!

Utilise le _tableau comme index dans la chaîne statique"DDDDGGGBBCCMMPFFHHVVWKJXQZ" manière dynamique avec des exceptions pour 0 et 1.

L'argument est un -1tableau de partitions terminé qui est transformé sur place en une -1chaîne terminée.

C # (compilateur interactif Visual C #) , 104 90 octets

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

Essayez-le en ligne!

Gelée , 34 32 octets

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

Essayez-le en ligne!

Je n'avais pas vu qu'il y avait une réponse plus courte de la gelée quand j'ai écrit ça, et cela utilise une approche différente alors j'ai pensé que ça valait le coup de poster aussi.

Merci à @JonathanAllan d'avoir économisé 2 octets!

Python 3 , 178 142 135 127 112 117 octets

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

Essayez-le en ligne!

-1 octet grâce à cdlane

correct grâce à mathmandan

Python 2 , 102 octets (ou peut-être 95?)

(Aussi bien pour 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))

Essayez-le en ligne!

Je ne pense pas que ce qui suit serait acceptable:

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

Cette deuxième version donnerait une sortie comme ['__', 'JX', 'QZ', 'K']. Les lettres seraient donc correctes, mais elles seraient rassemblées par valeur en points. (Si cela était acceptable, cela économiserait 7 octets.)

PHP , 101 octets

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

En tant que programme autonome, entrez via la ligne de commande:

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

Essayez-le en ligne!

Ou 112 octets en tant que fonction

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

Essayez-le en ligne!

Sortie

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

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

Essayez-le en ligne!

Perl 6 , 63 octets

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

Essayez-le en ligne!

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

Donc, essentiellement, il garde une recherche des décalages pour chaque valeur de mosaïque et les incrémente si nécessaire, en utilisant le décalage pour extraire un caractère du jeu disponible.