आप कितनी कैंडी खा सकते हैं?

Question

विचार के लिए TNB में Geobits को श्रेय

पर्याप्त विस्तार के बिना एक पोस्ट हाल ही में एक दिलचस्प खेल बना:

2 बच्चे कैंडी की एक सरणी के सामने बैठते हैं। कैंडी का प्रत्येक टुकड़ा 1 से गिना जाता है x, जिसमें xकैंडी की कुल मात्रा मौजूद होती है। प्रत्येक संख्या की ठीक 1 घटना है।

खेल का लक्ष्य बच्चों को कैंडी खाने के लिए है और कैंडी के मूल्यों को गुणा करना है जो उन्होंने अंतिम स्कोर पर पहुंचने के लिए खाए हैं, उच्च स्कोर जीत के साथ।

हालांकि मूल पोस्ट में महत्वपूर्ण जानकारी छूट गई, जैसे कि कैंडी का चयन कैसे किया जाता है, इसलिए हमारी कहानी में बच्चों ने फैसला किया कि बड़े बच्चे को पहले जाना है, और आधे कैंडी तक खा सकते हैं, हालांकि एक बार जब वह अपनी बारी के अंत की घोषणा करता है, वह अपना मन नहीं बदल सकता।

इस खेल में से एक बच्चे को कैंडी पसंद नहीं है, इसलिए वह जितना संभव हो उतना कम खाना चाहता है, और उसने देखा कि एक बार उसके पिताजी एक बार कुछ कोड लिखते हैं, और आंकड़े जो वह प्राप्त कौशल का उपयोग कर सकते हैं कि कितना कैंडी काम करना है। उसे जीत सुनिश्चित करने के लिए खाने की जरूरत है, जबकि अभी भी जितना संभव हो उतना कम भोजन करना चाहिए।

चुनौती

कैंडी की कुल संख्या को देखते हुए x, आपके कार्यक्रम या फ़ंक्शन को जीत सुनिश्चित करने के लिए सबसे कम मात्रा में कैंडी का उत्पादन करना चाहिए n, भले ही उसका प्रतिद्वंद्वी सभी शेष कैंडी को खाता हो।

स्वाभाविक रूप से बड़ी संख्या बड़ी संख्या बनाती है, इसलिए आप उसे जो भी राशि देंगे, वह nसबसे बड़ी संख्या खाएगा ।

नियम

• xहमेशा उस श्रेणी में एक सकारात्मक पूर्णांक होगा 0 < x! <= lजहां lआपकी भाषा की नंबर हैंडलिंग क्षमताओं की ऊपरी सीमा है
• यह गारंटी है कि बच्चा हमेशा nसबसे बड़ी संख्या खाएगा , उदाहरण के लिए x = 5और n = 2, वह खाएगा 4और5

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

x = 1
n = 1
(1 > 0)

x = 2
n = 1
(2 > 1)

x = 4
n = 2
(3 * 4 == 12 > 1 * 2 == 2)

x = 5
n = 2
(4 * 5 == 20 > 1 * 2 * 3 == 6)

x = 100
n = 42
(product([59..100]) > product([1..58]))

x = 500
n = 220
(product([281..500]) > product([1..280]))

स्कोरिंग

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

Comments

मैं कितना कैंडी खा सकता हूं? यह सब। कैंडी के सभी।

— AdmBorkBork

नया शीर्षक: "आपको कितनी कैंडी खाने की ज़रूरत है?"

— स्पेर

@ स्किड्सदेव को x = 0भी संभाला जाना चाहिए , कब से 0! = 1? (शायद xएक पॉजिटिव

— इंटेगर के

@ क्रोनोसाइडल ने "पॉजिटिव" पूर्णांक जोड़ा

— स्किड्सदेव

मैंने कैंडी के 10k टुकड़े जमीन पर फेंक दिए। थोड़ा सा आंकड़ा जमीन में एक छेद खोदा और मेरी वजह से एक विशाल कैंडी गुफा मिली। ):

— चन्द्रावत

Answer 1

पायथन 3 , 76 बाइट्स

F=lambda x:x<2or x*F(x-1)
f=lambda x,n=1:x<2or n*(F(x)>F(x-n)**2)or f(x,n+1)

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

इस तथ्य पर निर्भर करता है कि अभी भी जीतने के लिए $n$ कैंडी खाने के लिए और कैंडी की कुल संख्या $x$ , $\frac{x!}{(x-n)!}>(x-n)!$सच होना चाहिए, जिसका मतलब है$x!>((x-n)!)^2$।

-1 स्किड्सदेव से

-3 -6 बीएमओ से

