Hay un minijuego en Super Mario 3D World conocido como Lucky House . Consiste en una máquina tragamonedas con 4 bloques.

Cada bloque puede ser uno de los 5 iconos diferentes (Flor, Hoja, Campana, Cereza o Boomerang) y el objetivo del jugador es obtener la mayor cantidad posible de iconos idénticos ( ver un video ).

El jugador es recompensado con monedas, que a su vez pueden convertirse en vidas extra. Su tarea es calcular la cantidad de vidas adicionales ganadas.

Dependiendo de la cantidad de iconos que coincidan, la cantidad de monedas recompensadas es la siguiente:

• No coincide - 10 monedas
• Un par - 100 monedas
• Dos pares - 200 monedas
• Tres en su tipo: 300 monedas
• Cuatro de su tipo: 777 monedas

Ganas una vida extra (1UP) cada 100 monedas . Por lo tanto, tiene la garantía de ganar exactamente 1UP con un par , 2UP con dos pares y 3UP con 3 de su tipo . Sin embargo, el número de vidas ganadas sin partidos o 4 de su tipo depende de su stock inicial de monedas.

_{Fuente: Super Mario Wiki}

Entrada

Se le da el stock inicial de monedas $0 \le c < 100$ y una lista de cuatro valores $[v_1,v_2,v_3,v_4]$ representan los íconos finales en la máquina tragamonedas.

Salida

El número de vidas extra ganadas: $0$ , $1$ , $2$ , $3$ , $7$ u $8$ .

Reglas

• Puede tomar los iconos en cualquier formato razonable: por ejemplo, como una lista, como una cadena o como 4 parámetros distintos.
• Cada icono puede estar representado por un entero de un solo dígito o por un solo carácter . Por favor, especifique el conjunto de iconos utilizados en su respuesta. (Pero no tiene que explicar cómo se asignan a Flor, Hoja, Campana, etc., porque no importa en absoluto).
• No está permitido reasignar los valores de salida.
• Este es 🎰 code-golf 🎰.

Casos de prueba

En los siguientes ejemplos, usamos una lista de enteros en $[1..5]$ para representar los iconos.

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

Asamblea x86-16, 56 41 39 bytes

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

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:

Ingrese el recuento inicial de monedas DX, SIseñalando el inicio de bytes de "íconos" (que pueden ser '1'- '5', o cualquier valor de byte). Salida del número de 1UP's en BX.

Explicación:

La entrada de cuatro bytes se itera y se compara con los bytes restantes a la derecha, contando el número de coincidencias. Los puntajes para cada tipo de partido se otorgan y suman el total. Dado que un cuatro de un tipo es también tres de un tipo y también un par, el valor de cada tipo de puntuación se puede descomponer de la siguiente manera:

• 3 partidos = 4 1UP's + 77 monedas
• 2 coincidencias = 2 1UP's
• 1 partido = 1 1UP

Ejemplos:

[2, 2, 2, 2] (cuatro en una especie) = 7 1UP's + 77 monedas

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ío) = 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] (dos 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] (un par) = 1 1UP

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

Si el número de 1UP ganados es 0 al final, se otorgan 10 monedas. Si el total de monedas es superior a 100, se otorga 1UP adicional.

Aquí hay un programa de prueba para PC DOS que incluye rutinas adicionales para manejar el valor entero de E / S:

Descargue y pruebe LUCKY.COM para DOS.

Jalea ,  23 22 20  19 bytes

-1 gracias a Erik the Outgolfer (uso ³en lugar de ȷ2) también utilizado en la versión más reciente dos veces
-1 gracias a Grimy (reste uno antes de sumar en lugar de restar cuatro después)

^{Tal vez vencible?}

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

Un enlace diádico que acepta una lista y un número entero que produce un número entero.

Pruébalo en línea! O ver un conjunto de pruebas .

¿Cómo?

