असंभव डार्ट्स स्कोर

Question

मुझे यह देखकर आश्चर्य नहीं हुआ कि यह पहले से ही पूछा गया था, हालांकि डार्ट्स चेकआउट पर एक बड़ा सवाल है: डार्ट्स कोडगॉल्फ से मिलते हैं

आपकी चुनौती यह गणना करना है कि कौन से स्कोर 'एन' डार्ट्स के लिए अधिकतम स्कोर के नीचे 'एन' डार्ट्स के साथ संभव नहीं हैं। उदाहरण के लिए, n = 3 के लिए, अधिकतम संभव स्कोर 180 है ताकि आप वापस आ जाएं [163,166,169,172,173,175,176,178,179]

एक नंगे हड्डियों के नियम सारांश के लिए:

एक डार्ट के लिए संभावित स्कोर हैं:

• 0 (मिस)
• 1-20, 25, 50
• 1-20 का डबल या ट्रिपल

नियम:

• मानक कोड गोल्फ नियम लागू होते हैं
• आपको अपनी भाषा को किसी भी तरह से एक एकल पैरामीटर 'एन' लेना चाहिए, जो अधिकतम स्कोर के नीचे सभी अद्वितीय अंकों की सूची / सरणी देता है जो n डार्ट्स के साथ स्कोर नहीं किया जा सकता है। आप इन मानों को कंसोल पर प्रिंट भी कर सकते हैं।
• परिणामों का क्रम महत्वहीन है
• बाइट्स में सबसे छोटा कोड जीतता है

Comments

फॉर्मेटिंग के लिए माफी, फोन पर लिखना!

— बीरिटोल

कुछ हद तक संबंधित ; मुझे लगता है कि एक सीमा से लापता मूल्यों को खोजने के बारे में एक और एक था, लेकिन मैं इसे खोजने के लिए प्रतीत नहीं कर सकता।

— Giuseppe

ईमानदारी से माफी, मैंने उन आउटपुट को 3 डार्ट्स के मूल प्रश्न के उत्तर से खींच लिया, लेकिन सत्यापित नहीं किया! मैं सवाल अपडेट करूंगा!

— बीरटिपोल

कोई चिंता नहीं :-) मुझे ठीक लग रहा है!

— ग्यूसेप

Answer 1

पायथन 3 , 80 79 59 57 बाइट्स

^{-1 बाइट का धन्यवाद
अर्नाउल्ड -20 बाइट्स के लिए धन्यवाद, अर्बो
-2 बाइट्स के लिए धन्यवाद, नकारात्मक सात के लिए}

lambda x:[-i-~x*60for i in(x<2)*b'a[YUSOLI'+b'MJGDCA@>=']

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

Comments

मैं, इर्र, क्या ?!

— बेरीटिपोल

@beirtipol 2 डार्ट (अच्छी तरह से, 1 डार्ट पर भी, लेकिन एक और संख्या है) के बाद संख्याओं पर एक पैटर्न है, यह इस पैटर्न के आधार पर संख्याओं की गणना करता है।

— रॉड

आह, अच्छी तरह से खेला जाता है, वास्तव में अच्छी तरह से खेला जाता है

— beirtipol

@EriktheOutgolfer यदि आप कंप्रेस कर रहे हैं, तो आप सब कुछ कंप्रेस कर सकते हैं;) 59 बाइट्स

— ArBo

@negativeseven ने मुझे 60 चीज़ों के लिए हराया, कोशिश करने जा रहा था कि :) बाइटस्ट्रेस को अलग रखने पर अच्छा लगता है, हालांकि इसके बारे में सोचा नहीं था।

— ArBo

Answer 2

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

{^60*$_∖[X+] [[|(^21 X*^4),25,50]xx$_,]}

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

जानवर बल समाधान है कि सभी संभव डार्ट मूल्यों बाहर काम करता है।

Answer 3

जावास्क्रिप्ट (ईएस 6),  55  54 बाइट्स