-3 स्पियर से

तय करने के लिए +6 x = 1

Comments

आप 1 बाइट को शीर्ष फ़ंक्शन को बदलकर बचा सकते हैंfrom math import factorial as F

— स्किड्सदेव

आप शॉर्ट-सर्कुलेटिंग व्यवहार का उपयोग करके इन पुनरावर्तन को फिर से लिख सकते हैं, जैसे। दूसरे के लिए n*(F(x)>F(x-n)**2)or f(x,n+1):। इसी तरह x<2or x*F(x-1)पहले वाले के लिए जो आयात से कम है।

— ბიმო

उन सभी के तीन अच्छे सुझाव हैं, धन्यवाद। (और जोड़ा गया)

— nedla2004

-3 बाइट्स जिनके साथ import math;F=math.factorialमुझे शायद अजगर सुझावों का पता लगाने के लिए मेटा जाना चाहिए ...

— शुक्राणु

@ शेपर: लेकिन F=lambda x:x<2or x*F(x-1)तीन बाइट्स कम हैं?

— ბიმო

Answer 2

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

n=>(g=p=>x<n?g(p*++x):q<p&&1+g(p/n,q*=n--))(q=x=1)||n

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

कार्यात्मक श्रेणी

दिलचस्प बात यह है कि, बच्चों के उत्पादों के बीच अंतर हमेशा इतना बड़ा होता है कि IEEE 754 एन्कोडिंग में निहित परिशुद्धता का नुकसान कोई समस्या नहीं है।

नतीजतन, यह के लिए काम करता $0 \le n \le 170$ । इसके अलावा, मंटिसा और एक्सपोनेंट ओवरफ्लो (पैदावार + इन्फिनिटी ) दोनों और हमें BigInts (+1 बाइट) की आवश्यकता होगी ।

कैसे?

चलो $p$ अन्य बच्चे की कैंडी उत्पाद हो सकता है और जाने $q$ हमारे अपने कैंडी उत्पाद हो।

1. $p=n!$$q=1$

2. $q\ge p$

   • $p$$n$
   • $q$$n$
   • $n$

परिणाम आवश्यक पुनरावृत्तियों की संख्या है। (प्रत्येक पुनरावृत्ति पर, हम 'दूसरे बच्चे से अगली सबसे ऊँची कैंडी लेते हैं'।)

टिप्पणी की गई

$n!$

n => (           // main function taking n
  g = p =>       // g = recursive function taking p
    x < n ?      //   if x is less than n:
      g(         //     this is the first part of the recursion:
        p * ++x  //     we're computing p = n! by multiplying p
      )          //     by x = 1 .. n
    :            //   else (second part):
      q < p &&   //     while q is less than p:
      1 + g(     //       add 1 to the final result
        p / n,   //       divide p by n
        q *= n-- //       multiply q by n; decrement n
      )          //
)(q = x = 1)     // initial call to g with p = q = x = 1
|| n             // edge cases: return n for n < 2

Answer 3

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

ḊPÐƤ<!€TL

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।

कैसे?

ḊPÐƤ<!€TL - Link: integer, x                   e.g. 7
Ḋ         - dequeue (implicit range of x)           [   2,   3,   4,   5,   6,   7]
  ÐƤ      - for postfixes [all, allButFirst, ...]:
 P        -   product                               [5040,2520, 840, 210,  42,   7]
      €   - for each (in implicit range of x):
     !    -   factorial                             [   1,   2,   6,  24, 120, 720, 5040]
    <     - (left) less than (right)?               [   0,   0,   0,   0,   1,   1, 5040]
          -   -- note right always 1 longer than left giving trailing x! like the 5040 ^
       T  - truthy indices                          [                       5,   6, 7   ]
        L - length                                  3

Comments

यह प्रभावशाली है लेकिन अधिक शिक्षाप्रद होगा यदि समझाया गया

— सेटटॉप डेस

यह होगा ... :)

— जोनाथन एलन

@ सेटटॉप - जोड़ा गया।

— जोनाथन एलन

पसंद है ! और यह सभी प्रकार के

— गुटों के

नाह, अभी भी उन सभी उत्पादों और भाज्य (कुछ अन्य समाधानों से अधिक) की गणना करता है।

— जोनाथन एलन

Answer 4

आर , 70 41 38 बाइट्स

-29 क्योंकि डेनिस सभी आंतरिक कार्यों को जानता है

-3 स्कैन () इनपुट पर स्विच करना

sum(prod(x<-scan():1)<=cumprod(1:x)^2)

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

Nedla2004 के पायथन 3 उत्तर का बहुत ही सरल आर कार्यान्वयन ।

