Có một minigame trong Super Mario 3D World được gọi là Ngôi nhà may mắn . Nó bao gồm một máy đánh bạc với 4 khối.

Mỗi khối có thể là một trong 5 biểu tượng khác nhau (Hoa, Lá, Chuông, Cherry hoặc Boomerang) và mục tiêu của người chơi là có được càng nhiều biểu tượng giống hệt nhau càng tốt ( xem video ).

Người chơi được thưởng bằng tiền xu, từ đó có thể được chuyển đổi thành cuộc sống thêm. Nhiệm vụ của bạn là tính toán số lượng cuộc sống thêm đã giành được.

Tùy thuộc vào số lượng biểu tượng phù hợp, số lượng tiền thưởng được trao như sau:

• Không có trận đấu - 10 xu
• Một cặp - 100 xu
• Hai cặp - 200 xu
• Ba loại một - 300 xu
• Bốn loại một - 777 xu

Bạn giành được thêm một cuộc sống (1UP) cứ sau 100 xu . Do đó, bạn được đảm bảo giành được chính xác 1UP với một cặp , 2UP với hai cặp và 3UP với 3 loại . Tuy nhiên, số lượng cuộc sống giành được mà không có trận đấu hoặc 4 loại nào phụ thuộc vào cổ phiếu tiền xu ban đầu của bạn.

_{Nguồn: Super Mario Wiki}

Đầu vào

Bạn được cung cấp số tiền xu ban đầu $0 \le c < 100$ và danh sách bốn giá trị $[v_1,v_2,v_3,v_4]$ đại diện cho các biểu tượng cuối cùng trên máy đánh bạc.

Đầu ra

Số lượng cuộc sống thêm đã giành được: $0$ , $1$ , $2$ , $3$ , $7$ hoặc $8$ .

Quy tắc

• Bạn có thể lấy các biểu tượng ở bất kỳ định dạng hợp lý nào: ví dụ như một danh sách, dưới dạng chuỗi hoặc 4 tham số riêng biệt.
• Mỗi biểu tượng có thể được biểu thị bằng một số nguyên một chữ số hoặc một ký tự đơn . Vui lòng chỉ định bộ biểu tượng được sử dụng trong câu trả lời của bạn. (Nhưng bạn không cần phải giải thích cách chúng được ánh xạ tới Hoa, Lá, Chuông, v.v., vì nó hoàn toàn không thành vấn đề.)
• Bạn không được phép ánh xạ lại các giá trị đầu ra.
• Đây là 🎰 mã-golf 🎰.

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

Trong các ví dụ sau, chúng tôi sử dụng danh sách các số nguyên trong $[1..5]$ để thể hiện các biểu tượng.

coins  icons      output   explanation
-------------------------------------------------------------------------
  0    [1,4,2,5]    0      no matches  ->  0 +  10 =  10 coins -> nothing
 95    [3,1,2,4]    1      no matches  -> 95 +  10 = 105 coins -> 1UP
 25    [2,3,4,3]    1      one pair    -> 25 + 100 = 125 coins -> 1UP
 25    [4,5,5,4]    2      two pairs   -> 25 + 200 = 225 coins -> 2UP
  0    [2,5,2,2]    3      3-of-a-kind ->  0 + 300 = 300 coins -> 3UP
 22    [1,1,1,1]    7      4-of-a-kind -> 22 + 777 = 799 coins -> 7UP
 23    [3,3,3,3]    8      4-of-a-kind -> 23 + 777 = 800 coins -> 8UP
 99    [3,3,3,3]    8      4-of-a-kind -> 99 + 777 = 876 coins -> 8UP

hội x86-16, 56 41 39 byte

Nhị phân:

00000000: b103 33ed ac8b fe51 f2ae 7503 45eb f983  ..3....Q..u.E...
00000010: fd03 7504 80c2 4d43 03dd 59e2 e592 7502  ..u...MC..Y...u.
00000020: 040a 3c64 7201 43                        ..<dr.C

Chưa được lắp ráp:

B1 03           MOV  CL, 3              ; set up loop counter for 3 digits
            DIGIT_LOOP: 
33 ED           XOR  BP, BP             ; clear digit matches counter in BP
AC              LODSB                   ; load next digit char into AL
8B FE           MOV  DI, SI             ; start searching at next char
51              PUSH CX                 ; save outer digit loop counter 
            MATCH_LOOP: 
