In Super Mario 3D World gibt es ein Minispiel, das als Lucky House bekannt ist . Es besteht aus einem Spielautomaten mit 4 Blöcken.

Jeder Block kann aus 5 verschiedenen Symbolen bestehen (Blume, Blatt, Glocke, Kirsche oder Bumerang). Ziel des Spielers ist es, so viele identische Symbole wie möglich zu erhalten ( siehe Video ).

Der Spieler wird mit Münzen belohnt, die wiederum in Extraleben umgewandelt werden können. Ihre Aufgabe ist es, die Anzahl der gewonnenen Extraleben zu berechnen.

Abhängig von der Anzahl der übereinstimmenden Symbole werden folgende Münzen belohnt:

• Keine Treffer - 10 Münzen
• Ein Paar - 100 Münzen
• Zwei Paare - 200 Münzen
• Drei-von-einer-Art - 300 Münzen
• Four-of-a-kind - 777 Münzen

Sie gewinnen ein Extraleben (1UP) pro 100 Münzen . Somit gewinnen Sie garantiert genau 1UP mit einem Paar , 2UP mit zwei Paaren und 3UP mit 3-of-a-kind . Die Anzahl der gewonnenen Leben ohne Matches oder 4-of-a-Kind hängt jedoch von Ihrem ursprünglichen Münzbestand ab.

_{Quelle: Super Mario Wiki}

Eingang

Sie erhalten den anfänglichen Münzbestand $0 \le c < 100$ und eine Liste mit vier Werten $[v_1,v_2,v_3,v_4]$ die die letzten Symbole des Spielautomaten darstellen.

Ausgabe

Die Anzahl der gewonnenen Extraleben: $0$ , $1$ , $2$ , $3$ , $7$ oder $8$ .

Regeln

• Sie können die Symbole in jedem vernünftigen Format verwenden: z. B. als Liste, als Zeichenfolge oder als vier verschiedene Parameter.
• Jedes Symbol kann entweder durch eine einstellige Ganzzahl oder ein einzelnes Zeichen dargestellt werden . Bitte geben Sie die in Ihrer Antwort verwendeten Symbole an. (Aber Sie müssen nicht erklären, wie sie auf Blume, Blatt, Glocke usw. abgebildet sind, weil es überhaupt keine Rolle spielt.)
• Sie dürfen die Ausgabewerte nicht neu zuordnen.
• Dies ist " Code-Golf ".

Testfälle

In den folgenden Beispielen verwenden wir eine Liste von Ganzzahlen in $[1..5]$ , um die Symbole darzustellen.

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-Baugruppe, 56 41 39 Bytes

Binär:

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

Zerlegt:

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:

Geben Sie die Anzahl der Startmünzen ein DXund SIzeigen Sie auf den Beginn der "Symbol" -Bytes (dies kann '1'- '5'oder ein beliebiger Byte-Wert sein). Geben Sie die Anzahl der 1UPs in aus BX.

Erläuterung:

Die Eingabe von vier Bytes wird iteriert und mit den verbleibenden Bytes rechts verglichen, wobei die Anzahl der Übereinstimmungen gezählt wird. Die Punktzahlen für jede Art von Match werden vergeben und addieren sich zur Gesamtsumme. Da ein Four-of-a-Kind auch ein Three-of-a-Kind und ein One-Pair ist, kann der Wert jedes Score-Typs wie folgt zerlegt werden:

• 3 Übereinstimmungen = 4 1UP + 77 Münzen
• 2 Übereinstimmungen = 2 1UP's
• 1 Übereinstimmung = 1 1UP

Beispiele:

[2, 2, 2, 2] (Vierling) = 7 1UP's + 77 Münzen

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] (Drei-von-einer-Art) = 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] (zwei Paare) = 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] (ein Paar) = 1 1UP

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

Wenn die Anzahl der verdienten 1UPs am Ende 0 ist, werden 10 Münzen vergeben. Wenn die Gesamtzahl der Münzen 100 übersteigt, wird zusätzlich 1UP gutgeschrieben.

Hier ist ein Testprogramm für PC-DOS, das zusätzliche Routinen für die Verarbeitung der Ganzzahl-E / A enthält:

Laden Sie LUCKY.COM für DOS herunter und testen Sie es .

Jelly ,  23 22 20  19 Bytes