ċⱮ`’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ómo funciona la evaluación manual para cada tipo de 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 bytes

-13 usando un criterio diferente para la diferenciación, -9 combinando casos, -28 cambiando la casedeclaración a un ternario aritmético anidado, -4 gracias a @JonathanAllan, -1 optimizando los ternarios, -2 porque accidentalmente usé echoal agregar La optimización de Jonathan.

Toma el recuento de monedas en stdin y bloquea las entradas como argumentos. Los argumentos pueden ser números, caracteres o incluso cadenas:./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]

Pruébelo en línea: 117 104 95 67 63 62 60

Aquí está la magia de la respuesta 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 # (Visual C # interactivo Compilador) , 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

Un puerto de mi respuesta de Python, que se deriva de la respuesta de @ Dat.

Pruébalo en línea!

Python 2 , 63 bytes

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

Pruébalo en línea!

Tuve la misma idea que GammaFunction para usar sum(map(l.count,l))como "huella digital". Pero, en lugar de usar una fórmula aritmética en el resultado, utilizo una tabla de búsqueda, primero reduciendo el valor a 0 a 4 usando una cadena de modulación %14%5. Al dividir todos los valores de puntos por 100 se guardan unos pocos 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]

Pruébalo en línea!

Un puerto Python de mi puerto C de mi puerto Bash de mi respuesta Zsh, re-golf con la ayuda de la página "Consejos para jugar golf en Python". Último puerto, lo juro ... Me estoy quedando sin idiomas en los que me siento cómodo jugando al golf. Tenía curiosidad por cómo esta estrategia en comparación con las otras respuestas Python. De nuevo, probablemente haya alguna forma de superar esto.

Este resultó sorprendentemente bueno, así que agregué una tabla a continuación que resume lo que está sucediendo para que otros puedan portar o mejorar esto.

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 (prelanzamiento) , 63 bytes

¡Alabado sea la :=morsa!

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

Pruébalo en línea!

Perl 6 , 48 44 bytes

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

Pruébalo en línea!

Función de curry f(icons)(coins).

Python 2 , 96 91 89 bytes

-2 bytes gracias 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

Pruébalo en línea!

PHP, 153127 bytes

@ 640KB hizo algunos cambios realmente inteligentes para acortarlo aún más:

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

Pruébalo en línea!

Pitón 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

Pruébalo en línea!

Python 3.8 (prelanzamiento) , 78 bytes

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

La respuesta de Dat, pero jugó más.

Pruébalo en línea!

Perl 5 -pF , 46 bytes

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

Pruébalo en línea!

Primero de la entrada es el resultado del giro, usando 5 letras ASCII únicas, excepto q(sugieroabcde ). La segunda línea de entrada es el conteo actual de monedas.

¿Cómo?

-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 los números involucrados se dividen entre 100, por lo que el programa cuenta el número de vidas (incluidas las parciales) actualmente ganadas. El truco para esta solución está en el map. Si las entradas son posibles abcde, entonces cada uno de $a, $b, $c, $d, y $esostener la cuenta del número de veces que este personaje había sido visto. Eso se agrega a un total acumulado ( $q) cada vez que se ve un personaje. El total acumulado se incrementa si hay un cuatro de un tipo (efectivamente un bono de 177 monedas).

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

Pruébalo en línea!

¡Pensé que tenía que haber al menos una respuesta de JavaScript para un desafío de Arnauld!

El concepto aquí es principalmente utilizar el número de elementos distintos como clave de búsqueda.

• 1 único => 4 de un tipo
• 2 únicos => 2 pares o 3 de un tipo
• 3 únicos => 1 par
• 4 únicos => sin coincidencias

Para distinguir entre 2 pares y 3 de un tipo, se ordena la matriz de entrada y se comparan los 2 elementos del medio.

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;

Pruébalo en línea!

Entrada desde la línea de comando, salida a 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╓

Ejecutar y depurarlo

Este programa utiliza cualquier conjunto arbitrario de 5 enteros para iconos.

Procedimiento:

1. Sume el número de ocurrencias de cada elemento.
2. Divide entre 2 y luego mod 7.
3. El resultado es un número del 1 al 5. Use esto para buscar el premio de la moneda en una matriz fija.
4. Añadir al recuento inicial de monedas.
5. Dividir por 100.

Aquí está el resultado de un visualizador de estado de pila experimental en el que he estado trabajando para la próxima versión de Stax. Esta es una versión desempaquetada del mismo código con el estado de pila agregado a los comentarios.

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] 

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

Pruébalo en línea! El enlace incluye casos de prueba. Toma la entrada como 4 no dígitos ASCII imprimibles seguidos del número inicial de monedas en dígitos. Explicación:

O`\D

Ordene los no dígitos para que los símbolos idénticos se agrupen.

(\D)\1{3}
777¶

Puntajes de cuatro en 777.

(\D)\1\1
300¶

Tres puntajes de 300.

(\D)\1
100¶

Cada par puntúa 100, por lo que dos pares puntuarán 200.

\D{4}
10¶

Si no hubo partidos, ¡todavía ganas!

\d+\D*
$*

Convierta los valores a unario y tome la suma.

1{100}

Entero divide la suma por 100 y convierte de nuevo a decimal.

