问题

您被困在树林中的小屋中，只有一个旧的拼字游戏可以娱乐自己。通过检查，您会看到拼字游戏字母非常磨损，以至于每个字母都仅可见。

尽管如此，您还是决定玩游戏。您从书包中取出七个字母并将其放在托盘上，您面临的挑战是确定这些字母可能是什么。

因此，通常，给定点列表会将其转换为任何可能的字符串或字母列表。

拼字游戏瓷砖和发行

• 2个空白磁贴（得分0分）
• 1点：E×12，A×9，I×9，O×8，N×6，R×6，T×6，L×4，S×4，U×4
• 2分：D×4，G×3
• 3分：B×2，C×2，M×2，P×2
• 4点：F×2，H×2，V×2，W×2，Y×2
• 5分：K×1
• 8点：J×1，X×1
• 10点：Q×1，Z×1

所以，如果你有个列表[10,10,8,5,1,1,1]，然后"QZJKEEE"将是有效的，但"QQJKEEE"不会是有效的（因为在包里只有1 Q瓦）

问题特定规则

• 您可以假设所有输入都是有效的，并且将始终有7个图块（即，它将不是七个10点图块的列表，也不是9个图块）
• 您可以假设以前没有从包中拉出任何瓷砖（因此，分布是上述定义的英语瓷砖的标准分布）
• 您不必生成有效的单词，只需生成有效的字母字符串即可。
• 只要每个图块都有对应的字母，字符串的顺序就无关紧要。
• 点数是根据上面定义的标准英语拼字游戏点数得出的。
• 您可以输出大写或小写，对于空白图块，您可以输出空格字符或下划线“ _”
• 您的答案可能输出为图块的任何合理表示形式，例如列表，字符串，数组或序列

  ---

一般规则：

• 这是代码高尔夫球，因此最短答案以字节为单位。
  不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能简短的答案。
• 标准规则适用于具有默认I / O规则的答案，因此允许您使用STDIN / STDOUT，具有适当参数的函数/方法以及返回类型的完整程序。你的来电。
• 默认漏洞是禁止的。
• 如果可能的话，请添加一个带有测试代码的链接（即TIO）。
• 另外，强烈建议为您的答案添加说明。

测试用例

显然，由于可以输出任何可能的值，因此很难定义严格的测试用例。

某些情况下可能带有有效的返回值：

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

某些情况下返回值无效：

[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个字节

@supercat建议的较短变体

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

在线尝试！

JavaScript（ES6）， 137 ... 84 78 77  76字节

使用Neil的循环方法节省了10个字节

返回图块列表。用途_空白瓷砖。

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

在线尝试！

怎么样？

对于每个点数，我们从每组的第二个图块开始，循环浏览一组正好4 个图块（这对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        /

所有这些组都存储为31个字符的单个字符串：

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

注意：我们不需要将最终结果存储"_"在"_XJ_"，因为无论如何都不会访问它。

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

木炭，33字节

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

在线尝试！链接是详细版本的代码。说明：

 θ                  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

果冻， 31 30 27  26 字节

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

一个接受整数列表的单子链接，该整数列表产生一个字符列表。
-我以前的，下面的以及我对尼克·肯尼迪（Nick Kennedy）的改进的混搭

在线尝试！

输出的输入顺序与输入的顺序不同（允许这样做）。

在答案中使用我自己添加的2种语言很少会发生！（ṃ和ɓ这里）。

怎么样？

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

前一个@ 30

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

一个接受整数列表的单子链接，该整数列表产生一个字符列表。

在线尝试！

这个人的输出也是大小写混合的（允许）。

怎么样？

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

遍历输入，弹出可用字母。我只有每个字母中的一个，一起给该点类别提供7。现在使用打包字符串编码。

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

顺便说一句，这是编码前的原始字母字符串："_ E DG BCMP FHVW K JX QZ"。

在线尝试。

Perl 5，71个字节

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

在线尝试！

05AB1E，70 52 39 38 29 26 25 字节

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

-18个字节，感谢@ExpiredData。
通过使用相同的-13个字节，从@Maltysen的Pyth答案扩展为7号。
通过创建@JonathanAllan的Jelly答案端口来生成-9个字节，因此请确保对他进行投票！
-3个字节，感谢@Emigna。

产生一个字符列表，并使用小写字母和空格作为空白。

在线尝试或验证更多测试用例。

说明：

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

看到这个05AB1E尖矿（部分如何压缩字符串不是字典的一部分吗？）理解为什么.•3Oû}α›ηö‡.ÝŽ{•是"endgmpfykkzzzzjxzzqz "。

前38个字节的答案：

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

在线尝试或验证更多测试用例。

说明：

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

看到这个05AB1E尖矿（部分如何压缩字符串不是字典的一部分吗？）理解为什么.•Mñ&Àû«ì{₆v*Å+µ-•是"e dg bcmp fhvw k jx qz"。

C（gcc），110个字节

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

在线尝试！

动态使用该_数组作为静态字符串的索引"DDDDGGGBBCCMMPFFHHVVWKJXQZ"，但0和1例外。

参数是一个-1以分数-1结尾的分数数组，这些分数被原位转换为以- 结尾的字符串。

C＃（Visual C＃交互式编译器），104 90字节

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

在线尝试！

果冻，34 32字节

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

在线尝试！

当我写这篇文章时，我没有看到Jelly的回答更短，而且使用了不同的方法，因此我认为也值得发表。

感谢@JonathanAllan节省了2个字节！

Python 3中，178个 142 135 127 112 117字节

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

在线尝试！

-1字节归功于cdlane

正确的感谢mathmandan

Python 2，102个字节（或95个字节？）

（对于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))

在线尝试！

我认为以下情况不可接受：

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

第二个版本将给出类似的输出['__', 'JX', 'QZ', 'K']。因此，字母是正确的，但它们将通过点值进行收集。（如果可以接受，它将节省7个字节。）

PHP，101字节

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

作为独立程序，通过命令行输入：

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

在线尝试！

或112个字节作为函数

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

在线尝试！

输出量

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

红宝石，77 76字节

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

在线尝试！

Perl 6、63个字节

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

在线尝试！

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

因此，从本质上讲，它会为每个图块值保留偏移量的查找，并根据需要使用偏移量从可用集合中提取字符，以增加偏移量。