@ बस्ती के लिए 1 बाइट का धन्यवाद सहेजा गया

रॉड द्वारा उपयोग किए गए पैटर्न के आधार पर ।

n=>[...1121213+[n-1?33:2121242426]].map(x=>n-=x,n*=60)

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

Comments

s=60*n-> n*=60एक बाइट को बचाने के लिए।

— झबरा

@ शगुन थैंक्स। :) मैं अपने शुरुआती (अप्रकाशित) संस्करण की वजह से चूक गया, जहां का बाद में पुन: उपयोग किया गया था। $n$

— अरनुलद

Answer 4

पर्ल 6 , 39 बाइट्स (37 वर्ण)

यह निश्चित रूप से बड़े पैमाने पर स्लेजहैमर का उपयोग कर रहा है लेकिन यह काम करता है। (यह सिर्फ इसे बल नहीं देता है, यह क्रूरता से बल देता है)

{^60*$_∖[X+] (|(^21 X*^4),25,50)xx$_}

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

यहाँ इसका स्पष्टीकरण दिया गया है:

{                                   } anonymous block for the 
       ∖                                set difference of
 ^60*$_                                   - 0 .. max score (60 * throwcount)
        [X+]                    xx$_      - the cross addition (throwcount times) of 
             (                 )              all possible score values, being 
              |(    X*  )                       flattened cross multiplication of
                ^21   ^4                          0..20 and 0..3 (for double and triple)
                         ,25,50                 and 25 and 50

X* ^4पार गुणक डुप्लिकेट मानों का एक बहुत उत्पन्न करता है (वहाँ 20 शामिल शून्य और कि का हो जाएगा से पहले पार अलावा कर रही है), लेकिन जब से हम सेट अंतर का उपयोग करने वाले किसी भी समस्याओं का कारण नहीं है ∖जो अद्वितीय मूल्यों के साथ काम करता है।

यह वर्तमान में विफल रहता है $n == 1(जिसे खाली सेट लौटना चाहिए), लेकिन एक मुद्दा दायर किया गया है और भविष्य के संस्करणों में काम करेगा। जोकिंग का संस्करण एक नन्हा सा है, लेकिन $n == 1वर्तमान राकोडो में काम करता है ।

Comments

वाह, अजीब ... मेरे अतिरिक्त बाइट्स n = 1 समस्या को ठीक करने से हैं (हालांकि आप $ ^ के बजाय $ _ n -1 के लिए उपयोग कर सकते हैं)

— जो किंग

@ जोकिंग हा, मुझे नहीं लगता कि दो लोगों के साथ लगभग एक ही उत्तर देने में कुछ गड़बड़ है (विशेषकर जब से आपका वर्तमान संस्करणों बनाम मेरा काम है जो वर्तमान में सैद्धांतिक है) इसके अलावा, $ _ पर धन्यवाद, मेरे हिस्से पर कुल ब्रेनफार्ट

— user0721080601

Answer 5

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

20Ż;25×Ɱ3ẎṖœċ⁸§ṪṖḟƊ

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

Answer 6

MATL , 25 23 बाइट्स

@Giuseppe को धन्यवाद , जिन्होंने एक गलती को ठीक किया और 2 बाइट्स हासिल की!

25tE3:!21:q*vZ^!stP:wX-

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

व्याख्या

जानवर बल दृष्टिकोण।

25      % Push 25
tE      % Duplicate, double: gives 50
3:!     % Push column vector [1;2;3]
21:q    % Push row vector [0 1 ... 20]
*       % Multiply with broadcast. Gives a matrix with all products
v       % Concatenate everything into a column vector
Z^      % Implicit input: n. Cartesian power with exponent n
!s      % Sum of each row
tP      % Duplicate, flip: The first entry is now 60*n
:       % Push row vector [1 2 ... 60*n]
w       % Swap
X-      % Set difference. Implicit display

Comments

