डार्ट्स कोडगॉल्फ से मिलता है

Question

मुझे लगता है कि हर कोई डार्ट्स से परिचित है, कुछ लोग स्कोर को नहीं समझते हैं, इसलिए उन लोगों के लिए यहां एक उपयोगी लिंक है।

बोर्ड

एक डार्टबोर्ड की तुलना 20 टुकड़ों में पाई कट से की जा सकती है। प्रत्येक टुकड़ा 4 खंडों में विभाजित है।

• एक छोटी बाहरी रिंग जिसे डबल कहा जाता है (अंक x2)
• सिंगल नामक एक बड़ी रिंग (अंक X1)
• ट्रिपल नामक एक और छोटी अंगूठी (अंक x3)
• सिंगल नामक एक और बड़ी रिंग (अंक X1)

बोर्ड के मध्य में 2 और छल्ले हैं, एक हरा और लाल एक (क्लासिक बोर्ड)

• लाल अंगूठी, बोर्ड का केंद्र जिसे बुलसे या डबल बैल कहा जाता है और 50 अंकों के लिए अच्छा है। यह एक दोहरे के रूप में गिना जाता है और इसके कारण इसके साथ जांच करने की अनुमति दी जाती है।
• हरी अंगूठी, जिसे बैल कहा जाता है, एकल बैल या बस 25 और एक एकल के रूप में गिना जाता है।

चुनौती

3 डार्ट या उससे कम के साथ सभी चेकआउट कब्जे का पता लगाएं।
उपयोगकर्ता एक पूर्णांक में प्रवेश कर सकता है और आपको यह जांचना होगा कि 3 डार्ट्स (या कम) के साथ स्कोर 0 पर प्राप्त करना संभव है या नहीं।

उदाहरण

उदाहरण 1:

Input: 170  
Output: T20, T20, Bullseye

उदाहरण 2:

Input: 6  
Output: D3;  
        S3,S1,D1;  
        S2,D2;  
        S2,S2,D1;  
        D2,D1;  
        S4,D1;  
        D1,D1,D1;  
        S1,S1,D2;  
        T1,S1,D1;

उदाहरण 3:

Input: 169
Output: No possible checkout!

नियम

• बेसिक डार्ट नियम, आपको एक डबल (बोर्ड या बुल्सआई की बाहरी रिंग) के साथ समाप्त होना चाहिए
• बाहरी संसाधनों का कोई उपयोग नहीं।
• संभावित चेकआउट की हार्ड कोडिंग की अनुमति है, लेकिन याद रखें कि यह कोडगोल्फ है, यह आपके कोड को छोटा नहीं करेगा;)
• हिट करने के लिए सेल प्रारूप C + N में प्रदर्शित किया जाएगा जहां C = T ट्रिपल के लिए, D डबल के लिए और S सिंगल के लिए।
  • बुल्सआई को बुलसे या डीबी, डीबुल या कुछ सीम्यूलर कहा जा सकता है।

संभव चेकआउट

आपको आरंभ करने के लिए, उच्चतम संभव चेकआउट 170 है।
3 डार्ट्स में 169,168,166,165,163,162,159 संभव नहीं है।
सबसे कम संभव चेकआउट 2 है।

के अतिरिक्त

यह एक आवश्यकता नहीं है, सभी स्कोर के लिए सभी संभावित चेकआउट दिखाने की संभावना में जोड़ें। मूल रूप से क्योंकि मुझे आश्चर्य है कि कितने संयोजन संभव हैं: पी

विजेता सबसे छोटे कोड वाला होगा।

खुश कोडिंग।

Comments

पहला सूचीबद्ध नियम गलत है (और पहला उदाहरण अमान्य है) क्योंकि आप एक बैल पर भी समाप्त कर सकते हैं। यह स्पष्ट करना उपयोगी होगा कि क्या आप किसी कार्यक्रम, किसी समारोह या दोनों की अपेक्षा कर रहे हैं; और आउटपुट फॉर्मेट में कितना लचीलापन है।

— पीटर टेलर

@PeterTaylor मैं इसे और अधिक स्पष्ट कर दूंगा, क्योंकि बीच में हरी अंगूठी और लाल अंगूठी को सिंगल बैल और बुलसे या डबल बैल कहा जाता है।

— त्यूं प्रैंक

