В Super Mario 3D World есть мини-игра, известная как Счастливый Дом . Он состоит из игрового автомата с 4 блоками.

Каждый блок может представлять собой одну из 5 различных иконок («Цветок», «Лист», «Колокольчик», «Вишня» или «Бумеранг»), и цель игрока - получить как можно больше одинаковых иконок ( см. Видео ).

Игрок награждается монетами, которые в свою очередь могут быть превращены в дополнительные жизни. Ваша задача - вычислить количество выигранных дополнительных жизней.

В зависимости от количества соответствующих значков количество вознаграждаемых монет выглядит следующим образом:

• Нет совпадений - 10 монет
• Одна пара - 100 монет
• Две пары - 200 монет
• Три в своем роде - 300 монет
• Четверка - 777 монет

Вы выигрываете одну дополнительную жизнь (1UP) каждые 100 монет . Таким образом, вы гарантированно выиграете ровно 1UP с одной парой , 2UP с двумя парами и 3UP с 3 в своем роде . Тем не менее, количество жизней, выигранных без матчей или 4 в своем роде, зависит от вашего начального запаса монет.

_{Источник: Супер Марио Вики}

вход

Вам дан исходный запас монет $0 \le c < 100$ и список из четырех значений $[v_1,v_2,v_3,v_4]$ представляющих последние значки на игровом автомате.

Выход

Число дополнительных выигранных жизней: $0$ , $1$ , $2$ , $3$ , $7$ или $8$ .

правила

• Вы можете использовать значки в любом приемлемом формате: например, в виде списка, в виде строки или в качестве 4 различных параметров.
• Каждый значок может быть представлен либо однозначным целым числом, либо одним символом . Пожалуйста, укажите набор иконок, используемых в вашем ответе. (Но вам не нужно объяснять, как они отображаются на Flower, Leaf, Bell и т. Д., Потому что это не имеет значения.)
• Вы не можете переназначить выходные значения.
• Это « код-гольф» .

Контрольные примеры

В следующих примерах мы используем список целых чисел в $[1..5]$ для представления значков.

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, 56 41 39 байт

Binary:

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

разобранное:

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:

Введите начальное количество монет DX, SIуказывающее на начало байтов «значка» (которое может быть '1'- '5'или любое значение байта). Выведите количество 1UP в BX.

Объяснение:

Ввод четырех байтов повторяется и сравнивается с остальными байтами справа, считая количество совпадений. Баллы за каждый тип матча присуждаются и складываются в общую сумму. Поскольку четверка в своем роде также является тройкой в ​​своем роде, а также в одной паре, значение каждого типа оценки можно разложить следующим образом:

• 3 матча = 4 1UP + 77 монет
• 2 матча = 2 1UP
• 1 матч = 1 1UP

Примеры:

[2, 2, 2, 2] (четыре в своем роде) = 7 1UP + 77 монет

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] (три в своем роде) = 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] (две пары) = 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] (одна пара) = 1 1UP

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

Если количество заработанных 1UP в конце игры равно 0, присуждается 10 монет. Если общее количество монет превышает 100, присуждается дополнительная 1UP.

Вот тестовая программа для ПК DOS, которая включает в себя дополнительные процедуры для обработки целочисленных значений ввода / вывода:

Скачайте и протестируйте LUCKY.COM для DOS.

Желе ,  23 22 20  19 байт

-1 благодаря Эрику Outgolfer (используется ³вместо ȷ2), также использовавшемуся в более новой версии дважды
-1 благодаря Грими ( вычтите одно до суммирования вместо вычитания четырех после)

^{Может быть, победим?}

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

Двоичная ссылка, принимающая список и целое число, которое дает целое число.

Попробуйте онлайн! Или посмотрите тестовый набор .

Как?

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

Как оценка рук работает для каждого типа рук:

           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

Альтернатива 20: ĠẈị“¡ıKĖ‘S×4+E{»⁵+:³

Zsh , 117 ... 60 байт

-13 с помощью другого критерия для дифференциации, -9 с помощью комбинирования падежей, -28 с помощью замены caseоператора на вложенную арифметическую троицу, -4 благодаря @JonathanAllan, -1 с помощью оптимизации троичностей, -2 потому что я случайно использовал echoпри добавлении Оптимизация Джонатана.

Принимает монету на счет stdin и блокирует входные данные в качестве аргументов. Аргументы могут быть числами, символами или даже строками:./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]

Попробуйте онлайн: 117 104 95 67 63 62 60

Вот волшебство из 67-байтового ответа:

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 #) , 123 106 90 байт

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

Порт моего ответа на Python, полученный из ответа @ Dat.

Попробуйте онлайн!

Python 2 , 63 байта

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

Попробуйте онлайн!

