एक पासा 10,000 रोल का मूल्यांकन करें

Question

परिचय

पासा 10,000 एक पासा खेल है जिसे 6 पासे और कुछ लिखने के साथ खेला जा सकता है। खिलाड़ी पासा को कई बार घुमाते हैं और इसके अंत में एक अंक प्राप्त करते हैं। 10,000 अंक तक पहुंचने वाले खिलाड़ी ने सबसे पहले गेम जीता। एक रोल के स्कोर की गणना करना इस चुनौती में आपका काम है। पूर्ण नियमों के लिए
यहां देखें ।
कृपया ध्यान दें कि खेल के व्यापक रूप से ज्ञात होने के बाद से नियम (स्पष्ट रूप से स्कोरिंग) एक क्षेत्र से दूसरे क्षेत्र में बदल जाते हैं। हम नीचे दिए गए नियमों का उपयोग करते हैं।

चुनौती

एक पासा रोल का प्रतिनिधित्व करने वाले एक से छह तक छह नंबरों की सूची को देखते हुए, उनके स्कोर का उत्पादन करते हैं। स्कोर की गणना follwing तरीके से की जाती है:

• लोगों ने 100 अंकों की गिनती की
• फाइव्स 50 अंक मायने रखती है
• ट्रिपल ने अपने नंबर की संख्या 100 अंक बताई । उदाहरण के लिए तीन जुड़वाँ 200 अंक देते हैं। एक अपवाद तीन हैं जो 1000 अंकों की गणना करते हैं ।
• ऊपर बताए अनुसार दो संख्याओं में से छह की संख्या समान है। तो छह तारे 600 अंक देते हैं। वही लोगों के साथ किनारे के मामले के लिए जाता है: छह लोग 2,000 अंक हैं।
• एक डाई का एक से अधिक बार उपयोग नहीं किया जा सकता है। यदि एक मौत एक ट्रिपलेट का हिस्सा है, तो यह अन्य स्कोरिंग के लिए नहीं गिना जाता है। एक ट्रिपल में फाइव 500 अंक के अलावा 50 अंक नहीं देते हैं।
• स्कोर को अधिकतम करने के लिए ट्राइबल्स को हमेशा सबसे पहले गिना जाता है। तो तीन फाइव को कभी भी 150 अंकों में नहीं गिना जाता है। चार पत्नियों को एक ट्रिपल और एक साधारण पांच के रूप में गिना जाता है जो फिर 550 अंक देता है।

टिप्पणियाँ

• इनपुट में हमेशा एक से छह तक छह नंबर होंगे। आप अमान्य इनपुट प्राप्त नहीं करेंगे।
• नंबर किसी भी क्रम में हो सकते हैं। आप किसी विशिष्ट आदेश को नहीं मान सकते हैं।

नियम

• इनपुट प्रारूप आपके ऊपर है जब तक कि यह प्रीप्रोसेस नहीं किया गया है।
• कार्य या पूर्ण कार्यक्रम की अनुमति है।
• इनपुट / आउटपुट के लिए डिफ़ॉल्ट नियम ।
• मानक खामियां लागू होती हैं।
• यह कोड-गोल्फ है , इसलिए सबसे कम बाइट-काउंट जीतता है। टाईब्रेकर पहले जमा करना है।

परीक्षण के मामलों

[१, २, ३, ४, ५, ६] -> १५०
[१, १, १, २, ३, ५] -> १०५०
[१, १, १, १, १, १] -> २०००
[२, २, २, २, २, २] -> ४००
[६, ६, १, ५, ५, ६] -> 1००
[२, ३, ४, ६, २, ४] -> ०
[१, ५, १, ५, १, ५] -> १५००
[५, ५, ५, ५, २, ३] -> ५५०
[१, १, १, १, १, ५] -> १२५०
[३, ३, ४, ४, ३, ४] -> 4००

Comments

इसके अलावा, डाई पासा का विलक्षण रूप है ।

— mbomb007

@ThreeFx "एक पासा" अभी भी गलत है। देखें english.stackexchange.com/a/167107/125966

— mbomb007