आपका संस्करण काम नहीं करता है n=2, इसलिए मैंने इसे ठीक किया और बूट करने के लिए बाइट को बंद कर दिया! इसे ऑनलाइन आज़माएं!

— ग्यूसेप

ओह, चीजों को फिर से व्यवस्थित करके एक और बाइट पाया :-) 23 बाइट्स

— Giuseppe

@Giuseppe अरे, बहुत बहुत धन्यवाद!

— लुइस मेंडो

Answer 7

जे , ⁴⁸ 45 बाइट्स

2&>(35 44,q:626b66jh)&,60&*-1 4 8 14,q:@13090

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

-3 बाइट्स FrownyFrog के लिए धन्यवाद

एक क्रूर बल समाधान का प्रयास किया गया, लेकिन रॉड के विचार के इस अनुवाद को हरा पाने में सक्षम नहीं था।

Comments

हमेशा की तरह tyvm, @FrownyFrog

— योना

इससे भी कम626b66jh

— FrownyFrog

क्या आधार का उपयोग किया जा रहा है और J इसका उपयोग कैसे करता है?

— जोनाह

देख codegolf.stackexchange.com/questions/113103/...

— FrownyFrog

आह, ty। मैं भूल गया bथा कि वहाँ "सीमांकक" था और इसे संख्या के भाग के रूप में पढ़ रहा था ....

— योना

Answer 8

आर , 64 बाइट्स

function(n,`!`=utf8ToInt)c(60*n-!"",(!"#%),/")[n<2])

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

रॉड द्वारा पाया गया अद्भुत जवाब पोर्ट करता है ।

आर , 85 73 68 बाइट्स

function(n)setdiff(0:(60*n),combn(rep(c(0:20%o%1:3,25,50),n),n,sum))

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

जानवर बल nडार्ट्स के साथ सभी संभावित स्कोर उत्पन्न करता है , फिर उचित सेट अंतर लेता है।

मुझे याद दिलाने के लिए ऑरेंजचेयर के ऑक्टेव समाधान का श्रेय combn।

5 और बाइट्स का उपयोग करने के रॉबिन राइडर के सुझाव के लिए धन्यवाद %o%।

Comments

इस बारे में बहुत खेद है, मुझे उदाहरण की दोहरी जाँच करनी चाहिए थी!

— बीरटिपोल

के FUNतर्क का अच्छा उपयोग combn! आप प्राप्त कर सकते हैं 68 बाइट्स के साथ %o%के बजाय x*3,x*2।

— रॉबिन राइडर

@ रॉबिनडर दुहा। मैंने यह भी पता लगाने की कोशिश की कि ऑक्टेव उत्तर पर प्रसारण गुणन कैसे करें!

— ग्यूसेप

Answer 9

ऑक्टेव , 91 बाइट्स 73 बाइट्स 71 बाइट्स

एक और जानवर बल विधि।

@(n)setdiff(0:60*n,sum(combnk(repmat([x=0:20,x*2,x*3,25,50],1,n),n),2))

नीचे करने के लिए 73 बाइट्स ग्यूसेप करने के लिए धन्यवाद
combnk साथ nchoosek की जगह नीचे 71 बाइट्स के लिए

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

Answer 10

पायथ , 22 बाइट्स

-S*60Q+M^+yB25*M*U4U21

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

3 से अधिक इनपुट के लिए TIO में टाइम आउट करें।

-S*60Q+M^+yB25*M*U4U21Q   Implicit: Q=eval(input())
                          Trailing Q inferred
                 U4       Range [0-3]
                   U21    Range [0-20]
                *         Cartesian product of the two previous results
              *M          Product of each
          yB25            [25, 50]
         +                Concatenate
        ^             Q   Cartesian product of the above with itself Q times
      +M                  Sum each
                            The result is all the possible results from Q darts, with repeats
  *60Q                    60 * Q
 S                        Range from 1 to the above, inclusive
-                         Setwise difference between the above and the possible results list
                          Implicit print

