Problem

Sie sitzen in einer Hütte mitten im Wald fest und haben nur ein altes Scrabble-Set, um sich zu unterhalten. Bei der Überprüfung sehen Sie, dass die Scrabble-Buchstaben so abgenutzt sind, dass nur die Punkte für jeden Buchstaben sichtbar sind.

Trotzdem entscheiden Sie sich, ein Spiel zu spielen. Sie ziehen sieben Buchstaben aus der Tüte und legen sie auf Ihr Tablett. Ihre Herausforderung besteht darin, die möglichen Buchstaben zu bestimmen.

Wenn Sie also eine Liste von Punkten haben, konvertieren Sie diese in eine mögliche Zeichenfolge oder Liste von Buchstaben.

Scrabble Tiles und Distributionen

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

Wenn Sie also eine Punkteliste haben, [10,10,8,5,1,1,1]ist "QZJKEEE"diese zwar gültig, aber "QQJKEEE"nicht gültig (da sich nur 1 Q-Plättchen in der Tasche befindet).

Problemspezifische Regeln

• Sie können davon ausgehen, dass alle Eingaben gültig sind und dass es immer 7 Kacheln gibt (dh es wird keine Liste mit sieben 10-Punkte-Kacheln geben und es werden nicht 9 Kacheln sein).
• Sie können davon ausgehen, dass zuvor keine Kacheln aus dem Beutel gezogen wurden (daher entspricht die Verteilung der oben definierten englischen Kacheln der Standardverteilung).
• Sie müssen kein gültiges Wort generieren, sondern nur eine gültige Buchstabenfolge.
• Die Reihenfolge Ihrer Zeichenfolge spielt keine Rolle, solange für jedes Plättchen ein entsprechender Buchstabe vorhanden ist.
• Die Punkte basieren auf den oben definierten Standardpunkten für englische Scrabble-Kacheln.
• Sie können in Groß- oder Kleinschreibung ausgeben. Für eine leere Kachel können Sie entweder ein Leerzeichen oder einen Unterstrich '_' ausgeben.
• Ihre Antwort kann als eine angemessene Darstellung der Kacheln wie eine Liste, eine Zeichenfolge, ein Array oder eine Sequenz ausgegeben werden

  ---

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle

Da Sie jeden möglichen Wert ausgeben können, ist es offensichtlich schwierig, strenge Testfälle zu definieren.

Einige Fälle mit einem möglichen gültigen Rückgabewert:

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

Einige Fälle mit einem ungültigen Rückgabewert:

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

Eine kürzere Variante von @supercat vorgeschlagen

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

Probieren Sie es online!

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

Mit Neils Fahrradmethode 10 Bytes gespart

Gibt eine Liste von Kacheln zurück. Verwendet _für leere Fliesen.

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

Probieren Sie es online!

Wie?

Für jede Punktzahl durchlaufen wir eine Gruppe von genau 4 Plättchen, beginnend mit dem zweiten Plättchen jeder Gruppe (dies ist wichtig für 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        /

Alle diese Gruppen werden als einzelne Zeichenfolge mit 31 Zeichen gespeichert:

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

NB : Es wird nicht das letzte speichern müssen "_"in "_XJ_", da es sowieso nie zugegriffen werden.

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

Holzkohle , 33 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

 θ                  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 Bytes

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

Ein monadischer Link, der eine Liste von ganzen Zahlen akzeptiert, die eine Liste von Zeichen ergibt.
- ein Mischmasch meiner vorherigen und meiner Verbesserung von Nick Kennedy's

Probieren Sie es online!

Die Ausgabe erfolgt nicht in derselben Reihenfolge wie die Eingabe (dies ist zulässig).

Es kommt nicht oft vor, dass ich 2 meiner eigenen Ergänzungen zur Sprache in einer Antwort verwende! ( ṃund ɓhier).

Wie?

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

vorherige @ 30

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

Ein monadischer Link, der eine Liste von ganzen Zahlen akzeptiert, die eine Liste von Zeichen ergibt.

Probieren Sie es online!

Die Ausgabe dieses Benutzers erfolgt ebenfalls in gemischten Groß- und Kleinschreibung (dies ist zulässig).

Wie?

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

Loops through input, popping off the available letters. I just have one of each letter that together give 7 for that point category. Now using packed string encoding.

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, this is the original letter string before encoding: "_ E DG BCMP FHVW K JX QZ".

Try it online.

Perl 5, 71 bytes

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

Try it online!

05AB1E, 70 52 39 38 29 26 25 bytes

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

-18 bytes thanks to @ExpiredData.
-13 bytes by using the same extend to size 7 from @Maltysen's Pyth answer.
-9 bytes by creating a port of @JonathanAllan's Jelly answer, so make sure to upvote him!
-3 bytes thanks to @Emigna.

Results in a list of characters, and uses lowercase letters and a space for blanks.

Try it online or verify some more test cases.

Explanation:

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

See this 05AB1E tip of mine (section How to compress strings not part of the dictionary?) to understand why .•3Oû}α›ηö‡.ÝŽ{• is "endgmpfykkzzzzjxzzqz ".

Previous 38 bytes answer:

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

Try it online or verify some more test cases.

Explanation:

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

See this 05AB1E tip of mine (section How to compress strings not part of the dictionary?) to understand why .•Mñ&Àû«ì{₆v*Å+µ-• is "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;}

Try it online!

Uses the _ array as an index into the static string "DDDDGGGBBCCMMPFFHHVVWKJXQZ" dynamically with exceptions for 0 and 1.

Argument is a -1-terminated array of scores which is transformed in-place into a -1-terminated string.

C# (Visual C# Interactive Compiler), 104 90 bytes

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

Try it online!

Jelly, 34 32 bytes

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

Try it online!

I hadn’t seen there was a shorter Jelly answer when I wrote this, and this uses a different approach so I thought was worth posting as well.

Thanks to @JonathanAllan for saving 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]

Try it online!

-1 byte thanks to cdlane

correct thanks to mathmandan

Python 2, 102 bytes (or maybe 95?)

(Also fine for 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))

Try it online!

I don't think the following would be acceptable:

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

This second version would give output like ['__', 'JX', 'QZ', 'K']. So the letters would be correct, but they would be collected by point value. (If this were acceptable, it would save 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;}

As a standalone program, input via command line:

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

Try it online!

Or 112 bytes as a function

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

Try it online!

Output

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

Try it online!

Perl 6, 63 bytes

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

Try it 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

So essentially it keeps a lookup of offsets for each tile value and increments them as needed, using the offset to pull a character from the available set.