소개

주사위 10,000은 주사위 6 개와 쓸 수있는 주사위 게임입니다. 플레이어는 한 턴에 주사위를 여러 번 굴려서 그 끝에 점수를 얻습니다. 10,000 포인트에 도달 한 플레이어가 먼저 게임에서 승리합니다. 한 롤의 점수를 계산하는 것은이 도전에서 당신의 일입니다. 전체 규칙은
여기 를 참조하십시오.
게임이 널리 알려져 있기 때문에 규칙 (특히 점수)은 지역마다 다릅니다. 아래에 명시된 규칙을 사용합니다.

도전

주사위 롤을 나타내는 1에서 6까지의 6 개의 숫자 목록이 주어지면 점수를 출력합니다. 점수는 다음과 같이 계산됩니다.

• 이들 이여 카운트 100 점
• 파이브는 50 포인트를 센다
• 트리플렛의 수는 100 포인트로 계산 됩니다. 예를 들어 3 개의 2는 200 포인트를 제공합니다. 1000 점 을 세는 것은 예외 입니다.
• 같은 수의 6 개는 위에서 설명한 것처럼 3 개의 3 개로 계산됩니다. 그래서 6/3은 600 점을줍니다. 엣지 케이스도 마찬가지입니다. 6 개는 2,000 포인트입니다.
• 하나의 다이는 두 번 이상 사용할 수 없습니다. 주사위가 삼중 항의 일부인 경우, 다른 득점에는 포함되지 않습니다. 삼중 항의 5 는 500 점에 50 점을 더 하지 않습니다 .
• 트리플은 항상 점수를 극대화하기 위해 먼저 계산됩니다. 따라서 3-5는 150 점으로 계산되지 않습니다. 4 개의 파이브는 1 개의 트리플렛과 1 개의 보통 5로 계산되어 550 포인트가됩니다.

노트

• 입력은 항상 1에서 6까지 6 개의 숫자를 포함합니다. 유효하지 않은 입력을받지 않습니다.
• 번호는 임의의 순서로 지정할 수 있습니다. 특정 주문은 가정 할 수 없습니다.

규칙

• 사전 처리되지 않은 입력 형식은 사용자에게 달려 있습니다.
• 기능 또는 전체 프로그램이 허용됩니다.
• 입 / 출력의 기본 규칙 .
• 표준 허점이 적용됩니다.
• 이것은 code-golf 이므로 바이트 수가 가장 적습니다. Tiebreaker는 이전에 제출되었습니다.

테스트 사례

[1, 2, 3, 4, 5, 6]-> 150
[1, 1, 1, 2, 3, 5]-> 1050
[1, 1, 1, 1, 1, 1]-> 2000
[2, 2, 2, 2, 2, 2]-> 400
[6, 6, 1, 5, 5, 6]-> 800
[2, 3, 4, 6, 2, 4]-> 0
[1, 5, 1, 5, 1, 5]-> 1500
[5, 5, 5, 5, 2, 3]-> 550
[1, 1, 1, 1, 1, 5]-> 1250
[3, 3, 4, 4, 3, 4]-> 700

05AB1E , 34 31 30 바이트

7G¹N¢O3‰N*2LRN1Q+°*X5‚Nå_i¨}OO

설명

7G                                  # for N in 1..6
  ¹N¢O                              # count number of occurrences of N in input
      3‰                            # divmod 3
        N*                          # multiply by N
          2LRN1Q+°*                 # multiply by 10, 100 or 1000
                   X5‚Nå_i¨}        # if N is not 1 or 5, scrap the singles
                            OO      # sum all triple and single scores so far
                                    # implicitly display total sum

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

파이썬 2 152 148 125 바이트

아주 간단한 해결책. 더 골프를 칠 수 있습니다. L.count조금 길지만 L이 업데이트되어 첫 번째 통화를 제거 할 수 없습니다.

def f(L):s=n=0;exec"n+=1\nwhile L.count(n)>2:s+=[n*100,1e3][n<2];exec'L.remove(n);'*3\n"*6;C=L.count;print s+100*C(1)+50*C(5)

온라인으로 사용해보십시오 -(모든 테스트 사례)

언 골프 드 :

def f(L,s=0):
    L.sort()
    for n in range(1,7):
        while L.count(n)>2:
            s+=n*100*((n<2)*9+1) # multiply by 10 if n==1
            i=L.index(n)
            L=L[:i]+L[i+3:]
    s+=100*L.count(1)+50*L.count(5)
    print s