-1 dank Erik der Outgolfer ( ³anstelle von verwenden ȷ2) auch in neuerer Version zweimal verwendet
-1 dank Grimy (subtrahiere eins vor der Summierung statt subtrahiere vier danach)

^{Vielleicht schlagbar?}

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

Ein dyadischer Link, der eine Liste und eine Ganzzahl akzeptiert, die eine Ganzzahl ergibt.

Probieren Sie es online! Oder sehen Sie sich eine Testsuite an .

Wie?

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

So funktioniert die Handbewertung für jeden Handtyp:

           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 Bytes

-13 durch Verwenden eines anderen Unterscheidungskriteriums, -9 durch Kombinieren von Fällen, -28 durch Ändern der caseAnweisung in einen verschachtelten arithmetischen Ternär, -4 dank @JonathanAllan, -1 durch Optimieren der Ternäre, -2 weil ich versehentlich verwendet habeecho beim Hinzufügen verwendet habe Jonathans Optimierung.

Übernimmt die Münzzählung für stdin und blockiert Eingaben als Argumente. Argumente können Zahlen, Zeichen oder sogar Zeichenfolgen sein:./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]

Versuchen Sie es online: 117 104 95 67 63 62 60

Hier ist die Magie der 67-Byte-Antwort:

read coins
for block                  # for each element
  (( a+=${#${@:#$block}} ))
#          ${@:#$block}      remove all elements which don't match
#       ${#            }     count the remaining elements
# (( a+=                 ))  add that number to the total
<<<$[a?(a-12?6-a/2:coins>89):7+(coins>22)]
#    a?                     :7+(coins>22)  4*0 (all elements match all elements)
#      (a-12?     :coins>89)               4*3 (all elements match exactly one)
#      (a-12?6-a/2         )               3*1 + 1*3 ->  6, 6 -  6/2 -> 3
#                                          2*2 + 2*2 ->  8, 6 -  8/2 -> 2
#                                          2*3 + 2*2 -> 10, 6 - 10/2 -> 1

C # (Visual C # Interactive Compiler) , 123 106 90 Byte

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

Ein Port meiner Python-Antwort, der sich aus der Antwort von @ Dat ableitet.

Probieren Sie es online!

Python 2 , 63 Bytes

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

Probieren Sie es online!

Ich hatte die gleiche Idee wie GammaFunction zu verwenden , sum(map(l.count,l))als „Fingerabdruck“. Aber anstatt eine arithmetische Formel für das Ergebnis zu verwenden, verwende ich eine Nachschlagetabelle, indem ich den Wert zuerst mit einer Mod-Kette auf 0 bis 4 zerquetsche %14%5. Durch Teilen aller Punktwerte durch 100 wurden einige Bytes gespart.

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]

Probieren Sie es online!

Ein Python-Port von meinem C-Port von meinem Bash-Port von meiner Zsh-Antwort, neu golfen mit Hilfe der Seite "Tipps zum Golfen in Python". Letzter Hafen, ich schwöre ... mir gehen die Sprachen aus, in denen ich gerne Golf spiele. Ich war neugierig, wie diese Strategie im Vergleich zu den anderen Python-Antworten ist. Auch hier gibt es wahrscheinlich einen Weg, dies zu schlagen.

Dieser hat sich als überraschend gut erwiesen, daher habe ich unten eine Tabelle hinzugefügt, in der zusammengefasst ist, was passiert, damit andere dies portieren oder verbessern können.

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 (Vorabversion) , 63 Byte

Lobe das :=Walross!

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

Probieren Sie es online!

Perl 6 , 48 44 Bytes

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

Probieren Sie es online!

Curry-Funktion f(icons)(coins).

Python 2 , 96 91 89 Bytes

-2 Bytes dank @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

Probieren Sie es online!

PHP, 153 127 Bytes

@ 640KB hat einige wirklich clevere Änderungen vorgenommen, um es weiter zu verkürzen:

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

Probieren Sie es 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

Probieren Sie es online!

Python 3.8 (Vorabversion) , 78 Byte

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

Dat antwortete, spielte aber mehr.

Probieren Sie es online!

Perl 5 -pF , 46 Bytes

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

Probieren Sie es online!

Als erstes wird das Spinergebnis mit 5 eindeutigen ASCII - Buchstaben ausgegeben, mit Ausnahme von q(Ich schlage vorabcde ) . Die zweite Eingabezeile ist die aktuelle Münzzahl.

Wie?

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

Alle beteiligten Zahlen werden durch 100 geteilt, sodass das Programm die Anzahl der aktuell verdienten Leben (einschließlich der Teilleben) zählt. Der Trick zu dieser Lösung liegt in der map. Wenn die möglichen Einträge sind abcde, dann jeweils $a, $b, $c, $d, und $ehalten Sie die Zählung der Anzahl , wie oft hatte dieser Charakter vorher gesehen worden. Dies wird $qjedes Mal, wenn ein Charakter gesehen wird, zu einer laufenden Summe ( ) hinzugefügt . Die laufende Summe wird erhöht, wenn es einen Vierling gibt (effektiv ein Bonus von 177 Münzen).

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

Probieren Sie es online!

Ich dachte, es müsste mindestens eine JavaScript-Antwort auf eine Arnauld-Herausforderung geben!

Das Konzept hier besteht hauptsächlich darin, die Anzahl unterschiedlicher Elemente als Nachschlageschlüssel zu verwenden.

• 1 Unikat => 4 Gleiche
• 2 Unikate => 2 Paare oder 3 Gleiche
• 3 einzigartig => 1 Paar
• 4 Unikate => keine Treffer

Um zwischen 2 Paaren und 3 einer Art zu unterscheiden, wird das Eingabearray sortiert und die mittleren 2 Elemente verglichen.

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;

Probieren Sie es online!

Eingabe von der Kommandozeile, Ausgabe an 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╓

Führen Sie es aus und debuggen Sie es

Dieses Programm verwendet einen beliebigen Satz von 5 Ganzzahlen für Symbole.

Verfahren:

1. Addieren Sie die Anzahl der Vorkommen jedes Elements.
2. Teilen Sie durch 2 und dann mod 7.
3. Das Ergebnis ist eine Zahl von 1..5. Verwenden Sie diese Option, um den Münzpreis in einer festen Reihenfolge nachzuschlagen.
4. Addiere die anfängliche Münzzählung.
5. Teilen Sie durch 100.

Hier ist die Ausgabe eines experimentellen Stack-State-Visualizers, an dem ich für die nächste Veröffentlichung von stax gearbeitet habe. Dies ist eine entpackte Version desselben Codes mit dem Stapelstatus, der den Kommentaren hinzugefügt wurde.

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] 

Führen Sie dieses aus

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}

