[Question]
  [
## Problem
You're stuck in a cabin in the middle of the woods, with only an old scrabble set to entertain yourselves. Upon inspection you see that the scrabble letters are so worn, that only the points for each letter are visible. 
Nonetheless you decide to play a game. You pull seven letters from the bag and place them on your tray, your challenge is to determine what those letters could be. 
So generally, given a list of points convert it into any possible string or list of letters. 
---
## Scrabble Tiles and Distributions
* 2 blank tiles (scoring 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
So if you have a list of points `[10,10,8,5,1,1,1]` then `"QZJKEEE"` would be valid but `"QQJKEEE"` would not be valid (since there is only 1 Q tile in the bag)
---
## Problem Specific Rules
* You may assume all inputs are valid and that there will always be 7 tiles (i.e it wont be a list of seven 10 point tiles and won't be 9 tiles)
* You can assume no tiles have been previously pulled from the bag (so the distribution is the standard distribution of english tiles as defined above)
* You do not have to generate a valid word, only a valid string of letters.
* The order of your string is irrelevant as long as for each tile there is a corresponding letter.
* Points are based on the standard english scrabble tile points as defined above.
* You may output in upper or lower case, for a blank tile you may output either a space character or an underscore '\_'
* Your answer may output as any reasonable representation of the tiles such as a List, String, Array or Sequence
---
## General rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.  
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* [Standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer with [default I/O rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/), so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code (i.e. [TIO](https://tio.run/#)).
* Also, adding an explanation for your answer is highly recommended.
---
## Test Cases
Obviously since you can output any possible value it's difficult to define strict test cases.
Some cases with a *possible valid* return value:
```
[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"
```
Some cases with an *invalid* return value: 
```
[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)
```
  
[Answer]
# JavaScript (ES6), 72 bytes
*A shorter variant suggested by [@supercat](https://codegolf.stackexchange.com/users/3748/supercat)*
```
a=>a.map(o=n=>'?ED?BWQ?_EG?CFZ?_EDJMH?K?EGXPV'[n*9.4+(o[n]=7-~o[n])&31])
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/R1i5RLzexQCPfNs/WTt3e1cXeKTzQPt7V3d7ZLQpIu3j5eth727u6RwSEqUfnaVnqmWhr5Efnxdqa69aBaE01Y8NYzf/J@XnF@Tmpejn56RppGtGGBjoKBjog0lRHwQKMDGI1NbnQlCkY6mAgHMqMdBSMdRRMYAZiNc1IBwMBlf0HAA "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), ~~137 ... 84 78 77~~ 76 bytes
*Saved 10 bytes by using [Neil's cycling method](https://codegolf.stackexchange.com/a/182959/58563)*
Returns a list of tiles. Uses `_` for blank tiles.
```
a=>a.map(o=n=>"____FHVWGDGD_K__BCMPEEEE_ZQ__XJ"[n*20%44%32+(o[n]=-~o[n])%4])
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/R1i5RLzexQCPfNs/WTikeCNw8wsLdXdxd4r3j452cfQNcgSA@KjA@PsJLKTpPy8hA1cRE1dhIWyM/Oi/WVrcORGmqmsRq/k/OzyvOz0nVy8lP10jTiDY00FEw0AGRpjoKFmBkEKupyYWmTMFQBwPhUGako2Cso2ACMxCraUY6GAio7D8A "JavaScript (Node.js) – Try It Online")
### How?
For each number of points, we cycle through a group of exactly 4 tiles, starting with the *second* tile of each group (this is important for `G` vs `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        /
```
All these groups are stored as a single string of 31 characters:
```
____FHVWGDGD_K__BCMPEEEE_ZQ__XJ
^   ^   ^   ^   ^   ^   ^   ^
0   4   8  12  16  20  24  28
```
*NB*: We don't need to store the final `"_"` in `"_XJ_"`, as it will never be accessed anyway.
The number of points \$n\$ is converted to the correct index \$i\_n\$ into this string with:
$$i\_n=((20\times n)\bmod 44)\bmod 32$$
```
  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_
```
The current position in each group is stored in the object \$o\$.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 33 bytes
```
⭆θ§§⪪”＆↖“Ｖh_z↶∕¡⌈∨₂χ¹‖◨⌊″”¶ι№…θκι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaBTqKDiWeOalpFZowOjggpzMEg0lhZg815g8F/eYPCdn34CYPDePsPCYPO@YPBD0igCRgVFKOgpKMXlKmjoKmUDsnF8KNNw3PycFZG42WBQIrP//j4420lFAR7Gx/3XLcgA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 θ                  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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~31 30 27~~ 26 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“ñẒẎYñ(“Nut¦hß’ṃØA;€⁶ɓṢĖœị
```
A monadic Link accepting a list of integers which yields a list of characters.  
- a mishmash of my previous, below, and my improvement of [Nick Kennedy's](https://codegolf.stackexchange.com/a/182987/53748)
**[Try it online!](https://tio.run/##AU8AsP9qZWxsef//4oCcw7HhupLhuo5Zw7Eo4oCcTnV0wqZow5/igJnhuYPDmEE74oKs4oG2yZPhuaLElsWT4buL////MTAsMSwwLDMsMiwxLDEw "Jelly – Try It Online")**
The output is not given in the same order as the input (this is allowed).
Using 2 of my own additions to the language in an answer does not happen often! (`ṃ` and `ɓ` here).
### How?
```
“...“...’ṃØ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)
```
---
previous @ 30
```
“²rṛʂṂø5=Ɓṇ^N¥Y»⁾tky;⁶s2ɓṢĖUœị
```
A monadic Link accepting a list of integers which yields a list of characters.
[Try it online!](https://tio.run/##AVIArf9qZWxsef//4oCcwrJy4bmbyoLhuYLDuDU9xoHhuYdeTsKlWcK74oG@dGt5O@KBtnMyyZPhuaLEllXFk@G7i////1sxMCwwLDEwLDUsOCw4LDBd "Jelly – Try It Online")
This one's output is also mixed-case (this is allowed).
### How?
```
“...»⁾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"
```
[Answer]
# 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](http://pyth.herokuapp.com/?code=K%5BM%2aL7c.%22B_%15%C3%AA%15%C2%BA%C2%8D+%C3%A7%C3%91O%C3%92%0A7%C3%A2Ck%C3%91%C2%92%22%5CLm.%29%40K&test_suite=1&test_suite_input=%5B10%2C10%2C8%2C5%2C1%2C1%2C1%5D%0A%5B1%2C1%2C1%2C1%2C1%2C1%2C1%5D%0A%5B1%2C2%2C3%2C4%2C5%2C8%2C0%5D&debug=0).
[Answer]
# [Perl 5](https://www.perl.org/), 71 bytes
```
@a=(__,'E'x7,DDDDGGG,BBCCMMP,FFHHVVW,K,1,1,JX,1,QZ);say chop$a[$_]for<>
```
[Try it online!](https://tio.run/##K0gtyjH9/98h0VYjPl5H3VW9wlzHBQjc3d11nJycnX19A3Tc3Dw8wsLCdbx1DIHQKwJIBEZpWhcnViokZ@QXqCRGq8THpuUX2dj9/2/IZcRlzGXCZcplwWXwL7@gJDM/r/i/rq@pnoGhAQA "Perl 5 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~70~~ ~~52~~ ~~39~~ ~~38~~ ~~29~~ ~~26~~ 25 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
{ε.•3Oû}α›ηö‡.ÝŽ{•2ôÁyèNè?
```
-18 bytes thanks to *@ExpiredData*.  
-13 bytes by using the same extend to size 7 from [*@Maltysen*'s Pyth answer](https://codegolf.stackexchange.com/a/182956/52210).  
-9 bytes by creating a port of [*@JonathanAllan*'s Jelly answer](https://codegolf.stackexchange.com/a/182984/52210), so make sure to upvote him!  
Results in a list of characters, and uses lowercase letters and a space for blanks.
[Try it online](https://tio.run/##yy9OTMpM/f@/@txWvUcNi4z9D@@uPbfxUcOuc9sPb3vUsFDv8Nyje6uBMkaHtxxurDy8wu/wiv//ow0NdAx1DHSMdYyAtKFBLAA) or [verify some more test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/6nNb9R41LDL2P7y79tzGRw27zm0/vO1Rw0K9w3OP7q0Gyhgd3nK4sfLwCr/DK/7X6vyPjjY00DHQARKmOhZAaBCrE22ogwTBfCMdYx0TsAqQvJEOEoyNBQA).
**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?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `.•3Oû}α›ηö‡.ÝŽ{•` is `"endgmpfykkzzzzjxzzqz "`.
---
**Previous 38 bytes answer:**
```
.•Mñ&Àû«ì{₆v*Å+µ-•#ðšε7∍}IvDyèн©?ε®õ.;
```
[Try it online](https://tio.run/##yy9OTMpM/f9f71HDIt/DG9UONxzefWj14TXVj5rayrQOt2of2qoLlFI@vOHownNbzR919NZ6lrlUHl5xYe@hlfbnth5ad3irnvX//9FGOkgwFgA) or [verify some more test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSvbqS/X@9Rw2LfA9vVDvccHj3odWH11Q/amor0zrcqn1oqy5QSvnwhqMLz201f9TRW1tZ5lJ5eMWFvYdW2p/bemjd4a161v9ra4GGHNpm/z862tBAx0AHSJjqWAChQaxOtKEOEgTzjXSMdUzAKkDyRjpIMDYWAA).
**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?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `.•Mñ&Àû«ì{₆v*Å+µ-•` is `"e dg bcmp fhvw k jx qz"`.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 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!](https://tio.run/##dU5dS8MwFH3fr7gUhHwVmjinLpbBJuuYDObLFGsYodKZBztpii@lvz0msfrmuSEc7jn33Fulp6py7liqvM/YNeNTJjjLfAkRvukga1S965ZY3NfnFkliKZeWUkxsTuyC2JQvknuPoiiWy9Vqt9uv15vN4fD0sH1@fEnKY@k9QlGq5rPb@aWQgzNNBx/aNCgQ3Z4qBmEHEM@/SoWhn4BHUI2MNMpvutNlsCs5iV1/ECADOXAJBu5ilARKDY5yQJwxKVfepbuzQXGFUXiM@Mv8saT8NxoF5R9XNrY/W39ijZIL@9okDMaJwTke68rdOJ759w0 "C (gcc) – 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.
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~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!](https://tio.run/##Vc5PCwFBGIDxu0/xtqXmrTEH17VzwPqzCClk27TG4K01NDsyks@@nETP7Xd6VNlQJVW9m1GtMZWutX@Y/ExK8mFsbmdt812hvyjhEFV5JHMxtXtt2w/mI@lRLHShlWPMc8JIfjDYQgzdPrQ7kxn0BssVjAAgWQPMN4FYXAtyDFOfYUp1L8baHN0pwyqsrSw5zUpnyRxFciHDAh7wAzP6Dn9/DJ9N/tMLEcPqDQ "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~34~~ 32 bytes
```
“¿RÇĊƈ⁸⁾%ỵṆþœsṀṂ’ṃØAṣ”A;⁶ẋ€7⁸ịḢ€
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw5xD@4MOtx/pOtbxqHHHo8Z9qg93b324s@3wvqOTix/ubHi4s@lRw8yHO5sPz3B8uHPxo4a5jtaPGrc93NX9qGmNOVDLw93dD3csAnL@H530cOcMHaCJCrp2CkpAlTqH20FcEJPrcDtQSeR/JVcFF3cFJ2ffAAU3j7BwBW8FBQWvCAWFwCil/9Fc0YYGOgY6QMJUxwIIDWJ1gEI6SBAiYKRjrGMCVgNWYaSDBGO5YgE "Jelly – 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!
[Answer]
# [Python 3](https://docs.python.org/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!](https://tio.run/##JcZBC4IwFADgu7/i0cUNhlQWRNBFS6UQ6mKRyCPQ0WBtj7kO/flW0Xf66OXv1qQh9IMEyTRfR9BvtBo9e9yI/SImALj7w@1XWZaYZXle10csiqpqmjMeEHF/QTxdJ8lIWnkWY8w5j8AN/ulM27eqS8gS49I6UKAM6C6QU8YzydqZmItULMRSrMS04zy8LXllzRg@ "Python 3 – Try It Online")
*-1 byte thanks to cdlane*
*correct thanks to mathmandan*
[Answer]
# [Python 2](https://docs.python.org/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!](https://tio.run/##TY3LCsIwFET3fsXdJSmhtFVRCm58owi6UTEGiS@M1KSkkdavj7GCOAdmMQwz@cvetEpc2du7TDyOZwEiRSi8a6kwM0Hnqg0YkAodYATDCfQHiyWMp@sNzCHwzLbeVjsUFnkmLSacVZylIjzpp7K4IvwzUPkBKC4WC0LcL2AsjmhEvbVp1xNxCiymf3yDhDZpq@7UjYT@wXnaAK/cSGWh9IfuDQ "Python 2 – 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.)
[Answer]
# [PHP](https://php.net/), 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!](https://tio.run/##JYnLCsIwEAB/pZQ9NLBIehAKMS34RhH0omIppY2x8WLCNnoRvz1WZGAYGGdciCeFMy7SRJZq0s6Svz@6hDMRoJVljQucr3A62@1xuT6ecIuZzDdn5Hi4VOJmSTfKJNBQ94qaHjx7a2UsKJnAVUJbgq9YySvxT9k/297T8DBlI1DiE4o8DiHlgf80DtkA/wI "PHP – 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!](https://tio.run/##TZDRaoMwFIav51McJBcKZ6t1GxRcOuh0ldpt7c1WakWsTadjM5LEq9Jnd5ntqPkhCTkfHyenLur24bEuamBCcJEKVnOhyurTcmwPiHRpu2@qXJW8skhmH8iWxikG6E9x8vSywOfw/QMjHNHxbIUOLteJt@eCZXmhccgkUTbZxkQlVDZbqYRFdvT0gEP7huRxQskudhJPMNWIiuTesfUMgygmlQQKsQEQDx2t1ts9jnScBK8GA7geg7mEdTRbgdlB2MsFCU7rjLh4i3edp2d59SdhNDtZXOzlgvjTLqaR6OaM/x/Cuc1M6hvYcNAGlhccviSvUlblfMesroRgbtRGmdivlD/199@pp2zpOdmaWoSLNHibe8ax/QU "PHP – 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"
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~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!](https://tio.run/##TYpNC4JAGAbv/oonQSh4WzYrCFIPfVMEdaloWcJESSgQTSPU376ZFMjAHIaJ0@tbBbbqOm4e28Yrv2CO2RKT6XaHxepwxAasYn2qtD@XY5c93CgvwqIdi1Ba1teCyw5L7qHnt8DLUgkNED1OnCoNaVTBJdWRGvyTSX0a1N/vMqmB1CTzXe@GvMgKROkzgW4ksB0YiQ4DIiMEIpOyVB8 "Ruby – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 63 bytes
```
*>>.&{(<_ E DG BCMP FHVW K _ _ JX _ QZ>[$_]x 7).comb[%.{$_}++]}
```
[Try it online!](https://tio.run/##K0gtyjH7n1uplmb7X8vOTk@tWsMmXsFVwcVdwcnZN0DBzSMsXMFbIR4IvSKARGCUXbRKfGyFgrmmXnJ@blK0ql61SnyttnZs7f/ixEoFtTSNaCMdJBirac0FkzA00AEiCyA01THRMUGR0kGCQIn/AA "Perl 6 – 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.
]