Super Mario 3D World'de Lucky House olarak bilinen bir mini oyun var . 4 bloklu bir slot makinesinden oluşur.

Her blok 5 farklı ikondan biri olabilir (Çiçek, Yaprak, Çan, Kiraz veya Bumerang) ve oyuncunun amacı mümkün olduğu kadar özdeş ikonlar elde etmektir ( bir videoya bakın ).

Oyuncu, karşılığında ekstra hayatlara çevrilebilecek madeni paralarla ödüllendirilir. Göreviniz kazanılan fazladan hayat sayısını hesaplamak.

Eşleşen ikon sayısına bağlı olarak, ödüllendirilen jeton miktarı aşağıdaki gibidir:

• Eşleşme yok - 10 jeton
• Bir çift - 100 jeton
• İki çift - 200 jeton
• Üçlü - 300 jeton
• Dörtlü - 777 madeni para

Her 100 jetonda bir ekstra hayat (1UP) kazanırsınız . Bu nedenle, tam olarak sahip 1up kazanmak için garanti konum bir çift ile, 2UP iki çift ile ve 3UP 3-of-a-tür . Bununla birlikte, hiçbir eşleşme veya 4'lü tür kazanılmamış olan hayat sayısı, ilk madeni para stoğunuza bağlıdır.

_{Kaynak: Süper Mario Wiki}

Giriş

İlk jeton stoğuna $0 \le c < 100$ ve slot makinesindeki son ikonları temsil eden dört değerin bir listesi $[v_1,v_2,v_3,v_4]$ .

Çıktı

Kazanılan fazladan yaşam sayısı: $0$ ,$1$ ,$2$ ,$3$ ,$7$ veya$8$ .

kurallar

• Simgeleri makul herhangi bir biçimde alabilirsiniz: örneğin bir liste, bir dize veya 4 ayrı parametre.
• Her simge, tek basamaklı bir tam sayı veya tek bir karakter ile gösterilebilir . Lütfen cevabınızda kullanılan simge kümesini belirtin. (Ancak bunların Çiçek, Yaprak, Çan vb. İle nasıl eşleştirildiklerini açıklamanıza gerek yoktur, çünkü hiç önemli değil.)
• Çıkış değerlerini yeniden eşleştirmenize izin verilmiyor.
• Bu 🎰 kod golf 🎰.

Test durumları

Aşağıdaki örneklerde, simgeleri temsil etmek için $[1..5]$ tamsayı listesi kullanıyoruz .

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 Meclisi, 56 41 39 bayt

İkili:

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

unassembled:

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:

Giriş başlangıç ​​jeton sayımı DX ,SI (olabilir "simgesi" bayt başlamak işaret '1'- '5'veya herhangi bayt değeri). 1UP’ların sayısını girin BX.

Açıklama:

Dört baytın girişi yinelenir ve eşleşme sayısını sayarak kalan sağ baytla karşılaştırılır. Her bir eşleşme türü için puanlar verilir ve toplamı ekler. Dörtlü bir tür ayrıca üçlü ve aynı zamanda bir çift olduğundan, her bir puan türünün değeri aşağıdaki gibi ayrıştırılabilir:

• 3 eşleşme = 4 1UP's + 77 jeton
• 2 eşleşme = 2 1UP
• 1 eşleşme = 1 1UP

Örnekler:

[2, 2, 2, 2] (dörtlü) = 7 1UP's + 77 jeton

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] (üçlü) = 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] (iki çift) = 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] (bir çift) = 1 1UP

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

Kazanılan 1UP sayısı sonunda 0 ise, 10 jeton verilir. Toplam para 100'den büyükse, ek 1UP verilir.

İşte PC DOS için I / O tamsayı değerini işlemek için fazladan rutinler içeren bir test programı:

DOS için LUCKY.COM'u indirin ve test edin .

Jöle ,  23 22 20  19 bayt

