Giriş

Dice 10,000 6 zar ve yazılacak bir şey ile oynanabilen bir zar oyunudur. Oyuncular zarları birkaç kez döndürür ve sonunda bir puan kazanırlar. İlk 10.000 puana ulaşan oyuncu oyunu kazanır. Bu mücadelede bir topun skorunu hesaplamak sizin işiniz. Kuralların tamamı için
buraya bakın .
Oyun yaygın olarak bilindiği için kuralların (özellikle puanlama) bölgeden bölgeye değiştiğini lütfen unutmayın. Aşağıda açıklanan kuralları kullanıyoruz.

Meydan okuma

Bir zar atışını temsil eden bir ila altı arasındaki altı sayının bir listesi verildiğinde, puanlarını çıkarın. Puan aşağıdaki şekilde hesaplanır:

• Olanlar 100 puan sayar
• Beşleme 50 puan sayıyor
• Üçüzler sayılarını 100 puan olarak sayar . Örneğin üç ikişer 200 puan verir. Bir istisna, 1000 puan sayılan üç istisnadır .
• Aynı sayının altısı yukarıda açıklanan iki üçüz gibi sayılır. Yani üç üçlü 600 puan veriyor. Aşağıdakiler için de aynı durum geçerlidir: Altı tanesi 2.000 puan.
• Bir kalıp bir kereden fazla kullanılamaz. Bir kalıp üçüzün bir parçasıysa, diğer puanlamalar için sayılmaz. Üçüz beşli do not verdikleri 500 puanlara ek olarak 50 puan sayılır.
• Skoru en üst düzeye çıkarmak için her zaman ilk olarak üçe katlanır. Bu yüzden üç beşleme asla 150 puan olarak sayılmaz. Dört beş bir üçüz ve bir sıradan beş olarak sayılır ve bu sayı 550 puan verir.

notlar

• Giriş her zaman bir ila altı arasında altı sayı içerir. Geçersiz giriş almayacaksınız.
• Numaralar herhangi bir sırada olabilir. Belirli bir sipariş kabul edemezsiniz.

kurallar

• Önceden işlenmediği sürece giriş biçimi size kalmış.
• İşlev veya tam programa izin verilir.
• Giriş / çıkış için varsayılan kurallar .
• Standart boşluklar geçerlidir.
• Bu kod golf , bu yüzden en düşük bayt sayısı kazanır. Tiebreaker daha erken sunuluyor.

Test senaryoları

[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 bayt

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

açıklama

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

Çevrimiçi deneyin

Piton 2, 152 148 125 bayt

Oldukça basit bir çözüm. Daha fazla golf edilebilir. L.countbiraz uzun, ancak L güncellendiğinden ilk aramayı kaldıramadım.

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)

Çevrimiçi deneyin - (tüm test örnekleri)

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

Bazı golf kredi @Copper onun kodundan bazı ipuçlarını uygulamayı,

PowerShell v2 + v3 +, 147 144 137 133 bayt

$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'ü geçti 144 gibi mi?}

Girdiyi alır $args[0]ve sortkaydeder $n. Sonra, whilehala kalan unsurlar var, bir if/ else.

İlk eleman ( $xbazı baytların kaydedilmesi için saklanan sıcaklık ) üçüncü elemanla eşleşirse, bir üçlü var. Üzerine ekleyin $sbazı çarpım um sonucu 100*$xartı bir Boole tabanlı 900yalnızca $xolduğunu -equal için 1. Bu bize 1000üç kişi için gerekli olanı getiriyor. Daha sonra, içine, ilk iki elemanın soyulabilir $ave $bve Kalan$n - daha sonra işlenir üçlü üçüncü elemanın çıkarılması.

Aksi takdirde, üçlü yok, bu yüzden $sbaşka bir Boole tabanlı eklemenin sonucunu ekleyin . Biz eklemek 50eğer $xikisinden biri olduğunu 1veya 5sonra başka bir eklenti, 50's eğer -eqUAL için 1. Bu bölüm artık -inoperatör için v3 + gerektirir .

Her iki durumda da, henüz kaldırılacak bir elemanımız var, bu yüzden ilk elemanı soyun $ave kalanını bırakın $n.

Son olarak, döngü tamamlandıktan $ssonra boru hattına yerleştirin. Çıktı, Write-Outputyürütmenin sonunda örtüktür.

Test senaryoları

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 bayt

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

Girdileri sıralar ve dizgiler, böylece puanlama kombinasyonları normal ifade ile tanımlanabilir. Düzenleme: @Arnauld sayesinde 1 bayt kaydedildi.

Python 2 veya 3, 1231221211610910101021000 97 bayt

Python 2, 97 bayt

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

Test senaryoları ideone'de

Python 3, 97 bayt

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

Yakut, 80 78 bayt

Çevrimiçi deneyin!

@Ezrast tarafından -2 bayt.

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

Bu değil Haskell için bir meydan okuma. Ayrıca ben golf bu.

@Nimi sayesinde.

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 bayt

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

Test senaryoları:

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 bayt

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)

Bu bir lambda ifadesidir; kullanmak için, ekleyerek atayın f=.

İlk önce üçe iki kere (modül kullanarak) kontrol ediyoruz, üçlüyü giderken kaldırıyoruz; o zaman sadece 5ve1 geri döndürürüz.

Ideone üzerinde deneyin! (tüm test senaryolarında)

İşte benim eski Python 2 gönderimi:

Python 2, 176 172 171 145 136 134 133 bayt

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 sayesinde Python 2 çözümünde bir bayt kaydetti!

BAŞLAT (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

Her şeyi sed'de yapmak istedim, ama ekleme gerçekten zor ...

Açıklama:

1. Üçüz bulun 00, ilk numaraya ekleyin ve diğerini kaldırın
   örn. 1 2 1 3 1 4->100 2 3 4
2. İki üçlü olması durumunda 1. adımı tekrarlayın
3. Değiştir 10ile 1daha sonra 1birlikte 100
   örneğin 100-> 10-> 1000ya 1-> 1->100
4. Her değiştirin 5ve ardından değil 0ile50
5. Sonu olmayan herhangi bir sayıyı kaldırın 0
6. Boşluk gruplarını şununla değiştir: +
7. Ön ve arka kaldırma +s
8. Dize boşsa, bir 0
9. Son olarak bcher şeyi eklemek için boru .

Perl, 69 bayt

İçin +2 içerir -ap

STDIN üzerindeki giriş ile çalıştırın:

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) , 228227 bayt

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

Çevrimiçi deneyin!

Ben burada birçok, birçok potansiyel optimizasyonlar eksik gibi hissediyorum, ama yaptığımız sonunda 10 ile çarpılarak bir byte tasarruf. Giriş ayrı komut satırı argümanları olarak iletilmelidir.

Perl 5 -ap , 78 bayt

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

Çevrimiçi deneyin!