मुझे लगता है कि 1-हैंडलिंग का एक क्लीनर कार्यान्वयन है, और मैं घुंघराले ब्रेसिज़ को खोना चाहूंगा।

मैं पागल हूँ मैं एक दृष्टिकोण का उपयोग करने के लिए वापस नहीं गया, मैं एक सख्त कम-से-कम का उपयोग करता था, लेकिन यहां तक ​​कि अभी भी मुझे पता नहीं था कि एक cumprod()समारोह है। डेनिस द्वारा महान अनुकूलन।

Answer 5

एपीएल (डायलॉग यूनिकोड) , 10 बाइट्स

+/!≤2*⍨!∘⍳

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

पोर्ट ऑफ डेनिस का जवाब । इसके लिए अच्छी तरह से, डेनिस को धन्यवाद।

किस तरह:

+/!≤2*⍨!∘⍳ ⍝ Tacit function, takes 1 argument (E.g. 5)
         ⍳ ⍝ Range 1 2 3 4 5
       !∘  ⍝ Factorials. Yields 1 2 6 24 120
    2*⍨    ⍝ Squared. Yields 1 4 36 576 14400
  !        ⍝ Factorial of the argument. Yields 120.
   ≤       ⍝ Less than or equal to. Yields 0 0 0 1 1
+/         ⍝ Sum the results, yielding 2.

चूंकि यह उत्तर मेरे द्वारा कड़ाई से नहीं बनाया गया था, इसलिए मैं अपना मूल उत्तर नीचे रखूंगा।

---

एपीएल (डायलॉग यूनिकोड) , 14 12 11 बाइट्स

(+/!>×\)⌽∘⍳

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

उपसर्ग tacit फ़ंक्शन। मूल रूप से जोनाथन के जवाब का एक डायलाग बंदरगाह ।

चैट में मदद के लिए ngn और H.PWiz का धन्यवाद। मुझे बाइट बचाने के लिए ngn के लिए भी धन्यवाद।

डेनिस के लिए धन्यवाद कि मेरा मूल कोड गलत था। पता चलता है कि यह मुझे 2 बाइट बचा लिया।

उपयोग करता है ⎕IO←0।

किस तरह:

+/(!>×\)∘⌽∘⍳ ⍝ Tacit function, taking 1 argument (E.g. 5).
           ⍳ ⍝ Range 0 1 2 3 4
         ⌽∘  ⍝ Then reverse, yielding 4 3 2 1 0
  (    )∘    ⍝ Compose with (or: "use as argument for")
   !         ⍝ Factorial (of each element in the vector), yielding 24 6 2 1 1
     ×\      ⍝ Multiply scan. Yields 4 12 24 24 0
    >        ⍝ Is greater than. Yields 1 0 0 0 1
+/           ⍝ Finally, sum the result, yielding 2.

Comments

यदि +/कोष्ठक के अंदर जाता है, तो एक रचना को छोड़ा जा सकता है:(+/!>×\)⌽∘⍳

— ngn

Answer 6

हास्केल , 52 51 बाइट्स

$n$$\frac{x!}{(x-n)!}$$n$$(x-n)!$$n$

g b=product[1..b]
f x=[n|n<-[1..],g(x-n)^2<=g x]!!0

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

Answer 7

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

R!²<!ċ0

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

यह काम किस प्रकार करता है

R!²<!ċ0  Main link. Argument: n

R        Range; yield [1, ..., n].
 !       Map factorial over the range.
  ²      Take the squares of the factorials.
    !    Compute the factorial of n.
   <     Compare the squares with the factorial of n.
     ċ0  Count the number of zeroes.

Answer 8

पायथन 3 , 183 176 149 बाइट्स

R=reversed
def M(I,r=1):
 for i in I:r*=i;yield r
def f(x):S=[*range(1,x+1)];return([n for n,a,b in zip([0]+S,R([*M(S)]),[0,*M(R(S))])if b>a]+[x])[0]

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

यह O (N lot) के बजाय कुछ अन्य समाधान - 0 (N) गुणा से बहुत अधिक तेज़ है - लेकिन मैं कोड आकार को कम करने का प्रबंधन नहीं कर सकता।

-जो राजा से -27

Answer 9

साफ , 57 बाइट्स

import StdEnv
$x=while(\e=prod[1..x-e]^2>prod[1..x])inc 1

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

एक सीधे आगे समाधान।

Answer 10

05AB1E , 15 11 बाइट्स

E!IN-!n›iNq

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

E!IN-!n›iNq

