Il y a un mini-jeu dans Super Mario 3D World connu sous le nom de Lucky House . Il se compose d'une machine à sous à 4 blocs.

Chaque bloc peut être l'une des 5 icônes différentes (Fleur, Feuille, Cloche, Cerise ou Boomerang) et l'objectif du joueur est d'obtenir autant d'icônes identiques que possible ( voir une vidéo ).

Le joueur est récompensé par des pièces, qui à leur tour peuvent être converties en vies supplémentaires. Votre tâche consiste à calculer le nombre de vies supplémentaires gagnées.

Selon le nombre d'icônes qui correspondent, le nombre de pièces récompensées est le suivant:

• Pas de correspondance - 10 pièces
• Une paire - 100 pièces
• Deux paires - 200 pièces
• Trois pièces uniques - 300 pièces
• Quatre pièces uniques - 777 pièces

Vous gagnez une vie supplémentaire (1UP) toutes les 100 pièces . Par conséquent, vous êtes assuré de gagner exactement 1UP avec une paire , 2UP avec deux paires et 3UP avec 3-of-a-kind . Cependant, le nombre de vies gagnées sans match ou 4-of-a-kind dépend de votre stock de pièces initial.

_{Source: Super Mario Wiki}

Contribution

On vous donne le stock initial de pièces $0 \le c < 100$ et une liste de quatre valeurs $[v_1,v_2,v_3,v_4]$ représentant les icônes finales sur la machine à sous.

Sortie

Le nombre de vies supplémentaires gagnées: $0$ , $1$ , $2$ , $3$ , $7$ ou $8$ .

Règles

• Vous pouvez prendre les icônes dans n'importe quel format raisonnable: par exemple sous forme de liste, de chaîne ou de 4 paramètres distincts.
• Chaque icône peut être représentée soit par un entier à un chiffre, soit par un seul caractère . Veuillez spécifier l'ensemble d'icônes utilisé dans votre réponse. (Mais vous n'avez pas à expliquer comment ils sont associés à Flower, Leaf, Bell, etc., car cela n'a pas d'importance du tout.)
• Vous n'êtes pas autorisé à remapper les valeurs de sortie.
• C'est 🎰 code-golf 🎰.

Cas de test

Dans les exemples suivants, nous utilisons une liste d'entiers dans $[1..5]$ pour représenter les icônes.

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

Assemblage x86-16, 56 41 39 octets

Binaire:

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

Non assemblé:

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:

Entrez le décompte des pièces de départ DX, en SIpointant vers le début des octets "icône" (qui peuvent être '1'- '5', ou n'importe quelle valeur d'octet). Sortie le nombre de 1UP dans BX.

Explication:

L'entrée de quatre octets est itérée et comparée aux octets restants à droite, en comptant le nombre de correspondances. Les scores pour chaque type de match sont attribués et totalisent. Puisqu'un quatre-de-un-type est également trois-de-un-type et aussi une paire, la valeur de chaque type de score peut être décomposée comme suit:

• 3 matchs = 4 1UP + 77 pièces
• 2 matchs = 2 1UP
• 1 match = 1 1UP

Exemples:

[2, 2, 2, 2] (quatre pièces uniques) = 7 1UP + 77 pièces

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] (trois en un) = 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] (deux paires) = 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] (une paire) = 1 1UP

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

Si le nombre de 1UP gagnés est de 0 à la fin, 10 pièces sont attribuées. Si le nombre total de pièces est supérieur à 100, un 1UP supplémentaire est attribué.

Voici un programme de test pour PC DOS qui comprend des routines supplémentaires pour gérer les E / S de valeur entière:

Téléchargez et testez LUCKY.COM pour DOS.

Gelée ,  23 22 20  19 octets

-1 grâce à Erik l'Outgolfer (utiliser ³à la place de ȷ2) également utilisé deux fois dans la version plus récente
-1 grâce à Grimy (soustrayez-en un avant de sommer au lieu de soustraire quatre après)

^{Peut-être battable?}

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

Un lien dyadique acceptant une liste et un entier qui donne un entier.

Essayez-le en ligne! Ou consultez une suite de tests .

Comment?

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

Fonctionnement de l'évaluation des mains pour chaque type de main:

           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

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

Zsh , 117 ... 60 octets

-13 en utilisant un critère différent pour la différenciation, -9 en combinant les cas, -28 en changeant l' caseinstruction en un ternaire arithmétique imbriqué, -4 grâce à @JonathanAllan, -1 en optimisant les ternaires, -2 parce que j'ai accidentellement utilisé echolors de l'ajout Optimisation de Jonathan.

Prend le nombre de pièces sur stdin et bloque les entrées comme arguments. Les arguments peuvent être des nombres, des caractères ou même des chaînes:./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]

Essayez en ligne: 117 104 95 67 63 62 60

Voici la magie de la réponse de 67 octets:

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 octets

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

