बेस्ट याटजी स्कोर

26

याहत्ज़ी एक खेल है जिसमें पाँच छह-तरफा पासा और एक स्कोर शीट तेरह अलग-अलग बक्से के साथ एक स्कोर को भरने के लिए है। प्रत्येक बॉक्स के अपने स्कोरिंग नियम हैं:

  • 1s, 2s, 3s, 4s, 5s, 6s सभी स्कोर अंक संबंधित पासा के योग के बराबर है (यानी, 3s, 3, 1, 5] के रोल के रूप में स्कोर किया गया 3s 6 अंक से सम्मानित किया जाएगा: 3 प्रत्येक 3 के लिए)।
  • 3-ऑफ-ए-और 4-ऑफ-ए-तरह (जैसा कि वे ध्वनि करते हैं, तीन या चार पासा एक ही है) सभी पांच पासा के योग के बराबर अंक अंक।
  • पूरा घर (दो पासा एक मूल्य दिखाते हैं, अन्य तीन अन्य दिखाते हैं) 25 अंक
  • छोटे सीधे (लगातार चार मूल्यों) स्कोर 30 अंक
  • बड़े सीधे (सभी लगातार मूल्यों) स्कोर 40 अंक
  • याहत्ज़ी (सभी पासा एक ही मूल्य दिखाते हैं) स्कोर 50 अंक

तेरहवां (मौका) समझ में आता है खेल, लेकिन इस चुनौती के लिए इतना नहीं; इसके अतिरिक्त खेल में अतिरिक्त याहटेज़ के लिए बोनस है जो यहाँ कोई मतलब नहीं है। क्योंकि चुनौती है ...

इनपुट के रूप में पांच पासे दिए गए (पांच पूर्णांक 1-6, इनपुट हालांकि सुविधाजनक है, आप मान सकते हैं कि इनपुट हमेशा वैध होता है), उस 'हाथ' के लिए उच्चतम स्कोर संभव है। इस चुनौती के प्रयोजनों के लिए, ऊपर दी गई सूची में केवल स्कोरिंग विधियां वैध हैं (विशेष रूप से, मौका इस चुनौती के लिए एक वैध स्कोर बॉक्स नहीं है)। स्कोर अपने दशमलव सांख्यिक मूल्य के रूप में आउटपुट होना चाहिए, चाहे वह पूर्णांक हो या कोई स्ट्रिंग प्रतिनिधित्व, जो भी हो। इसे तुरंत एक नंबर के रूप में पहचाना जाना चाहिए। व्हाट्सएप का लीडिंग / ट्रेलिंग ठीक है, यह स्कोर प्राप्त करने के बारे में है और प्रस्तुति नहीं।

कोड गोल्फ, इसलिए किसी दिए गए भाषा में सबसे कम बाइट्स के साथ उत्तर जीतता है। मानक खामियों से मना किया।

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

(ध्यान दें कि ये सभी स्वतंत्र हैं, चुनौती पासा के एक 'हाथ' के लिए है):

in: 1 5 4 3 2
out: 40
in: 1 1 4 3 1
out: 10
in: 2 2 6 5 3
out: 6
in: 2 4 2 4 6
out: 8
in: 1 1 1 1 1
out: 50
in: 5 2 5 3 6
out: 10
in: 1 6 3 4 2
out: 30
in: 1 3 1 1 3
out: 25
in: 6 5 5 6 6
out: 28
in: 1 2 3 5 6
out: 6
code-golf  number 
— brhfl
स्रोत
3
क्या हमें इसके बजाय पुराने प्रश्न को बंद करना चाहिए? IMO यह उस से बेहतर प्रश्न है ...
— Giuseppe
5
IMO यह स्कोर के डुप्लीकेट गेम के सभी डुप्लिकेट पर नहीं है। यह स्पष्ट रूप से बताता है कि यह एक हाथ के लिए उच्चतम स्कोर है, जहां दूसरा प्रश्न डाई रोल की सूची से पूरे स्कोर के लिए पूछ रहा है। अंत में, और सबसे महत्वपूर्ण बात, मुझे "डुबकी-पेस्ट" परिदृश्य में उपयोग किए जा सकने वाले संभावित डूप से कोई उत्तर नहीं दिखता है। कृपया फिर से विचार करें।
— DevelopingDeveloper
— Giuseppe
2
FWIW, मैं पुराने सवाल से अवगत था जब मैंने इसे एक साथ रखा। मेरे विचार गूंज उठे @DevelopingDeveloper ने क्या कहा। एक बार पहले एक अभ्यास के रूप में ऐसा करने के बाद, मुझे इस प्रक्रिया को अनुकूलित करने के कुछ दिलचस्प अवसर मिले। मुझे भी लगता है कि यह एक कठिन चुनौती है।
— ब्रम्हल।
"तेरहवीं (मौका) खेल में समझ में आता है, लेकिन इस चुनौती के लिए इतना नहीं है" तो क्या यह गिना जाता है?
— यूनीहेड्रोन