E                For loop with N from [1 ... input]
 !               Push factorial of input    
  IN-            Push input - N (x - n)
     !           Factorial
      n          Square
       ›         Push input! > (input - N)^2 or x! > (x - n)^2
        i        If, run code after if top of stack is 1 (found minimum number of candies)
         N       Push N
          q      Quit, and as nothing has been printed, N is implicitly printed

मेरे पायथन प्रस्तुत के रूप में एक ही दृष्टिकोण का उपयोग करता है । बहुत नई 05AB1E कोड या स्पष्टीकरण पर कोई सुझाव बहुत सराहना की।

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

Comments

अच्छा उत्तर! आप गोल्फ 3 बाइट्स कर सकते हैं इस तरह के इनपुट को तोड़ने के बिना 1। यदि इफ-स्टेटमेंट सत्य है, तो यह इंडेक्स Nको स्टैक पर धकेल देगा और प्रोग्राम से बाहर निकल जाएगा (उस इंडेक्स को अनुमानित रूप से आउटपुट करना)। इनपुट के 1लिए if-statement गलत होगा, लेकिन यह 1एकल-पुनरावृति लूप के बाद अपने इनपुट को अनुमानित रूप से आउटपुट करेगा ।

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

दरअसल, 3 के बजाय 4 बाइट्स बचाए जा सकते हैं: इसे ऑनलाइन 11 बाइट्स आज़माएं । इनपुट का उपयोग पहले !तथ्य के लिए स्पष्ट रूप से किया जाएगा , अब चूंकि स्टैक खाली है क्योंकि अब हम if-result को डुप्लिकेट / ट्रिपल नहीं करते हैं।

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

इन विचारों के लिए धन्यवाद। हालाँकि मुझे अंत में मुद्रण का यह विचार नहीं आया, फिर भी मैंने लूप को जल्दी समाप्त करने के बारे में सोचा। ब्रेक, एंड, लीव और एस्केप की तलाश के बाद, मैंने सोचा कि मैं जिस तरह से काम करता है ठीक से समझ नहीं पा रहा था। किसी तरह मेरे लिए कभी समाप्त नहीं हुआ।

— nedla2004

आपका उत्तर पहले से ही बहुत अच्छा था। यह आम तौर पर एक मौजूदा जवाब को आगे गोल्फ के लिए आसान है, फिर इसे अपने आप से कुछ भी नहीं करने के लिए। अगर मैं खुद इस चुनौती को पूरा कर लेता तो शायद मैं 15 या 14 बाइट्स में ही समाप्त हो जाता। मैंने तोड़ने के अपने विचार का इस्तेमाल किया और इसे बदले में एक समाप्ति और निहित उत्पादन के साथ बदल दिया, इसके बाद मैंने कुछ चीजों की कोशिश की, और अंत में मैंने देखा कि मुझे अब डुप्लिकेट की आवश्यकता नहीं थी, जो 1कि इनपुट को स्पष्ट रूप से इनपुट करते हुए परीक्षण के मामले को भी ठीक कर देगा। जब स्टैक खाली हो। :)

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

FYI करें: मैंने डेनिस elly 'जेली उत्तर को पोर्ट करके 7 बाइट्स का विकल्प पोस्ट किया है । हमेशा की तरह, डेनिस -जेली कोड-गोल्फिंग के मामले में जादू का प्रदर्शन करने में सक्षम है ..; पी

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

Answer 11

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

ạ‘rP>ạ!¥
1ç1#«

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

1 सही ढंग से संभालता है।

Answer 12

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

ＮθＩ⊕ΣＥθ‹Π⊕…ιθ∨Π…¹⊕ι¹

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｎθ                      Input `n`
    Σ                   Sum of
      θ                 `n`
     Ｅ                  Mapped over implicit range
        Π               Product of
           ι            Current value
          …             Range to
            θ           `n`
         ⊕              Incremented
       ‹                Less than
              Π         Product of
                ¹       Literal 1
               …        Range to
                  ι     Current value
                 ⊕      Incremented
             ∨          Logical Or
                   ¹    Literal 1
   ⊕                    Incremented
  Ｉ                     Cast to string
                        Implicitly print

Productके Noneबजाय चारकोल रिटर्न में एक खाली सूची पर 1, इसलिए मुझे तार्किक रूप से Orयह करना होगा।

Comments

क्या आप सुनिश्चित हैं कि ये अक्षर प्रत्येक 8 बिट हैं?

— रोजलूपी