Retina , 56 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Toma la entrada como 4 no dígitos ASCII imprimibles seguidos del número inicial de monedas en dígitos. Explicación:

(\D)\1{3}
777¶

Puntajes de cuatro en 777.

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

Cada par tiene un puntaje de 100. wToma en consideración todos los pares, para que puedan ser intercalados, además de tres de un tipo puede descomponerse en tres pares, por lo tanto, puntuar automáticamente 300.

\D{4}
10¶

Si no hubo partidos, ¡todavía ganas!

\d+\D*
*

Convierta los valores a unario y tome la suma.

_{100}

Entero divide la suma por 100 y convierte de nuevo a decimal.

APL + WIN, 42 bytes

Solicita iconos seguidos de stock de monedas.

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

Pruébalo en línea! Cortesía de Dyalog Classic.

Bash , 76 75 71 70 bytes

-4 gracias a @JonathanAllan, -1 al reorganizar el ternario.

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

Bash puerto de mi respuesta Zsh. Pruébalo en línea! Pruébalo en línea! Pruébalo en línea! Pruébalo en línea!

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

-1 por x+=(..!=..) -5 al regresar mediante asignación , -4 gracias a Jonathan Allan al reemplazar !=con <, lo que ahorra bytes en otro lugar, -1 al reorganizar el ternario.

Desde @ceilingcat: -2 al declarar iy xfuera de la función, -1 estableciendo x=iy decrementando en su xlugar.

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

Otro puerto de mi respuesta Zsh. No estoy familiarizado con el golf C, probablemente haya otro truco en algún lugar para reducirlo aún más. 92 84 82 81 79 Pruébelo en línea!

05AB1E , 20 19 18 bytes

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

Puerto de la respuesta Jelly de @JonathanAllan , ¡así que asegúrate de votarlo!
-2 bytes gracias a @Grimy .

Toma la lista de iconos como primera entrada (ser [1,2,3,4,5]) y la cantidad de monedas como segunda entrada.

Pruébelo en línea o verifique todos los casos de prueba . (El conjunto de pruebas usa en T‚à+lugar de TMI+, que es una alternativa de bytes iguales).

Explicación:

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

Pruébalo en línea!

Carbón , 30 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Toma datos como el número de monedas y una matriz de cualquier valor comparable de Python como iconos. Explicación:

≔⊘ΣＥη№ηιη

Robar descaradamente el truco de @ GammaFunction de calcular la mitad de la suma de los recuentos.

⁻η∕²∨›⁸η⁹

Restar 2de la suma, resultando así en los valores 0, 1, 2, 3apropiadamente, pero para 4-de-a-tipo, se divide el 2por 9primera, dando como resultado 7.777....

∨...∕¹χ

Pero si el resultado es 0, entonces no hubo coincidencias, así que reemplácelo con 0.1. (Usar un literal no me ayuda aquí porque necesitaría un separador).

Ｉ⌊⁺∕θ¹⁰⁰...

Divida las monedas iniciales entre 100 y agregue las ganancias, luego ponga el resultado en el suelo y eche a cadena para obtener resultados implícitos.

Pyth , 32 bytes

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

Pruébalo en línea!

Inspirado en la solución de 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'..$')

Pruébalo en línea!

Desenrollado:

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 bytes

^{-7 bytes gracias 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'\..*'

Pruébalo en línea!

Una gran operación ternaria con sabor a PowerShell basada en la agrupación y clasificación de los recuentos de la lista de entrada. El tipo es necesario porque aprovechamos el hecho de que la lista agrupada se acorta cuanto más repeticiones hay. De hecho, aquí están todos los valores posibles:

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

Truncar a un int todavía es costoso.

Desenrollado:

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#⌋&

Pruébalo en línea!

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)

Logró soltar 11 bytes (y corregir un error) gracias a @Giuseppe. Manejé otros 10 inspirados por la idea de @ Giuseppe / 10.

Sin golf

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
}

Pruébalo en línea!

Conjunto 8051 (compila a 158 bytes)

Este es un enfoque ingenuo VEEEEEEEEEERRY, esto aún no se ha probado y no se ha defendido, pero estoy bastante seguro de que funciona. Las cosas a considerar son:

1) el 8051 es una máquina acumuladora, es decir. necesita instrucciones mov que otras arquitecturas pueden no necesitar en absoluto.

2) el 8051 es una máquina de 8 bits, por lo que debe hacerse algún truco para los números> 255, lo que genera más código y es una desventaja de la plataforma sobre los demás.

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