जवाबों:

6

आर , 146 141 बाइट्स

function(d)max(unique(d<-sort(d))*(g=table(d)),any(g>2)*sum(d),all(2:3%in%g)*25,(s=sum((R=diff(d))==1))<4&all(R<2)*30,(s>3)*40,(0==sd(d))*50)

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

प्लैनपस द्वारा बहिष्कृत

एक सूची के रूप में इनपुट लेता है, और स्कोर लौटाता है।

थोडा असम्बद्ध:

function(d){
 d <- sort(d)
 u <- unique(d)                  # unique dice
 g <- table(d)                   # table of counts
 Ns <- u*g                       # scores as 1s, 2s, ... etc.
 NKind <- any(g>2)*sum(d)        # 3 or 4 of a kind if any counts are at least 3
 FHouse <- all(2:3%in%g)*25      # full house is 25 if 2 & 3 are in counts
 R <- diff(d)                    # consecutive differences
 s <- sum(R==1)                  # sum of differences equal to 1
 sStraight <- s<4 &              # if the number of 1s is 3 and
               all(R<2)*30       # no consecutive numbers are 2 apart
 bStraight <- (s>3)*40           # all 1s means big straight
 Yahtzee <- sd(d)==0             # sd = 0 means all are equal
 max(Ns,NKind,FHouse,sStraight,bStraight,Yahtzee)
}

— ग्यूसेप
स्रोत
f(c(1,2,3,5,6))विफल रहता है - इसे 6 का उत्पादन करना चाहिए और इसके बजाय 30 उपज चाहिए। ऐसा इसलिए होता है क्योंकि आप यह गिन रहे हैं कि कितने जोड़े (पोस्ट-छंटाई) एक-एक करके अलग-अलग हैं, जो कि उपरोक्त अनुक्रम के लिए वास्तव में चार है, भले ही वह सीधा न हो चार में से। मुझे लगता है कि मैं इसमें भाग गया जब मैंने इसे कुछ समय पहले एक अभ्यास के रूप में किया था, और मुझे शायद इसे एक परीक्षण के मामले के रूप में जोड़ना चाहिए ...
— brhfl
@ अब यह तय हो गया है।
— ग्यूसेप
4

आर, 136 134 बाइट्स

function(n,y=table(factor(n,1:6)),z=sum(!diff(diff(sort(n)))))max(1:6*y,c(25,sum(n),10*3:5)[c(all(y<4&y-1),any(y>2),z>1,z>2,any(y>4))])

@Giuseppe के लिए 2 बाइट्स नीचे घसीटा !

इंडेंट,

function(n, #vector of die scores
         y=table(factor(n,1:6)), #Contingency table
         z=sum(!diff(diff(sort(n))))) #Diff of diff of ordered scores
    max(1:6*y,
        c(25,sum(n),10*3:5)*c(all(y<4&y-1), #Full house
                            any(y>2), #3 and 4 of a kind
                            z>1, #Small straight
                            z>2, #Long straight
                            any(y>4))] #Yahtzee

कुछ परीक्षण मामले:

> f=function(n,y=table(factor(n,1:6)),z=sum(!diff(diff(sort(n)))))max(1:6*y,c(25,sum(n),10*3:5)*c(all(y<4&y-1),any(y>2),z>1,z>2,any(y>4)))
> f(c(2,4,2,4,6))
[1] 8
> f(c(1,2,3,5,6))
[1] 6
> f(c(6,5,5,6,6))
[1] 28
> f(c(6,5,3,1,4))
[1] 30
> f(c(6,5,3,2,4))
[1] 40
— plannapus
स्रोत
1
हुह, मैंने factorविचलित होने से पहले एक गर्म सेकंड के लिए विचार किया। लेकिन मुझे लगता है कि अगर मैं z( sमेरे जवाब में) आपके दृष्टिकोण का उपयोग करता हूं, तो मैं 134 के लिए मेरा
— Giuseppe
साथ ही, आप का उपयोग करके तीन बाइट्स बचा सकता है all(y<4&y-1)और का उपयोग कर *के बजाय [, और स्थापित करने के yबजाय एक समारोह तर्क के रूप में की तुलना में इनलाइन, और यह अभी भी सभी प्रकार के परीक्षण से गुजरता है: यह ऑनलाइन कोशिश करो!
— ग्यूसेप
इसके अलावा, मैंने पुनर्गठन किया maxऔर मुझे लगता है कि इसने yइनलाइन को स्थापित करने से बचा लिया ।
— ग्यूसेप
3

बैच, 359 बाइट्स

@echo off
set/at=s=m=r1=r2=r3=r4=r5=r6=0
for %%r in (%*)do set/a"m+=!(m-r%%r),r%%r+=1,t+=%%r,p=s-r%%r*%%r,p&=p>>9,s-=p
goto %m%
:1
if %r1% neq %r6% set s=40&goto g
:2
set/at=r3*r4*(r2*(r1+r5)+r5*r6)
if %t% gtr 0 set s=30
goto g
:3
set/a"s=r1^r2^r3^r4^r5^r6"
if %s%==1 if %t% lss 25 set s=25&goto g
:4
set/as=t
goto g
:5
set s=50
:g
echo %s%

स्पष्टीकरण:

@echo off
set/at=s=m=r1=r2=r3=r4=r5=r6=0
for %%r in (%*)do set/a"m+=!(m-r%%r),r%%r+=1,t+=%%r,p=s-r%%r*%%r,p&=p>>9,s-=p
goto %m%

प्रत्येक संख्या के लिए पासा की संख्या की गणना करें, साथ ही अधिकतम, और सभी पासा की कुल राशि, साथ ही एक ही संख्या के पासा के उच्चतम कुल।

:1
if %r1% neq %r6% set s=40&goto g

यदि सभी पासा अलग-अलग हैं, तो यह एक लंबा सीधा हो सकता है, लेकिन इसके लिए या तो नहीं 1या नहीं की जरूरत है 6।

:2
set/at=r3*r4*(r2*(r1+r5)+r5*r6)
if %t% gtr 0 set s=30
goto g

अन्यथा, या यदि अधिकांश दो पासे एक जैसे हैं, तो यह अभी भी एक छोटा सीधा हो सकता है। कम से कम एक 3और एक होना चाहिए और 4अन्य चार संख्याओं का संयोजन भी होना चाहिए ।

:3
set/a"s=r1^r2^r3^r4^r5^r6"
if %s%==1 set s=25&goto g

अगर वहाँ तीन पासा एक ही हैं, एक पूर्ण घर के लिए जाँच करें, के बाद से 3^2==1। हालांकि, कुछ पूर्ण घर, जैसे कि 6s और 5s, का स्कोर 3-ऑफ-ए-तरह होता है।

:4
set/as=t
goto g

अन्यथा, या यदि चार समान हैं, तो कुल स्कोर करें।

:5
set s=50

और अगर पाँच ही हैं, तो याहत्ज़ी!

:g
echo %s%

सर्वश्रेष्ठ स्कोर का उत्पादन।

— नील
स्रोत
1
संभावित [५,५,६,६,६] की याद दिलाने के लिए धन्यवाद -अच्छे-से-पूर्ण-घर के नुकसान के रूप में - मैंने इसे एक परीक्षण मामले के रूप में जोड़ा है। मुझे पता था कि अजीब फ्रिंज मामलों की एक जोड़ी थी जिसे मैं भूल रहा था।
— brhfl
3

जेली , 58 बाइट्स

ċЀ`Ṁ>2ȧS
ṢI=1Ạµ-ƤẸ,E;ṢI$E$;⁸Lƙ`Ṣ⁼2,3¤a3,5,4,2.Ṁ×⁵»Ç»Sƙ`Ṁ$

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

— आउटग्रॉफर को एरिक करें
स्रोत
यह पूरी तरह से वैध है, लेकिन मैं उत्सुक हूं और जेली को यह जानने के लिए पर्याप्त नहीं है कि मैं इसे अपने दम पर बाहर कर दूं ... पूरे घर में वापसी क्यों होती है 25.0जबकि किसी अन्य मामले में पीछे नहीं है .0?
— ब्रफ्ल
@brhfl खैर, क्योंकि यह 2.5 × 10 = 25.0(फ्लोट अंकगणित) के रूप 30में अनुमानित है , जबकि अन्य जैसे कि 3 × 10 = 30(पूर्णांक अंकगणित) के रूप में अनुमान लगाए जाते हैं ।
— आउटगॉल्फ
2
धन्यवाद! मैंने वास्तव में अपने प्रश्न को अच्छी तरह से नहीं कहा था; मैं अधिक उत्सुक था कि आप किस विधि का उपयोग कर रहे हैं एक पूर्ण घर का पता लगाने के लिए जो गणित को अलग तरीके से करता है - लेकिन अब जब मैं इसके बारे में सोचता हूं, तो मैं अनुमान लगा रहा हूं कि यह सिर्फ 2.5, 3, 4, 5 * 10 बनाम करने के लिए गोल्फ खिलाड़ी है। 25, 30, 40, 50. सोचिए मैंने अपने सवाल का जवाब दिया।
— ब्रफल
@ बछेड़ा, चूंकि × 102 बाइट्स है, 2.52 बाइट्स की तरह ही है 25, और 3,5,43 बाइट्स को बचाता है 30,50,40, इसलिए 3 + 0 - 2 = 1 बाइट बचती है।
— एरिक आउटोलॉफ़र
2

पर्ल 6 , 159 बाइट्स

->\b{max map {$_(b)},|(1..6).map({*{$_}*$_}),{.kxxv.sum*?.values.grep(*>2)},{25*(6==[*]
.values)},30*?*{3&4&(1&2|2&5|5&6)},40*?*{2&3&4&5&(1|6)},50*(*.keys==1)}

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

चूंकि इनपुट को स्वीकार किया जा सकता है "हालांकि यह सुविधाजनक है," मेरा कार्य इसे Bagवर्ग के एक उदाहरण के रूप में लेता है , जो कि बहुलता वाला एक कंटेनर है। ए Bagभी एक साहचर्य कंटेनर है; बैग में $bag{$key}कितनी बार $keyआता है।

फ़ंक्शन का बड़ा हिस्सा केवल उन कार्यों की एक सूची है जो प्रत्येक संभव याहत्ज़ी हाथ का मूल्यांकन करते हैं, उस हाथ या शून्य के लिए स्कोर लौटाते हैं यदि हाथ के लिए शर्तें पूरी नहीं होती हैं।

  • |(1..6).map({ *{$_} * $_ })छह कार्यों की एक सूची है जो 1-6 की संख्या के दोहराया रनों के आधार पर हाथों का मूल्यांकन करते हैं। अग्रणी |इस सूची को आसपास की सूची में समतल करता है।
  • {.kxxv.sum * ?.values.grep(* > 2) }3- और 4 के एक तरह के हाथों का मूल्यांकन करता है। .kxxvएक पर Bagरिटर्न कुंजी प्रत्येक के बहुलता के साथ दोहराया, मरने रोल के मूल सूची उबरने, और .sumनिश्चित रूप से पासा का योग। यह राशि एक बूलियन मान ( ?) से गुणा की जाती है जो कि सही है यदि बैग का .values(यानी, गुणकों) का मान 2 से बड़ा है।
  • { 25 * (6 == [*] .values) }पूरे घर का मूल्यांकन करता है। 25 एक बूलियन मूल्य से गुणा किया जाता है जो कि सच है यदि गुणन का गुणनफल 6 है, जो पांच पासा के लिए हो सकता है यदि एक 3 है और दूसरा 2 है।
  • 30 * ?*{ 3 & 4 & (1 & 2 | 2 & 5 | 5 & 6) }छोटे सीधे हाथ का मूल्यांकन करता है। यह एक WhateverCodeसमारोह है; दूसरा सितारा *है Bag। ब्रेसिज़ के बीच की अभिव्यक्ति 3 और 4 के जंक्शनों का जंक्शन है, और 1 और 2, या 2 और 5, या 5 और 6 Bagमें से एक है। इस जंक्शन को परिणाम में इसी गुणा के जंक्शन में खोज रहे हैं । यदि 3 और 4 की mulitplicities, और कम से कम 1 और 2, या 2 और 5, या 5 और 6 में से एक हैं, तो नॉनज़ेरो हैं, जब जंक्शन एक बूलियन (साथ ?) के लिए मजबूर होता है , और यह बूलियन 30 से गुणा किया जाता है। स्कोर पाने के लिए।
  • 40 * ?*{ 2 & 3 & 4 & 5 & (1 | 6) }इसी तरह बड़े सीधे हाथ का मूल्यांकन करता है। यह सरल है क्योंकि पासा में प्रत्येक संख्या 2-5 और 1 या 6 शामिल होनी चाहिए।
  • 50 * (*.keys == 1)याहत्ज़ी हाथ का मूल्यांकन करता है। यह केवल 50 गुना बूलियन मूल्य है जो कि सही है यदि अलग-अलग पासा की संख्या एक है।
— शॉन
स्रोत
2

पिप , 65 63 बाइट्स

n:_NgM\,6MXn*\,6AL[2<MXn23=JSNn3<Y#MX Jn^0MXn=5]*[$+g25--y*t50]

पासे को पांच कमांड-लाइन तर्क के रूप में लेता है। इसे ऑनलाइन आज़माएं!

अघोषित + स्पष्टीकरण

(यह मूल संस्करण है।)

                    g is list of cmdline args; t is 10 (implicit)

Y                   Yank into y:
  _Ng                function that counts occurrences of its argument in g
 M                   mapped to
  \,6                inclusive range from 1 to 6
                    This gives us how many dice are showing each number 1-6

s:                  Assign to s:
  # MX               length of max of
      Jy ^ 0         join y into string and split on zeros
                    This gives us the length of the longest straight

MX                  Max of
   y * \,6           each die frequency in y, times its value
 AL                  to which list append
   [                 this list:
                      3- and 4-of-a-kind:
    MXy > 2 & $+g      If max frequency is 3 or more, sum of g (else 0)
                      Full house:
    23 = J SNy & 25    Sort y and join into string; if it's 000023, 25 (else 0)
                      Straights:
    s > 3 & --s*t      If s is 4 or more, (s-1)*10 (else 0)
                      Yahtzee:
    MXy = 5 & 50       If max frequency is 5, 50 (else 0)
   ]
                    The result of the last expression is autoprinted
— DLosc
स्रोत
1

रूबी , 184 बाइट्स

पूरा कार्यक्रम। इनपुट का परीक्षण करना आसान बनाने के लिए, $/=' '"रिक्त स्थान द्वारा अलग किए गए" प्रारूप में पढ़ने के लिए शीर्ष पर जोड़ें । (191 वर्ण)

a=$<.map &:to_i
b=a.|c=[]
d=(1..6).map{|x|e=a.count x
c<<x*e
e}
e=a.sum
p !b[1]?50:b[4]&&!(a&[1,6])[1]?40:(1..3).any?{|x|(a&[*x..x+3])[3]}?30:(d-[0,2,3])[0]?d.max>2?e:c.max: [25,e].max

मैंने 200 बाइट्स अवरोध को तोड़ दिया और मैंने इसे एक दर्जन बाइट्स के साथ आराम से नष्ट कर दिया!

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

व्याख्या

हालांकि बहुत अच्छा नहीं है। आशा है आपको कुछ रूबी ज्ञान ~ होगा

a=$<.map &:to_i # a: input as [number]*5
b=a.|c=[]       # c: [], b: a.uniq
d=(1..6).map{|x|
    e=a.count x # e: occurrence count in a 
    c<<x*e      # add (number * occurrence count) to c
    e           # return value in d
}
e=a.sum         # e: sum of input
p !b[1] ? 50 :  #   condition to print 50 <= if a.uniq has length 0 (el 1 is nil)
  b[4] &&       #   condition to print 40 <= if a.uniq has length 5 (el 4 exists)
  !(a&[1,6])[1] ? 40 : # <- arr & [mask]  # and a does not have both 1 and 6
  (1..3).any?{|x| # condition to print 30 <= if any of 1..4, 2..5, 3..6
  (a&[*x..x+3])[3]} ? 30 : # [3] to assert entire mask is found in a
  (d-[0,2,3])[0] ? # if, after removing 0 (not found) 2 (a pair) 3 (a triple)
                   # and something is found, this is not full house
  d.max > 2 ?   # is triple / quadruple ?
     e :        # weakly dominating alternatives
     c.max      # choose best by-suit
  : [25,e].max  # choose best by-score
— Unihedron
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.