บทนำ

Dice 10,000 เป็นเกมลูกเต๋าที่สามารถเล่นได้กับ 6 ลูกเต๋าและสิ่งที่จะเขียน ผู้เล่นหมุนลูกเต๋าหลายครั้งต่อเทิร์นและได้รับคะแนนเมื่อสิ้นสุด ผู้เล่นที่ถึง 10,000 คะแนนก่อนชนะเกม การคำนวณคะแนนม้วนหนึ่งคืองานของคุณในการท้าทายนี้
ดูที่นี่สำหรับกฎทั้งหมด
โปรดทราบว่ากฎ (โดยเฉพาะการให้คะแนน) เปลี่ยนจากภูมิภาคหนึ่งไปยังอีกภูมิภาคหนึ่งเนื่องจากเกมดังกล่าวเป็นที่รู้จักอย่างกว้างขวาง เราใช้กฎที่ให้ไว้ด้านล่าง

ความท้าทาย

รับรายการของตัวเลขหกจากหนึ่งถึงหกแสดงถึงการทอยลูกเต๋าส่งออกคะแนนของพวกเขา คะแนนถูกคำนวณในวิธีการ follwing:

• คนนับ100คะแนน
• Fives นับ50คะแนน
• สามเท่านับจำนวนของพวกเขาคูณ100คะแนน ตัวอย่างเช่นสอง twos ให้ 200 คะแนน ข้อยกเว้นคือสามตัวซึ่งนับ1,000คะแนน
• หกในจำนวนเดียวกันนับเป็นสองสามเท่าตามที่อธิบายไว้ข้างต้น หกสิบหกให้ 600 คะแนน กรณีเดียวกันกับเคสขอบ: หกอันคือ 2,000 คะแนน
• หนึ่งตายไม่สามารถใช้มากกว่าหนึ่งครั้ง หากความตายเป็นส่วนหนึ่งของแฝดมันจะไม่นับรวมการทำสกอร์อื่น ๆ ห้าคนใน triplet ทำไม่ได้นับ 50 คะแนนนอกเหนือจาก 500 คะแนนที่พวกเขาให้
• จะมีการนับสามครั้งแรกเสมอเพื่อเพิ่มคะแนน ดังนั้นสามครั้งจึงไม่นับเป็น 150 คะแนน สี่ fives นับเป็นหนึ่ง triplet และหนึ่งสามัญห้าซึ่งให้ 550 คะแนน

หมายเหตุ

• อินพุตจะมีตัวเลขหกตัวจากหนึ่งถึงหกเสมอ คุณจะไม่ได้รับการป้อนข้อมูลที่ไม่ถูกต้อง
• หมายเลขสามารถอยู่ในลำดับใดก็ได้ คุณอาจจะไม่ถือว่าการสั่งซื้อใด ๆ ที่เฉพาะเจาะจง

กฎระเบียบ

• รูปแบบอินพุตขึ้นอยู่กับคุณตราบใดที่ยังไม่ได้ประมวลผลล่วงหน้า
• อนุญาตให้ใช้ฟังก์ชั่นหรือโปรแกรมเต็มรูปแบบ
• กฎเริ่มต้นสำหรับอินพุต / เอาต์พุต
• ช่องโหว่มาตรฐานใช้
• นี่คือcode-golfดังนั้นจำนวนไบต์ที่น้อยที่สุดจึงชนะ Tiebreaker เป็นการส่งก่อนหน้า

กรณีทดสอบ

[1, 2, 3, 4, 5, 6] -> 150
[1, 1, 1, 2, 3, 5] -> 1,050
[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] -> 1,500
[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

ลองออนไลน์

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

ลองออนไลน์ - (ทุกกรณีทดสอบ)

Ungolfed:

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]และsorts $nมันเก็บไว้ลงไป จากนั้นwhileยังมีองค์ประกอบเหลืออยู่เราประเมินค่าifelse /

หากองค์ประกอบแรก (เก็บไว้ใน$xการบันทึกบางไบต์) ตรงกับองค์ประกอบที่สามเรามีสาม เพิ่มไปยัง$sหนอผลคูณบาง100*$xบวกบูลีนที่ใช้900เฉพาะในกรณีที่$xเป็นทางเพศที่จะ-eq 1สิ่งนี้ทำให้เรามีสิ่งที่จำเป็น1000สำหรับสามคน จากนั้นให้ลอกองค์ประกอบสองชิ้นแรกออกเป็น$aส่วน$bๆ และส่วนที่เหลือเข้าไป$n- นำส่วนที่สามของสามออกมาจัดการในภายหลัง

มิฉะนั้นเราจะไม่มีทริปเปิลเพิ่มขึ้นเพื่อเพิ่ม$sผลลัพธ์ของการเพิ่มตาม Boolean เราได้เพิ่ม50ถ้า$xเป็นอย่างใดอย่างหนึ่ง1หรือ5แล้วเพิ่มอีก50ถ้ามัน-eqUAL ไป1ไป ตอนนี้ส่วนนี้ต้องการ v3 + สำหรับ-inผู้ประกอบการ

ไม่ว่าในกรณีใดเรายังคงมีองค์ประกอบที่ยังไม่ได้ลบออกดังนั้นให้ลอกองค์ประกอบแรกออก $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

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

เรียงลำดับและป้อนค่าอินพุตเพื่อให้ชุดค่าผสมคะแนนสามารถระบุได้โดยใช้ regexp แก้ไข: บันทึก 1 ไบต์ขอบคุณ @Arnauld

Python 2 หรือ 3 123 122 121 116 109 108 104 102 100 97 ไบต์

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

กรณีทดสอบเปิดอยู่ ideone

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

Ruby, 80 78 ไบต์

ลองออนไลน์!

-2 ไบต์จาก @ezrast

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

Haskell, 130 123 ไบต์

นี่ไม่ใช่ความท้าทายสำหรับ Haskell นอกจากนี้ฉันเล่นกอล์ฟนี้

ขอบคุณ @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

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

Python 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=เตรียม

ก่อนอื่นเราตรวจสอบ triples สองครั้ง (โดยใช้โมดูลัส) ลบ triples ที่เราไป จากนั้นเราก็เพิ่มจำนวน5และ1เพิ่มคะแนนและส่งคืน

ลองใช้กับ Ideone! (กับกรณีทดสอบทั้งหมด)

นี่คือการส่ง Python 2 ที่เก่ากว่าของฉัน:

Python 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

บันทึกไบต์บนโซลูชัน Python 2 ด้วย @ mbomb007!

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

ฉันอยากจะทำทุกอย่างด้วยความลำบาก แต่การเพิ่มมันยากจริงๆ ...

คำอธิบาย:

1. ค้นหา triplet เพิ่ม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เพื่อเพิ่มทุกอย่างขึ้น

Perl, 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 Core) , 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 ในตอนท้าย อินพุตควรถูกส่งผ่านเป็นบรรทัดคำสั่งแยกกัน

Perl 5 -ap , 78 ไบต์

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

ลองออนไลน์!