@RosLuP चारकोल कई भाषाओं में से एक है जो आपको यहाँ मिल सकती है, जो ASCII के बजाय एक कस्टम कोड पेज का उपयोग करती है। इसका अर्थ है कि प्रत्येक आठ-बिट मान को कस्टम प्रतीक के लिए मैप किया जाता है; इन प्रतीकों को प्रोग्रामर को यह याद रखने में मदद करने के लिए डिज़ाइन किया गया है कि प्रत्येक बाइट की तुलना में थोड़ा आसान होता है, अगर वे केवल मानकीकृत कोड पृष्ठों में से एक के बीच बेतरतीब ढंग से बिखरे हुए थे। PPCG चैट में अधिक जानकारी के लिए बेझिझक पूछें ।

— फरलक्स

Answer 13

PHP , 107 बाइट्स

<?php $x=fgets(STDIN);function f($i){return $i==0?:$i*f($i-1);}$n=1;while(f($x)<f($x-$n)**2){$n++;}echo $n;

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

$x^2>((x-1)!)^2$

इस चुनौती के लिए PHP सबमिशन से फैक्टोरियल फंक्शन का उपयोग करता है (धन्यवाद @ donutdan4114)

Answer 14

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

Min[n/.Solve[#!>(#-n)!^2, Integers]]/.n->1&

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

Answer 15

05AB1E , 7 बाइट्स

L!ns!@O

पोर्ट ऑफ डेनिस J answer जेली उत्तर , इसलिए यदि आप इस उत्तर को पसंद करते हैं तो उसे सुनिश्चित करना सुनिश्चित करें!

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

स्पष्टीकरण:

L          # List in the range [1, (implicit) input]
 !         # Take the factorial of each
  n        # Then square each
   s!      # Take the factorial of the input
     @     # Check for each value in the list if they are larger than or equal to the
           # input-faculty (1 if truthy; 0 if falsey)
      O    # Sum, so determine the amount of truthy checks (and output implicitly)

Answer 16

जाप -x, 7 बाइट्स

पोर्ट ऑफ डेनिस 'जेली समाधान।

केवल व्यवहार में काम करता है n=4जैसा कि हम ऊपर वैज्ञानिक बोध में मिलता है।

õÊ®²¨U²

कोशिश करो

õ           :Range [1,input]
 Ê          :Factorial of each
  ®         :Map
   ²        :  Square
    ¨       :  Greater than or equal to
     U²     :  Input squared
            :Implicitly reduce by addition

Answer 17

सी # (.NET कोर) , 93 बाइट्स

n=>{int d(int k)=>k<2?1:k*d(k-1);int a=1,b=d(n),c=n;for(;;){a*=n;b/=n--;if(a>=b)return c-n;}}

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

@ अरनुलद के जावास्क्रिप्ट उत्तर के आधार पर।

Answer 18

सी (जीसीसी) , 68 बाइट्स

n;f(x){int i=2,j=x,b=1,g=x;while(i<j)b*i>g?g*=--j:(b*=i++);n=x-j+1;}

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

संपादित करें: mults के खिलाफ व्यापार बाइट्स, x + n के बजाय 2 * x mults कर रहा है

संपादित करें: मैक्रो के माध्यम से लंबे समय के बजाय इंट में वापस जाना। 34 के साथ लंबे समय में विफल हो जाएगा।

खैर मैं सी। में यह 21 पर विफल है।

एक संभावित अस्पष्टता है कि क्या अच्छा बच्चा हमेशा जीतना चाहता है या कभी नहीं हारता है ... आपको क्या लगता है?

Comments

आमतौर पर हम टी को किसी भी प्रकार से परिभाषित करने की अनुमति नहीं देते हैं। आप T के सभी संदर्भों को हटाकर 72 बाइट्स प्राप्त कर सकते हैं, लेकिन आपको अभी भी i / j / b / g घोषित करना होगा। इसे ऑनलाइन आज़माएं!

— लैंबडाटा

ठीक है, मैंने इंट के साथ संस्करण को वापस रखा, जो अभी भी 68 बाइट्स है। इसलिए मैं वास्तव में धोखा नहीं दे रहा था;)

— बालजोला

मैं वहाँ एक विकल्प के रूप में टी संस्करण छोड़ दूँगा। बड़े / छोटे प्रकारों को आज़माना दिलचस्प है। हालांकि अच्छा प्रस्तुत!

— लाम्बेबेटा

Answer 19

पायथन 3 , 75 बाइट्स

f=lambda n:n<1or f(n-1)*n
n=lambda x:x-sum(f(n)**2<f(x)for n in range(1,x))

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

74 बाइट्स संस्करण

f=lambda n:n<1or f(n-1)*n
n=lambda x:1+sum(f(n)>f(x)**.5for n in range(x))

लेकिन यह संस्करण 500 के लिए बह निकला ...