Super Mario 3D World에는 Lucky House 로 알려진 미니 게임이 있습니다 . 4 개의 블록이있는 슬롯 머신으로 구성됩니다.

각 블록은 5 개의 서로 다른 아이콘 (꽃, 잎, 종, 체리 또는 부메랑) 중 하나 일 수 있으며 플레이어의 목표는 가능한 많은 동일한 아이콘을 얻는 것입니다 ( 비디오 참조 ).

플레이어는 동전으로 보상을 받고 여분의 생명으로 전환 될 수 있습니다. 당신의 임무는이긴 생명의 수를 계산하는 것입니다.

일치하는 아이콘 수에 따라 보상되는 코인의 양은 다음과 같습니다.

• 일치하는 항목이 없습니다-10 동전
• 한 쌍-100 동전
• 두 쌍-200 동전
• 3 가지 종류-300 동전
• 네 종류-777 코인

당신은 100 코인마다 하나의 추가 생명 (1UP)을 얻습니다 . 따라서 1 쌍으로 정확히 1UP , 2 쌍으로 2UP, 3 가지 종류의 3UP으로 승리 할 수 ​​있습니다 . 그러나 일치하지 않거나 4 가지 종류 의 생명으로 얻은 생명의 수는 초기 코인 주식에 따라 다릅니다.

_{출처 : 슈퍼 마리오 위키}

입력

초기 코인 주식 과 슬롯 머신의 최종 아이콘을 나타내는 4 개의 값 의 목록이 제공 됩니다.$0 \le c < 100$$[v_1,v_2,v_3,v_4]$

산출

추가 생명의 수는 $0$ , $1$ , $2$ , $3$ , $7$ 또는 $8$ 입니다.

규칙

• 아이콘을 합리적인 형식 (예 : 목록, 문자열 또는 4 개의 고유 한 매개 변수)으로 사용할 수 있습니다.
• 각 아이콘은 한 자리 정수 또는 한 문자 로 표시 될 수 있습니다 . 답변에 사용 된 아이콘 세트를 지정하십시오. (단, 중요하지 않기 때문에 꽃, 잎, 종 등에 어떻게 매핑되는지 설명 할 필요는 없습니다.)
• 출력 값을 다시 매핑 할 수 없습니다.
• 이것은 🎰 code-golf 🎰입니다.

테스트 사례

다음 예에서는 의 정수 목록을 사용 하여 아이콘을 나타냅니다.$[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 바이트

이진 :

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.

설명:

4 바이트의 입력이 반복되고 오른쪽의 나머지 바이트와 비교되어 일치 횟수를 계산합니다. 각 경기 유형에 대한 점수가 부여되고 총합이됩니다. 4 가지 종류도 3 가지 종류와 1 쌍이므로 각 점수 유형의 값은 다음과 같이 분해 될 수 있습니다.

• 3 건 = 4 1UP + 77 개 동전
• 2 건 = 2 1UP
• 1 경기 = 1 1UP

예 :

[2, 2, 2, 2] (4 가지 종류) = 7 1UP 's + 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 가지 종류) = 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 쌍) = 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이 수여됩니다.

다음은 정수 값 I / O를 처리하기위한 추가 루틴을 포함하는 PC DOS 용 테스트 프로그램입니다.

DOS 용 LUCKY.COM 을 다운로드하여 테스트 하십시오 .

젤리 ,  23 22 20  19 바이트

-1 덕분 에릭 Outgolfer (사용하는 ³대신에,은 ȷ2) 또한 두 새로운 버전에서 사용
-1 덕분에 검댕으로 더럽혀진 (합산 대신 이후 네 전에 감산 한 감산)

^{아마도 이길 수 있습니까?}

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

리스트와 정수를 허용하는 정수를 허용하는 2 진 링크.

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

방법?

ċⱮ`’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 분화에 대해 다른 기준을 사용하여 -13 , 케이스를 결합하여 -28 변화에 의해 case, 중첩 된 원에 산술 문 -3 입어 @JonathanAllan에 -1 의 ternaries를 최적화하여 -2 I 실수로 사용하기 때문에 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 번호 (카메라 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

내 파이썬 답변의 포트는 @Dat의 답변에서 파생됩니다.

온라인으로 사용해보십시오!

파이썬 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)). 그러나 결과에 산술 공식을 사용하는 대신 룩업 테이블을 사용하고 먼저 mod chain을 사용하여 값을 0에서 4까지 좁 힙니다 %14%5. 모든 포인트 값을 100으로 나누면 몇 바이트가 절약되었습니다.

파이썬 3 , 68 바이트

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

온라인으로 사용해보십시오!

내 Zsh 답변의 Bash 포트 내 C 포트의 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

온라인으로 사용해보십시오!

펄 6 , 48 44 바이트

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

온라인으로 사용해보십시오!

카레 기능 f(icons)(coins).

파이썬 2 , 96 91 89 바이트

@Kevin Cruijssen 덕분에 -2 바이트

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, 153127 바이트

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

온라인으로 사용해보십시오!

파이썬 (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의 답변이지만 더 많은 골프를 쳤다.

온라인으로 사용해보십시오!

펄 5 -pF , 46 바이트

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

온라인으로 사용해보십시오!

입력의 첫 번째는 q(나는 제안 abcde)을 제외하고 5 개의 고유 ASCII 문자를 사용하여 회전 결과 입니다. 두 번째 입력 라인은 현재 코인 수입니다.

방법?

-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캐릭터를 볼 때마다 누적 합계 ( )에 추가됩니다 . 4 가지 종류 (실제로 177 개의 코인 보너스)가 있으면 누적 합계가 올라갑니다.

자바 스크립트 (Node.js) , 64 바이트

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

온라인으로 사용해보십시오!

Arnauld 챌린지에 대해 최소한 하나의 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로 나눈 다음 mod 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¶

3 점 만점 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받습니다. 모든 페어를 고려하여 인터리브 될 수 있고, 3 가지 종류를 3 개의 페어로 분해하여 자동으로 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 바이트

-JonathanAllan 덕분에 -4 , 3 진을 다시 정렬하여 -1 .

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

내 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 의 젤리 답변 포트 , 그래서 그를 투표해야합니다!
@Grimy 덕분에 -2 바이트 .

아이콘 목록을 첫 번째 입력 ( [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 바이트

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

온라인으로 사용해보십시오!링크는 자세한 버전의 코드입니다. 입력을 코인 수로, 파이썬과 비슷한 값의 배열을 아이콘으로 사용합니다. 설명:

≔⊘ΣＥη№ηιη

@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 바이트

^{mazzy 덕분에 -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 기반의 3 항 작업입니다. 그룹화 된 목록이 더 짧을수록 반복 횟수가 짧다는 사실을 활용하기 때문에 정렬이 필요합니다. 실제로 다음은 가능한 모든 값입니다.

(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)

@Giuseppe 덕분에 11 바이트를 삭제하고 버그를 수정했습니다. @Giuseppe의 10/10 아이디어에서 영감을 얻은 추가 10 개를 관리했습니다.

언 골프

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