Ada mini game di Super Mario 3D World yang dikenal sebagai Lucky House . Ini terdiri dari mesin slot dengan 4 blok.

Setiap blok mungkin salah satu dari 5 ikon berbeda (Bunga, Daun, Bel, Cherry atau Boomerang) dan tujuan pemain adalah untuk mendapatkan ikon identik sebanyak mungkin ( lihat video ).

Pemain diberi koin, yang pada gilirannya dapat dikonversi menjadi kehidupan ekstra. Tugas Anda adalah menghitung jumlah nyawa ekstra yang dimenangkan.

Bergantung pada jumlah ikon yang cocok, jumlah koin yang dihadiahi adalah sebagai berikut:

• Tidak ada yang cocok - 10 koin
• Satu pasang - 100 koin
• Dua pasang - 200 koin
• Tiga jenis - 300 koin
• Empat jenis: 777 koin

Anda memenangkan satu kehidupan ekstra (1UP) setiap 100 koin . Karenanya, Anda dijamin akan menang tepat 1UP dengan satu pasangan , 2UP dengan dua pasangan dan 3UP dengan 3-of-a-kind . Namun, jumlah nyawa dimenangkan tanpa pertandingan atau 4-of-a-kind tergantung pada stok koin awal Anda.

_{Sumber: Super Mario Wiki}

Memasukkan

Anda diberi stok koin awal $0 \le c < 100$ dan daftar empat nilai $[v_1,v_2,v_3,v_4]$ mewakili ikon terakhir pada mesin slot.

Keluaran

Jumlah nyawa ekstra yang dimenangkan: $0$ , , , , atau .$1$$2$$3$$7$$8$

Aturan

• Anda dapat mengambil ikon dalam format apa pun yang masuk akal: misalnya sebagai daftar, sebagai string, atau sebagai 4 parameter berbeda.
• Setiap ikon dapat diwakili oleh integer satu digit atau karakter tunggal . Silakan tentukan set ikon yang digunakan dalam jawaban Anda. (Tapi kamu tidak harus menjelaskan bagaimana mereka dipetakan ke Flower, Leaf, Bell, dll., Karena itu tidak masalah sama sekali.)
• Anda tidak diizinkan untuk memetakan ulang nilai output.
• Ini adalah 🎰 kode-golf 🎰.

Uji kasus

Dalam contoh berikut, kami menggunakan daftar bilangan bulat di untuk mewakili ikon.$[1..5]$

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

x86-16 Majelis, 56 41 39 byte

Biner:

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

Belum dirakit:

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:

Masukkan jumlah koin awal DX, SIarahkan ke mulai dari "ikon" byte (yang bisa '1'- '5', atau nilai byte apa pun). Keluarkan jumlah 1UP di BX.

Penjelasan:

Input empat byte diulang dan dibandingkan dengan byte yang tersisa di sebelah kanan, dengan menghitung jumlah kecocokan. Skor untuk setiap jenis pertandingan diberikan dan ditambahkan hingga total. Karena four-of-a-kind juga tiga-of-a-kind dan juga satu-pasangan, nilai dari masing-masing jenis skor dapat diuraikan sebagai berikut:

• 3 pertandingan = 4 1UP + 77 koin
• 2 pertandingan = 2 1UP
• 1 pertandingan = 1 1UP

Contoh:

[2, 2, 2, 2] (four-of-a-kind) = 7 1UP + 77 koin

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] (three-of-a-kind) = 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] (dua pasangan) = 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] (satu pasang) = 1 1UP

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

Jika jumlah 1UP yang diperoleh adalah 0 di akhir, 10 koin diberikan. Jika total koin lebih besar dari 100, 1UP tambahan diberikan.

Berikut ini adalah program uji untuk PC DOS yang mencakup rutinitas ekstra untuk menangani nilai integer I / O:

Unduh dan uji LUCKY.COM untuk DOS.

Jelly ,  23 22 20  19 byte

-1 berkat Erik the Outgolfer (digunakan ³sebagai pengganti ȷ2) juga digunakan dalam versi yang lebih baru dua kali
-1 berkat Grimy (kurangi satu sebelum menjumlahkan alih-alih mengurangi empat sesudahnya)

^{Mungkin bisa dikalahkan?}

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

Tautan diad menerima daftar dan bilangan bulat yang menghasilkan bilangan bulat.

Cobalah online! Atau lihat test-suite .

Bagaimana?