그의 코드의 팁을 사용하여 @Copper에 대한 골프 크레딧

PowerShell을 V2 + V3 +, 147 144 137 133 바이트

$n=$args[0]|sort;while($n){if(($x=$n[0])-eq$n[2]){$s+=100*$x+900*($x-eq1);$a,$b,$n=$n}else{$s+=50*($x-in1,5)+50*($x-eq1)}$a,$n=$n};$s

_{144가 144와 비슷해 보이나요?}

입력을 $args[0]받아 sort저장합니다 $n. 그런 다음 while여전히 요소가 남아 있으므로 if/를 평가합니다 else.

첫 번째 요소 ( $x일부 바이트를 저장하기 위해 저장된 온도 )가 세 번째 요소와 일치하면 트리플이 있습니다. 에 추가 $s일부 곱셈의 음 결과 100*$x플러스 부울 기반 900경우에만 $x입니다 -eq연간가 1. 이것은 우리에게 1000세 사람 의 필수 조건 을 얻습니다 . 그 다음으로 첫 번째 두 요소를 박리 $a하고 $b, 그리고 나머지로 $n- 후 처리되는 트리플의 번째 요소를 제거하는 단계를 포함한다.

그렇지 않으면 트리플이 없으므로 $s다른 부울 기반 추가의 결과를 더합니다. 우리는 추가 할 50경우 $x중 하나입니다 1또는 5다음 다른에 추가, 50그것의 경우 -eq연간에 1. 이 섹션에는 이제 -in연산자에 v3 +가 필요합니다 .

두 경우 모두 아직 제거 할 요소가 있으므로 첫 번째 요소를 벗겨 내고 $a나머지를에 남겨 두십시오 $n.

마지막으로 루프가 완료되면 $s파이프 라인에 배치 하십시오. 출력은 Write-Output실행이 끝날 때 암시 적 입니다.

테스트 사례

PS C:\Tools\Scripts\golfing> (1,2,3,4,5,6),(1,1,1,2,3,5),(1,1,1,1,1,1),(2,2,2,2,2,2),(6,6,1,5,5,6),(2,3,4,6,2,4),(1,5,1,5,1,5),(5,5,5,5,2,3),(1,1,1,1,1,5),(3,3,4,4,3,4)|%{($_-join',')+" -> "+(.\evaluate-dice-1000.ps1 $_)}
1,2,3,4,5,6 -> 150
1,1,1,2,3,5 -> 1050
1,1,1,1,1,1 -> 2000
2,2,2,2,2,2 -> 400
6,6,1,5,5,6 -> 800
2,3,4,6,2,4 -> 0
1,5,1,5,1,5 -> 1500
5,5,5,5,2,3 -> 550
1,1,1,1,1,5 -> 1250
3,3,4,4,3,4 -> 700

자바 스크립트 (ES6), 87 86 바이트

a=>a.sort().join``.replace(/(.)\1\1|1|5/g,s=>r+=s>>7?s/1.11:s>5?1e3:s>1?50:100,r=0)&&r

정규식을 사용하여 점수 조합을 식별 할 수 있도록 입력을 정렬하고 문자열 화합니다. 편집 : @ Arnauld 덕분에 1 바이트가 절약되었습니다.

파이썬 2 또는 3, 123122121116109108104102100 97 바이트

파이썬 2, 97 바이트

lambda r:100*sum(c/3*((v<2)*9+v)+c%3*(v<2or(v==5)/2.)for v,c in enumerate(map(r.count,range(7))))

테스트 사례는 아이디어입니다

파이썬 3, 97 바이트