Comments

छोटा नहीं है, लेकिन अगर आप प्रदर्शन में बदलाव U4करते हैं S3तो थोड़ा सुधार होता है क्योंकि दोनों कार्टेजियन उत्पादों को उन सभी अतिरिक्त बेकार 0 से निपटना नहीं पड़ता है। इनपुट 3 आउटपुट ~ 13 सेकंड में ~ 30 के बजाय उस मामले में (हालांकि इनपुट 4 अभी भी बाहर है, और यह कोड गोल्फ है, इसलिए इससे कोई फर्क नहीं पड़ता; पी)।

— केविन क्रूज़सेन

@ केविनक्रूजसेन बहुत अच्छी बात है, मैंने यह नहीं सोचा था कि मैं कार्टेशियन उत्पाद के दोनों किनारों पर एक 0 शामिल था। अगर मुझे कोई और गोल्फ या कारण मिलें तो मुझे इसमें शामिल होना सुनिश्चित होगा, धन्यवाद!

— सोक

बहुत बुरा वहाँ Pyth में 0-आधारित समावेशी श्रेणी नहीं है .. मैंने यह कोशिश की -S*60QsM^*MP*S3aU21 25, लेकिन उस स्थान के बीच 21और 25थोड़ा परेशान है .. के साथ 0-आधारित समावेशी श्रेणी yTका उपयोग किया जा सकता है 21, थोड़े इस तरह से: -S*60QsM^*MP*S3a}ZyT25( लेकिन फिर बिना Zपाठ्यक्रम के, }0-आधारित समावेशी श्रेणी के साथ प्रतिस्थापित किया गया)। हो सकता है कि आपको 25सूची में जोड़ने और 75पहले कार्टेशियन उत्पाद के बाद हटाने के इस वैकल्पिक दृष्टिकोण में गोल्फ के लिए कुछ दिखाई दे ?

— केविन क्रूज़सेन

Answer 11

स्टैक्स , 24 बाइट्स

¿ß☺o↕αg╠╩╬ò▼í¬«¥↕▄í■♣▓î►

इसे चलाएं और डीबग करें

यह n = 3 के लिए बहुत धीमा है, और वहां से खराब हो जाता है।

Answer 12

पायथन 2 , 125 बाइट्स

lambda n:set(range(60*n))-set(map(sum,product(sum([range(0,21*j,j)for j in 1,2,3],[25,50]),repeat=n)))
from itertools import*

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

---

पायथन 3 , 126 125 122 बाइट्स

lambda n:{*range(60*n)}-{*map(sum,product(sum([[i,i*2,i*3]for i in range(21)],[25,50]),repeat=n))} 
from itertools import*

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

_{-3 बाइट्स, रॉड के लिए धन्यवाद}

Comments

@rod धन्यवाद, :)

— TFeld

Answer 13

05AB1E , 21 20 18 बाइट्स

20Ý25ª3Lδ*˜¨ãOZÝsK

-3 बाइट्स @Grimy के लिए धन्यवाद ।

कार्टिजियन उत्पाद बिलिन के कारण इनपुट जितनी तेज़ी से बढ़ता है, उतनी ही तेज़ी से बाहर निकलता है ã।

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

स्पष्टीकरण:

20Ý                 # Push a list in the range [0, 20]
   25ª              # Append 25 to this list
      3L            # Push a list [1,2,3]
        δ*          # Multiply the top two lists double-vectorized:
                    #  [[0,0,0],[1,2,3],[2,4,6],[3,6,9],...,[20,40,60],[25,50,75]]
          ˜         # Flatten this list: [0,0,0,1,2,...,40,60,25,50,75]
           ¨        # Remove the last value (the 75)
            ã       # Create all possible combinations of the (implicit) input size,
                    # by using the cartesian power
             O      # Sum each inner list of input amount of values together
              Z     # Get the maximum (without popping the list), which is 60*input
               Ý    # Create a list in the range [0, 60*input]
                s   # Swap so the initially created list is at the top of the stack again
                 K  # And remove them all from the [0, 60*input] ranged list
                    # (then output the result implicitly)