उत्कृष्ट प्रश्न के लिए +1। यह वास्तविक दुनिया की समस्या है जिसे सुलझाने में कंप्यूटर अच्छे हैं। आप एस 2 डी 1 डी 1 में 6 फेंक सकते हैं, जो आपके उदाहरण आउटपुट से गायब है (यह वहां होना चाहिए, जब तक कि आप एस 2 एस 2 डी 1 और डी 1 डी 1 डी 1 को एक ही नहीं मानते हैं, लेकिन वे स्पष्ट रूप से अलग-अलग सूचीबद्ध हैं।) आउटपुट प्रारूप और परिणामों की गिनती के बारे में मामूली अस्पष्टता जो मैं अपने उत्तर में संबोधित करूंगा।

— लेवल रिवर सेंट

Answer 1

C ++ 248/228 230/214 वर्ण

Rev 0:

int f(int s){char m[4]="SDT";int t=0;for(int b=2;b<77;b+=1+(b==62)*12)for(int a=2;a<77;a+=1+(a==62)*12){int c=s-a/3*(a%3+1)-b/3*(b%3+1);if(((c+38)/40==1)|(c==50)&&(c%2==0)&(a>=b)){printf("%c%d %c%d D%d\n",m[a%3],a/3,m[b%3],b/3,c/2);t++;}}return t;}

Rev 1. कुछ वर्णों को एक साथ सभी चर घोषित करके, और अनावश्यक कोष्ठक को हटाकर सहेजा गया। यह पता चला है कि सी ++ में सभी तर्क और बिटवाइज़ और / या तुलना की तुलना में कम पूर्वता है।

int f(int s){char m[4]="SDT";int a,b,c,t=0;for(b=2;b<77;b+=1+(b==62)*12)for(a=2;a<77;a+=1+(a==62)*12){c=s-a/3*(a%3+1)-b/3*(b%3+1);if(c>1&c<41|c==50&&c%2==0&a>=b){printf("%c%d %c%d D%d\n",m[a%3],a/3,m[b%3],b/3,c/2);t++;}}return t;}

मैंने कार्यक्रम के बजाय एक समारोह किया, जैसा कि दूसरों ने किया है। यह पाया संभावनाओं की कुल संख्या देता है। कुल सुविधा को समाप्त करके इसे 230 से 214 वर्णों तक कम किया जा सकता है।

नमूना उत्पादन, स्कोर 6:

मैं अलग-अलग पहले और दूसरे डार्ट्स को एक ही संयोजन के रूप में गिनता हूं, जैसा कि ओपी ने किया है (उदाहरण:

T1 S1 D1 = S1 T1 D1) भले ही यह एक अतिरिक्त 7 वर्णों का हो। मैं हमेशा उच्च स्कोर पहले (दोहरीकरण और ट्रेबलिंग को अनदेखा करता हूं) को सूचीबद्ध करता हूं क्योंकि मुझे लगता है कि यह खिलाड़ी के लिए अधिक प्रासंगिक है (जो अपनी रणनीति को बदल सकता है यदि वह पहले डार्ट से चूक जाता है।) उसी कारण से मैं डार्ट्स को क्रम के अनुसार सूचीबद्ध करता हूं। दूसरा डार्ट। मैं तीसरे डार्ट को अन्य दो से पूरी तरह से अलग मानता हूं, इसलिए मैं डी 1 डी 2 और डी 2 डी 1 को अलग-अलग मामले मानता हूं जबकि ओपी ने उन्हें समान रूप से सूचीबद्ध किया है।

गिनती की इस प्रणाली के साथ मुझे 42336 कुल संभावनाएं मिलती हैं , जो कि एममबॉस के समान है। अलग-अलग पहले और दूसरे डार्ट्स को अलग-अलग संयोजनों के रूप में गिना जाता है, यह 83349 तक जाता है।

मैंने सेट के साथ लूप के लिए उपयोग नहीं किया है जैसा कि दूसरों ने किया है (मैं सी ++ के लिए काफी नया हूं और मुझे यह भी पता नहीं है कि क्या यह संभव है।) इसके बजाय मैं लूप वेतन वृद्धि में एक सशर्त दुरुपयोग करने के लिए 20 से 25 तक कूद जाता हूं .मैं एक एकल लूप से चर का उपयोग एक एकल डार्ट के लिए सभी संभावित स्कोर को सांकेतिक शब्दों में बदलना करने के लिए करता हूं, जैसे: एस 1 डी 1 टी 1 एस 2 डी 2 टी 2 आदि। मापांक और विभाजन को डिकोड करने के लिए। यह छोरों के लिए अधिक घोषित करने की क्रिया पर बचाता है, हालांकि यह भावों को अधिक जटिल बनाता है।

