चिकन मैकनगेट नंबर

29

विवरण

चिकन मैकनगेट संख्या वे संख्याएं हैं जिन्हें 6, 9 या 20 की राशि के रूप में व्यक्त किया जा सकता है - मैकडॉनल्ड्स द्वारा बेचे जाने वाले प्रसिद्ध चिकन मैकगेट्स बॉक्स के शुरुआती आकार । उस राशि में, एक संख्या एक से अधिक बार हो सकती है, इसलिए 6 + 6 = 12ऐसी संख्या भी है, और संख्या में उल्लेखित आकारों में से कम से कम एक "समाहित" होना चाहिए। पहले चिकन McNugget नंबर हैं:

6
9
6 + 6 = 12
6 + 9 = 15
9 + 9 = 6 + 6 + 6 = 18
20
6 + 6 + 9 = 21
...

चुनौती

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है, जो, एक सकारात्मक पूर्णांक दिया गया है, यह निर्धारित करता है कि क्या इस संख्या को वर्णित तरीके से व्यक्त किया जा सकता है, इसलिए यह एक चिकन मैकगैग नंबर है। फिर उसे अपने निर्णय के आधार पर एक सत्य या मिथ्या मूल्य का उत्पादन करना चाहिए।

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

6 -> true
7 -> false
12 -> true
15 -> true
21 -> true
40 -> true
42 -> true

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे कम उत्तर और मानक खामियां लागू होती हैं!

code-golf  number  decision-problem 
— racer290
स्रोत
15
यह ध्यान दिया जाना चाहिए कि "1, 2, 3, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 22, 23, 25, 28, 31, 31 को छोड़कर सभी पूर्णांक संख्याएँ McNugget संख्याएँ हैं। 34, 37, और 43. " ( मैथवर्ल्ड )
— लीक नून
1
ठीक है, तो चलो इसे एक संपीड़न चुनौती के रूप में लेते हैं, लेकिन नोट के लिए धन्यवाद
— racer290
3
किसी के पास इसके लिए OEIS लिंक है ???
— क्रेगआर 8806
2
आपके पास 4 पीस नगेट पैक के खिलाफ क्या है? mcdonalds.com/us/en-us/product/chicken-mcnuggets-4-piece.html
— Dan Neely
2
— जेसन सी

जवाबों:

37

पायथन, 27 बाइट्स

lambda n:0x82492cb6dbf>>n&1

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

— एंडर्स कसीगोर
स्रोत
11
यह जादुई कोड क्या है o_O यह अद्भुत है
— हाइपरनेट्रिनो
आप निकाल सकते हैं ~क्योंकि आप आउटपुट स्वैप कर सकते हैं।
— लीक नन
1
इसके अलावा, 8953174650303इसकी लंबाई समान है 0x82492cb6dbf(यद्यपि कम पठनीय)।
— लीक नन
2
@HyperNeutrino मैजिक नंबर में केवल वही बिट्स सेट होते हैं जो उन नंबरों के अनुरूप होते हैं जो चिकन मैकगेट संख्या नहीं हैं । इसके द्विआधारी प्रतिनिधित्व को देखो और यह बहुत स्पष्ट हो जाएगा।
— डेविड
1
शर्म की बात है कि आप आसानी से आधार 64 के साथ इसी विचार का उपयोग नहीं कर सकते
— याकूब गार्बी जूल
29

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

lambda n:0<=n--n%3*20!=3

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

व्याख्या

के साथ 6और 9अकेले ही, सभी पूर्णांकों को विभाज्य बना सकते हैं, 3जो कि अधिक से अधिक होते हैं 3, जैसा कि ओवस की टिप्पणी में कहा गया है । यह माना जाता है कि कोई भी बना सकता है 0। निष्कर्ष में, कोई भी बना सकता है 0,6,9,12,15,...।

एक उदाहरण के साथ 20, एक बना सकते हैं 20,26,29,32,35,...:।