У меня была та же идея, что и GammaFunction, чтобы использовать ее sum(map(l.count,l))в качестве «отпечатка пальца». Но вместо того, чтобы использовать арифметическую формулу для результата, я использую справочную таблицу, сначала уменьшая значение до 0-4, используя цепочку модов %14%5. Разделив все значения точек на 100, вы сэкономили несколько байтов.

Python 3 , 68 байт

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

Попробуйте онлайн!

Порт Python моего C-порта моего Bash-порта с моим ответом Zsh, измененный с помощью страницы «Советы по игре в гольф на Python». Последний порт, я клянусь ... У меня заканчиваются языки, в которых мне удобно играть в гольф. Мне было любопытно, как эта стратегия сравнивается с другими ответами Python. Опять же, возможно, есть какой-то способ победить это.

Этот получился на удивление хорошим, поэтому я добавил таблицу ниже, обобщающую то, что происходит, чтобы другие могли портировать или улучшить это.

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 (предварительная версия) , 63 байта

Хвала :=моржу!

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

Попробуйте онлайн!

Perl 6 , 48 44 байта

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

Попробуйте онлайн!

Функция карри f(icons)(coins).

Python 2 , 96 91 89 байт

-2 байта благодаря @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

Попробуйте онлайн!

PHP, 153 127 байт

@ 640KB внес некоторые действительно умные изменения, чтобы сократить его:

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

Попробуйте онлайн!

Python 3 , 126 111 108 103 байт

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

Попробуйте онлайн!

Python 3.8 (предварительная версия) , 78 байт

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

Dat ответ, но игра в гольф больше.

Попробуйте онлайн!

Perl 5 -pF , 46 байт

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

Попробуйте онлайн!

Первым из входных данных является результат вращения, использующий любые 5 уникальных букв ASCII, кроме q(я предлагаю abcde). Вторая строка ввода - текущее количество монет.

Как?

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

Все задействованные числа делятся на 100, поэтому программа рассчитывает количество жизней (включая частичные), заработанных в настоящее время. Хитрость к этому решению в map. Если возможные записи abcde, то каждый из $a, $b, $c, $dи $eпровести подсчет количества раз этот персонажем ранее видели. Это добавляется к текущему итогу ( $q) каждый раз, когда виден персонаж. Промежуточный итог увеличивается, если есть четыре вида (по сути, бонус в 177 монет).

JavaScript (Node.js) , 64 байта

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

Попробуйте онлайн!

Я подумал, что должен быть хотя бы один ответ JavaScript на вызов Арно!

Идея здесь в основном заключается в использовании количества различных элементов в качестве ключа поиска.

• 1 уникальный => 4 вида
• 2 уникальных => 2 пары или 3 вида
• 3 уникальных => 1 пара
• 4 уникальных => нет совпадений

Чтобы различать 2 пары и 3 вида, входной массив сортируется и сравниваются средние 2 элемента.

PHP ,89 84 байта

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

Попробуйте онлайн!

Ввод из командной строки, вывод в STDOUT:

$ php lucky.php 99 3333
8

$ php lucky.php 0 2522
3

$ php lucky.php 0 abaa
3

Stax , 23 байта

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

Запустите и отладьте его

Эта программа использует любой произвольный набор из 5 целых чисел для иконок.

Процедура:

1. Сложите количество вхождений каждого элемента.
2. Разделите на 2, а затем мод 7.
3. Результатом является число от 1..5. Используйте это, чтобы найти приз монеты в фиксированном массиве.
4. Добавьте к начальному количеству монет.
5. Разделите на 100.

Вот вывод из экспериментального визуализатора состояния стека, над которым я работал для следующего выпуска Stax. Это распакованная версия того же кода с добавленным в комментарии состоянием стека.

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] 

Запустите этот

Сетчатка 0.8.2 , 72 байта

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

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Принимает ввод в виде 4-значных печатных ASCII-цифр, за которыми следует начальное количество монет в цифрах. Объяснение:

O`\D

Сортируйте не-цифры так, чтобы идентичные символы были сгруппированы вместе.

(\D)\1{3}
777¶

Четверка очков 777.

(\D)\1\1
300¶

Три в своем роде баллы 300.

(\D)\1
100¶

Каждая пара получает 100 баллов, поэтому две пары получат 200 баллов.

\D{4}
10¶

Если не было матчей, тогда вы все равно выигрываете!

\d+\D*
$*

Преобразуйте значения в одинарные и возьмите сумму.

1{100}

Целое число разделить сумму на 100 и преобразовать обратно в десятичную.

Сетчатка , 56 байт

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

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Принимает ввод в виде 4-значных печатных ASCII-цифр, за которыми следует начальное количество монет в цифрах. Объяснение:

(\D)\1{3}
777¶

Четверка очков 777.

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

Каждая пара получает 100 баллов. При этом wучитываются все пары, так что они могут чередоваться, плюс три в своем роде могут быть разложены на три пары, таким образом, автоматически получая 300 баллов.

\D{4}
10¶

Если не было матчей, тогда вы все равно выигрываете!

\d+\D*
*

Преобразуйте значения в одинарные и возьмите сумму.

_{100}

Целое число разделить сумму на 100 и преобразовать обратно в десятичную.

APL + WIN, 42 байта

Подсказки для значков и монет.

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

Попробуйте онлайн! Предоставлено Dyalog Classic

Баш , 76 75 71 70 байт

-4 благодаря @JonathanAllan, -1 , переставляя троичный.

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

Bash порт моего Zsh ответа. Попробуйте онлайн! Попробуйте онлайн! Попробуйте онлайн! Попробуйте онлайн!

C (gcc) , 92 84 82 81 79 78 байтов

-1 на x+=(..!=..) -5 , возвращая через присваивание , -4 благодаря Джонатану Аллану, заменив !=на <, который сохраняет байты в другом месте, -1 , переставив троицу.

От @ceilingcat: -2 путем объявления iи xвыхода из функции, -1 путем установки x=iи уменьшения 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);}

Еще один порт моего Zsh ответа. Я не знаком с игрой в гольф C, возможно, здесь есть еще одна хитрость, чтобы еще больше ее уменьшить. 92 84 82 81 79 Попробуйте онлайн!

05AB1E , 20 19 18 байт

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

Порт @JonathanAllan 's Jelly ответ , так что обязательно проголосуйте за него !!
-2 байта благодаря @Grimy .

Принимает список значков в качестве первого ввода (существо [1,2,3,4,5]) и количество монет в качестве второго ввода.

Попробуйте онлайн или проверьте все контрольные примеры . ( T‚à+Вместо этого используется набор тестов TMI+, который является альтернативой равных байтов.)

Объяснение:

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)

Скала , 88 байт

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

Попробуйте онлайн!

Древесный уголь , 30 байт

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

Попробуйте онлайн! Ссылка на подробную версию кода. Принимает ввод как количество монет и массив любых сопоставимых значений Python в виде значков. Объяснение:

≔⊘ΣＥη№ηιη

Бесстыдно украсть трюк @ GammaFunction по вычислению половины суммы отсчетов.

⁻η∕²∨›⁸η⁹

Вычитание 2из суммы, таким образом , приводя к значениям 0, 1, 2, 3надлежащим образом , но для 4-в своем роде, разделить 2на 9первый, в результате чего 7.777....

∨...∕¹χ

Но если результат равен 0, совпадений не было, поэтому замените его на 0.1. (Использование литерала здесь не помогает, потому что мне нужен разделитель.)

Ｉ⌊⁺∕θ¹⁰⁰...

Разделите начальные монеты на 100 и прибавьте выигрыш, затем напишите результат и приведите к строке для неявного вывода.

Pyth , 32 байта

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

Попробуйте онлайн!

Вдохновленный решением GammaFunction. Принимает вход как [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 байта

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

Попробуйте онлайн!

раскатал:

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 байт

^{-7 байт благодаря маззи}

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

Попробуйте онлайн!

Большая старая троичная операция со вкусом PowerShell, построенная на группировке и сортировке количества входного списка. Сортировка необходима, потому что мы используем тот факт, что сгруппированный список становится короче, чем больше повторений. На самом деле, вот все возможные значения:

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

Усечение до int все еще дорого.

раскатал:

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 байта

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

Попробуйте онлайн!

R, 102 , 91 , 81 байт

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

Удалось сбросить 11 байтов (и исправить ошибку) благодаря @Giuseppe. Управляется еще 10, вдохновленными идеей @ Giuseppe's / 10.

Ungolfed

f=function(b,v){
  s = table(v)          #included in fn inputs
  a = b+10*all(s<2)     #covers all different case
  a = a+477*any(s>3)    #Covers 4 of a kind
  d = sum(s==2)+3*any(s>2) #covers 1 and 2 pair, 3 of a kind.
  a%/%100+d         #sum appropriate values
}

Попробуйте онлайн!

Сборка 8051 (компилируется в 158 байт)

Это наивный подход VEEEEEEEEEERRY, это еще не проверено и не испытано, но я уверен, что это работает. Что нужно учитывать:

1) 8051 является аккумуляторной машиной, т.е. ему нужны инструкции mov, которые могут вообще не понадобиться другим архитектурам.

2) 8051 - это 8-битная машина, поэтому для чисел> 255 необходимо проделать некоторую хитрость, что приводит к большему количеству кода и поэтому является недостатком платформы по сравнению с другими.

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