Comments

उस नोट पर, अधिकतम 60 * input, 180 नहीं है।

— ग्रैमी

@Grimy हाँ, मेरी मूर्खता को नज़रअंदाज़ करें .. मैंने टेस्ट सूट में गलत परिणाम देखा, लेकिन निश्चित रूप से मैंने सिर्फ एक गलती की। मुझे काम पर एक लंबे दिन के बाद शाम को कोडगुल्फ नहीं करना चाहिए ..>।>

— केविन क्रूज़सेन

Answer 14

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

21Ḷ×þ3R¤;25;50FœċµS€³×60¤R¤ḟ

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

Answer 15

मठगोल्फ , 26 बाइट्स

╟*rJrN▐3╒*mÅ~*╡ak.ε*mÉa─Σ-

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

-2 बाइट्स केविन क्रूज़सेन की बदौलत

व्याख्या

╟*r                          push [0, ..., 60*input-1]
   Jr                        push [0, ..., 20]
     N▐                      append 25 to the end of the list
       3╒                    push [1, 2, 3]
         *                   cartesian product
          mÅ                 explicit map
            ~                evaluate string, dump array, negate integer
             *               pop a, b : push(a*b)
              ╡              discard from right of string/array
               a             wrap in array
                k            push input to TOS
                 .           pop a, b : push(b*a) (repeats inner array input times)
                  ε*          reduce list with multiplication (cartesian power)
                    mÉ       explicit map with 3 operators
                      a      wrap in array (needed to handle n=1)
                       ─     flatten array
                        Σ    sum(list), digit sum(int)
                         -   remove possible scores from [0, 60*input-1]

Comments

-2 बदलकर बाइट्स 3╒*mÅ~*N_∞α+करने के लिए N▐3╒*mÅ~*╡। (पुनश्च: आप अपने स्पष्टीकरण हेडर में " इनपुट 3 के लिए " क्यों उल्लेख करते हैं ?)

— केविन क्रूज़सेन

अच्छा काम है, जब मैं अपने लैपटॉप पर वापस आऊंगा तो इसे बदल दूंगा! मेरे पास एक 31-बायटर था जब मैंने उत्तर लिखना शुरू किया, जो अधिक जटिल था, इसलिए मैं पूरी तरह से स्पष्टीकरण जोड़ना चाहता था, लेकिन फिर मुझे पोस्ट में समाधान मिला

— अधिकतम

Answer 16

वोल्फ्राम भाषा (गणितज्ञ) , 69 बाइट्स