इसका नतीजा यह है कि एक अप्रयुक्त डार्ट को T0 के रूप में दिखाया गया है, लेकिन मुझे लगता है कि यह स्पष्ट है कि इसका क्या मतलब है, विशेष रूप से (एक ही संयोजन के रूप में अलग-अलग पहले और दूसरे डार्ट्स पर विचार करके) मैं उन सभी को शुरुआत में एक साथ समूह में लाने में सक्षम रहा हूं मेरे आउटपुट का।

यहाँ अनप्लग्ड संस्करण। अन्य सुविधाओं के एक जोड़े का उपयोग कर रहे हैं & && ऑपरेटरों के साथ चुनिंदा | इस तरह से कि मैं बिना कोष्ठक के पूर्ववर्तीता के आदेश देना चाहता हूं।

int f(int s)
{
  char m[4] = "SDT";
  int a,b,c,t=0;
    for (b = 2; b < 77; b += 1 + (b == 62) * 12)
      for (a = 2; a < 77; a += 1 + (a == 62) * 12){
        c = s - a / 3 * (a % 3 + 1) - b / 3 * (b % 3 + 1);
        if (c>1 & c<41 | c == 50 && c % 2 == 0 & a >= b){
          printf("%c%d %c%d D%d\n", m[a % 3], a / 3, m[b % 3], b / 3, c / 2);
          t++;
        }
     }
   return t;
}

Comments

204 बाइट्स

— सीलिंगकैट

Answer 2

MATLAB ( 299 249 241 वर्ण)

यह मेरी पहली गंभीर गोल्फ है। मेरा पहला प्रयास (136 वर्ण) सही परिणाम देता है, लेकिन सही प्रारूपण के साथ नहीं। यह प्रत्येक डार्ट के लिए अंकों की संख्या को देखते हुए सभी संभावनाएं देता है। इसका मतलब है कि सिंगल 20 और डबल 10 में एक अलग प्रविष्टि है, हालांकि, वे दोनों 20 के रूप में प्रदर्शित होते हैं। बेशक, अंतिम डार्ट हमेशा डबल होता है।

function f(x);u=[1:20 25].';y=[u;2*u; 3*u(1:end-1)];v=combvec([combnk(y,2);[y y];[zeros(62,1) y];[0 0]].',y(22:42).').';v(sum(v,2)==x,:)

दूसरे प्रयास में स्वरूपण में सुधार हुआ है, जिसने निश्चित रूप से वर्णों की संख्या में वृद्धि की है:

function f(x);h=.1;u=h+[1:20,25].';y=[u;2*u;3*u(1:20)];v=combvec([combnk(y,2);[y,y];h*ones(62,1),y];[h,h]].',y(22:42).').';t='SDT';r=@fix;strrep(arrayfun(@(x)[t(int8((x-r(x))/h)),num2str(h*r(x)/(x-r(x)))],v(sum(r(v),2)==x,:),'un',0),'S0','')

299 से 249 वर्णों में सुधार हुआ, जबकि साथ ही साथ आउटपुट स्वरूपण में भी सुधार हुआ। इस उन्नत संस्करण के लिए उदाहरण के मामलों के लिए आउटपुट है:

च (170):

'T20'    'T20'    'D25'

च (6):

'S1'    'S3'    'D1'
'S1'    'T1'    'D1'
'S2'    'D1'    'D1'
'S2'    'S2'    'D1'
'D1'    'D1'    'D1'
''      'S4'    'D1'
''      'D2'    'D1'
'S1'    'S1'    'D2'
''      'S2'    'D2'
''      'D1'    'D2'
''      ''      'D3'

च (169):

Empty cell array: 0-by-3

अतिरिक्त:

मेरी गणना कौशल के अनुसार डार्ट गेम को समाप्त करने के लिए कुल 42336 संभावनाएं हैं।

Comments