F2/ AE          REPNZ SCASB             ; search until digit in AL is found 
75 03           JNZ  CHECK_FOUR         ; is end of search?
45              INC  BP                 ; if not, a match was found, increment count
EB F9           JMP  MATCH_LOOP         ; continue looping 
            CHECK_FOUR: 
83 FD 03        CMP  BP, 3              ; is four of a kind? 
75 04           JNE  SCORE_DIGIT        ; if not, add number of matches to 1UP's
80 C2 4D        ADD  DL, 77             ; add 77 to coin count 
43              INC  BX                 ; +1 1UP extra for four-of-a-kind
            SCORE_DIGIT:
03 DD           ADD  BX, BP             ; Add number of matches to total, set ZF if 0
59              POP  CX                 ; restore outer digit loop position
E2 E5           LOOP DIGIT_LOOP         ; keep looping
92              XCHG DX, AX             ; coin count to AX for shorter compare
75 02           JNZ  FINAL_SCORE        ; if 1UPs > 0, no consolation prize
04 0A           ADD  AL, 10             ; award 10 coins
            FINAL_SCORE:
3C 64           CMP  AL, 100            ; is coin score over 100?
72 01           JB   DONE               ; if not, no extra 1UP
43              INC  BX                 ; otherwise, increment 1UP
            DONE:

Nhập số xu bắt đầu vào DX, SItrỏ đến bắt đầu các byte "biểu tượng" (có thể là '1'- '5'hoặc bất kỳ giá trị byte nào). Xuất số lượng 1UP trong BX.

Giải trình:

Đầu vào của bốn byte được lặp lại và so sánh với các byte còn lại ở bên phải, đếm số lượng khớp. Điểm cho mỗi loại trận đấu được trao và cộng tổng số. Vì bốn loại cũng là một loại ba và cũng là một cặp, nên giá trị của từng loại điểm có thể được phân tách như sau:

• 3 trận đấu = 4 1UP + 77 xu
• 2 trận đấu = 2 1UP
• 1 trận đấu = 1 1UP

Ví dụ:

[2, 2, 2, 2] (bốn loại) = 7 1UP + 77 xu

2 [2, 2, 2] = 3 matches = 4 1UP's + 77 coins
   2 [2, 2] = 2 matches = 2 1UP's
      2 [2] = 1 match   = 1 1UP

[2, 5, 2, 2] (ba loại một) = 3 1UP

2 [5, 2, 2] = 2 matches = 2 1UP's
   5 [2, 2] = 0 matches
      2 [2] = 1 match   = 1 1UP

[4, 5, 5, 4] (hai cặp) = 2 1UP

4 [5, 5, 4] = 1 match   = 1 1UP
   5 [5, 4] = 1 match   = 1 1UP
      5 [4] = 0 matches

[2, 3, 4, 3] (một cặp) = 1 1UP

2 [3, 4, 3] = 0 matches
   3 [4, 3] = 1 match   = 1 1UP
      4 [3] = 0 matches

Nếu số lượng 1UP kiếm được là 0 ở cuối, thì 10 xu được trao. Nếu tổng số tiền lớn hơn 100, thêm 1UP được trao.

Dưới đây là chương trình thử nghiệm cho PC DOS bao gồm các thường trình bổ sung để xử lý giá trị I / O số nguyên:

Tải xuống và kiểm tra LUCKY.COM cho DOS.

Thạch ,  23 22 20  19 byte

-1 nhờ Erik, Outgolfer (sử dụng ³thay thế ȷ2) cũng được sử dụng trong phiên bản mới hơn hai lần
-1 nhờ Grimy (trừ một trước khi tóm tắt thay vì trừ bốn sau đó)

^{Có thể đánh bại?}

