Há um minigame no Super Mario 3D World conhecido como Lucky House . Consiste em uma máquina caça-níqueis com 4 blocos.

Cada bloco pode ser um dos 5 ícones diferentes (Flor, Folha, Sino, Cereja ou Bumerangue) e o objetivo do jogador é obter o maior número possível de ícones idênticos ( veja um vídeo ).

O jogador é recompensado com moedas, que por sua vez podem ser convertidas em vidas extras. Sua tarefa é calcular o número de vidas extras ganhas.

Dependendo do número de ícones correspondentes, a quantidade de moedas recompensadas é a seguinte:

• Sem correspondências - 10 moedas
• Um par - 100 moedas
• Dois pares - 200 moedas
• Três-de-um-tipo - 300 moedas
• Four-of-a-kind - 777 moedas

Você ganha uma vida extra (1UP) a cada 100 moedas . Portanto, você ganha exatamente 1UP com um par , 2UP com dois pares e 3UP com 3 tipos . No entanto, o número de vidas ganhadas sem combinações ou 4 do tipo depende do seu estoque inicial de moedas.

_{Fonte: Super Mario Wiki}

Entrada

Você recebe o estoque inicial de moedas $0 \le c < 100$ e uma lista de quatro valores$[v_1,v_2,v_3,v_4]$ representam os ícones finais na máquina caça-níqueis.

Saída

O número de vidas extras ganhas: $0$ , $1$ , $2$ , $3$ , $7$ ou $8$ .

Regras

• Você pode pegar os ícones em qualquer formato razoável: por exemplo, como uma lista, como uma string ou como 4 parâmetros distintos.
• Cada ícone pode ser representado por um número inteiro de um dígito ou um único caractere . Especifique o conjunto de ícones usados ​​na sua resposta. (Mas você não precisa explicar como eles são mapeados para Flor, Folha, Sino, etc., porque isso não importa.)
• Você não tem permissão para remapear os valores de saída.
• Este é o " código-golfe ".

Casos de teste

Nos exemplos a seguir, usamos uma lista de números inteiros em $[1..5]$ para representar os ícones.

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 bytes

Binário:

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

Desmontado:

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:

Insira a contagem inicial de moedas DX, SIapontando para o início dos bytes de "ícones" (que podem ser'1' - '5'ou qualquer valor de byte). Emita o número de 1UPs em BX.

Explicação:

A entrada de quatro bytes é iterada e comparada com os bytes restantes à direita, contando o número de correspondências. As pontuações para cada tipo de partida são concedidas e somadas ao total. Como um quádruplo é também três e um par, o valor de cada tipo de pontuação pode ser decomposto da seguinte maneira:

• 3 correspondências = 4 1UP's + 77 moedas
• 2 correspondências = 2 1UP's
• 1 partida = 1 1UP

Exemplos:

[2, 2, 2, 2] (quatro) = 7 1UP's + 77 moedas

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] (três) = 3 1UP's

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

[4, 5, 5, 4] (dois pares) = 2 1UP's

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

[2, 3, 4, 3] (um par) = 1 1UP

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

Se o número de 1UPs ganhos for 0 no final, 10 moedas serão concedidas. Se o total de moedas for maior que 100, um 1UP adicional será concedido.

Aqui está um programa de teste para o PC DOS que inclui rotinas extras para lidar com o valor inteiro de E / S:

Faça o download e teste o LUCKY.COM for DOS.

Geléia ,  23 22 20  19 bytes

-1 graças a Erik the Outgolfer (use ³no lugar de ȷ2) também usado na versão mais recente duas vezes
-1 graças a Grimy (subtrai um antes da soma em vez de subtrair quatro depois)

^{Talvez imbatível?}

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

Um link diádico que aceita uma lista e um número inteiro que gera um número inteiro.

Experimente online! Ou veja uma suíte de testes .

Quão?

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

Como a avaliação da mão funciona para cada tipo de mão:

           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 bytes

-13 usando um critério diferente para diferenciação, -9 combinando casos, -28 alterando a caseinstrução para um ternário aritmético aninhado, -4 graças a @ Jonathan JonathanAllan, -1 otimizando os ternários, -2 porque usei acidentalmente echoao adicionar Otimização de Jonathan.

Adota contagem de moedas com stdin e bloqueia entradas como argumentos. Os argumentos podem ser números, caracteres ou até seqüências de caracteres:./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]

Experimente online: 117 104 95 67 63 62 60

Aqui está a mágica da resposta de 67 bytes:

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 # (compilador interativo do Visual C #) , 123 106 90 bytes

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

Uma porta da minha resposta python, derivada da resposta da @ Dat.