परिणाम को दिखाना चाहिए कि किस सेल को हिट करना है, इसलिए पहले यह कहता है कि 60 60 50होना चाहिए T20 T20 Bullseye। मैं प्रश्न में इसे और स्पष्ट करूँगा। हालांकि अच्छा है, लगभग वहाँ :)

— Teun Pronk

हां, मैंने पहले ही इशारा कर दिया था कि मैं खुद को बाहर करूंगा। यह पहला अधूरा प्रयास है। ;)

— mmumboss

उफ़ माफ करना योग्य, मैं कोड के बारे में उत्सुक था और परिणाम मैंने xD के ऊपर की कहानी नहीं पढ़ी

— Teun Pronk

यह बेहतर होना चाहिए। केवल एक चीज जो मैं सोच सकता हूं, वह यह है कि बैल को अभी भी 25 के रूप में प्रदर्शित किया जाता है। लेकिन मुझे उम्मीद है कि यह ठीक है, क्योंकि अन्यथा हार्ड कोड के अलावा कोई अन्य संभावना नहीं है, जो कि बस कोई मज़ा नहीं है।

— mmumboss

25 के रूप में एकल बैल वास्तव में स्वीकार्य है, इसका एक ही तरीका है कि आप 25 को 1 डार्ट किसी भी तरह फेंक सकते हैं

— तून Pronk

Answer 3

रूबी (260 वर्ण)

"अंतिम एक डबल होना चाहिए" लापता टुकड़ा था - यह पता नहीं लगा सका कि 168 के परिणाम क्यों नहीं होने चाहिए ...

c=->n,d=3{d=d-1;r=[];n==0?[r]:(d>=0&&n>0?(o='0SDT';((1..20).map{|p|(1..3).map{|h|c.(n-p*h,d).map{|m|r<<["#{o[h]}#{p}"]+m}}};c.(n-50,d).map{|m|r<<['DB']+m};c.(n-25,d).map{|m|r<<[?B]+m})):1;r.select{|*i,j|j[?D]}.tap{|x|d!=2?1:puts(x.map{|i|"#{i.join(?,)};"})})}

सी। (170)

T20,T20,DB;

सी। (6)

S1,S1,D2;
S1,T1,D1;
S1,S3,D1;
D1,D1,D1;
D1,S2,D1;
D1,D2;
T1,S1,D1;
S2,D1,D1;
S2,S2,D1;
S2,D2;
D2,D1;
S3,S1,D1;
D3;
S4,D1;

Answer 4

पायथन 2.7 (270 वर्ण)

यकीन नहीं है कि अजगर एक-लाइनर की अनुमति देगा, लेकिन वह तीन में है।

def f(n):
 a={'%s%s'%('0SDT'[i],n):n*i for n in range(1,21)+[25] for i in [1,2,3] if n*i<75};a['']=0
 for r in [' '.join(h[:3]) for h in [(x,y,z,a[x]+a[y]+a[z]) for x in a for y in a for z in {k:a[k] for k in a if 'D' in k}] if h[3]==n and len(h[0])<=len(h[1])]:print r

या 278+ एक उचित 'नो चेकआउट' संदेश के साथ चार्ट (जैसे 290 यहाँ):

def f(n):
 a={'%s%s'%('0SDT'[i],n):n*i for n in range(1,21)+[25] for i in [1,2,3] if n*i<75};a['']=0;
 for r in [' '.join(h[:3]) for h in [(x,y,z,a[x]+a[y]+a[z]) for x in a for y in a for z in {k:a[k] for k in a if 'D' in k}] if h[3]==n and len(h[0])<=len(h[1])] or ['No Checkout']:print r

ये रहा:

च (170)

T20 T20 D25

च (6)

S3 S1 D1
S2 S2 D1
S2 D1 D1
S1 S3 D1
S1 S1 D2
S1 T1 D1
 S2 D2
 S4 D1
  D3
 D2 D1
 D1 D2
T1 S1 D1
D1 S2 D1
D1 D1 D1

च (169)

No Checkout

जिन चीजों से मैं खुश नहीं हूं:

for x in a for y in a for z in

यह कुल का 10% से अधिक है। क्या इत्यादि के बिना एक अधिक कॉम्पैक्ट तरीका है?

and len(h[0])<=len(h[1])