के दो उदाहरणों के साथ 20, एक बना सकते हैं 40,46,49,52,55,...:।

तीन उदाहरणों के लिए आवश्यक नहीं है 3 x 20 = 10 x 6।

ध्यान दें कि जिन मामलों 20की आवश्यकता नहीं है, वे भी 3 से विभाज्य हैं; जिन मामलों में एक 20की आवश्यकता होती है, उनमें से एक को छोड़ देता है 2; जिन मामलों में दो 20की जरूरत है, उनमें से एक को छोड़ दिया जाता है 1।

20इसलिए आवश्यक संख्या की गणना की जा सकती है (-n)%3। फिर, हम n-(((-n)%3)*20)संख्या से 20आवश्यक संख्या को निकालने के लिए करते हैं । हम फिर जांचते हैं कि यह संख्या गैर-नकारात्मक है, लेकिन नहीं है 3।

— लीक नन
स्रोत
— श्री एक्सकोडर
@ Mr.Xcoder अपडेट किया गया।
— लीकी नून
f=lambda n:n%3<1<n-2or n>20and f(n-20)क्या वह काम करता है?
— जकार्इ
@ Zacharý धन्यवाद, अद्यतन।
— लीकी नून
1
f=अब आप इसे हटा सकते हैं क्योंकि यह पुनरावर्ती नहीं है।
— नॉटजैगन
8

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

lambda n:-n%3-n/20<(n%20!=3)

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

— XNOR
स्रोत
कुछ ट्रायल-एंड-एरर का उपयोग करना और पहले भाग को श्रेणी में मैप करना, मेरे पास एक मोटा विचार है कि यह कैसे काम करता है। हालांकि, मैं यह जानना चाहूंगा कि आप इस समाधान के साथ कैसे आए।
— लीक नन
@LeakyNun मजेदार, मैंने सोचा कि यह प्राकृतिक तरीका था और आपका चतुर था :)। मैंने नोट किया कि (n%3,n/20)आपकी अपवर्जित सूची से संभावित मूल्य हैं {(2, 0), (1, 0), (1, 1)}। के -n%3बजाय का उपयोग कर एक असमानता दी n/20>=(-n)%3। वहां से, मैंने कुछ समय के लिए रिवर्स किया, {3,23,43}जो 63,83 को प्रभावित किए बिना 3 मॉड 20 हैं, ... मैंने इन कामों के लिए असमानता के समापन बिंदु को बदलते पाया।
— 19
वैसे मेरी विधि में वास्तव में समस्या को हल करना शामिल है, जबकि आपका तरीका बहिष्कृत सूची में दिए गए मानों से भरा हुआ है, इसलिए मैं कहूंगा कि मेरी विधि अधिक प्राकृतिक है :)
— लीक नून
7

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

ṗ3’æ.“©µÞ‘ċ

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

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

ṗ3’æ.“©µÞ‘ċ  Main link. Argument: n

ṗ3           Cartesian power; yield all 3-tuples over [1, ..., n].
  ’          Decrement all coordinates.
     “©µÞ‘   Yield [6, 9, 20].
   æ.        Take the dot product of each 3-tuple and [6, 9, 20].
          ċ  Count the occurrences of n (Positive for Chicken McNuggets numbers).
— डेनिस
स्रोत
4
चिकन McNuggets ™ और जेली! Mmmm !!!
— सीजे डेनिस
@CJDennis वास्तव में यह चिकन मैगगेट्स © और जेली है।
— caird coinheringaahing
@cairdcoinheringaahing वास्तव में यह चिकन McNuggets® और जेली है।
— दान
5

हास्केल , 36 बाइट्स

f n|n<1=n==0
f n=any(f.(n-))[6,9,20]

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

व्याख्या

