Vấn đề

Bạn đang bị mắc kẹt trong một cabin ở giữa rừng, chỉ có một bộ đồ nguệch ngoạc cũ để giải trí. Khi kiểm tra, bạn thấy rằng các chữ cái viết nguệch ngoạc đã bị mòn, chỉ có thể nhìn thấy các điểm cho mỗi chữ cái.

Tuy nhiên, bạn quyết định chơi một trò chơi. Bạn kéo bảy chữ cái từ túi và đặt chúng vào khay của bạn, thử thách của bạn là xác định những chữ cái đó có thể là gì.

Vì vậy, nói chung, đưa ra một danh sách các điểm chuyển đổi nó thành bất kỳ chuỗi hoặc danh sách các chữ cái có thể.

Gạch vụn và phân phối

• 2 ô trống (ghi 0 điểm)
• 1 điểm: E × 12, A × 9, I × 9, O × 8, N × 6, R × 6, T × 6, L × 4, S × 4, U × 4
• 2 điểm: D × 4, G × 3
• 3 điểm: B × 2, C × 2, M × 2, P × 2
• 4 điểm: F × 2, H × 2, V × 2, W × 2, Y × 2
• 5 điểm: K × 1
• 8 điểm: J × 1, X × 1
• 10 điểm: Q × 1, Z × 1

Vì vậy, nếu bạn có một danh sách các điểm [10,10,8,5,1,1,1]thì "QZJKEEE"sẽ hợp lệ nhưng "QQJKEEE"sẽ không hợp lệ (vì chỉ có 1 ô Q trong túi)

Vấn đề quy tắc cụ thể

• Bạn có thể cho rằng tất cả các đầu vào là hợp lệ và sẽ luôn có 7 ô (nghĩa là nó sẽ không có danh sách bảy ô 10 điểm và sẽ không phải là 9 ô)
• Bạn có thể giả sử không có gạch nào được lấy trước đó từ túi (vì vậy phân phối là phân phối chuẩn của gạch tiếng Anh như được xác định ở trên)
• Bạn không phải tạo một từ hợp lệ, chỉ có một chuỗi các chữ cái hợp lệ.
• Thứ tự chuỗi của bạn không liên quan miễn là đối với mỗi ô có một chữ cái tương ứng.
• Điểm được dựa trên các điểm xếp gạch tiếng Anh tiêu chuẩn như được xác định ở trên.
• Bạn có thể xuất ra chữ hoa hoặc chữ thường, đối với ô trống, bạn có thể xuất ký tự khoảng trắng hoặc dấu gạch dưới '_'
• Câu trả lời của bạn có thể xuất ra dưới dạng bất kỳ biểu diễn hợp lý nào của các ô như Danh sách, Chuỗi, Mảng hoặc Chuỗi

  ---

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm

Rõ ràng vì bạn có thể xuất bất kỳ giá trị có thể nào, rất khó để xác định các trường hợp kiểm tra nghiêm ngặt.

Một số trường hợp có giá trị trả về hợp lệ có thể :

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

Một số trường hợp có giá trị trả về không hợp lệ :