Experimente online!

Python 2 , 63 bytes

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

Experimente online!

Eu tive a mesma idéia que GammaFunction para usar sum(map(l.count,l))como uma "impressão digital". Mas, em vez de usar uma fórmula aritmética no resultado, eu uso uma tabela de pesquisa, primeiro pressionando o valor de 0 a 4 usando uma cadeia de mods %14%5. Dividir todos os valores dos pontos por 100 salvou alguns bytes.

Python 3 , 68 bytes

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

Experimente online!

Uma porta Python da minha porta C da minha porta Bash da minha resposta Zsh voltou a jogar com a ajuda da página "Dicas para jogar golfe em Python". Última porta, eu juro ... Estou ficando sem idiomas em que estou confortável jogando golfe. Fiquei curioso em saber como essa estratégia se comparava às outras respostas do Python. Novamente, provavelmente há uma maneira de superar isso.

Este foi surpreendentemente bom, então eu adicionei uma tabela abaixo resumindo o que está acontecendo para que outros possam portar ou melhorar isso.

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 (pré-lançamento) , 63 bytes

Louvado seja a :=morsa!

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

Experimente online!

Perl 6 , 48 44 bytes

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

Experimente online!

Função ao curry f(icons)(coins).

Python 2 , 96 91 89 bytes

-2 bytes graças 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

Experimente online!

PHP, 153 127 bytes

O @ 640KB fez algumas alterações realmente inteligentes para encurtar ainda mais:

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

Experimente online!

Python 3 , 126 111 108 103 bytes

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

Experimente online!

Python 3.8 (pré-lançamento) , 78 bytes

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

A resposta de Dat, mas jogou mais.

Experimente online!

Perl 5 -pF , 46 bytes

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

Experimente online!

A primeira entrada é o resultado da rotação, usando 5 letras ASCII exclusivas, exceto q (sugiroabcde ). A segunda linha de entrada é a contagem atual de moedas.

Quão?

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

Todos os números envolvidos são divididos por 100, portanto, o programa conta o número de vidas (incluindo as parciais) atualmente conquistadas. O truque para esta solução está no map. Se as entradas possíveis são abcde, em seguida, cada um $a, $b, $c, $d, e $erealizar a contagem do número de vezes que este personagem tinha sido visto anteriormente. Isso é adicionado a um total em execução ( $q) toda vez que um personagem é visto. O total acumulado é aumentado se houver quatro do mesmo tipo (efetivamente um bônus de 177 moedas).

JavaScript (Node.js) , 64 bytes

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

Experimente online!

Imaginei que deveria haver pelo menos uma resposta JavaScript para um desafio de Arnauld!

O conceito aqui é principalmente usar o número de elementos distintos como uma chave de pesquisa.

• 1 único => 4 de um tipo
• 2 únicos => 2 pares ou 3 do mesmo tipo
• 3 únicos => 1 par
• 4 únicos => sem correspondências

Para distinguir entre 2 pares e 3 de um tipo, a matriz de entrada é classificada e os 2 elementos do meio são comparados.

PHP ,89 84 bytes

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

Experimente online!

Entrada da linha de comando, saída para STDOUT:

$ php lucky.php 99 3333
8

$ php lucky.php 0 2522
3

$ php lucky.php 0 abaa
3

Stax , 23 bytes

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

Execute e depure

Este programa usa qualquer conjunto arbitrário de 5 números inteiros para ícones.

Procedimento:

1. Adicione o número de ocorrências de cada elemento.
2. Divida por 2 e depois mod 7.
3. O resultado é um número de 1..5. Use isso para procurar o prêmio da moeda em uma matriz fixa.
4. Adicione à contagem inicial de moedas.
5. Divida por 100.

Aqui está a saída de um visualizador de estado de pilha experimental em que estive trabalhando para a próxima versão do stax. Esta é uma versão descompactada do mesmo código com o estado da pilha adicionado aos comentários.

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] 

Execute este

Retina 0.8.2 , 72 bytes

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

Experimente online!O link inclui casos de teste. Recebe a entrada como 4 dígitos não ASCII imprimíveis, seguidos pelo número inicial de moedas em dígitos. Explicação:

O`\D

Classifique os não dígitos, para que símbolos idênticos sejam agrupados.

(\D)\1{3}
777¶

Resultados quatro-de-um-tipo 777.

(\D)\1\1
300¶

Três pontuações de 300.

(\D)\1
100¶

Cada par tem 100 pontos, então dois pares terão 200 pontos.

\D{4}
10¶

Se não houve jogos, você ainda ganha!

\d+\D*
$*

Converta os valores em unário e pegue a soma.

1{100}

Inteiro divida a soma por 100 e converta novamente em decimal.

Retina , 56 bytes

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

Experimente online! O link inclui casos de teste. Recebe a entrada como 4 dígitos não ASCII imprimíveis, seguidos pelo número inicial de moedas em dígitos. Explicação:

(\D)\1{3}
777¶

Resultados quatro-de-um-tipo 777.

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

Cada par tem 100 pontos. O wleva em consideração todos os pares, para que possam ser intercalados, e os três do mesmo tipo podem ser decompostos em três pares, marcando automaticamente 300.

\D{4}
10¶

Se não houve jogos, você ainda ganha!

\d+\D*
*

Converta os valores em unário e pegue a soma.

_{100}

Inteiro divida a soma por 100 e converta novamente em decimal.

APL + WIN, 42 bytes

Solicita ícones seguidos por estoque de moedas.

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

Experimente online! Cortesia de Dyalog Classic

Bash , 76 75 71 70 bytes

-4 graças a @ JonathanAllan, -1 reorganizando o ternário.

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

Porta Bash da minha resposta Zsh. Experimente online! Experimente online! Experimente online! Experimente online!

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

-1 pela x+=(..!=..) -5 por retornando através de atribuição , -4 graças a Jonathan Allan, substituindo !=com< , o que poupa bytes noutro local, -1 rearranjando a ternário.

De @ceilingcat: -2 declarando ie xfora da função, -1 definindox=i e 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);}

Outra porta da minha resposta Zsh. Não estou familiarizado com o golfe C, provavelmente há outro truque em algum lugar aqui para reduzi-lo ainda mais. 92 84 82 81 79 Experimente online!

05AB1E , 20 19 18 bytes

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

Porto da resposta de @JonathanAllan Jelly , por isso não deixe de votar nele !!
-2 bytes graças a @Grimy .

Toma a lista de ícones como primeira entrada (sendo [1,2,3,4,5]) e a quantidade de moedas como segunda entrada.

Experimente online ou verifique todos os casos de teste . (O conjunto de testes usa em T‚à+vez de TMI+, que é uma alternativa igual a bytes.)

Explicação:

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 bytes

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

Experimente online!

Carvão , 30 bytes

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

Experimente online! Link é a versão detalhada do código. Recebe entrada como o número de moedas e uma matriz de quaisquer valores comparáveis ​​do Python como ícones. Explicação:

≔⊘ΣＥη№ηιη

Rouba descaradamente o truque do @ GammaFunction de calcular metade da soma das contagens.

⁻η∕²∨›⁸η⁹

Subtraia 2da soma, resultando assim nos valores 0, 1, 2, 3apropriadamente, mas para 4 do mesmo tipo, divida o 2por 9primeiro, resultando em 7.777....

∨...∕¹χ

Mas se o resultado for 0, não houve correspondências, então substitua-o por 0.1. (Usar um literal não me ajuda aqui porque eu precisaria de um separador.)

Ｉ⌊⁺∕θ¹⁰⁰...

Divida as moedas iniciais por 100 e adicione os ganhos, depois coloque o resultado no chão e jogue na sequência para obter resultados implícitos.

Pitão , 32 bytes

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

Experimente online!

Inspirado na solução da GammaFunction. Toma entrada como [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 bytes

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

Experimente online!

Desenrolado:

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 bytes

^{-7 bytes graças ao 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'\..*'

Experimente online!

Uma grande operação ternária com sabor do PowerShell, criada ao agrupar e classificar as contagens da lista de entradas. A classificação é necessária porque aproveitamos o fato de que a lista agrupada fica mais curta quanto mais repetições existirem. De fato, aqui estão todos os valores possíveis:

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

Truncar para um int ainda é caro.

Desenrolado:

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 bytes

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

Experimente online!

R, 102 , 91 , 81 bytes

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

Conseguiu eliminar 11 bytes (e corrigir um erro) graças a @Giuseppe. Gerenciei mais 10 inspirados na ideia de @ Giuseppe / 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
}

Experimente online!

Montagem 8051 (compila para 158 bytes)

Esta é uma abordagem ingênua da VEEEEEEEEEERRY, ainda não foi testada e não-destruída, mas estou bastante confiante de que funciona. As coisas a considerar são:

1) o 8051 é uma máquina acumuladora, ou seja. ele precisa de instruções mov que outras arquiteturas podem não precisar.

2) o 8051 é uma máquina de 8 bits; portanto, devem ser feitos alguns truques para os números> 255, o que gera mais código e, portanto, uma desvantagem da plataforma em relação aos outros.

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