Khi còn bé, tôi đã từng chơi bài " đánh gôn " rất nhiều. Thử thách của bạn, nếu bạn chọn chấp nhận nó, là tính điểm của một tay golf. Vì có hơn 9000 biến thể trong trò chơi bài ^{1 này} , chúng tôi sẽ tuân theo các quy tắc tôi nhớ khi chơi.

Quy tắc của trò chơi)

• Bạn kết thúc một vòng với 6 thẻ, và bạn muốn càng ít điểm càng tốt.

• Joker không được sử dụng.

• Aces và 2s có giá trị tương ứng -1 và -2 điểm.

• Jack và Kings đều có giá trị 0 điểm.

• Thẻ từ 3 đến 10 là mệnh giá trị. Tuy nhiên, những thứ này bị hủy khi bạn ghép chúng lại. Ví dụ: 5 có giá trị 5 điểm, nhưng hai 5s có ​​giá trị bằng không. Ba 5s có ​​giá trị 5 điểm, (vì 2 đầu tiên được ghép nối, nhưng thứ 3 thì không.) Và bốn 5s có ​​giá trị 0 (vì nó tạo thành 2 cặp).

• Nữ hoàng có giá trị 15 điểm. Nữ hoàng không thể bị hủy bỏ, ví dụ 2 nữ hoàng trị giá 30 điểm.

Quy tắc (của thử thách)

Đầu vào sẽ là một mảng các số nguyên, hoặc 6 số nguyên riêng lẻ. Bất cứ ai bạn thích. 1 đại diện cho ace, 2-10 đại diện cho 2-10 và Jack, Queen và King đại diện cho 11, 12 và 13. Đầu ra là số điểm của tay theo các quy tắc trên. Bạn có thể giả định một cách an toàn rằng tất cả các đầu vào là hợp lệ, ví dụ: không có số nào xuất hiện quá 4 lần và tất cả các số nằm trong phạm vi [1, 13]. Đầu vào và đầu ra có thể ở bất kỳ định dạng hợp lý.

Kiểm tra IO:

[11, 10, 3, 1, 2, 2]    --> 8
[4, 5, 5, 3, 8, 7]      --> 22
[2, 2, 2, 2, 1, 1]      --> -10 (The lowest score possible)
[12, 12, 12, 12, 10, 9] --> 79 (The highest score possible)
[9, 9, 9, 9, 11, 1]     --> -1
[8, 8, 8, 8, 11, 13]    --> 0
[10, 9, 3, 7, 12, 2]    --> 42
[1, 2, 3, 4, 5, 6]      --> 15
[10, 9, 2, 3, 4, 1]     --> 23
[10, 3, 12, 3, 7, 12]   --> 47

Câu trả lời ngắn nhất trong byte chiến thắng!

¹ không thực sự, nhưng có rất nhiều biến thể.

Bình thường, 28 27 25 byte

s+*L%/Qd2}3Tm?<d3_d*15q12

Hãy thử trực tuyến. Bộ thử nghiệm.

Giải trình

• Đầu tiên, Pyth tự động nối thêm một số biến. Mã bây giờ s+*L%/Qd2}3Tm?<d3_d*15q12dQ.
• }3Ttạo danh sách [3, 4, 5, 6, 7, 8, 9, 10].
• Multiply mỗi số trong danh sách đó ( *L) cho số con số đó trong đầu vào ( /Qd), theo modulo 2 ( %... 2). Kết quả là 0 cho các số được ghép nối và chính số đó cho các số không được ghép nối.
• Bản đồ qua các số đầu vào ( mchụp Q):
  • Nếu số nhỏ hơn 3 ( ?<d3), hãy phủ định nó ( _d).
  • Mặt khác, kiểm tra xem nó có phải là 12 ( q12d) không, và nhân số boolean với 15 ( *15). Kết quả là 15 cho nữ hoàng và 0 cho bất cứ điều gì khác.
• Nối các danh sách ( +). Danh sách kết quả hiện chứa điểm cho các số không ghép đôi (phần đầu tiên) và các thẻ đặc biệt A, 2, Q (phần thứ hai), với một số số 0 bổ sung.
• Cuối cùng, lấy tổng của kết quả ( s).

Giải pháp thay thế 25 byte

-+s*L%/Qd2}3T*15/Q12s<#3Q

Điều này hoạt động tương tự như cái đầu tiên, nhưng đếm riêng biệt các nữ hoàng và phủ nhận các con át chủ bài và twos bằng một bộ lọc.

Python 2, 72 70 byte