lambda r:100*sum(c//3*((v<2)*9+v)+c%3*(v<2or(v==5)/2)for v,c in enumerate(map(r.count,range(7))))

루비, 80 78 바이트

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

@ezrast에서 -2 바이트

->d{s=0;7.times{|i|c=d.count i;i<2&&i=10;s+=c>2?c/3*i*100:1>i%5?c%3*i*10:0};s}

하스켈 130 123 바이트

하스켈에게는 도전 이 아닙니다 . 또한 나는 이것을 골프하고 있습니다.

@nimi에게 감사합니다.

import Data.List
f=g.sort
g(x:a@(y:z:b))|x>z=j x+g a|0<1=100*h x+g b
g(x:y)=j x+g a
g _=0
h 1=10
h x=x
j 1=100
j 5=50
j _=0

자바 스크립트 (ES6), 85 84 바이트

x=>x.map(v=>s+=v*(((z+=1<<v*3)>>v*3&7)%3?v-5?v-1?0:10:1:v-5?v-1?10:80:8),s=z=0)|10*s

테스트 사례 :

let F =
x=>x.map(v=>s+=v*(((z+=1<<v*3)>>v*3&7)%3?v-5?v-1?0:10:1:v-5?v-1?10:80:8),s=z=0)|10*s

console.log(F([1, 2, 3, 4, 5, 6])); // 150
console.log(F([1, 1, 1, 2, 3, 5])); // 1050
console.log(F([1, 1, 1, 1, 1, 1])); // 2000
console.log(F([2, 2, 2, 2, 2, 2])); // 400
console.log(F([6, 6, 1, 5, 5, 6])); // 800
console.log(F([2, 3, 4, 6, 2, 4])); // 0
console.log(F([1, 5, 1, 5, 1, 5])); // 1500
console.log(F([5, 5, 5, 5, 2, 3])); // 550
console.log(F([1, 1, 1, 1, 1, 5])); // 1250
console.log(F([3, 3, 4, 4, 3, 4])); // 700

파이썬 3, 131 바이트

lambda r,C=list.count:sum([x%7*100,1e3][x%7<2]*(C(r,x%7)>2and not exec('r.remove(x%7);'*3))for x in range(14))+50*C(r,5)+100*C(r,1)

이것은 람다 식입니다. 사용하려면을 앞에 추가하여 지정하십시오 f=.

먼저 모듈러스를 사용하여 트리플을 두 번 확인하여 트리플을 제거합니다. 우리는 단순히의 수를 추가 5하고 1점수에 그것을 돌려줍니다.

Ideone에서 사용해보십시오! (모든 테스트 사례와 함께)

내 오래된 Python 2 제출은 다음과 같습니다.

파이썬 2 176 172 171 145 136 134 133 바이트

def e(r):s=x=0;exec'x+=1;a=x%7;\nif r.count(a)>2:exec"r.remove(a);"*3;s+=[a*100,1e3][a<2]\n'*14;C=r.count;s+=50*C(5)+100*C(1);print s

@ mbomb007 덕분에 Python 2 솔루션의 바이트를 절약했습니다!

배쉬 (sed + bc) 161

sed -re's/([1-6])(.*)\1(.*)\1/\100\2\3/g;s/([1-6])( .*)\1( .*)\1/\100\2\3/g;s/10/1/g; s/1/100/g;s/5( |$)/50 /g;s/[1-6][^0]//g;s/ +/+/g;s/(^\+|\+$)//g;s/^$/0/'|bc

나는 모든 것을 sed로하고 싶었지만 추가는 정말 어렵다 ...

설명:

1. 추가, 삼중 찾기 00첫 번째 숫자에 다른 제거
   예를 1 2 1 3 1 4->100 2 3 4
2. 트리플이 두 개인 경우 1 단계를 반복합니다.
3. 교체 10로 1다음 1과 100
   예 100-> 10-> 1000나 1-> 1->100
4. 각 교체 5다음에하지 0와50
5. 끝나지 않는 숫자를 제거하십시오 0
6. 공백 그룹을 다음으로 바꿉니다. +
7. 선행 및 후행 +s 제거
8. 문자열이 비어 있으면 0
9. 마지막으로 파이프를 연결 bc하여 모든 것을 추가하십시오.

펄, 69 바이트

에 +2 포함 -ap

STDIN의 입력으로 실행하십시오.

dice10000.pl <<< "5 1 1 1 1 1"

dice10000.pl:

#!/usr/bin/perl -ap
$_=join 0,sort@F,A;print;s%(10|\d)\1\1|10|5%$n+=$1.0||$&%eg;$_=$n.0

C # (.NET 코어) , (228) 227 바이트

class A{static void Main(string[] a){int[] x=new int[7];int i=0,s=0;for(;i<6;i++)x[int.Parse(a[i])]++;while(i>0){while(x[i]>2){s+=i>1?10*i:100;x[i]-=3;}i--;}while(x[1]-->0)s+=10;while(x[5]-->0)s+=5;System.Console.Write(s*10);}}

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

나는 여기에 많은, 많은 잠재적 인 최적화를 누락 같은 느낌,하지만 난 한 말에 10을 곱하여 바이트 저장합니다. 입력은 별도의 명령 행 인수로 전달되어야합니다.

펄 5 -ap , 78 바이트

$_=join'',sort@F;s|(\d)\1\1|!($\+=$1*($1-1?2:20))|ge;$\+=y/5//+2*y/1//}{$\*=50

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