-1 The Outgolfer sayesinde ( ³yerine ȷ2kullanılır) ayrıca yeni sürümde iki kez de kullanılır
-1 Güvenlik çok kötü (toplayarak yerine sonradan dört çıkarılarak önce bir çıkarma)

^{Belki dövülebilir?}

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

Bir listeyi ve tamsayı veren bir tamsayıyı kabul eden ikili bir Bağlantı.

Çevrimiçi deneyin! Veya bir test odasına bakın .

Nasıl?

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

El değerlendirmesi, her el tipi için nasıl çalışır:

           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

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

Zsh , 117 ... 60 bayt

-13 , farklılaşma için farklı bir kriter kullanılarak -9 , olgu birleştirerek -28 değiştirerek case, iç içe geçmiş bir aritmetik üçlü deyimi -4 sayesinde @JonathanAllan için, -1 , ternaries optimize ederek -2 yanlışlıkla kullandığı içinecho eklerken Jonathan'ın optimizasyonu.

Stdin'de jeton sayımı alır ve girdileri argüman olarak engeller. Bağımsız değişkenler sayılar, karakterler veya hatta dizeler olabilir:./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]

Çevrimiçi deneyin: 117 104 95 67 63 62 60

İşte 67 byte cevabındaki sihir:

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 # Etkileşimli Derleyici) , 123 106 90 bayt

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

Python cevabımın limanı @ Dat'ın cevabından türetilmiş

Çevrimiçi deneyin!

Python 2,63 bayt

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

Çevrimiçi deneyin!

GammaFunction ile aynı sum(map(l.count,l))"parmak izi" olarak kullanmak için aynı fikre sahiptim . Ancak, sonuçta aritmetik bir formül kullanmak yerine, önce bir mod zinciri kullanarak değeri 0 ile 4 arasında susturan bir arama tablosu kullanıyorum %14%5. Tüm nokta değerlerini 100'e bölerek birkaç bayt kaydedildi.

Python 3 , 68 bayt

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

Çevrimiçi deneyin!

Zsh cevabımın Bash portumun C portumun bir Python portu, "Python'da golf oynamak için ipuçları" sayfasından yardım alarak tekrar golf oynadı. Son liman, yemin ederim ... Golf oynamaktan hoşlandığım dilleri tükeniyor. Diğer Python cevaplarına kıyasla bu stratejinin ne olduğunu merak ediyordum. Yine, muhtemelen bunu yenmenin bir yolu var.

Bu, şaşırtıcı derecede iyi çıktı, bu yüzden başkalarının neler yapabileceğini veya iyileştirebileceğini özetleyen bir tablo ekledim.

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 (yayın öncesi) , 63 bayt

Deniz aygırı övün :=!

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

Çevrimiçi deneyin!

Perl 6 , 48 44 bayt

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

Çevrimiçi deneyin!

Körili işlevi f(icons)(coins).

Python 2 , 96 91 89 bayt

@Kevin Cruijssen sayesinde -2 bayt

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

Çevrimiçi deneyin!

PHP, 153 127 bayt

@ 640KB daha da kısaltmak için bazı akıllı değişiklikler yaptı:

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

Çevrimiçi deneyin!

Python 3 , 126 111 108 103 bayt

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

Çevrimiçi deneyin!

Python 3.8 (yayın öncesi) , 78 bayt

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

Dat'ın cevabı, fakat daha çok golf oynadı.

Çevrimiçi deneyin!

Perl 5 -pF , 46 bayt

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

Çevrimiçi deneyin!

Girişin ilk dışında herhangi 5 benzersiz bir ASCII harfler kullanılarak, spin sonucudur qÖnerim (abcde ) . İkinci girdi satırı mevcut jeton sayımıdır.

Nasıl?

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