ċⱮ`’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

Cara evaluasi tangan bekerja untuk setiap jenis tangan:

           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

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

Zsh , 117 ... 60 byte

-13 dengan menggunakan kriteria berbeda untuk diferensiasi, -9 dengan menggabungkan kasus, -28 dengan mengubah casepernyataan ke ternary aritmatika bersarang, -4 terima kasih kepada @JonathanAllan, -1 dengan mengoptimalkan terner, -2 karena saya secara tidak sengaja digunakan echoketika menambahkan Optimasi Jonathan.

Mengambil hitungan koin pada stdin, dan memblokir input sebagai argumen. Argumen dapat berupa angka, karakter, atau bahkan string:./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]

Cobalah online: 117 104 95 67 63 62 60

Inilah keajaiban dari jawaban 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 # (Visual C # Interactive Compiler) , 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

Port jawaban python saya, yang berasal dari jawaban @ Dat.

Cobalah online!

Python 2 , 63 byte

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

Cobalah online!

Saya memiliki ide yang sama dengan Fungsi Gamma untuk digunakan sum(map(l.count,l))sebagai "sidik jari". Tapi, alih-alih menggunakan rumus aritmatika pada hasilnya, saya menggunakan tabel pencarian, pertama-tama menekan nilai menjadi 0 hingga 4 menggunakan rantai mod %14%5. Membagi semua nilai poin dengan 100 menghemat beberapa 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]

Cobalah online!

Port Python pada port C saya pada port Bash pada jawaban Zsh saya, golf ulang dengan bantuan dari halaman "Tips untuk bermain golf di Python". Port terakhir, saya bersumpah ... Saya kehabisan bahasa. Saya nyaman bermain golf. Saya ingin tahu bagaimana strategi ini dibandingkan dengan jawaban Python lainnya. Sekali lagi, mungkin ada beberapa cara untuk mengalahkan ini.

Yang ini ternyata sangat bagus, jadi saya menambahkan tabel di bawah ini yang meringkas apa yang terjadi sehingga orang lain dapat port atau meningkatkan ini.

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 (pra-rilis) , 63 byte

Puji :=walrus!

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

Cobalah online!

Perl 6 , 48 44 byte

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

Cobalah online!

Fungsi kari f(icons)(coins).

Python 2 , 96 91 89 byte

-2 byte terima kasih kepada @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

Cobalah online!

PHP, 153 127 byte

@ 640KB membuat beberapa perubahan yang sangat pintar untuk mempersingkat lebih lanjut:

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

Cobalah online!

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

Cobalah online!

Python 3.8 (pra-rilis) , 78 byte

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

Dat menjawab, tetapi lebih banyak bermain golf.

Cobalah online!

Perl 5 -pF , 46 byte

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

Cobalah online!

Input pertama adalah hasil putaran, menggunakan 5 huruf ASCII unik, kecuali q(saya sarankan abcde). Input baris kedua adalah jumlah koin saat ini.

Bagaimana?

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

Semua jumlah yang terlibat dibagi dengan 100, sehingga program ini menghitung jumlah nyawa (termasuk yang sebagian) saat ini diperoleh. Trik untuk solusi ini ada dimap . Jika memungkinkan entri abcde, kemudian masing-masing $a, $b, $c, $d, dan $ememegang hitungan berapa kali karakter ini sebelumnya pernah terlihat. Itu akan ditambahkan ke total berjalan ( $q) setiap kali karakter terlihat. Total berjalan dinaikkan jika ada empat jenis (efektif bonus 177 koin).

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

Cobalah online!

Saya pikir harus ada setidaknya satu jawaban JavaScript untuk tantangan Arnauld!

Konsep di sini terutama untuk menggunakan jumlah elemen berbeda sebagai kunci pencarian.

• 1 unik => 4 sejenis
• 2 unik => 2 pasang atau 3 sejenis
• 3 unik => 1 pasangan
• 4 unik => tidak ada yang cocok

Untuk membedakan antara 2 pasangan dan 3 jenis, array input diurutkan dan elemen 2 tengah dibandingkan.

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;

Cobalah online!

Input dari baris perintah, output ke 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╓

Jalankan dan debug itu

Program ini menggunakan set sembarang 5 bilangan bulat untuk ikon.

Prosedur:

1. Jumlahkan jumlah kemunculan setiap elemen.
2. Bagi dengan 2 dan kemudian mod 7.
3. Hasilnya adalah angka dari 1..5. Gunakan ini untuk mencari hadiah koin dalam array yang tetap.
4. Tambahkan ke jumlah koin awal.
5. Bagi dengan 100.

Inilah output dari visualizer state stack eksperimental yang telah saya kerjakan untuk rilis stax berikutnya. Ini adalah versi tanpa kode yang sama dengan status stack yang ditambahkan ke komentar.

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] 

Jalankan yang ini

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

Cobalah online! Tautan termasuk kasus uji. Mengambil input sebagai 4 digit ASCII yang dapat dicetak diikuti oleh jumlah koin awal dalam digit. Penjelasan:

O`\D

Urutkan non-digit sehingga simbol identik dikelompokkan bersama.

(\D)\1{3}
777¶

Skor empat-of-a-kind 777.

(\D)\1\1
300¶

Three-of-a-kind skor 300.

(\D)\1
100¶

Setiap pasangan mendapat skor 100, jadi dua pasangan akan mendapat skor 200.

\D{4}
10¶

Jika tidak ada pertandingan maka Anda masih menang!

\d+\D*
$*

Konversikan nilai menjadi unary dan ambil jumlahnya.

1{100}

Integer membagi jumlah dengan 100 dan mengkonversi kembali ke desimal.

