JavaScript (ES6), 72 bytes

A shorter variant suggested by @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!

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

Saved 10 bytes by using Neil's cycling method

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!

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=((20times 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$.

Charcoal, 33 bytes

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

Try it online! Link is to verbose version of code. Explanation:

 θ                  Input array

⭆                   Map over elements and join

     ”...”          Literal string " nEnDGnBCMPnFHVWnKnnnJXnnQZ"

    ⪪     ¶         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;€⁶ɓṢĖœị

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

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!

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"

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.