İlgili sayıların tümü 100'e bölünmüştür, bu nedenle program şu anda kazanılan yaşam sayısını (kısmi olanlar dahil) saymaktadır. Bu çözümün püf noktası map. Olası girişler varsa abcde, o zaman her birinin $a, $b, $c, $d, ve $ebu karakter, daha önce görülenden kaç kez sayısını tutun. Bu toplam çalışanlara eklenir ($q bir karakter her görüldüğünde ) . Eğer dördüncüsü varsa (toplamda 177 jeton bonusu) koşu toplamı çarpılır.

JavaScript (Node.js) , 64 bayt

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

Çevrimiçi deneyin!

Arnauld meydan okumasına en az bir JavaScript cevabı olması gerektiğini düşündüm!

Buradaki kavram, esas olarak, farklı unsurların sayısını bir arama anahtarı olarak kullanmaktır.

• 1 benzersiz => bir tür 4
• 2 benzersiz => 2 çift veya 3 tür
• 3 benzersiz => 1 çift
• 4 benzersiz => eşleşme yok

2 çift ve 3 tür arasında bir ayrım yapmak için, giriş dizisi sıralanır ve orta 2 eleman karşılaştırılır.

PHP ,89 84 bayt

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

Çevrimiçi deneyin!

Komut satırından giriş, çıkış STDOUT:

$ php lucky.php 99 3333
8

$ php lucky.php 0 2522
3

$ php lucky.php 0 abaa
3

Stax , 23 bayt

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

Koş ve hata ayıkla

Bu program, simgeler için herhangi bir 5 tamsayı kümesi kullanır.

Prosedür:

1. Her elemanın oluşum sayısını toplayın.
2. 2'ye bölün ve ardından mod 7.
3. Sonuç, 1 ile 5 arasında bir sayıdır. Bozuk para ödülünü sabit bir dizide aramak için bunu kullanın.
4. İlk jeton sayımına ekleyin.
5. 100'e bölün.

İşte stax'ın bir sonraki sürümü için üzerinde çalıştığım deneysel bir yığın durumu görselleştiricisinin çıktısı. Bu, yorumlara eklenen yığın durumuyla aynı kodun paketlenmemiş bir sürümüdür.

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] 

Bunu çalıştır

Retina 0.8.2 , 72 bayt

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Girdiyi basılabilir 4 ASCII olmayan basamak, ardından ilk basılan para sayısı olarak alır. Açıklama:

O`\D

Rakam olmayan rakamları, aynı semboller birlikte gruplanacak şekilde sıralayın.

(\D)\1{3}
777¶

Dörtlü skorlar 777.

(\D)\1\1
300¶

Üçlü skorlar 300.

(\D)\1
100¶

Her çift 100 puan alır, böylece iki çift 200 puan alır.

\D{4}
10¶

Kibrit yoksa o zaman hala kazanırsın!

\d+\D*
$*

Değerleri birliğe dönüştürün ve toplamı alın.

1{100}

Tamsayı, toplamı 100'e böler ve tekrar ondalık basamağa dönüştürür.

Retina , 56 bayt

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Girdiyi basılabilir 4 ASCII olmayan basamak, ardından ilk basılan para sayısı olarak alır. Açıklama:

(\D)\1{3}
777¶

Dörtlü skorlar 777.

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

Her bir çift 100 puan walır. Bütün çiftleri hesaba katarlar, böylece birleştirilebilirler, artı üçlü üç çift halinde ayrıştırılabilir ve böylece otomatik olarak 300 puan kazanabilir.

\D{4}
10¶

Kibrit yoksa o zaman hala kazanırsın!

\d+\D*
*

Değerleri birliğe dönüştürün ve toplamı alın.

_{100}

Tamsayı, toplamı 100'e böler ve tekrar ondalık basamağa dönüştürür.

APL + WIN, 42 bayt

Madeni para stoku tarafından takip edilen ikonlar için bilgi istemi.

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

Çevrimiçi deneyin! Dyalog Classic'in İzniyle

Bash , 76 75 71 70 bayt

-4 @JonathanAllan sayesinde, -1 üçgeni yeniden düzenleyerek.

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

Zsh cevabımın Bash limanı. Çevrimiçi deneyin! Çevrimiçi deneyin! Çevrimiçi deneyin! Çevrimiçi deneyin!

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

-1 ile x+=(..!=..) -5 ile ataması dönen , -4 Jonathan Allan sayesinde yerine !=sahip <başka bir yerde, bayt kazandırır, -1 ve üçlü yeniden düzenleyerek.

@Ceilingcat itibaren: -2 bildirerek ive xişlev dışında, -1 ayarlayarak x=ive azalan xyerine.

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

Zsh cevabımın başka bir limanı. C golf oynamaya aşina değilim, muhtemelen daha fazla azaltmak için burada bir yerlerde başka bir numara var. 92 84 82 81 79 Online deneyin!

05AB1E , 20 19 18 bayt

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

Liman içinde @JonathanAllan 'ın Jelly cevap , çok emin onu upvote yapmak !! @Grimy
sayesinde -2 bayt .

Simgelerin listesini ilk girdi (varlık [1,2,3,4,5]) ve ikinci girdi olarak jeton miktarını alır.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın . (Test paketi T‚à+yerine TMI+eşit baytlık bir alternatif kullanır.)

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Kömür , 30 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Girdiyi sikke sayısı olarak ve herhangi bir Python karşılaştırılabilir değerin dizisini simge olarak alır. Açıklama:

≔⊘ΣＥη№ηιη

Utanmadan @ GammaFunction'ın sayma toplamının yarısını hesaplama hilesini çaldı.

⁻η∕²∨›⁸η⁹

Çıkarma 2, böylece değerleri ile sonuçlanır toplamından 0, 1, 2, 3uygun, ancak 4-a-türü için, bölme 2ile 9sonuçlanan ilk 7.777....

∨...∕¹χ

Fakat sonuç 0 ise, o zaman eşleşme yoktu, bunun yerine bununla değiştirin 0.1. (Bir hazır bilgiyi kullanmak bana burada yardımcı olmaz, çünkü bir ayırıcıya ihtiyacım olacak.)

Ｉ⌊⁺∕θ¹⁰⁰...

İlk paraları 100'e bölün ve kazancınızı ekleyin, ardından sonucu döşeyin ve örtük çıktılar için dizgiye aktarın.

Pyth , 32 bayt

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

Çevrimiçi deneyin!

GammaFunction'ın çözümünden ilham aldı. Girişi olarak alır [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 bayt

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

Çevrimiçi deneyin!

unrolled:

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 bayt

^{Mazzy sayesinde -7 bayt}

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

Çevrimiçi deneyin!

Giriş listesindeki sayıları gruplama ve sıralama üzerine kurulu büyük bir PowerShell aromalı üçlü operasyon. Sıralama gerekli çünkü gruplandırılmış listenin kısaldığı gerçeğinden faydalanıyoruz. Aslında, işte tüm olası değerler:

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

Bir int için kesmek hala pahalıdır.

unrolled:

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 Dili (Mathematica) , 54 bayt

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

Çevrimiçi deneyin!

R, 102 , 91 , 81 bayt

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

@Giuseppe sayesinde 11 byte bırakmayı (ve bir hatayı düzeltmeyi) başardı. @ Giuseppe'nin / 10 fikrinden esinlenerek 10 kişi daha yönetti.

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
}

Çevrimiçi deneyin!

8051 Assembly (158 bayt için derlenir)

Bu bir VEEEEEEEEEERRY saf yaklaşımı, bu henüz denenmemiş ve asılmamış fakat çalıştığından eminim. Dikkate alınacak şeyler:

1) 8051 bir akümülatör makinasıdır yani. diğer mimarilerin hiç ihtiyaç duymayacağı mov talimatlara ihtiyacı var.

2) the 8051 is an 8bit machine therefor there has to be done some trickery for the numbers >255 which makes for more code and is therefor a disadvantage of the platform over the others.

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