C'è un minigioco in Super Mario 3D World noto come Lucky House . Si compone di una slot machine con 4 blocchi.

Ogni blocco può essere una delle 5 icone diverse (Fiore, Foglia, Campana, Ciliegia o Boomerang) e l'obiettivo del giocatore è quello di ottenere quante più icone identiche possibili ( vedi un video ).

Il giocatore viene premiato con monete, che a loro volta possono essere convertite in vite extra. Il tuo compito è calcolare il numero di vite extra vinte.

A seconda del numero di icone corrispondenti, la quantità di monete premiate è la seguente:

• Nessuna corrispondenza - 10 monete
• Una coppia - 100 monete
• Due coppie - 200 monete
• Tris: 300 monete
• Four-of-a-kind - 777 monete

Vinci una vita extra (1UP) ogni 100 monete . Pertanto, sei sicuro di vincere esattamente 1UP con una coppia , 2UP con due coppie e 3UP con 3-of-a-kind . Tuttavia, il numero di vite vinte senza partite o 4 di un tipo dipende dalla tua moneta iniziale.

_{Fonte: Super Mario Wiki}

Ingresso

Ti viene dato lo stock iniziale di monete e un elenco di quattro valori rappresentano le icone finali sulla slot machine.$0 \le c < 100$$[v_1,v_2,v_3,v_4]$

Produzione

Il numero di vite extra vinte: , , , , o .$0$$1$$2$$3$$7$$8$

Regole

• Puoi prendere le icone in qualsiasi formato ragionevole: ad es. Come un elenco, come una stringa o come 4 parametri distinti.
• Ogni icona può essere rappresentata da un numero intero a una cifra o da un singolo carattere . Si prega di specificare il set di icone utilizzate nella risposta. (Ma non devi spiegare come sono mappati su Fiore, Foglia, Campana, ecc., Perché non importa affatto.)
• Non è consentito rimappare i valori di output.
• Questo è 🎰 code-golf 🎰.

Casi test

Negli esempi seguenti, utilizziamo un elenco di numeri interi in per rappresentare le icone.$[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 Assembly, 56 41 39 byte

Binario:

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

smontato:

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:

Inserire il conteggio iniziale delle monete DX, SIindicando l'inizio dei byte "icona" (che possono essere '1'- '5'o qualsiasi valore di byte). Emette il numero di 1UP in BX.

Spiegazione:

L'input di quattro byte viene ripetuto e confrontato con i rimanenti byte a destra, contando il numero di corrispondenze. I punteggi per ogni tipo di incontro vengono assegnati e sommati al totale. Poiché un quadrilatero è anche un tris e una coppia, il valore di ciascun tipo di punteggio può essere scomposto come segue:

• 3 partite = 4 1UP + 77 monete
• 2 partite = 2 1UP
• 1 partita = 1 1UP

Esempi:

[2, 2, 2, 2] (quadrilatero) = 7 monete 1UP + 77 monete

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] (tris) = 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] (due coppie) = 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] (una coppia) = 1 1UP

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

Se il numero di 1UP guadagnati è 0 alla fine, vengono assegnate 10 monete. Se le monete totali sono superiori a 100, viene assegnato un ulteriore 1UP.

Ecco un programma di test per PC DOS che include routine extra per gestire l'I / O del valore intero:

Scarica e prova LUCKY.COM per DOS.

Gelatina ,  23 22 20  19 byte

-1 grazie a Erik the Outgolfer (utilizzare ³al posto di ȷ2) utilizzato anche nella versione più recente due volte
-1 grazie a Grimy (sottrarre uno prima della somma invece di sottrarre quattro dopo)

^{Forse battibile?}

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

Un collegamento diadico che accetta un elenco e un numero intero che produce un numero intero.

Provalo online! Oppure vedi una suite di test .

Come?

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

Come funziona la valutazione della mano per ogni tipo di mano:

           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

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

Zsh , 117 ... 60 byte

-13 usando un criterio diverso per la differenziazione, -9 combinando i casi, -28 cambiando l' caseaffermazione in un ternario aritmetico annidato, -4 grazie a @JonathanAllan, -1 ottimizzando i ternari, -2 perché l'ho usato accidentalmente echodurante l'aggiunta L'ottimizzazione di Jonathan.

Prende il conteggio delle monete su stdin e blocca gli input come argomenti. Gli argomenti possono essere numeri, caratteri o persino stringhe:./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]

Provalo online: 117 104 95 67 63 62 60

Ecco la magia della risposta a 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 # (compilatore interattivo 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