इसका उपयोग दो डार्ट फिनिश (जैसे ['', 'S1', 'D1'] और ['S1', '', 'D1'] के मामले में डुप्लिकेट को रोकने के लिए किया जाता है। मैं बात करने के लिए डीम ऑर्डर करता हूं (हे - अंतिम डार्ट को एक डबल होना है, इसलिए स्पष्ट रूप से ऑर्डर मायने रखता है), लेकिन गैर-थ्रो एक विशेष मामला है।

Answer 5

05AB1E , 43 बाइट्स

20L25ª3Lâ¨Ðʒθ<}Uã«XâXìε˜2ô}ʒPOQ}εε`…TSDsèì

बहुत धीमी गति से .. सूची की सूची के रूप में आउटपुट, या कोई खाली सूची संभव नहीं है। मेरे बैल हैं S25और D25; अगर इसकी अनुमति नहीं है तो मैं इसे बदल सकता हूं।

इसे ऑनलाइन आज़माएं या एक बार में कुछ परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

कुछ चरण हैं:

1) सभी संभावित एकल, डबल और ट्रिपल डार्ट की सूची बनाएं:

20L         # Create a list in the range [1,20]
   25ª      # Append 25 to this list
      3L    # Create a list in the range [1,3]
        â   # Create all possible pairs of these two lists
         ¨  # Remove the last pair (which is the Triple Bull)
            # Now we have a list of all possible darts:
            #  [[1,1],[1,2],[1,3],[2,1],...,[20,3],[25,1],[25,2]]

2) 3 डार्ट्स तक सभी संभव फिनिशर्स (एक डबल के साथ समाप्त) प्राप्त करें:

Ð           # Triplicate this list
 ʒ  }       # Filter the top copy by:
  θ         #  Where the last value
   <        #  Decremented by 1 is truthy (==1), so all doubles
     U      # Pop this filtered list of doubles, and store it in variable `X`
 ã          # Create all possible pairs of the list of darts with itself
  «         # Merge it with the list of darts
            # We now have a list containing all possible variations for 1 or 2 darts
 Xâ         # Then create all possible pairs of these with the doubles from variable `X`
   Xì       # And prepend the doubles themselves as well
            # Now we have all possible variations of 1 double; 1 dart + 1 double;
            # or 2 darts + 1 double
     ε   }  # Map each to:
      ˜     #  Deep-flatten the list
       2ô   #  And split it into parts of size 2
            #  (this is to convert for example a 2 darts + 1 double from
            #   [[[20,3],[5,1]],[1,2]] to [[20,3],[5,1],[1,2]])
            # Now we have a list of all possible finishers of up to 3 darts

3) केवल उन लोगों को रखें जिनके लिए कुल स्कोर इनपुट-पूर्णांक के बराबर है:

ʒ   }       # Filter this list by:
 P          #  Get the product of each inner-most lists
            #   i.e. [[20,3],[5,1],[1,2]] → [60,5,2]
  O         #  Take the sum of those
            #   i.e. [60,5,2] → 67
   Q        #  Check if this value is equal to the (implicit) input-integer
            # Now we only have the finishers left with a total value equal to the input

4) डेटा को प्री-प्रिंटेड परिणाम-सूची में परिवर्तित करें (यानी [[20,3],[5,1],[1,2]]बन जाता है ["T20","S5","D2"]):

ε           # Map each of the remaining finishers of up to 3 darts to:
 ε          #  Map each inner list to:
  `         #   Push both values separately to the stack ([20,3] → 20 and 3)
   …TSD     #   Push string "TSD"
       s    #   Swap to get the integer for single/double/triple at the top of the stack
        è   #   Use it to index into the string
            #   NOTE: 05AB1E has 0-based indexing with automatic wraparound,
            #   so the triple 3 will wrap around to index 0 for character "T"
         ì  #   Prepend this character in front of the dart-value
            # (after which the result is output implicitly as result)

Answer 6

कोटलिन , 254 बाइट्स

नोट: algorythm Level River St के C ++ उत्तर पर आधारित है।

{s:Int->val m="SDT"
var c=0
val r=(2..62).toList()+listOf(75,76)
for(t in r)for(o in r){val l=s-o/3*(o%3+1)-t/3*(t%3+1)
if((l>1&&l<41||l==50)&&l%2==0&&o>=t){println("${m[o%3]}${o/3},${m[t%3]}${t/3},D${l/2}")
c++}}
if(c<1)println("No possible checkout!")}

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