ċⱮ`’SṚḌH׳«777»⁵+:³

Một liên kết dyadic chấp nhận một danh sách và một số nguyên mang lại một số nguyên.

Hãy thử trực tuyến! Hoặc xem một bộ thử nghiệm .

Làm sao?

ċⱮ`’SṚḌH׳«777»⁵+:³ - Link: list a, integer n   e.g. [x,x,x,x], 22
 Ɱ`                 - map across a with:
ċ                   -   count occurrences in a       [4,4,4,4]
   ’                - decrement                      [3,3,3,3]
    S               - sum (call this s)              12
     Ṛ              - reverse (implicit toDigits)    [2,1]
      Ḍ             - un-decimal                     21
       H            - halve                          10.5
         ³          - 100                           100
        ×           - multiply                     1050
           777      - 777                           777
          «         - minimum                       777
               ⁵    - 10                             10
              »     - maximum                       777  (handles 0 -> 10)
                +   - add (n)                       799
                  ³ - 100                           100
                 :  - integer division                7

Cách đánh giá tay hoạt động cho từng loại tay:

           Hand:    no-pair     pair        2-pair      trips       4-of-a-kind
(sorted) counts:    [1,1,1,1]   [1,1,2,2]   [2,2,2,2]   [1,3,3,3]   [4,4,4,4]
      decrement:    [0,0,0,0]   [0,0,1,1]   [1,1,1,1]   [0,2,2,2]   [3,3,3,3]
            sum:    0           2           4           6           12
       reversed:    [0]         [2]         [4]         [6]         [2,1]
     un-decimal:    0           2           4           6           21
         halved:    0           1           2           3           10.5
      times 100:    0           100         200         300         1050
    min(x, 777):    0           100         200         300         777
     max(x, 10):    10          100         200         300         777

Thay thế 20: ĠẈị“¡ıKĖ‘S×4+E{»⁵+:³

Zsh , 117 ... 60 byte

-13 bằng cách sử dụng một tiêu chí khác biệt để phân biệt, -9 bằng cách kết hợp các trường hợp, -28 bằng cách thay đổi casecâu lệnh thành một ternary số học lồng nhau, -4 nhờ @JonathanAllan, -1 bằng cách tối ưu hóa các ternary, -2 vì tôi vô tình sử dụng echokhi thêm Tối ưu hóa của Jonathan.

Lấy đồng xu đếm trên stdin và chặn đầu vào làm đối số. Đối số có thể là số, ký tự hoặc thậm chí là chuỗi:./foo.zsh flower leaf flower boomerang

read c
for i;for j;((a+=i<j))
<<<$[!a?7+(c>22):a-6?6-a:c>89]

Dùng thử trực tuyến: 117 104 95 67 63 62 60

Đây là phép thuật từ câu trả lời 67 byte:

read coins
for block                  # for each element
  (( a+=${#${@:#$block}} ))
#          ${@:#$block}      remove all elements which don't match
#       ${#            }     count the remaining elements
# (( a+=                 ))  add that number to the total
<<<$[a?(a-12?6-a/2:coins>89):7+(coins>22)]
#    a?                     :7+(coins>22)  4*0 (all elements match all elements)
#      (a-12?     :coins>89)               4*3 (all elements match exactly one)
#      (a-12?6-a/2         )               3*1 + 1*3 ->  6, 6 -  6/2 -> 3
#                                          2*2 + 2*2 ->  8, 6 -  8/2 -> 2
#                                          2*3 + 2*2 -> 10, 6 - 10/2 -> 1

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

a=>b=>(a+("Ĭ̉Èd\n"[(b=b.GroupBy(x=>x,(o,p)=>p.Count())).Count()*(b.Max()==3?0:1)]))/100

Một cổng câu trả lời python của tôi, được lấy từ câu trả lời của @ Đạt.

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

Python 2 , 63 byte

lambda x,l:int([3,1,7.77,2,.1][sum(map(l.count,l))%14%5]+x/1e2)

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

Tôi có cùng ý tưởng với GammaFunction để sử dụng sum(map(l.count,l))làm "dấu vân tay". Nhưng, thay vì sử dụng công thức số học trên kết quả, tôi sử dụng bảng tra cứu, trước tiên, squishing giá trị từ 0 đến 4 bằng chuỗi mod %14%5. Chia tất cả các giá trị điểm cho 100 đã lưu một vài byte.

Python 3 , 68 byte

def f(c,a):x=sum(map(a.count,a))//2;return[c//90,x-2,7+(c>22)][x//3]

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

Một cổng Python của cổng C của tôi trên cổng Bash của câu trả lời Zsh của tôi, được chơi lại với sự trợ giúp từ trang "Mẹo chơi gôn trong Python". Cổng cuối cùng, tôi thề ... Tôi đang hết ngôn ngữ Tôi cảm thấy thoải mái khi chơi golf. Tôi tò mò không biết chiến lược này so với các câu trả lời khác của Python. Một lần nữa, có lẽ có một số cách để đánh bại điều này.

Điều này hóa ra tốt đáng ngạc nhiên, vì vậy tôi đã thêm một bảng dưới đây tóm tắt những gì đang xảy ra để những người khác có thể chuyển hoặc cải thiện điều này.

Type          Example  map(a.count,a)  sum(__)   x=__//2  x//3   array lookup
----------------------------------------------------------------------------
none         [1,2,3,4]    [1,1,1,1]        4       2       0      c//90
pair         [1,1,2,3]    [2,2,1,1]        6       3       1      x-2 -> 1
two pair     [1,3,1,3]    [2,2,2,2]        8       4       1      x-2 -> 2
3-of-a-kind  [1,3,1,1]    [3,1,3,3]       10       5       1      x-2 -> 3
4-of-a-kind  [3,3,3,3]    [4,4,4,4]       16       8       2      7+(c>22)

Python 3.8 (tiền phát hành) , 63 byte

Ca ngợi :=con hải mã!

lambda c,a:[2+c//90,x:=sum(map(a.count,a))//2,9+(c>22)][x//3]-2

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

Perl 6 , 48 44 byte

{*/100+((0,0,1,3,7.77)[.Bag{*}].sum||.1)+|0}

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

Chức năng cuộn tròn f(icons)(coins).

Python 2 , 96 91 89 byte

-2 byte nhờ @Kevin Cruijssen

lambda x,a,b,c,d:(x+(100*sum((a==b,a==c,a==d,b==c,b==d,c==d))or 10)+177*(a==b==c==d))/100

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

PHP, 153 127 byte

@ 640KB đã thực hiện một số thay đổi thực sự thông minh để rút ngắn hơn nữa:

function($c,$s){for(;++$x<6;$n+=$m>3?777:($m>2?300:($m>1)*100))for($m=!$y=-1;++$y<5;$m+=$s[$y]==$x);return($c+($n?:10))/100|0;}

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

Python 3 , 126 111 108 103 byte

def f(c,a):x=sorted([a.count(i)for i in set(a)]);return([300,777,200,100,10][len(x)*(x[-1]!=3)]+c)//100

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

Python 3.8 (tiền phát hành) , 78 byte

lambda c,a:(ord("Ĭ̉Èd\n"[len(x:=[*map(a.count,{*a})])*(max(x)!=3)])+c)//100

Câu trả lời của Đạt, nhưng đánh gôn nhiều hơn.

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

Perl 5 -pF , 46 byte

map$q+=$$_++,@F;$_=0|<>/100+($q>5?7.77:$q||.1)

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

Đầu tiên của đầu vào là kết quả quay, sử dụng bất kỳ 5 chữ cái ASCII duy nhất, ngoại trừ q(tôi đề nghịabcde ). Dòng đầu vào thứ hai là số xu hiện tại.

Làm sao?

-F     # CLI option splits the input into individual characters in @F
map
   $q+=   # $q holds the result of the calculation here
          # possible values are 0,1,2,3,6
   $$_    # This interprets $_ as a variable reference, thus if $_ is 'a', this variable is $a
   ++     # increment after adding it to $q
,@F;      # iterate over the elements of @F
$_=0|     # force the result to be an integer
   <>/100 # divide the current coin count by 100
   +($q>5?7.77  # if $q is over 5, then there must have been 4 of a kind
   :$q||.1)     # otherwise, use $q, unless it is 0, then use .1
-p        # CLI option implicitly outputs $_

Tất cả các con số liên quan được chia cho 100, vì vậy chương trình đang đếm số lượng cuộc sống (bao gồm cả một phần) hiện đang kiếm được. Bí quyết cho giải pháp này là trong map. Nếu các mục có thể là abcde, sau đó mỗi người $a, $b, $c, $d, và $egiữ đếm số lần nhân vật này trước đây đã được nhìn thấy. Điều đó được thêm vào tổng số ( $q) mỗi lần nhìn thấy một ký tự. Tổng số hoạt động được tăng lên nếu có bốn loại (có hiệu quả là tiền thưởng 177 xu).

JavaScript (Node.js) , 64 byte

c=>a=>[,7.77,a.sort()[1]-a[2]?2:3,1,.1][new Set(a).size]+c*.01|0

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

Tôi đoán rằng phải có ít nhất một câu trả lời JavaScript cho một thử thách Arnauld!

Khái niệm ở đây chủ yếu là sử dụng số lượng các yếu tố riêng biệt làm khóa tra cứu.

• 1 duy nhất => 4 loại
• 2 duy nhất => 2 cặp hoặc 3 loại
• 3 duy nhất => 1 cặp
• 4 duy nhất => không khớp

Để phân biệt giữa 2 cặp và 3 loại, mảng đầu vào được sắp xếp và 2 yếu tố ở giữa được so sánh.

PHP ,89 84 byte

foreach(count_chars($argv[2])as$a)$b+=[2=>1,3,7.77][$a];echo$argv[1]/100+($b?:.1)|0;

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

Đầu vào từ dòng lệnh, đầu ra đến STDOUT:

$ php lucky.php 99 3333
8

$ php lucky.php 0 2522
3

$ php lucky.php 0 abaa
3

Stax , 23 byte

¿^∩û:¶á☺ⁿ£z⌐└≤♂EM¥t(,5╓

Chạy và gỡ lỗi nó

Chương trình này sử dụng bất kỳ bộ 5 số nguyên tùy ý cho các biểu tượng.

Thủ tục:

1. Cộng số lần xuất hiện của từng yếu tố.
2. Chia cho 2 rồi mod 7.
3. Kết quả là một số từ 1..5. Sử dụng điều này để tra cứu giải thưởng tiền xu trong một mảng cố định.
4. Thêm vào số lượng xu ban đầu.
5. Chia cho 100.

Đây là đầu ra từ một trình hiển thị trạng thái ngăn xếp thử nghiệm mà tôi đã làm việc cho phiên bản tiếp theo của stax. Đây là một phiên bản giải nén của cùng một mã với trạng thái ngăn xếp được thêm vào bình luận.

c               input:[2, 3, 4, 3] 25 main:[2, 3, 4, 3] 
{[#m            input:[2, 3, 4, 3] 25 main:[1, 2, 1, 2] 
|+              input:[2, 3, 4, 3] 25 main:6 
h7%             input:[2, 3, 4, 3] 25 main:3 
":QctI*12A"!    input:[2, 3, 4, 3] 25 main:[300, 777, 10, 100, 200] 3 
@               input:[2, 3, 4, 3] 25 main:100 
a+              main:125 [2, 3, 4, 3] 
AJ/             main:1 [2, 3, 4, 3] 

Chạy cái này

Võng mạc 0.8.2 , 72 byte

O`\D
(\D)\1{3}
777¶
(\D)\1\1
300¶
(\D)\1
100¶
\D{4}
10¶
\d+\D*
$*
1{100}

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Có đầu vào là 4 chữ số ASCII có thể in được, theo sau là số xu ban đầu bằng chữ số. Giải trình:

O`\D

Sắp xếp các chữ số không sao cho các ký hiệu giống hệt nhau được nhóm lại với nhau.

(\D)\1{3}
777¶

Bốn điểm số 777.

(\D)\1\1
300¶

Điểm ba trong số 300 điểm.

(\D)\1
100¶

Mỗi cặp đạt 100 điểm, vì vậy hai cặp sẽ đạt 200 điểm.

\D{4}
10¶

Nếu không có trận đấu thì bạn vẫn thắng!

\d+\D*
$*

Chuyển đổi các giá trị thành unary và lấy tổng.

1{100}

Số nguyên chia tổng cho 100 và chuyển đổi thành số thập phân.

Võng mạc , 56 byte

(\D)\1{3}
777¶
w`(\D).*\1
100¶
\D{4}
10¶
\d+\D*
*
_{100}

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Có đầu vào là 4 chữ số ASCII có thể in được, theo sau là số xu ban đầu bằng chữ số. Giải trình:

(\D)\1{3}
777¶

Bốn điểm số 777.

w`(\D).*\1
100¶

Mỗi cặp có 100 điểm. Tất wcả các cặp đều được xem xét, sao cho chúng có thể được xen kẽ, cộng với ba loại có thể được phân tách thành ba cặp, do đó tự động đạt 300 điểm.

\D{4}
10¶

Nếu không có trận đấu thì bạn vẫn thắng!

\d+\D*
*

Chuyển đổi các giá trị thành unary và lấy tổng.

_{100}

Số nguyên chia tổng cho 100 và chuyển đổi thành số thập phân.

APL + THẮNG, 42 byte

Nhắc nhở cho các biểu tượng theo sau bởi cổ phiếu coin.

  ⌊(.01×⎕)+.1⌈+/1 3 7.77×+⌿(+⌿⎕∘.=⍳5)∘.=1↓⍳4

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

Bash , 76 75 71 70 byte

-4 cảm ơn @Jonathan ALLan, -1 bằng cách sắp xếp lại chim nhạn.

read c
for i;{ for j;{ ((a+=i<j));};}
echo $[!a?7+(c>22):a-6?6-a:c>89]

Cổng Bash của câu trả lời Zsh của tôi. Hãy thử trực tuyến! Hãy thử trực tuyến! Hãy thử trực tuyến! Hãy thử trực tuyến!

C (gcc) , 92 84 82 81 79 78 byte

-1 bằng x+=(..!=..) -5 bằng cách quay lại qua bài tập , -4 nhờ Jonathan Allan bằng cách thay thế !=bằng <, giúp tiết kiệm byte ở nơi khác, -1 bằng cách sắp xếp lại bộ ba.

Từ @ceilingcat: -2 bằng cách khai báo ivà xbên ngoài hàm, -1 bằng cách đặt x=ivà giảm dần xthay thế.

i,x;f(c,a)int*a;{for(i=x=16;i--;)x-=a[i/4]>=a[i%4];c=x?x-6?6-x:c>89:7+(c>22);}

Một cổng khác của câu trả lời Zsh của tôi. Tôi không quen với việc chơi gôn C, có lẽ có một mẹo khác ở đây để giảm bớt nó. 92 84 82 81 79 Hãy thử trực tuyến!

05AB1E , 20 19 18 byte

D¢<OR;т*777T)Åm+т÷

Cảng @Jonathan ALLan 's Jelly câu trả lời , vì vậy hãy chắc chắn để upvote ông !!
-2 byte nhờ @Grimy .

Lấy danh sách các biểu tượng làm đầu vào đầu tiên (hiện hữu [1,2,3,4,5]) và số lượng xu làm đầu vào thứ hai.

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm . (Bộ kiểm tra sử dụng T‚à+thay vì TMI+, là một thay thế byte bằng nhau.)

Giải trình:

D                   # Duplicate the first (implicit) input-list
 ¢                  # Count the amount of occurrences in itself
  <                 # Decrease each count by 1
   O                # Sum these
    R               # Reverse it
     ;              # Halve it
      т*            # Multiply by 100
        777         # Push 777
           T        # Push 10
            )       # Wrap all three values into a list
             Åm     # Get the median of these three values
               +    # Add the second (implicit) input to it
                т÷  # And integer-divide it by 100
                    # (after which the result is output implicitly)

Scala , 88 byte

(c,v)=>(Seq(777,300,200,100,0,10)((v.groupBy(x=>x).map(_._2.size+1).product-5)/2)+c)/100

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

Than , 30 byte

≔⊘ΣＥη№ηιηＩ⌊⁺∕θ¹⁰⁰∨⁻η∕²∨›⁸η⁹∕¹χ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lấy đầu vào là số lượng xu và một mảng của bất kỳ giá trị so sánh Python nào làm biểu tượng. Giải trình:

≔⊘ΣＥη№ηιη

Ăn cắp một cách đáng xấu hổ @ GammaFactor thủ thuật tính toán bằng một nửa tổng số đếm.

⁻η∕²∨›⁸η⁹

Trừ 2từ Tóm lại, do đó dẫn đến các giá trị 0, 1, 2, 3một cách thích hợp, nhưng đối với 4-of-a-loại, phân chia 2bằng cách 9đầu tiên, kết quả 7.777....

∨...∕¹χ

Nhưng nếu kết quả là 0, thì không có kết quả khớp nào, vì vậy hãy thay thế bằng 0.1thay thế. (Sử dụng nghĩa đen không giúp tôi ở đây vì tôi sẽ cần một dấu phân cách.)

Ｉ⌊⁺∕θ¹⁰⁰...

Chia số tiền ban đầu cho 100 và thêm vào số tiền thắng, sau đó xếp kết quả và chuyển thành chuỗi cho đầu ra ngầm.

Bình thường , 32 byte

AQ-@[+K2/G90J/sm/HdH2+9>G22)/J3K

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

Lấy cảm hứng từ giải pháp của GammaFactor. Đưa đầu vào là [coins, [icons]].

AQ                               # Q is the input. Set G := Q[0], H := Q[1]
    [                      )     # Construct a list from the following entries:
     +K2/G90                     # [0] (K:=2) + G/90 (/ is integer division)
            J                    # [1] J:=
              s                  #        reduce on + (
               m   H             #          map entries of H as d on (
                /Hd              #            number of occurences of d in H ) )
             /      2            #                                               / 2
                     +9>G22      # [2] 9 + (G > 22)
   @                        /J3  # Take element at position J/3
  -                            K # Subtract K (=2)

PowerShell , 94 byte

param($n,$l)$r=@{2=100;3=300;4=777}[($l|group|% c*t)]|?{$_;$n+=$_}
+(($n+10*!$r)-replace'..$')

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

Chưa được kiểm soát:

param($nowCoins,$values)
$groupCounts=$values|group|% count
$rewardedCoins=@{2=100;3=300;4=777}[$groupCounts]|?{
    $_                          # output matched only
    $nowCoins+=$_               # and accumulate
}
$nowCoins+=10*!$rewardedCoins   # add 10 coins if no rewarded conis
+($nowCoins-replace'..$')       # truncate last two digits

PowerShell , 114 107 byte

^{-7 byte nhờ mazzy}

param($n,$l)((((0,.1,1)[+($x=($l|group|% c*t|sort))[2]],2,3)[$x[1]-1],7.77)[$x[0]-eq4]+".$n")-replace'\..*'

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

Một hoạt động ternary có hương vị PowerShell lớn ol được xây dựng khi nhóm và sắp xếp số lượng của danh sách đầu vào. Việc sắp xếp là cần thiết bởi vì chúng tôi tận dụng thực tế là danh sách được nhóm càng ngắn thì càng có nhiều sự lặp lại. Trong thực tế, đây là tất cả các giá trị có thể:

(1,1,1,1)
(1,1,2)
(2,2)
(1,3)
(4)

Cắt ngắn đến một int vẫn còn đắt tiền.

Chưa được kiểm soát:

param($n,$l)
$x=$l|group|% c*t|sort
(((                      #Start building a list...
   (0,.1,1)[+$x[2]],     #where spot 0 holds dummy data or handles no match and 1 pair
    2,3)[$x[1]-1],       #Overwrite the dummy data with 2-pair or 3-o-k
   7.77)[$x[0]-eq4]      #OR ignore all that and use spot 1 because it's a 4-o-k
   +".$n"                #Use that value and add CoinCnt via int-to-string-to-decimal
)-replace'\..*'          #Snip off the decimal part

Ngôn ngữ Wolfram (Mathicala) , 54 byte

⌊{,.1,1,2,3,,,7.77}[[Total[Counts@#2^2]/2]]+.01#⌋&

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

R, 102 , 91 , 81 byte

f=function(b,v,s=table(v))(477*any(s>3)+b+10*all(s<2))%/%100+sum(s==2)+3*any(s>2)

Được quản lý để giảm 11 byte (và sửa lỗi) nhờ @Giuseppe. Quản lý thêm 10 cảm hứng từ ý tưởng / 10 của @ Giuseppe.

Ung dung

f=function(b,v){
  s = table(v)          #included in fn inputs
  a = b+10*all(s<2)     #covers all different case
  a = a+477*any(s>3)    #Covers 4 of a kind
  d = sum(s==2)+3*any(s>2) #covers 1 and 2 pair, 3 of a kind.
  a%/%100+d         #sum appropriate values
}

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

8051 hội (biên dịch thành 158 byte)

Đây là một sự chấp thuận ngây thơ của VEEEEEEEEEERRY, điều này chưa được kiểm chứng và không có căn cứ nhưng tôi khá tự tin rằng nó hoạt động. Những điều cần xem xét là:

1) 8051 là một máy tích lũy tức là. nó cần hướng dẫn Mov mà các kiến ​​trúc khác có thể không cần.

2) 8051 là một máy 8 bit, do đó phải thực hiện một số mánh khóe cho các số> 255 tạo ra nhiều mã hơn và có nhược điểm của nền tảng so với các nền tảng khác.

CSEG AT 0000H

coinStackOnes equ 0xf3
coinStackTens equ 0xf4
coinStackHundreds equ 0xf5 ; leave one byte as guard so that if that gets corrupted it doesnt really matter

values1 equ 0xf7
values2 equ 0xf8
values3 equ 0xf9
values4 equ 0xfa

numOfFlowers equ 0xfb
numOfLeaf equ 0xfc
numOfBell equ 0xfd
numOfCherry equ 0xfe
numOfBoomerang equ 0xff

flower equ 1
leaf equ 2 
bell equ 3
cherry equ 4
boomerang equ 5

numOfHeartsReceived equ 0xf1

mov r1, #4
mov r0, numOfFlowers
clearNumOfRegs: mov @r0, #0d
        inc r0
        djnz r1, clearNumOfRegs
;if you reach this all numOfXXXX registers are zeroed

mov r0, #values1 
mov r1, #flower

mov a, #6 ; innercounter
mov b, #5 ; outercounter
checkfornextpossibleitem:   mov r2, a; backup countervar
                mov a, @r0 ; store given value in a
                xrl a, @r1 ; xor a with item
                jnz nextItem ; if value!=item -> nextitem
                mov a, #numOfFlowers ;if you end up here a=0 (ie value == item) --> generate addr for numOfReg <-- load a with addr for numOfFlowers
                add a, r1 ; since items are only numbers you can add the item to get the addr for numOfReg a=addr(numOfReg)
                xch a, r1 ; change the item with the addr as r1 is indirect register
                inc @r1 ; increment numOfRegister
                xch a, r1; r1 = item
                ;next item              
                nextItem:   inc r1 ; increment item
                        mov a, r2 ; restore counter
                        dec a; decrement counter
                        cjne a, #0, checkfornextpossibleitem 
                        ;if you reach this you have successfully tested one value against all items and therefor the next value must be tested
                        mov a, #6; reset the innercounter
                        dec b; decrement the outercounter
                        inc r0; increment the register that points to the value-under-test
                        xch a,b; cjne works with a but not with b therefor exchange them
                        cjne a, #0, here ; do the comparison; if you dont jump here you have tested all values 
                        jmp howManyPairsDoIHave; if you didnt jump above you have the now the number of flowers and so on
                        here:   xch a,b ; and change back
                            jmp checkfornextpossibleitem ; check the next value
howManyPairsDoIHave:    mov r0,#0; store numOfPairsHere initialize with zeros
            mov r1, numOfFlowers; 
            mov b, #6; use as counter to know when you went through all numOfRegisters
analyseNumOfRegister:   mov a, @r1 ; load the numOfregister for some math
            xrl a, #2; a will contain zero if numOfXXX = 2
            jnz numOfXXXWasNot2; if you do not jump here you have 2 XXX therefor 
            inc r0; increment the number of pairs
            jmp nextNumOfRegister; continiue with the next one
            numOfXXXWasNot2:    mov a, @r1; restore the number of XXX and try the next magic value
                        xrl a, #3; will contain zero if you have a three of a kind                      
                        jnz no3XXX; if you dont jump here however you have a three of a kind
                        jz add300Coins
                        no3XXX:     mov a, @r1; restore number of XXX
                                xrl a, #4; a will contain zero if 4 of a kind
                                jnz nextNumOfRegister; if you numOfXXX!=4 you can only continiue trying to find something in the next numof register
                                jz add777Coins; if you didnt jump above how ever you will have to add the 777 coins as you detected a 4 of a kind
nextNumOfRegister:  inc r0; move pointer to the next numofregister
            djnz b, analyseNumOfRegister; if you havent already analysed all numofregisters then continue
            ; if you have however you end up here so you will have to take a look at the numOfPairs
            cjne r0, #1, tryIf2Pairs; test if you have 1 pair if not try if you have 2
            jmp add100Coins; if you have 1 pair however add the 100 coins
            tryIf2Pairs:    cjne r0, #2, youMustHave0Pairs; test if you have 2 pairs if not you can be sure to have 0 of them
                    jmp add200Coins; if you have 2 pairs however add them
youMustHave0Pairs:  ; add 10 coins
            inc coinStackTens
            mov a, coinStackTens
            cjne a, #10d, howManyHearts ; if your tens digit isnt outta range continue with the calculation of the number of hearts
            inc coinStackHundreds; if it is outta range do correct that
            mov coinStackTens, #0
            jmp howManyHearts;
add100Coins:    inc coinStackHundreds; here the digit can not possibly have an invalid value...
        jmp howManyHearts
add200Coins:    mov a, coinStackHundreds
        add a, #2
        mov coinStackHundreds, a
        jmp howManyHearts ; also here no invalid values possible
add300Coins:    mov a, coinStackHundreds
        add a, #3
        mov coinStackHundreds, a
        jmp howManyHearts ; same again
add777Coins:    mov r0, #coinStackOnes
        mov r2, #3
add7:       mov a, r0
        mov r1, a
        mov a, @r0
        add a, #7
        mov b, a; b contains the possibly invalid version of the ones digit     
        da a; if you have an invalid value its lower nibble gets corrected this way
        anl a, 0x0f; and the higher one gets corrected this way
        xch a,b; a and b must be swapped in order to make subb work ie b contains now the corrected value and a has the maybe faulty value
        subb a,b; returns zero if all the corrections had no effect therefor the next digit can be increased by 7
        jz nextDigit
        inc r1
        inc @r1
        nextDigit:  inc r0
                djnz r2, add7;

howManyHearts:  mov numOfHeartsReceived, coinStackHundreds
loop_forever:   sjmp loop_forever
        END