यह समाधान लगभग उतना ही सीधा है जितना इसे प्राप्त किया जा सकता है। पहली पंक्ति यह घोषित करती है कि किसी भी संख्या में 1 से कम के लिए यह एक McNugget संख्या है यदि n==0। यह कहना है कि 0एक McNugget नंबर है और सभी नकारात्मक संख्या नहीं हैं।

दूसरी पंक्ति यह घोषणा करती है कि अन्य सभी संख्याओं के लिए, nएक McNugget संख्या है यदि यह किसी भी Nugget आकार को घटाता है, एक McNugget संख्या है।

यह एक बहुत ही सरल पुनरावर्ती खोज है।

— गेहूं का जादूगर
स्रोत
3

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

_20$%3$¿o>3

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

मेरे पायथन उत्तर का पोर्ट , लेकिन थोड़ा संशोधित: 20विभाज्य तक घटाएं 3, फिर जांचें कि क्या यह इनपुट 0,6,9,...से मैपिंग 0द्वारा है (उपयोग करके or), और फिर जांचें कि क्या यह अधिक से अधिक है 3।

केवल तीन नंबर है कि उत्पादन 0में पहला कदम को पूरा करने पर है 0, 20या 40पहले एक डोमेन से बाहर जा रहा है, और बाकी की तुलना में अधिक होने के साथ 3।

— लीक नन
स्रोत
मुझे न जाने कैसे इनपुट दर्ज करना है ..
— racer290
@ racer290 कमांड-लाइन तर्क।
— आउटगॉल्फ जूल
3

मैथेमेटिका, 53 बाइट्स