Complement[Range[60#],Tr/@{Array[1##&,{4,21},0,##&],25,50}~Tuples~#]&

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

Lirtosiast के जवाब के आधार पर ।

Arrayतीसरा तर्क ऑफसेट (डिफ़ॉल्ट 1) को निर्दिष्ट करता है, और इसका चौथा तर्क सिर को उपयोग करने के बजाय निर्दिष्ट करता है List। ##&के बराबर है Sequence, इसलिए Array[1##&,{4,21},0,##&](और चपटा) रिटर्न देता है Sequenceजिसमें बाहरी उत्पाद के सदस्य होते हैं 0..3और 0..20।

Answer 17

चारकोल , 36 बाइट्स

Ｉ⁺Ｅ…wvtsqpmjgkhea_[YS⎇⊖θ⁹¦¹⁷℅ι×⁶⁰⁻θ²

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। @ रॉड के एल्गोरिथ्म का उपयोग करता है; ब्रूट बल ने 60 बाइट ली होंगी। स्ट्रिंग को 9 वर्णों में विभाजित करके काम करता है यदि इनपुट 1 से अधिक है, तो वर्णों के अध्यादेशों को लेना और 60 के उपयुक्त एकाधिक जोड़ना है।

Answer 18

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 305 बाइट्स

(a,b)=>(int)Math.Pow(a,b);f=n=>{var l=new List<int>(new int[21].SelectMany((_,x)=>new[]{x,x*2,x*3})){25,50};int a=l.Count,b,c,d,e=P(a,n),f;var r=new int[e];for(b=e;b>0;b--)for(c=0;c<n;c++){d=b;while(d>P(a,c+1))d-=P(a,c+1);f=(d/P(a,c))-1;r[b-1]+=l[f>0?f:0];}return Enumerable.Range(0,l.Max()*n).Except(r);}

खैर, सी # में सभी संभावित संयोजनों की गणना करने का एक आसान तरीका नहीं लगता है, इसलिए एक कोड की यह आपदा मेरे साथ आ सकती है।

इसके अलावा इसे पूरा करने के बारे में 30s ...

बेहतर समाधान देखना पसंद करेंगे।

P=(a,b)=>(int)Math.Pow(a,b);
F=n=>
{
    var l=new List<int>(new int[21].SelectMany((_,x)=>new[]{x,x*2,x*3})){25,50};
    int a=l.Count,b,c,d,e=P(a,n),f;
    var r=new int[e];
    for(b=e;b>0;b--)
        for(c=0;c<n;c++)
        {
            d=b;
            while(d>P(a,c+1))
                d-=P(a,c+1);
            f=(d/P(a,c))-1;
            r[b-1]+=l[f>0?f:0];
        }
    return Enumerable.Range(0,l.Max()*n).Except(r);
}

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

Comments

लगता है कि आप अपने वास्तविक गोल्फ जवाब पोस्ट करने के लिए भूल गया। आमतौर पर लोग गोल्फ वाले के नीचे इसका अनियंत्रित रूप रखते हैं।

— विस्कह

@ अच्छी तरह से, मैं आमतौर पर एक गोल्फ पोस्ट करता हूं अगर यह समझ में आता है, लेकिन चूंकि यह एक बहुत लंबा था, इसलिए मैंने इसे करने का कोई मतलब नहीं देखा क्योंकि यह वैसे भी टियो लिंक में पाया जा सकता है, लेकिन मुझे लगता है कि आप फिर भी सही हैं

— इनत 3

Answer 19

कोटलीन , 118 बाइट्स

{n:Int->val i=if(n<2)listOf(23,24,31,25,37,41,44,47)
else
List(0){0}
i+List(9){n*60-listOf(17,14,11,8,7,5,4,2,1)[it]}}

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

Answer 20

पर्ल 5 -n , 96 93 91 बाइट्स

$"=',';@b=map{$_,$_*2,$_*3,25,50}0..20;map$r[eval]=1,glob"+{@b}"x$_;map$r[$_]||say,0..$_*60

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

यह रन समय के बजाय कोड लंबाई के लिए अनुकूलित किया गया था, इसलिए यह धीमा है। यह अपने लुकिंग हैश के लिए बहुत सारी अनावश्यक प्रविष्टियाँ उत्पन्न करता है। @bसरणी को uniqगति के माध्यम से चलाने से यह बहुत बढ़ जाता है, लेकिन 5 और बाइट का खर्च होता है, इसलिए मैंने ऐसा नहीं किया।

Answer 21

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 81 बाइट्स

Complement[Range[60#-1],Total/@Tuples[Flatten[{Array[Times,{3,20}],0,25,50}],#]]&

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

मैथेमेटिका में कुछ संबंधित भवन शामिल हैं FrobeniusSolveऔर प्रतिबंधित रूप हैं IntegerPartitions, लेकिन उनमें से कोई भी क्रूर बल से कम नहीं है।

Comments

यह गलत है - इसे वापस लौटना चाहिए{163,166,169,172,173,175,176,178,179}

— Attitat

@attinat फिक्स्ड।

— lirtosiast

69 बाइट्स

— एटीनैट

@attinat इसे स्वयं पोस्ट करें।

— lirtosiast