@ mbomb007 देखें इस ।

— थ्री एफएक्स

@ mbomb007 जर्मन में एकवचन और बहुवचन के लिए एक ही है, अंग्रेजी को इतना जटिल क्यों होना पड़ता है? : पी लेकिन धन्यवाद वैसे भी, मरने लगता है वास्तव में बेहतर :)

— Denker

@DenkerAffe आह लेकिन क्या यह "डाइस पासा", "डाई डाइस" या "दास पासा" है?

— डेव

Answer 1

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

इसे ऑनलाइन आज़माएं

Answer 2

पायथन 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

कुछ गोल्फ का श्रेय @ कोपर को जाता है , जो अपने कोड के कुछ सुझावों का उपयोग करता है

Answer 3

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/ a का मूल्यांकन करते हैं else।

यदि पहला तत्व ( $xकुछ बाइट्स को बचाने के लिए टेम्पर्ड) तीसरे तत्व से मेल खाता है, तो हमारे पास एक ट्रिपल है। पर जोड़े $sउम कुछ गुणा के परिणाम 100*$xके साथ साथ एक बूलियन आधारित 900केवल तभी $xहै -eqUAL के लिए 1। यह हमें 1000तीन लोगों के लिए अपेक्षित हो जाता है। फिर, में पहले दो तत्वों से दूर छील $a, और $b, और में शेष $n- ट्रिपल के तीसरे तत्व को हटाने के बाद नियंत्रित किया जाता है।

अन्यथा, हमारे पास एक ट्रिपल नहीं है, इसलिए $sएक और बूलियन-आधारित जोड़ के परिणाम को जोड़ें । हम जोड़ने 50अगर $xहै या तो 1या 5, फिर एक और पर जोड़ने 50अगर यह के -eqUAL के लिए 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

Comments

फिर से: '144 पार कर गया': अपने स्ट्राइकथ्रू को बोल्ड करें, यह अधिक स्पष्ट होगा।

— स्टैकस्टक

Answer 4

जावास्क्रिप्ट (ईएस 6), 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 के माध्यम से पहचाना जा सके। संपादित करें: @Annauld के लिए 1 बाइट धन्यवाद सहेजा गया।

Comments

s>>7के बजाय s>111पहले संस्करण में एक बाइट बचाता है

— Arnauld

Answer 5

अजगर 2 या 3, 123 122 121 116 109 108 104 102 100 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))))

Answer 6

रूबी, 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}

Comments

यह मुझे एक SyntaxError देता है। मुझे लगता है कि आपको पहले बृहदान्त्र के बाद एक स्थान की आवश्यकता है।

— जॉर्डन

@ जोर्डन भले ही इसने रिप्लाई पर ठीक काम किया हो। फिर भी यह टूट जाता है ... यह ठीक है, मैंने तर्क को फिर से इसकी आवश्यकता नहीं होने के लिए कहा

— वैल्यू इंक

i<2&&i=10आपको 2 बाइट्स बचाता है।

— एज़स्ट्रा

Answer 7

हास्केल, 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

Answer 8

जावास्क्रिप्ट (ईएस 6), 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

Answer 9

पायथन 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 पर यह कोशिश करो! (सभी परीक्षण मामलों के साथ)

यहाँ मेरा पुराना अजगर 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

पायथन 2 समाधान पर एक बाइट को बचाया @ mbomb007 के लिए धन्यवाद!

Comments

print sपायथन 2 में छोटा है

— mbomb007

@ mbomb007 धन्यवाद! मैं इसे संपादित करूँगा।

— कॉपर

Answer 10

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

मैं यह सब 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सब कुछ जोड़ने के लिए अंतिम रूप से पाइप ।

Answer 11

पर्ल, 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

Comments

यह "2 2 2 2 2 2" जैसे इनपुट के लिए काम नहीं करता है

— Xcali

Answer 12

सी # (.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 से गुणा करके। इनपुट को अलग कमांड लाइन आर्ग्स के रूप में पास किया जाना चाहिए।

Answer 13

पर्ल ५ -ap , 78 बाइट्स

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

इसे ऑनलाइन आज़माएं!