!Flatten@Table[Tr/@Tuples[{6,9,20},i],{i,#}]~FreeQ~#&
— J42161217
स्रोत
शायद आप FrobeniusSolveफ़ंक्शन का उपयोग कर सकते हैं ।
— एलेफाल्फा
3

गणितज्ञ, 20 बाइट्स

0<=#-20Mod[-#,3]!=3&

अनाम फ़ंक्शन। इनपुट और रिटर्न के रूप में Trueया Falseआउटपुट के रूप में एक संख्या लेता है । लॉकी नन के जवाब से कॉपी किया गया , कुछ अतिरिक्त दुरुपयोग के साथ Inequality।

— LegionMammal978
स्रोत
3

x86-64 मशीन कोड, 22 बाइट्स

48 B8 41 92 34 6D DB F7 FF FF 83 F9 40 7D 03 48 D3 E8 83 E0 01 C3

उपरोक्त बाइट्स 64-बिट x86 मशीन कोड में एक फ़ंक्शन को परिभाषित करता है जो यह निर्धारित करता है कि इनपुट मूल्य एक चिकन मैकगैग नंबर है या नहीं। विंडोज पर उपयोग किए जाने ECXवाले Microsoft 64-बिट कॉलिंग कन्वेंशन के बाद, रजिस्टर में एकल पॉजिटिव पूर्णांक पैरामीटर पारित किया गया है। परिणाम EAXरजिस्टर में लौटाया गया बूलियन मान है ।

असेंबली असेंबली mnemonics:

; bool IsMcNuggetNumber(int n)
; n is passed in ECX
    movabs  rax, 0xFFFFF7DB6D349241   ; load a 64-bit constant (the bit field)
    cmp     ecx, 64
    jge     TheEnd                    ; if input value >= 64, branch to end
    shr     rax, cl
TheEnd:
    and     eax, 1                    ; mask off all but LSB
    ret

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

हम इस मूल्य को रजिस्टर में लोड करके शुरू करते हैं। यह 64-बिट मान है, जो पहले से ही 8 बाइट्स को सांकेतिक शब्दों में बदलना है, इसके अलावा हमें एक-बाइट REX.W उपसर्ग की आवश्यकता है, इसलिए हम वास्तव में बाइट्स के मामले में काफी खर्च किए जा रहे हैं, लेकिन यह समाधान का दिल है, इसलिए मुझे लगता है कि यह इसके लायक है।

हम फिर इनपुट वैल्यू द्वारा फील्ड को राइट शिफ्ट करते हैं। * अंत में, हम सभी को छोड़ देते हैं, लेकिन सबसे कम-क्रम बिट, और यही हमारा बूलियन परिणाम बन जाता है।

हालाँकि, चूंकि आप वास्तव में मूल्य में बिट्स की संख्या से अधिक द्वारा स्थानांतरित नहीं कर सकते हैं, यह केवल ०-६३ से इनपुट के लिए काम करता है। उच्च इनपुट मानों का समर्थन करने के लिए, हम फ़ंक्शन के शीर्ष पर एक परीक्षण सम्मिलित करते हैं, जो कि इनपुट वैल्यू के निचले भाग की शाखाएँ> = 64 हैं। इसके बारे में केवल एक ही बात दिलचस्प है कि हम बिट-फ़ील्ड को लगातार और फिर शाखा में लोड करते हैं RAXउस निर्देश के नीचे, जो सबसे कम-क्रम बिट से मास्क करता है, इस प्रकार यह सुनिश्चित करता है कि हम हमेशा 1 लौटें।

इसे ऑनलाइन आज़माएं!
(C फ़ंक्शन कॉल को एक विशेषता के साथ एनोटेट किया गया है, जो GCC को Microsoft कॉलिंग कन्वेंशन का उपयोग करके कॉल करने का कारण है जो कि एक असेंबली कोड का उपयोग करता है। यदि TIO ने MSVC प्रदान किया था, तो यह आवश्यक नहीं होगा।)

__
* एक पारी के विकल्प के रूप में, हम x86 BTनिर्देश का उपयोग कर सकते थे , लेकिन यह 1 बाइट को सांकेतिक शब्दों में बदलना है, इसलिए कोई फायदा नहीं हुआ। जब तक हमें एक अलग कॉलिंग कन्वेंशन का उपयोग करने के लिए मजबूर किया गया था जो ECXरजिस्टर में इनपुट मूल्य को आसानी से पारित नहीं करता था । यह एक समस्या होगी, क्योंकि SHR आवश्यकता है कि इसके स्रोत हो संकार्य CLएक गतिशील पारी गिनती के लिए। इसलिए, एक अलग कॉलिंग कन्वेंशन की आवश्यकता होगी कि हम MOVजो भी रजिस्टर इसमें पास किए गए थे ECX, उससे इनपुट वैल्यू को एड करते हैं , जिसकी कीमत हमें 2 बाइट से चुकानी पड़ेगी। BTअनुदेश का उपयोग कर सकते हैं किसी भी केवल 1 बाइट की लागत से, एक स्रोत के रूप में संकार्य रजिस्टर। तो, उस स्थिति में, यह बेहतर होगा।BTकैरी फ़्लैग (CF) में संबंधित बिट का मान डालता है, इसलिए आप SETCपूर्णांक रजिस्टर में उस मूल्य को प्राप्त करने के लिए एक निर्देश का उपयोग करेंगे, जैसे ALकि यह कॉलर को वापस किया जा सकता है।

वैकल्पिक कार्यान्वयन, 23 बाइट्स

यहां एक वैकल्पिक कार्यान्वयन है जो यह निर्धारित करने के लिए मोडुलो और गुणन कार्यों का उपयोग करता है कि इनपुट मूल्य चिकन मैकगैग संख्या है या नहीं।

यह सिस्टम V AMD64 कॉलिंग कन्वेंशन का उपयोग करता है , जो EDIरजिस्टर में इनपुट मूल्य को पास करता है । परिणाम अभी भी एक बूलियन है, में लौटा EAX।

ध्यान दें, हालांकि, उपरोक्त कोड के विपरीत, यह एक उलटा बूलियन है (कार्यान्वयन सुविधा के लिए)। falseयदि इनपुट मान चिकन McNugget नंबर है, या trueइनपुट मान चिकन McNugget नंबर नहीं है , तो यह वापस आ जाता है ।

                    ; bool IsNotMcNuggetNumber(int n)
                    ; n is passed in EDI
8D 04 3F            lea    eax, [rdi+rdi*1]   ; multiply input by 2, and put result in EAX
83 FF 2B            cmp    edi, 43
7D 0E               jge    TheEnd             ; everything >= 43 is a McNugget number
99                  cdq                       ; zero EDX in only 1 byte
6A 03               push   3
59                  pop    rcx                ; short way to put 3 in ECX for DIV
F7 F1               div    ecx                ; divide input value by 3
6B D2 14            imul   edx, edx, 20       ; multiply remainder of division by 20
39 D7               cmp    edi, edx
0F 9C C0            setl   al                 ; AL = (original input) < (input % 3 * 20)
                 TheEnd:
C3                  ret

इसके बारे में जो कुरूप है वह शीर्ष पर तुलना-और-शाखा द्वारा इनपुट मान> = 43 को स्पष्ट रूप से संभालने की आवश्यकता है। जाहिर तौर पर ऐसा करने के अन्य तरीके भी हैं, जिन्हें करने की आवश्यकता नहीं है, जैसे कि केर्ड कॉइनरहाइडिंग का एल्गोरिथ्म , लेकिन यह एक बहुत अधिक बाइट्स को सांकेतिक शब्दों में बदलना होगा, इसलिए यह एक उचित समाधान नहीं है। मुझे लगता है कि मैं शायद कुछ बिट-टिडलिंग ट्रिक को याद कर रहा हूं, जो इस काम को अधिक भव्यता से कर देगा और ऊपर के बिटफील्ड-आधारित समाधान की तुलना में कम बाइट्स होगा (क्योंकि बिटफील्ड खुद को बहुत सारे बाइट्स को एन्कोडिंग करता है), लेकिन मैंने इसके लिए अध्ययन किया है थोड़ी देर और अभी भी इसे देख नहीं सकते।

ओह ठीक है, वैसे भी ऑनलाइन कोशिश करो !

— कोडी ग्रे
स्रोत
3

05AB1E, 17 16 बाइट्स

ŽGç₂в©IED®âO«]I¢

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

व्याख्या

  ŽGç₂в                 The list [6, 9, 20]
       ©                Store this list in register_c
        IE              Loop <input> number of times
           ®â           Cartesian product stack contents with list in register_c
             O          Sum up the contents of each sub array
          D   «         List duplicated before taking Cartesian product, concat
               ]        End for loop
                I¢      Count occurences of input