Probieren Sie es online! Link enthält Testfälle. Nimmt die Eingabe als 4 druckbare ASCII-Nicht-Ziffern vor, gefolgt von der anfänglichen Anzahl von Münzen in Ziffern. Erläuterung:

O`\D

Sortieren Sie die Nicht-Ziffern so, dass identische Symbole zusammen gruppiert werden.

(\D)\1{3}
777¶

Four-of-a-Kind-Scores 777.

(\D)\1\1
300¶

Drei-Punkte-Punkte 300.

(\D)\1
100¶

Jedes Paar erhält 100 Punkte, zwei Paare erhalten also 200 Punkte.

\D{4}
10¶

Wenn es keine Spiele gäbe, gewinnst du trotzdem!

\d+\D*
$*

Wandle die Werte in unary um und nimm die Summe.

1{100}

Ganzzahl dividiert die Summe durch 100 und wandelt sie in eine Dezimalzahl um.

Netzhaut , 56 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Nimmt die Eingabe als 4 druckbare ASCII-Nicht-Ziffern vor, gefolgt von der anfänglichen Anzahl von Münzen in Ziffern. Erläuterung:

(\D)\1{3}
777¶

Four-of-a-Kind-Scores 777.

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

Jedes Paar erhält eine Punktzahl von 100. Dabei werden walle Paare berücksichtigt, so dass sie verschachtelt werden können. Außerdem können Drei-von-einer-Art-Paare in drei Paare zerlegt werden, wodurch automatisch eine Punktzahl von 300 erzielt wird.

\D{4}
10¶

Wenn es keine Spiele gäbe, gewinnst du trotzdem!

\d+\D*
*

Wandle die Werte in unary um und nimm die Summe.

_{100}

Ganzzahl dividiert die Summe durch 100 und wandelt sie in eine Dezimalzahl um.

APL + WIN, 42 Bytes

Eingabeaufforderungen für Symbole, gefolgt von Münzvorrat.

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

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic

Bash , 76 75 71 70 Bytes

-4 danke an @JonathanAllan, -1 durch Neuordnung des Ternärs .

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

Bash Port meiner Zsh Antwort. Probieren Sie es online! Probieren Sie es online! Probieren Sie es online! Probieren Sie es online!

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

-1 mal x+=(..!=..) -5 durch Zurücksenden per Zuweisung , -4 dank Jonathan Allan durch Ersetzen !=durch <, was Bytes an anderer Stelle spart, -1 durch Neuanordnen des Ternären.

Von @ceilingcat: -2 durch Deklarieren iund xaußerhalb der Funktion, -1 durch Setzen x=iund Dekrementieren 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);}

Ein weiterer Port meiner Zsh-Antwort. Ich bin mit C-Golf nicht vertraut, es gibt wahrscheinlich irgendwo einen anderen Trick, um ihn weiter zu reduzieren. 92 84 82 81 79 Online ausprobieren!

05AB1E , 20 19 18 Bytes

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

Port of @JonathanAllan 's Jelly antworte , also stelle sicher, dass du ihn positiv bewertest !!
-2 Bytes dank @Grimy .

Nimmt die Liste der Symbole als erste Eingabe (Wesen [1,2,3,4,5]) und die Anzahl der Münzen als zweite Eingabe.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle . (Die Testsuite verwendet T‚à+stattdessen TMI+, was eine Alternative mit gleichen Bytes darstellt.)

Erläuterung:

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

Probieren Sie es online!

Kohle , 30 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Nimmt Eingaben als Anzahl der Münzen und ein Array beliebiger Python-Vergleichswerte als Symbole. Erläuterung:

≔⊘ΣＥη№ηιη

Stehlen Sie schamlos den Trick von @ GammaFunction, die Hälfte der Anzahl zu berechnen.

⁻η∕²∨›⁸η⁹

Subtrahieren Sie 2von der Summe und erhalten Sie die 0, 1, 2, 3entsprechenden Werte. Teilen Sie bei einem Vierling das Ergebnis 2durch das 9erste, was zur Folge hat 7.777....

∨...∕¹χ

Wenn das Ergebnis jedoch 0 ist, wurden keine Übereinstimmungen gefunden. Ersetzen Sie es 0.1stattdessen durch. (Die Verwendung eines Literal hilft mir hier nicht, da ich ein Trennzeichen benötigen würde.)

Ｉ⌊⁺∕θ¹⁰⁰...

Teilen Sie die Anfangsmünzen durch 100 und addieren Sie die Gewinne. Setzen Sie dann das Ergebnis auf den Boden und setzen Sie es für die implizite Ausgabe in einen String um.

Pyth , 32 Bytes

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

Probieren Sie es online!

Inspiriert von der GammaFunction-Lösung. Übernimmt die Eingabe als [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'..$')

Probieren Sie es online!

Abgerollt:

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

Probieren Sie es online!

Eine große alte ternäre Operation mit PowerShell-Charakter, die auf dem Gruppieren und Sortieren der Anzahl der Eingaben basiert. Die Sortierung wird benötigt, da wir die Tatsache nutzen, dass die gruppierte Liste umso kürzer wird, je mehr Wiederholungen vorhanden sind. In der Tat sind hier alle möglichen Werte:

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

Das Abschneiden auf ein int ist immer noch teuer.

Abgerollt:

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

Probieren Sie es 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)

Es ist gelungen, dank @Giuseppe 11 Bytes zu löschen (und einen Fehler zu beheben). Weitere 10 wurden von der Idee von @ Giuseppe / 10 inspiriert.

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
}

Probieren Sie es online!

8051 Assembly (kompiliert auf 158 Bytes)

Dies ist ein VEEEEEEEEEERRY naiver Ansatz, dies ist noch ungetestet und ungolfed, aber ich bin ziemlich zuversichtlich, dass das funktioniert. Dinge zu beachten sind:

1) der 8051 ist eine Akkumulatormaschine dh. Es werden mov-Anweisungen benötigt, die andere Architekturen möglicherweise gar nicht benötigen.

2) Die 8051 ist eine 8-Bit-Maschine, daher müssen einige Tricks für die Zahlen> 255 ausgeführt werden, was zu mehr Code führt und daher einen Nachteil der Plattform gegenüber den anderen darstellt.

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