Una porta della mia risposta Python, che deriva dalla risposta di @ Dat.

Provalo online!

Python 2 , 63 byte

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

Provalo online!

Ho avuto la stessa idea di GammaFunction da usare sum(map(l.count,l))come "impronta digitale". Ma, invece di usare una formula aritmetica sul risultato, uso una tabella di ricerca, prima schiacciando il valore da 0 a 4 usando una catena mod %14%5. Dividendo tutti i valori dei punti per 100 salvati alcuni 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]

Provalo online!

Una porta Python della mia porta C della mia porta Bash della mia risposta Zsh, ri-giocata con l'aiuto della pagina "Suggerimenti per giocare a golf in Python". Ultimo porto, lo giuro ... sto esaurendo le lingue in cui mi sento a mio agio nel golf. Ero curioso di sapere come questa strategia rispetto alle altre risposte di Python. Ancora una volta, c'è probabilmente un modo per batterlo.

Questo si è rivelato sorprendentemente buono, quindi ho aggiunto una tabella che riassume ciò che sta accadendo in modo che altri possano portarlo o migliorarlo.

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 (pre-release) , 63 byte

Loda il :=tricheco!

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

Provalo online!

Perl 6 , 48 44 byte

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

Provalo online!

Funzione al curry f(icons)(coins).

Python 2 , 96 91 89 byte

-2 byte grazie a @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

Provalo online!

PHP, 153 127 byte

@ 640KB ha apportato alcune modifiche davvero intelligenti per accorciarlo ulteriormente:

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

Provalo 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

Provalo online!

Python 3.8 (pre-release) , 78 byte

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

La risposta di Dat, ma ha giocato di più.

Provalo online!

Perl 5 -pF , 46 byte

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

Provalo online!

Il primo di input è il risultato della rotazione, usando 5 lettere ASCII univoche, tranne q(suggerisco abcde). La seconda riga di input è l'attuale conteggio delle monete.

Come?

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

Tutti i numeri coinvolti sono divisi per 100, quindi il programma sta contando il numero di vite (comprese quelle parziali) attualmente guadagnate. Il trucco di questa soluzione sta nel map. Se le voci possibili sono abcde, poi ognuno di $a, $b, $c, $d, e $etenere il conto del numero di volte che questo personaggio era stato precedentemente visto. Viene aggiunto a un totale $qparziale ( ) ogni volta che viene visto un personaggio. Il totale parziale viene aumentato se vi è un quadruplo (effettivamente un bonus di 177 monete).

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

Provalo online!

Ho pensato che ci fosse almeno una risposta JavaScript a una sfida di Arnauld!

Il concetto qui è principalmente quello di utilizzare il numero di elementi distinti come chiave di ricerca.

• 1 unico => 4 di un tipo
• 2 unici => 2 coppie o 3 di un tipo
• 3 unici => 1 coppia
• 4 unico => nessuna corrispondenza

Al fine di distinguere tra 2 coppie e 3 di un tipo, l'array di input viene ordinato e i 2 elementi centrali vengono confrontati.

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;

Provalo online!

Input da riga di comando, output a 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╓

Esegui ed esegui il debug

Questo programma utilizza qualsiasi set arbitrario di 5 numeri interi per le icone.

Procedura:

1. Aggiungi il numero di occorrenze di ciascun elemento.
2. Dividi per 2 e poi mod 7.
3. Il risultato è un numero compreso tra 1 e 5. Usa questo per cercare il premio in monete in un array fisso.
4. Aggiungi al conteggio iniziale delle monete.
5. Dividi per 100.

Ecco l'output di un visualizzatore dello stato dello stack sperimentale su cui ho lavorato per la prossima versione di stax. Questa è una versione decompressa dello stesso codice con lo stato dello stack aggiunto ai commenti.

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] 

Esegui questo

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}

Provalo online! Il link include casi di test. Accetta input come 4 cifre non ASCII stampabili seguite dal numero iniziale di monete in cifre. Spiegazione:

O`\D

Ordinare le non cifre in modo che i simboli identici siano raggruppati insieme.

(\D)\1{3}
777¶

Punteggi a quattro punte 777.

(\D)\1\1
300¶

Punteggi a tre nel genere 300.

(\D)\1
100¶

Ogni coppia segna 100, quindi due coppie ne segnano 200.

\D{4}
10¶

Se non ci sono state partite, allora vinci comunque!

\d+\D*
$*

Converti i valori in unari e prendi la somma.

1{100}

Numero intero dividere la somma per 100 e riconvertirla in decimale.

Retina , 56 byte

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

Provalo online! Il link include casi di test. Accetta input come 4 cifre non ASCII stampabili seguite dal numero iniziale di monete in cifre. Spiegazione:

(\D)\1{3}
777¶

Punteggi a quattro punte 777.

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

Ogni coppia ha un punteggio di 100. wPrende in considerazione tutte le coppie, in modo che possano essere intercalate, più tre di un tipo possono essere scomposte in tre coppie, ottenendo così un punteggio automatico di 300.

\D{4}
10¶

Se non ci sono state partite, allora vinci comunque!

\d+\D*
*

Converti i valori in unari e prendi la somma.

_{100}

Numero intero dividere la somma per 100 e riconvertirla in decimale.

APL + WIN, 42 byte

Richiede icone seguite da stock di monete.

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

Provalo online! Per gentile concessione di Dyalog Classic

Bash , 76 75 71 70 byte

-4 grazie a @JonathanAllan, -1 riorganizzando il ternario.

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

Porta bash della mia risposta Zsh. Provalo online! Provalo online! Provalo online! Provalo online!

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

-1 da x+=(..!=..) -5 dal ritorno tramite l'assegnazione , -4 grazie a Jonathan Allan sostituendo !=con <, che consente di risparmiare byte altrove, -1 riorganizzando il ternario.

Da @ceilingcat: -2 dichiarando ie xal di fuori della funzione, -1 invece impostando x=ie decrementando 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);}

Un'altra porta della mia risposta Zsh. Non ho familiarità con il golf C, probabilmente c'è un altro trucco da qualche parte qui per ridurlo ulteriormente. 92 84 82 81 79 Provalo online!

05AB1E , 20 19 18 byte

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

La risposta di Jelly al porto di @JonathanAllan , quindi assicurati di votarlo !!
-2 byte grazie a @Grimy .

Prende l'elenco delle icone come primo input (essere [1,2,3,4,5]) e la quantità di monete come secondo input.

Provalo online o verifica tutti i casi di test . (La suite di test utilizza T‚à+invece di TMI+, che è un'alternativa di byte uguali.)

Spiegazione:

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

Provalo online!

Carbone , 30 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Prende input come numero di monete e una matrice di valori paragonabili a Python come icone. Spiegazione:

≔⊘ΣＥη№ηιη

Rubare senza vergogna il trucco di @ GammaFunction di calcolare metà della somma dei conteggi.

⁻η∕²∨›⁸η⁹

Sottrarre 2dalla somma, conseguente valori 0, 1, 2, 3opportunamente, ma per 4-di-un-genere, dividere il 2dalla 9prima, con conseguente 7.777....

∨...∕¹χ

Ma se il risultato è 0, allora non c'erano corrispondenze, quindi sostituiscilo con 0.1invece. (L'uso di un valore letterale non mi aiuta qui perché avrei bisogno di un separatore.)

Ｉ⌊⁺∕θ¹⁰⁰...

Dividi le monete iniziali per 100 e aggiungi le vincite, quindi calcola il risultato e lancia sulla stringa per l'output implicito.

Pyth , 32 byte

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

Provalo online!

Ispirato alla soluzione di GammaFunction. Accetta input come [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'..$')

Provalo online!

srotolato:

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

Provalo online!

Una grande operazione ternaria al sapore di PowerShell basata sul raggruppamento e l'ordinamento dei conteggi dell'elenco di input. L'ordinamento è necessario perché sfruttiamo il fatto che l'elenco raggruppato si accorcia più si ripetono. In effetti, ecco tutti i possibili valori:

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

Troncare a un int è ancora costoso.

srotolato:

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

Wolfram Language (Mathematica) , 54 byte

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

Provalo 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)

Gestito per eliminare 11 byte (e correggere un bug) grazie a @Giuseppe. Gestito altri 10 ispirati all'idea di @ Giuseppe's / 10.

Ungolfed

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
}

Provalo online!

8051 Assembly (compila fino a 158 byte)

Questa è un'approvazione ingenua da parte di VEEEEEEEEEERRY, non è ancora stata testata e non controllata ma sono abbastanza fiduciosa che funzioni. Le cose da considerare sono:

1) l'8051 è un accumulatore cioè. ha bisogno di istruzioni mov che potrebbero non essere necessarie ad altre architetture.

2) l'8051 è una macchina a 8 bit per cui bisogna fare qualche trucco per i numeri> 255, il che rende più codice ed è quindi uno svantaggio della piattaforma rispetto agli altri.

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