— फिरना
स्रोत
1
आपके पास TIO लिंक डुप्लिकेट हैं।
— अज्ञानता का प्रतीक
1
अच्छा जवाब। PPCG और 05AB1E की दुनिया में आपका स्वागत है। :) गोल्फ के लिए एक बात का उपयोग करना है …स्ट्रिंग के लिए (वहाँ 1-, 2, और 3-चार तार के लिए buitins कर रहे हैं, जा रहा है ', „और …क्रमशः)। मुझे लगता है कि और अधिक गोल्फ हो सकता है, शायद एक अलग दृष्टिकोण का उपयोग करके, लेकिन इसकी परवाह किए बिना यह एक अच्छा पहला जवाब है। मुझ से +1।
— केविन क्रूज़सेन
1
वास्तव में सही था। Builtin का उपयोग करके एक 12 byter मिले Åœ: … ÇIÅœåPOĀ। यह पूरी तरह से अलग दृष्टिकोण है, इसलिए यदि आप चाहते हैं कि मैं इसे एक गोल्फ के बजाय एक अलग जवाब के रूप में पोस्ट करूं, तो मुझे बताएं। PS: अगर 100AB1E कोडपेज में अनप्रिंटर्स की अनुमति दी गई है, तो मुझे 100% यकीन नहीं है । यह उस मामले में एक अलग एन्कोडिंग में हो सकता है, जो कुछ वर्णों को प्रत्येक के बजाय 2 बाइट्स के रूप में गिना जाएगा .. उस स्थिति में ŽBo21в+1 बाइट के लिए एक विकल्प हो सकता है।
— केविन क्रूज़सेन
जैसे केविन का उल्लेख है, आपके स्ट्रिंग में 3 बाइट्स में से कोई भी 05ab1e कोड पेज में नहीं है और इस प्रकार यूटीएफ -8 में पूरे कार्यक्रम की गिनती के बिना उपयोग नहीं किया जा सकता है जो इसे बहुत लंबा बना देगा। आप हालांकि ŽGç₂вप्रक्रिया में एक बाइट को बचाते हुए स्ट्रिंग के बजाय उपयोग कर सकते हैं ।
— एमीना
केविन, इसके लिए जाओ। विभिन्न दृष्टिकोणों को देखना अच्छा होगा। Emigna, धन्यवाद आप सुझाव के लिए, मैं परिवर्तन कर देगा
— राजस्व
2

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

n=>'ABCDEFHIKLNOQRTWXZ]`cfl'.includes(String.fromCharCode(n+65))

कोड स्निपेट दिखाएं

falseचिकन McNugget संख्या के लिए आउटपुट , trueअन्यथा।

— darrylyeo
स्रोत
मैं कम से कम एक "इसे आज़माएं" लिंक
— चाहूंगा
@ racer290 जोड़ा गया।
— darrylyeo
n=>~'ABCDEFHIKLNOQRTWXZ]`cfl'.search(String.fromCharCode(n+65))63 बाइट्स के लिए
— Oki
2

जावा, 21 57 24 बाइट्स

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

golfed:

n->(n-=n*2%3*20)>=0&n!=3

Ungolfed:

import java.util.*;

public class ChickenMcNuggetNumbers {

  private static final Set<Integer> FALSE_VALUES = new HashSet<>(Arrays.asList(
    new Integer[] { 0, 1, 2, 3, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 22, 23,
    25, 28, 31, 34, 37, 43 }));

  public static void main(String[] args) {
    for (int i = 0; i < 45; ++i) {
      System.out.println(i + " -> expected=" + !FALSE_VALUES.contains(i)
        + ", actual=" + f(n->(n-=n*2%3*20)>=0&n!=3, i));
    }
  }

  public static boolean f(java.util.function.Function<Integer, Boolean> f, int n) {
    return f.apply(n);
  }
}
परिणाम के लिए गलत है 26 = 20 + 6।
— लीक नून
@LeakyNun एल्गोरिथम बहुत भोला था। मुझे प्लान बी के साथ जाना था जिसमें कुछ बाइट्स जोड़े गए थे, लेकिन अब हर समय सही परिणाम दिखाई देते हैं। मुझे प्रश्न में परीक्षण मामलों पर भरोसा करने के बजाय सभी मूल्यों को पुनरावृत्त करना चाहिए।
— लीकी नून
1
24 बाइट्स (ऊपर देखें)
— लीकी नून
1
@LeakyNun धन्यवाद! मुझे अभी भी गोल्फ के बारे में बहुत कुछ सीखना है।
1

हास्केल, 64 56 बाइट्स

मैंने कोई भी मुश्किल चालबाजी नहीं की, लेकिन अन्य उत्तरों को देखते हुए यह वास्तव में Bitsमॉड्यूल को आयात करने और उन तरीकों का उपयोग करने के लिए छोटा हो सकता है । यह दृष्टिकोण बहुत अधिक सीधे जाँच करता है।

f x=(\l->elem x[i*6+j*9+k*20|i<-l,j<-l,k<-l,x/=0])[0..x]
— qfwfq
स्रोत
1
बाइट काउंट 66नहीं है 64। लेकिन आप बहुत सारे कोष्ठकों को बचा सकते हैं और x/=0कुछ बाइट्स को बचाने के लिए एक गार्ड रख सकते हैं, यहां देखें ।
— ბიმო
1

जावास्क्रिप्ट, 92 78 72 बाइट्स

* @Jonasw की बदौलत 14 बाइट बचाईं

a=>!(a in[0,1,2,3,4,5,7,8,10,11,13,14,16,17,19,22,23,25,28,31,34,37,43])

इस तथ्य का उपयोग करता है कि "1, 2, 3, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 22, 23, 25, 28, 31, 34 को छोड़कर सभी पूर्णांक संख्याएं हैं। , 37, और 43. " @ LeakyNun की टिप्पणी से

— SuperStormer
स्रोत
एक सरल सरणी का उपयोग करके .split के लिए बाइट्स को सहेजा जाएगा ...
— जोनास विल्म्स
@ जोनास की सरणी 108 बाइट्स है, स्प्लिटेड स्ट्रिंग 73 बाइट्स है
— सुपरस्टॉर्मर
उम jsbin.com/bucihuqefi/edit?console -11 बाइट्स ...
— जोनास विल्म्स
1

++ , 35 बाइट्स जोड़ें

D,f,@,A6$%0=@20$%0=A3$%0=A8<A43<s1<

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

देखो मा, नहीं जबकि छोरों। या तार। या सूचीबद्ध करता है। या वास्तव में कुछ भी जो बाइट्स को बचाने में मदद करता है। लेकिन मुख्य रूप से Add ++ पता नहीं है कि उनमें से कोई भी क्या है।

3 महीने बाद, मुझे एहसास हुआ कि यह अमान्य था, और इसे ठीक कर दिया। किसी तरह, कि यह 13 बाइट्स द्वारा संचालित। यह एक फ़ंक्शन है जो एक तर्क लेता है और परीक्षण करता है कि क्या यह तर्क चिकन McNugget नंबर है या नहीं।

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

D,f,@,                        - Create a monadic (one argument) function called f (example argument: 3)
A                             - Push the argument again; STACK = [3 3]
 6                            - Push 6;                  STACK = [3 3 6]
  $                           - Swap the top two values; STACK = [3 6 3]
   %                          - Modulo;                  STACK = [3 3]
    0                         - Push 0;                  STACK = [3 3 0]
     =                        - Are they equal?          STACK = [3 0]
      @                       - Reverse the stack;       STACK = [0 3]
       20                     - Push 20;                 STACK = [0 3 20]
         $                    - Swap the top two values; STACK = [0 20 3]
          %                   - Modulo;                  STACK = [0 3]
           0                  - Push 0;                  STACK = [0 3 0]
            =                 - Are they equal?          STACK = [0 0]
             A                - Push the argument;       STACK = [0 0 3]
              3               - Push 3;                  STACK = [0 0 3 3]
               $              - Swap the top two values; STACK = [0 0 3 3]
                %             - Modulo;                  STACK = [0 0 0]
                 0            - Push 0;                  STACK = [0 0 0 0]
                  =           - Are they equal?          STACK = [0 0 1]
                   A          - Push the argument;       STACK = [0 0 1 3]
                    8         - Push 8;                  STACK = [0 0 1 3 8]
                     <        - Less than;               STACK = [0 0 1 0]
                      A       - Push the argument;       STACK = [0 0 1 0 3]
                       43     - Push 43;                 STACK = [0 0 1 0 3 43]
                         <    - Less than;               STACK = [0 0 1 0 0]
                          s   - Sum;                     STACK = [1]
                           1  - Push 1;                  STACK = [1 1]
                            < - Less than;               STACK = [0]
— केर्ड सिक्काहिरिंग
स्रोत
1

एक्सेल, 87 बाइट्स

=AND(OR(MOD(A1,3)*MOD(A1,20)*IF(A1>43,MOD(A1-40,3),1)*IF(A1>23,MOD(A1-20,3),1)=0),A1>5)

वैकल्पिक रूप से, 92 बाइट्स:

=CHOOSE(MOD(A1,3)+1,A1>3,IF(A1>43,MOD(A1-40,3)=0,A1=40),IF(A1>23,MOD(ABS(A1-20),3)=0,A1=20))
— Wernisch
स्रोत
0

गणितज्ञ, 59 बाइट्स

!Select[IntegerPartitions@#,{6,9,20}~SubsetQ~#&]=={}&&#!=0&
— J42161217
स्रोत
0

जावास्क्रिप्ट 37 बाइट्स

चिकन McNugget संख्या और दूसरों के लिए एक सकारात्मक पूर्णांक nऔर आउटपुट लेता है ।truefalse

F=n=>!(n<0||(n%6&&!F(n-9)&&!F(n-20)))

व्याख्या

F=n=>!(            // negate the internal test for non-Chicken McNugget numbers
    n<0 || (       // if n < 0, or
        n%6 &&     // if n % 6 is truthy,
        !F(n-9) && // and n-9 is not a Chicken McNugget number
        !F(n-20)   // and n-20 is not a Chicken McNugget number
                   // then n is not a Chicken McNugget number
    )
)

इस फ़ंक्शन पर पुनरावृत्ति जघन्य है, और किसी भी पर्याप्त रूप से बड़े के लिए n, आप कॉल स्टैक सीमा को पार कर जाएंगे। यहाँ एक संस्करण है जो जाँचने से उन सीमाओं से बचता है कि क्या nसबसे बड़ा गैर-चिकन मैकगैग नंबर (43 बाइट्स [सबसे बड़ा गैर-चिकन McNugget नंबर होने के लिए बोनस अंक?]) से बड़ा है:?

F=n=>n>43||!(n<0||(n%6&&!F(n-9)&&!F(n-20)))

कोड स्निपेट दिखाएं

— asgallant
स्रोत
0

जावास्क्रिप्ट ईएस 5, 46 बाइट्स

n=>n>5&&(!(n%20)||(n<24?!(n%3):n<44?n%3-1:1));

स्पष्ट बूलियन उत्तर, 50 बाइट्स:

n=>!!(n>5&&(!(n%20)||(n<24?!(n%3):n<44?n%3-1:1)));

अनाड़ी, लेकिन यह काम हो जाता है। रिटर्न falseया 0हर मूल्य के लिए 0, 1, 2, 3, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 22, 23, 25, 28, 31, 34 , 37, या 43, और true, -1या1 सब कुछ के लिए।

स्पष्ट समाधान रिटर्न trueया falseकेवल।

n=>!!(                                          ); forces Boolean type (optional)
      n>5                                          false for 0, 1, 2, 3, 4, 5 (and negative inputs)
            !(n%20)                                explicit true for 20, 40
                      n<24?!(n%3)                  false for 7, 8, 10, 11, 13, 14, 16, 17, 19, 22, 23
                                  n<44?n%3-1       false for 25, 28, 31, 34, 37, 43
— ricdesi
स्रोत
0

क्लोजर 33 बाइट्स

ठीक त्वरित प्रयास पर: #(-> %(rem 20)(rem 9)(rem 6)(= 0))

— MONODA43
स्रोत
0

परी / जीपी , 48 बाइट्स

0झूठा है बाकी सब सत्य है।

n->n*Vec(1/(1-x^6)/(1-x^9)/(1-x^20)+O(x^n++))[n]

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

— alephalpha
स्रोत
अप्रासंगिक टिप्पणी: आप के इस जवाब से क्या समस्या थी? # ~ सेटप्रीसिटी ~ 1 &
— J42161217
@ जेनी_मैथी यह 0.25परीक्षण के मामले को विफल करता है।
— इलफ़लफा
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.