[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

Một biến thể ngắn hơn được đề xuất bởi @supercat

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

Hãy thử trực tuyến!

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

Đã lưu 10 byte bằng cách sử dụng phương pháp đi xe đạp của Neil

Trả về một danh sách gạch. Sử dụng _cho gạch trống.

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

Hãy thử trực tuyến!

Làm sao?

Đối với mỗi số điểm, chúng tôi quay vòng qua một nhóm gồm 4 ô chính xác, bắt đầu bằng ô thứ hai của mỗi nhóm (điều này rất quan trọng đối Gvới 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        /

Tất cả các nhóm này được lưu trữ dưới dạng một chuỗi gồm 31 ký tự:

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

NB : Chúng tôi không cần phải lưu trữ các thức "_"trong "_XJ_", vì nó sẽ không bao giờ được truy cập anyway.

Số lượng điểm $n$ được chuyển đổi thành chỉ mục chính xác $i_n$ thành chuỗi này với:

  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$

Than , 33 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

 θ                  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

Thạch ,  31 30 27  26 byte

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

Liên kết đơn được chấp nhận danh sách các số nguyên mang lại danh sách các ký tự.
- một sự nhầm lẫn trước đây của tôi, bên dưới và sự cải thiện của tôi về Nick Kennedy

Hãy thử trực tuyến!

Đầu ra không được đưa ra theo cùng thứ tự với đầu vào (điều này được cho phép).

Việc sử dụng 2 bổ sung của riêng tôi vào ngôn ngữ trong câu trả lời không xảy ra thường xuyên! ( ṃvàɓ ở đây).

Làm sao?

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

trước @ 30

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

Liên kết đơn được chấp nhận danh sách các số nguyên mang lại danh sách các ký tự.

Hãy thử trực tuyến!

Đầu ra này cũng là trường hợp hỗn hợp (điều này được cho phép).

Làm sao?

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

Vòng lặp thông qua đầu vào, bật ra các chữ cái có sẵn. Tôi chỉ có một trong mỗi chữ cái cùng nhau đưa ra 7 cho loại điểm đó. Bây giờ sử dụng mã hóa chuỗi đóng gói.

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, đây là chuỗi ký tự gốc trước khi mã hóa : "_ E DG BCMP FHVW K JX QZ".

Hãy thử trực tuyến .

Perl 5 , 71 byte

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

Hãy thử trực tuyến!

05AB1E , 70 52 39 38 29 26 25 byte

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

-18 byte nhờ @ExpiredData .
-13 byte bằng cách sử dụng cùng mở rộng đến kích thước 7 từ @Maltysen Pyth câu trả lời 's .
-9 byte bằng cách tạo ra một cổng của @JonathanAllan 's câu trả lời Jelly , vì vậy hãy chắc chắn để upvote anh ta!
-3 byte nhờ @Emigna .

Kết quả trong một danh sách các ký tự, và sử dụng chữ cái viết thường và khoảng trắng cho khoảng trắng.

Dùng thử trực tuyến hoặc xác minh thêm một số trường hợp thử nghiệm .

Giải trình:

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

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để chuỗi nén không nằm trong từ điển? ) Để hiểu tại sao .•3Oû}α›ηö‡.ÝŽ{•là "endgmpfykkzzzzjxzzqz ".

Câu trả lời 38 byte trước:

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

Hãy thử trực tuyến hoặc xác minh một số trường hợp thử nghiệm .

Giải trình:

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

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để chuỗi nén không nằm trong từ điển? ) Để hiểu tại sao .•Mñ&Àû«ì{₆v*Å+µ-•là "e dg bcmp fhvw k jx qz".

C (gcc) , 110 byte

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

Hãy thử trực tuyến!

Sử dụng _mảng như một chỉ mục vào chuỗi tĩnh"DDDDGGGBBCCMMPFFHHVVWKJXQZ" cách linh hoạt với các ngoại lệ cho 0 và 1.

Đối số là một -1mảng các điểm số đã bị hủy bỏ được chuyển đổi tại chỗ thành một-1 chuỗi kết thúc.

C # (Trình biên dịch tương tác Visual C #) , 104 90 byte

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

Hãy thử trực tuyến!

Thạch , 34 32 byte

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

Hãy thử trực tuyến!

Tôi đã không thấy có một câu trả lời Jelly ngắn hơn khi tôi viết bài này và nó sử dụng một cách tiếp cận khác vì vậy tôi nghĩ cũng đáng để đăng.

Cảm ơn @JonathanAllan vì đã tiết kiệm 2 byte!

Python 3 , 178 142 135 127 112 117 byte

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

Hãy thử trực tuyến!

-1 byte nhờ cdlane

đúng nhờ vào mathgersan

Python 2 , 102 byte (hoặc có thể 95?)

(Cũng tốt cho 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))

Hãy thử trực tuyến!

Tôi không nghĩ những điều sau đây sẽ được chấp nhận:

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

Phiên bản thứ hai này sẽ cho đầu ra như thế nào ['__', 'JX', 'QZ', 'K']. Vì vậy, các chữ cái sẽ chính xác, nhưng chúng sẽ được thu thập theo giá trị điểm. (Nếu điều này được chấp nhận, nó sẽ tiết kiệm được 7 byte.)

PHP , 101 byte

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

Là một chương trình độc lập, nhập thông qua dòng lệnh:

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

Hãy thử trực tuyến!

Hoặc 112 byte là một hàm

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

Hãy thử trực tuyến!

Đầu ra

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

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

Hãy thử trực tuyến!

Perl 6 , 63 byte

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

Hãy thử trực tuyến!

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

Vì vậy, về cơ bản, nó sẽ tìm kiếm các giá trị bù cho từng giá trị ô và tăng chúng khi cần, sử dụng phần bù để kéo một ký tự từ bộ có sẵn.