Un port de ma réponse python, qui est dérivé de la réponse de @ Dat.

Essayez-le en ligne!

Python 2 , 63 octets

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

Essayez-le en ligne!

J'ai eu la même idée que GammaFunction à utiliser sum(map(l.count,l))comme "empreinte digitale". Mais, au lieu d'utiliser une formule arithmétique sur le résultat, j'utilise une table de recherche, en écrasant d'abord la valeur de 0 à 4 à l'aide d'une chaîne de mod %14%5. La division de toutes les valeurs en points par 100 a permis d'économiser quelques octets.

Python 3 , 68 octets

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

Essayez-le en ligne!

Un port Python de mon port C de mon port Bash de ma réponse Zsh, re-joué avec l'aide de la page "Conseils pour jouer au golf en Python". Dernier port, je le jure ... Je suis à court de langues, je suis à l'aise pour jouer au golf. J'étais curieux de voir comment cette stratégie par rapport aux autres réponses Python. Encore une fois, il y a probablement un moyen de battre cela.

Celui-ci s'est révélé étonnamment bon, j'ai donc ajouté un tableau ci-dessous résumant ce qui se passe afin que d'autres puissent porter ou améliorer cela.

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é-version) , 63 octets

Louez le :=morse!

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

Essayez-le en ligne!

Perl 6 , 48 44 octets

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

Essayez-le en ligne!

Fonction curry f(icons)(coins).

Python 2 , 96 91 89 octets

-2 octets grâce à @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

Essayez-le en ligne!

PHP, 153 127 octets

@ 640KB a fait des changements vraiment intelligents pour le raccourcir encore:

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

Essayez-le en ligne!

Python 3 , 126 111 111 108 103 octets

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

Essayez-le en ligne!

Python 3.8 (pré-version) , 78 octets

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

La réponse de Dat, mais plus de golf.

Essayez-le en ligne!

Perl 5 -pF , 46 octets

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

Essayez-le en ligne!

La première entrée est le résultat de rotation, en utilisant 5 lettres ASCII uniques, sauf q(je suggèreabcde ). La deuxième ligne d'entrée est le nombre actuel de pièces.

Comment?

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

Tous les nombres impliqués sont divisés par 100, donc le programme compte le nombre de vies (y compris les vies partielles) actuellement gagnées. L'astuce pour cette solution est dans le map. Si les entrées possibles sont abcde, alors chacun $a, $b, $c, $det $etenir le compte du nombre de fois que ce personnage avait déjà été vu. Cela s'ajoute à un total cumulé ( $q) à chaque fois qu'un personnage est vu. Le total cumulé est augmenté s'il y en a quatre (en fait un bonus de 177 pièces).

JavaScript (Node.js) , 64 octets

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

Essayez-le en ligne!

Je pensais qu'il devait y avoir au moins une réponse JavaScript à un défi Arnauld!

Le concept ici est principalement d'utiliser le nombre d'éléments distincts comme clé de recherche.

• 1 unique => 4 d'une sorte
• 2 uniques => 2 paires ou 3 d'un genre
• 3 uniques => 1 paire
• 4 uniques => pas de correspondances

Afin de faire la distinction entre 2 paires et 3 paires, le tableau d'entrée est trié et les 2 éléments du milieu sont comparés.

PHP ,89 84 octets

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

Essayez-le en ligne!

Entrée depuis la ligne de commande, sortie vers STDOUT:

$ php lucky.php 99 3333
8

$ php lucky.php 0 2522
3

$ php lucky.php 0 abaa
3

Stax , 23 octets

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

Exécuter et déboguer

Ce programme utilise n'importe quel ensemble arbitraire de 5 entiers pour les icônes.

Procédure:

1. Additionnez le nombre d'occurrences de chaque élément.
2. Divisez par 2 puis mod 7.
3. Le résultat est un nombre compris entre 1 et 5. Utilisez-le pour rechercher le prix de la pièce dans un tableau fixe.
4. Ajoutez au nombre initial de pièces.
5. Divisez par 100.

Voici la sortie d'un visualiseur d'état de pile expérimental sur lequel j'ai travaillé pour la prochaine version de stax. Il s'agit d'une version décompressée du même code avec l'état de la pile ajouté aux commentaires.

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] 

Exécutez celui-ci

Retina 0.8.2 , 72 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Prend la saisie sous forme de 4 chiffres ASCII imprimables suivis du nombre initial de pièces en chiffres. Explication:

O`\D

Triez les non-chiffres afin que les symboles identiques soient regroupés.

(\D)\1{3}
777¶

Quatre en un 777.

(\D)\1\1
300¶

Trois pièces uniques 300.

(\D)\1
100¶

Chaque paire marque 100, donc deux paires marqueront 200.

\D{4}
10¶

S'il n'y a pas eu de matchs, vous gagnez quand même!

\d+\D*
$*

Convertissez les valeurs en unaire et prenez la somme.

1{100}

Entier divisez la somme par 100 et reconvertissez en décimal.

Rétine , 56 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Prend la saisie sous forme de 4 chiffres ASCII imprimables suivis du nombre initial de pièces en chiffres. Explication:

(\D)\1{3}
777¶

Quatre en un 777.

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

Chaque paire obtient un score de 100. Le wprend toutes les paires en considération, de sorte qu'elles peuvent être entrelacées, plus trois du genre peuvent être décomposées en trois paires, obtenant ainsi automatiquement 300 points.

\D{4}
10¶

S'il n'y a pas eu de matchs, vous gagnez quand même!

\d+\D*
*

Convertissez les valeurs en unaire et prenez la somme.

_{100}

Entier divisez la somme par 100 et reconvertissez en décimal.

APL + WIN, 42 octets

Demande des icônes suivies du stock de pièces.

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

Essayez-le en ligne! Gracieuseté de Dyalog Classic

Bash , 76 75 71 70 octets

-4 merci à @JonathanAllan, -1 en réorganisant le ternaire.

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

Port bash de ma réponse Zsh. Essayez-le en ligne! Essayez-le en ligne! Essayez-le en ligne! Essayez-le en ligne!

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

-1 par x+=(..!=..) -5 en revenant par affectation , -4 merci à Jonathan Allan en remplaçant !=par< , ce qui économise des octets ailleurs, -1 en réorganisant le ternaire.

De @ceilingcat: -2 en déclarant iet en xdehors de la fonction, -1 en définissantx=i et décrémentant à la xplace.

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 autre port de ma réponse Zsh. Je ne suis pas familier avec le golf C, il y a probablement un autre truc quelque part ici pour le réduire davantage. 92 84 82 81 79 Essayez-le en ligne!

05AB1E , 20 19 18 octets

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

Port de la réponse Jelly de @JonathanAllan , alors assurez-vous de lui donner un vote positif !!
-2 octets grâce à @Grimy .

Prend la liste des icônes comme première entrée (étant [1,2,3,4,5] ) et la quantité de pièces comme deuxième entrée.

Essayez-le en ligne ou vérifiez tous les cas de test . (La suite de tests utilise T‚à+au lieu de TMI+, qui est une alternative à octets égaux.)

Explication:

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 octets

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

Essayez-le en ligne!

Fusain , 30 octets

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

Essayez-le en ligne!Le lien est vers la version détaillée du code. Prend l'entrée comme le nombre de pièces et un tableau de toutes les valeurs comparables Python sous forme d'icônes. Explication:

≔⊘ΣＥη№ηιη

Voler sans vergogne l'astuce de @ GammaFunction de calculer la moitié de la somme des comptes.

⁻η∕²∨›⁸η⁹

Soustrayez 2de la somme, ce qui donne les valeurs 0, 1, 2, 3appropriées, mais pour 4-of-a-kind, divisez le 2par d' 9abord, ce qui donne7.777... .

∨...∕¹χ

Mais si le résultat est 0, il n'y a pas de correspondance, remplacez-le par 0.1 place. (L'utilisation d'un littéral ne m'aide pas ici car j'aurais besoin d'un séparateur.)

Ｉ⌊⁺∕θ¹⁰⁰...

Divisez les pièces initiales par 100 et ajoutez les gains, puis fixez le résultat et convertissez-le en chaîne pour une sortie implicite.

Pyth , 32 octets

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

Essayez-le en ligne!

Inspiré par la solution de GammaFunction. Prend l'entrée comme [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 octets

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

Essayez-le en ligne!

Déroulé:

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 octets

^{-7 octets grâce à 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'\..*'

Essayez-le en ligne!

Une grande opération ternaire aromatisée PowerShell basée sur le regroupement et le tri des comptes de la liste d'entrée. Le tri est nécessaire car nous tirons parti du fait que la liste groupée se raccourcit au fur et à mesure des répétitions. En fait, voici toutes les valeurs possibles:

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

La troncature en int est toujours coûteuse.

Déroulé:

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 octets

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

Essayez-le en ligne!

R, 102 , 91 , 81 octets

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

Géré pour supprimer 11 octets (et corriger un bogue) grâce à @Giuseppe. Géré 10 autres inspirés par l'idée de @ Giuseppe / 10.

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

Essayez-le en ligne!

8051 Assembly (compile en 158 octets)

Ceci est une approche naïve VEEEEEEEEEERRY, ce n'est pas encore testé et non golfé mais je suis assez confiant qui fonctionne. Les choses à considérer sont:

1) le 8051 est une machine à accumulateur ie. il a besoin d'instructions mov dont d'autres architectures peuvent ne pas avoir besoin du tout.

2) le 8051 est une machine à 8 bits, il faut donc faire quelque ruse pour les nombres> 255, ce qui fait plus de code et est donc un inconvénient de la plate-forme par rapport aux autres.

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