f=lambda x,*T:[x*(-1)**T.count(x),~x%2*15,-x][(x-3)/8]+(T>()and f(*T))

Đã có lúc tôi ước Python được điều trị 0**0 == 0một lần để tôi có thể làm được (-condition)**num. Gọi như thế f(11, 10, 3, 1, 2, 2).

Phiên bản 72 byte trước đó:

f=lambda x,*T:[~x%2*15,x*(-1)**(x<3or T.count(x))][x<11]+(T>()and f(*T))

> <> , 63 57 56 + 2 = 65 59 58 byte

Các số đầu vào dự kiến ​​sẽ nằm trên ngăn xếp khi bắt đầu chương trình, vì vậy +2 byte cho -vcờ. Hãy thử trực tuyến!

</!?lp6$+1g6:
3\0
?\::6g2%*{+}1+:b=
;\~16g-26g2*-c6gf*+n

Vì tất cả các giá trị không được sử dụng trong trường mã được khởi tạo 0, nên nó có thể được sử dụng để tìm ra có bao nhiêu giá trị hiện diện trên ngăn xếp bằng cách lấy giá trị tại [value,6], tăng nó và đưa nó trở lại trường mã. Tổng số sau đó được tính như sau:

T = 0 + {for x in 3 to 10, x*([x,6]%2)} - [1,6] - 2*[2,6] + 15*[12,6]

Chỉnh sửa: tắt 6 byte bằng cách cấu trúc lại đầu vào và chuyển các bước tính toán xung quanh. Phiên bản trước:

:6g1+$6pl0=?\
/-*2g62-g610/
c ;n$\
6:b=?/>::6g2%*{+}1+!
\gf*+3/

Chỉnh sửa 2: đã lưu 1 byte, nhờ Sp3000

MATL , 27 26 byte

3:10=s2\7M*G12=15*Gt3<*_vs

Đầu vào là một mảng cột, nghĩa là các giá trị được phân tách bằng dấu chấm phẩy.

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp kiểm tra (điều này thêm một vòng lặp để lấy tất cả các đầu vào và thay thế Gbằng cách 1$0Gđẩy đầu vào mới nhất).

Giải trình

3:10=    % Take input implicitly. Compare with range [3 4 ... 10], with broadcast
s        % Sum of each column: how may threes, fours, ... tens there are
2\       % Modulo 2
7M       % Push [3 4 ... 10] again
*        % Element-wise multiply (the sum of this array is the score of 3...10)
G        % Push input again
12=      % Compare with 12, element-wise
15*      % Multiply by 15 (this is the score of 12)
G        % Push input again
t3<      % Duplicate. True for entries 1 or 2
*_       % Multiply and negate (the sum of this array is the score of 1, 2)
v        % Concatenate all stack concents into a vertical array
s        % Sum of array. Implicitly display

Bình - 37 36 35

Điều này có vẻ quá lớn, nhưng FGITW.

J<#h;K-QS2++*15/K12sm*d%/Jd2{J_s@S2

Phòng thử nghiệm .

JavaScript (ES6), 63 byte

a=>a.map(e=>r+=e<3?-e:e>10?e-12?0:15:(m[e]^=1)?e:-e,r=0,m=[])|r

Hoặc nếu bạn thích,

a=>a.map(e=>r-=e<3?e:e>10?e-12?0:-15:(m[e]^=1)?-e:e,r=0,m=[])|r

Perl 5 , 74 +1 ( -a) = 75 byte

map$s+=/12/?15:$_<3?-$_:$_<11?$k{$_}?-delete$k{$_}:($k{$_}=$_):0,@F;say $s

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

Perl 5.10.0 + -n, 115 64 60 56 byte

$p+=$_-12?$_>2?$_<11?++$l[$_]%2?$_:-$_:0:-$_:15}{say$p

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

Giải trình:

Thêm -nvòng lặp xung quanh nó:

# Used variables:
# $_: input (auto)
# $p: points
# $l[n]: number of occurences of n (for 3-10)
while (<>) { # for every input
    $p += $_ - 12 ? # if the input is not 12 (queen) ...
        $_ > 2 ? # then: if it's > 2 (not ace or 2) ...
            $_ < 11 ? # then: if < 11 (3-10) ...
                ++$l[$_] % 2 ? # then: if it's an odd occurence (1st, 3rd, 5th, ...)
                    $_ # add it
                    : -$_ # else subtract it
            : 0 # no points for other stuff (J, K)
        : -$_ # negative points for ace and 2
    : 15 # 15 points for queen
}
{ # after input:
    say $p # output points
}