Retina , 56 byte

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

Cobalah online! Tautan termasuk kasus uji. Mengambil input sebagai 4 digit ASCII yang dapat dicetak diikuti oleh jumlah koin awal dalam digit. Penjelasan:

(\D)\1{3}
777¶

Skor empat-of-a-kind 777.

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

Masing-masing pasangan mendapat nilai 100. wMempertimbangkan semua pasangan, sehingga mereka dapat disisipkan, ditambah tiga jenis dapat diuraikan menjadi tiga pasangan, sehingga secara otomatis mencetak 300.

\D{4}
10¶

Jika tidak ada pertandingan maka Anda masih menang!

\d+\D*
*

Konversikan nilai menjadi unary dan ambil jumlahnya.

_{100}

Integer membagi jumlah dengan 100 dan mengkonversi kembali ke desimal.

APL + WIN, 42 byte

Anjuran untuk ikon diikuti oleh stok koin.

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

Cobalah online! Atas perkenan Dyalog Classic

Bash , 76 75 71 70 byte

-4 Terima kasih kepada @JonathanAllan, -1 dengan mengatur ulang terner.

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

Bash port jawaban Zsh saya. Cobalah online! Cobalah online! Cobalah online! Cobalah online!

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

-1 oleh x+=(..!=..) -5 dengan kembali melalui tugas , -4 berkat Jonathan Allan dengan mengganti !=dengan <, yang menyimpan byte tempat lain, -1 dengan menata ulang terner tersebut.

Dari @ceilingcat: -2 dengan mendeklarasikan idan di xluar fungsi, -1 dengan mengatur x=idan mengurangi x.

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

Port lain dari jawaban Zsh saya. Saya tidak terbiasa dengan golf C, mungkin ada trik lain di sini untuk menguranginya lebih lanjut. 92 84 82 81 79 Cobalah secara online!

05AB1E , 20 19 18 byte

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

Port of @JonathanAllan jawaban Jelly , jadi pastikan untuk membatalkannya !!
-2 byte terima kasih kepada @Grimy .

Mengambil daftar ikon sebagai input pertama (sedang [1,2,3,4,5] ), dan jumlah koin sebagai input kedua.

Cobalah secara online atau verifikasi semua kasus uji . (Test suite digunakanT‚à+ alih-alih TMI+, yang merupakan alternatif byte yang sama.)

Penjelasan:

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

Cobalah online!

Arang , 30 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Mengambil input sebagai jumlah koin dan array nilai sebanding Python sebagai ikon. Penjelasan:

≔⊘ΣＥη№ηιη

Tanpa malu-malu mencuri trik menghitung @ GammaFunction dari setengah jumlah hitungan.

⁻η∕²∨›⁸η⁹

Kurangi 2dari jumlah, sehingga menghasilkan nilai-nilai yang 0, 1, 2, 3tepat, tetapi untuk 4-of-a-kind, bagi 2dengan yang 9pertama, menghasilkan 7.777....

∨...∕¹χ

Tetapi jika hasilnya 0, maka tidak ada kecocokan, jadi gantilah dengan 0.1. (Menggunakan literal tidak membantu saya di sini karena saya akan membutuhkan pemisah.)

Ｉ⌊⁺∕θ¹⁰⁰...

Bagilah koin awal dengan 100 dan tambahkan pada kemenangan, kemudian rangkai hasilnya dan masukkan ke string untuk output tersirat.

Pyth , 32 byte

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

Cobalah online!

Terinspirasi oleh solusi GammaFunction. Mengambil input sebagai [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'..$')

Cobalah online!

Belum dibuka:

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 berkat 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'\..*'

Cobalah online!

Operasi ternary besar PowerShell dengan rasa yang dibangun di atas pengelompokan dan pengurutan jumlah daftar input. Penyortiran diperlukan karena kami memanfaatkan fakta bahwa daftar yang dikelompokkan semakin pendek semakin banyak pengulangan yang ada. Bahkan, inilah semua nilai yang mungkin:

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

Memotong ke int masih mahal.

Belum dibuka:

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

Bahasa Wolfram (Mathematica) , 54 byte

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

Cobalah online!

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)

Berhasil menurunkan 11 byte (dan memperbaiki bug) berkat @Giuseppe. Dikelola 10 lebih lanjut terinspirasi oleh / 10 ide @ Giuseppe

Tidak disatukan

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
}

Cobalah online!

8051 Assembly (kompilasi hingga 158 bytes)

Ini adalah pendekatan naif VEEEEEEEEEERRY, ini belum teruji dan tidak diserang tetapi saya cukup percaya diri yang bekerja. Hal yang perlu dipertimbangkan adalah:

1) 8051 adalah mesin akumulator yaitu. diperlukan instruksi bergerak yang mungkin tidak diperlukan oleh arsitektur lain sama sekali.

2) 8051 adalah mesin 8bit karena itu harus dilakukan beberapa tipu daya untuk angka> 255 yang membuat lebih banyak kode dan karenanya ada kerugian dari platform atas yang lain.

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