सीमा में एक पूर्णांक को देखते हुए 0 <= n < 2**64, न्यूनतम आकार के कंटेनर का उत्पादन करता है जो इसमें से फिट हो सकता है

बिट: 1
कुतरना: ४
बाइट: 8
संक्षिप्त: 16
int: 32
लंबा: 64

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

0 -> 1
1 -> 1
2 -> 4
15 -> 4
16 -> 8
123 -> 8
260 -> 16
131313 -> 32
34359750709 -> 64

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है।

code-golf number binary

— नीला
स्रोत

10

यह काफी आसान होता अगर 2एक आउटपुट भी होता ...

— ETHproductions

1

@ETHproductions यह होगा लेकिन अफसोस, ऐसा नहीं है (यह मुझे लंबे समय तक के लिए दूर ले लिया एक एल्गोरिथ्म है कि यह किया लिखने के लिए)

— ब्लू

काश मैं समस्या को समझ पाता। ... रुको, यह सभी चाहते हैं कि बिट्स की राशि को संख्या को समाहित करने की आवश्यकता है, अगले मूलभूत संरचना के लिए गोल?

— z0rberg का

2

धन्यवाद! मुझे इसका एहसास तब हुआ जब मैंने टिप्पणी लिखी और उसे बहुत देर से संपादित किया। मुझे लगता है कि मुझे बात करने के लिए एक रबर बतख की आवश्यकता है ...

— z0rberg की

2

@ डैनियल यहां के जवाब दूसरे प्रश्न के लिए पूरी तरह से अलग दृष्टिकोण लेते हैं। जब मैं कहता हूं 'से प्रेरित है तो इसका मतलब' नकल 'नहीं है। इस प्रश्न के लिए मान्य होने के लिए कोई जवाब नहीं दिया जा सकता है

— ब्लू

3

05AB1E , 10 बाइट्स

bg.²îD1Q+o

व्याख्या

bg         Push the length of the binary representation of input without leading zeros
  .²î      Push x = ceil(log2(length))
     D1Q+  Add 1 if x == 1 or add 0 otherwise
         o Push pow(2,x) and implicitly display it

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

— Osable
स्रोत

22

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

f=lambda n:4**(n>1)*(n<16)or 2*f(n**.5)

गिना जाता है कि 2 के आउटपुट से बचने के लिए किसी विशेष आवरण के साथ nनीचे को कितनी बार वर्गमूल लेना चाहिए 16।

यदि 2 को शामिल किया गया था, तो हम कर सकते थे

f=lambda n:n<2or 2*f(n**.5)

1 के लिए सच के साथ।

41 बाइट्स:

f=lambda n,i=1:i*(2**i>n)or f(n,i<<1+i%2)

बार बार प्रतिपादक दोगुना हो जाता है iजब तक 2**i>n। विषम होने पर एक अतिरिक्त बिट को शिफ्ट i=1करने से स्कीप किया जाता i=4है i।

ऑल्ट 45 बाइट्स:

f=lambda n,i=4:4**(n>1)*(2**i>n)or 2*f(n,i*2)

— XNOR
स्रोत

7

यह मुझे विस्मित करने के लिए कभी नहीं रोकता है कि आप किसी समस्या के लिए कितने समाधानों के साथ आ सकते हैं। मूल रूप से एक प्रोग्रामर के रूप में मैंने एक समस्या का हल ढूंढना सीख लिया है और जब तक यह काम करता है तब तक इसके साथ काम करता है। लगता है कि मुझे अभी भी गोल्फ के बारे में बहुत कुछ सीखना है! आदर करना।

— एलप्रेड्रो

@xnor, 10 या 1 का वर्गमूल हमेशा 1 (अनंत पुनरावृत्ति or 2*f(n**.5)) होने पर आपका पहला उत्तर आउटपुट कैसे होता है ?

— डेफरन

2

@ डफरन मेरा मानना है कि orकेवल कुछ फाल्सी (शून्य) का मूल्यांकन करने से पहले भाग का मूल्यांकन किया जाता है। N = 0 के लिए, और n = 1 के लिए, का n>1मूल्यांकन करता है False, जिसे एक संख्यात्मक अभिव्यक्ति में शून्य के रूप में माना जाता है, और इसका n<16मूल्यांकन करता है True, जिसे एक संख्यात्मक अभिव्यक्ति के रूप में माना जाता है। तो 4**(n>1)*(n<16)1. है

— ट्राइकोप्लाक्स

1

@trichoplax, यह सही है। स्पष्टीकरण के लिए धन्यवाद।

— 20

12

जे, 19 बाइट्स

मोनडिक क्रिया सही पर संख्या ले रही है और कंटेनर के आकार को बाहर निकाल रही है। लिखने के समान तरीके हैं, इसलिए मैंने दोनों को शामिल किया है।

2^2(>.+1=>.)@^.#@#:
2^s+1=s=.2>.@^.#@#:

विस्फोट से समझाया:

2^2(>.+1=>.)@^.#@#: NB. takes one argument on the right...
                 #: NB. write it in binary
               #@   NB. length (i.e. how many bits did that take?)
  2          ^.     NB. log base 2 of that
   (>.     )@       NB. ceiling
      +1=>.         NB. +1 if needed (since no container is two bits wide)
2^                  NB. base 2 exponential

क्या कूल है हम देख रहे हैं जे में लॉग बेस 2 लेने के दो अलग-अलग तरीके हैं पहला स्पष्ट है 2^., जो एक संख्यात्मक लॉगरिथम है। दूसरा है #@#:, जिसे "बेस -2 प्रतिनिधित्व की लंबाई" के रूप में पढ़ा जा सकता है। यह वन-प्लस-फ्लोर-ऑफ-लॉग-बेस -2 के लगभग बराबर है, सिवाय इसके कि #:0वन-एलिमेंट लिस्ट है 0, जो कि वास्तव में हम चाहते हैं। यह 1+2<.@^.1&>.8 बाइट्स से धड़कता है।

REPL में उपयोग में:

   f =: 2^2(>.+1=>.)@^.#@#:
   f 131313
32
   f 34359750709
64
   (,.f"0) 0 1 2 15 16 123 260
  0  1
  1  1
  2  4
 15  4
 16  8
123  8
260 16

पुराने, अत्यधिक चतुर 20 बाइट समाधान।

2&^.(>.+1=>.&.)@#@#: NB. takes one argument on the right...
                #@#: NB. how many bits
2&^.                 NB. log base 2 of that
     >.              NB. ceiling
       +1=>.         NB. +1 if needed (since no container is two bits wide)
    (       &.)      NB. undo log base 2

— algorithmshark
स्रोत

9

पायथन, 53 50 49 बाइट्स

lambda n:[w for w in[1,4,8,16,32,64]if n<2**w][0]

— orlp
स्रोत

1

lambda n:[w for w in[1,4,8,16,32,64]if n<2**w][0]एक बाइट छोटा है

— ब्लू

कुछ ऐसा ही पोस्ट करने वाला था। +1

— ElPedro 21

8

गणितज्ञ, 44 39 38 बाइट्स

5 बाइट्स के लिए @orlp और 1 बाइट के लिए @MartinEnder को धन्यवाद।

FirstCase[{1,4,8,16,32,64},x_/;2^x>#]&

सूची में पहले तत्वों को शामिल करता है {1, 4, 8, 16, 32, 64}जैसे कि 2 ^ संख्या इनपुट से अधिक है।

— जंगवान मिन
स्रोत

8

पिप , 19 बाइट्स

(a<2**_FI2**,7RM2i)

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

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

                     a is 1st cmdline arg, i is 0 (implicit)
         2**,7       Construct powers of 2 from 0 to 6 [1 2 4 8 16 32 64]
              RM2    Remove 2
       FI            Filter for elements for which:
 a<2**_                a is less than 2 to that element
(                i)  Get 0th item of resulting list and autoprint

— DLosc
स्रोत

7

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

n=>[1,4,8,16,32,64].find(b=>2**b>n)

— नील
स्रोत

2

एक पुनरावर्ती संस्करण जैसे f=(n,b=1)=>2**b>n&&b-2?b:f(n,b*2)थोड़ा छोटा होना चाहिए।

— अरण्युलड

6

गणितज्ञ, ४६ ४३ ३ by बाइट्स

3 बाइट्स बचाने के लिए JungHwan Min और Martin Ender को धन्यवाद! एक बड़ी 5-बाइट बचत के लिए ngenisis के लिए धन्यवाद!

2^⌈Log2@BitLength@#⌉/.{2->4,0->1}&

एक nonnegative पूर्णांक को इनपुट के रूप में लेना और एक सकारात्मक पूर्णांक वापस करना है। BitLength@#इनपुट में बिट्स की संख्या की गणना करता है, और फिर 2^⌈Log2@...⌉2 की सबसे छोटी शक्ति की गणना करता है जो कम से कम बिट्स की संख्या के रूप में बड़ी है। अंत में, /.{2->4,0->1}उस विशेष मामले का ख्याल रखता है जो बिट और नायब के बीच कोई "भतीजी" नहीं है, और अजीब इनपुट के लिए उत्तर को भी ठीक करता है 0।

— ग्रेग मार्टिन
स्रोत

2

के BitLength@#बजाय का उपयोग करके 3 बाइट्स सहेजें ⌊1+Log2@#⌋। इसके बजाय आप के ∞साथ बदलने के बजाय एक और 2 बाइट्स की बचत 1कर सकते हैं 0और आप पहले के लिए बंधे हैं।

— ngenisis

1

यह वास्तव में पूरी तरह से किया जा सकता है BitLength। मेरा जवाब

— ngenisis

4

जूलिया, 40 बाइट्स

n->filter(x->n<big(2)^x,[1;2.^(2:6)])[1]

यह एक अनाम फ़ंक्शन है जो 2 को छोड़कर, 0 से 6 तक की शक्तियों की एक सरणी उत्पन्न करता है, और इसे केवल उन तत्वों x को फ़िल्टर करता है, जैसे कि 2 ^x इनपुट से अधिक है। पहला ऐसा तत्व उत्तर है। दुर्भाग्य से यह x = 64 BigIntपर अतिप्रवाह से बचने के लिए 2 को बढ़ावा देने की आवश्यकता है ।

यह वास्तव में ऑरलपी के पायथन जवाब के समान है, हालांकि मैंने इस दृष्टिकोण को मनगढ़ंत करने से पहले इसे नहीं देखा था।

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

— एलेक्स ए।
स्रोत

4

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

{first 1+<*>$_,1,4,8,16,32,64}

+<पर्ल 6 का लेफ्ट बिट शिफ्ट ऑपरेटर है, जिसे कई अन्य भाषाएं कॉल करती हैं <<।

— शॉन
स्रोत

4

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

f n=[2^i|i<-0:[2..],2^2^i>n]!!0

32-बाइट ऑल्ट:

f n|n<2=1|n<16=4|1>0=2*f(sqrt n)

— XNOR
स्रोत

2

जावा, 143 बाइट्स।

int f(long a){a=Long.toBinaryString(a).length();if(a<2)return 1;if(a<5)return 4;if(a<9)return 8;if(a<17)return 16;if(a<33)return 32;return 64;}

— पावेल
स्रोत

1

मुझे पता है कि मैं इसे कम कर सकता हूं, जब मैं कंप्यूटर पर हूं तो Io इसे कर सकता है।

— पावेल

2

50 बाइट्स return a<2?1:a<5?4:a<9?8:a<17?16:a<33?32:64;

— बचाएं

@Mindwin मुझे पता है, लेकिन मैं यात्रा कर रहा हूं और थोड़ी देर के लिए कंप्यूटर तक पहुंच नहीं होगी। मैं इसके चारों ओर मिलूँगा।

— पावेल

क्या स्कोर इसे बना देता है ... लव बाइट ?

— इंजीनियर टोस्ट

2

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

f x=head$filter((>x).(2^))$[1,4,8,16,32,64]

— क्षार
स्रोत

2

रूबी, 39 36 बाइट्स

->n{2**[0,*2..6].find{|p|2**2**p>n}}

गोल्फ की मदद करने के लिए धन्यवाद GB

— एलेक्सिस एंडरसन
स्रोत

कोष्ठक के बिना भी काम करना चाहिए। इसके अलावा, सूची 0,2,3,4,5,6 हो सकती है और 1 << 2 ** पी का उपयोग कर सकती है।

— जीबी

... क्योंकि तब आप 0, * 2..6 का उपयोग कर सकते थे।

— GB

2

जावा 8, 65 55 बाइट्स

यह एक लंबोदर अभिव्यक्ति है जो एक longरिटर्न लेता है और एक रिटर्न देता है int। जावा में पहले कभी भी गोल्फ नहीं खेला जाता है, इसलिए इसे आसानी से हराया जा सकता है:

x->{int i=1;while(Math.pow(2,i)<=x)i<<=1+i%2;return i;}

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

के लिए 47 बाइट्स , हम हो सकता है:

x->{int i=1;while(1L<<i<=x)i<<=1+i%2;return i;}

हालाँकि, 1L<<iरिटर्न वैल्यू के लिए ओवरफ्लो 32 से अधिक है, इसलिए यह अंतिम टेस्टकेस के लिए विफल रहता है।

— FlipTack
स्रोत

1

यह रिटर्न 4जब साथ परीक्षण किया 16जब यह 8. इसके अलावा वापस जाने के लिए माना जाता है आप कर सकते हैं अभी भी गोल्फ के आसपास कोष्ठक निकाल कर इस समाधान i<<=1+i%2;के बिना के बाद से {}है, जबकि पाश होगा केवल अगली पंक्ति पर अमल

— Kritixi lithos

@KritiiLithos को अब ठीक किया जाना चाहिए - क्षमा करें, मेरे जावा की जंग

— लगी है

2

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

2^(f=BitLength)[f@#-1]/. 2->4&

स्पष्टीकरण:

आज्ञा देना Nnonnegative पूर्णांक का सेट है। दो कार्यों को परिभाषित करें N, BitLengthऔर NextPowerइस प्रकार है:

BitLength(n) := min {x in N : 2^x - 1 >= n}
NextPower(n) := 2^(min {x in N : 2^x >= n})

यह समाधान अनिवार्य रूप से NextPower(BitLength(n))दिए गए पूर्णांक की गणना करता है n >= 0। के लिए n > 0, हम यह देख सकते हैं NextPower(n) = 2^BitLength(n-1), इसलिए NextPower(BitLength(n)) = 2^BitLength(BitLength(n)-1)।

अब मैथेमेटिका BitLengthने जो परिभाषा दी, उससे मैं सहमत हूं n >= 0। के लिए n < 0, BitLength[n] == BitLength[BitNot[n]] == BitLength[-1-n]इसलिए BitLength[-1] == BitLength[0] == 0। इस प्रकार हम के वांछित जवाब पाने 1के लिए n==0।

जब से हम बिट से निबल के लिए सीधे छोड़, हम का जवाब की जगह 2के साथ 4।

— ngenisis
स्रोत

1

अच्छी तरह से निर्मित! (शर्म करो कि अंतरिक्ष आवश्यक है।)

— ग्रेग मार्टिन

2

बैश, 49 बाइट्स 48 बाइट्स

for((y=1;$[y==2|$1>=1<<y];$[y*=2])){ :;};echo $y

या

for((y=1;$[y==2|$1>=1<<y];)){ y=$[y*2];};echo $y

एक स्क्रिप्ट में सहेजें और एक तर्क के रूप में परीक्षण की जाने वाली संख्या को पास करें।

संपादित करें: प्रतिस्थापित || साथ |, जो काम करता है क्योंकि तर्क हमेशा 0 या 1 होते हैं।

नोट: यह पूर्णांकों के लिए सबसे बड़े धनात्मक पूर्णांक तक काम करता है जिसे बैश का आपका संस्करण संभाल सकता है। यदि मेरे पास समय है, तो मैं इसे 32-बिट हस्ताक्षरित अंकगणित का उपयोग करने वाले बैश के संस्करणों में 2 ^ 64-1 तक काम करने के लिए संशोधित करूंगा।

इस बीच, यहां एक 64-बाइट समाधान है जो मनमाने ढंग से बड़ी संख्या (किसी भी संस्करण में बाश) के लिए काम करता है:

for((x=`dc<<<2o$1n|wc -c`;$[x==2||x&(x-1)];$[x++])){ :;};echo $x

— मिशेल स्पेक्टर
स्रोत

2

ढेर, 34 30 बाइट्स

@n 1 2 6|>2\^,:n 2 log>keep 0#

या

{!1 2 6|>2\^,:n 2 log>keep 0#}

पहला टीओएस पर इनपुट लेता है और टीओएस पर आउटपुट छोड़ता है; दूसरा एक फ़ंक्शन है। यहाँ कोशिश करो!

व्याख्या

@n 1 2 6|>2\^,:n 2 log>keep 0#
@n                               set TOS to `n`
   1 2 6|>2\^,                   equiv. [1, ...2 ** range(2, 6)]
              :                  duplicate it
               n                 push `n`
                 2 log           log base-2
                      >          element-wise `>`
                       keep      keep only truthy values
                            0#   yield the first element

यहाँ इसका एक उदाहरण उत्तर पर काम कर रहा है :

> 8    (* input *)
(8)
> @n 1 2 6|>2\^,:n 2 log>keep 0#    (* function *)
(4)
>    (* output *)
(4)

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

> {!1 2 6|>2\^,:n 2 log>keep 0#} @:f
()
> (0 1 2 15 16 123 260 131313 34359750709) $f map
((1 1 4 4 8 8 16 32 64))
>

या, एक पूर्ण कार्यक्रम के रूप में:

{!1 2 6|>2\^,:n 2 log>keep 0#} @:f

(0 1 2 15 16 123 260 131313 34359750709) $f map

out

— कोनोर ओ ब्रायन
स्रोत

2

रैकेट 45 बाइट्स

(findf(λ(x)(>(expt 2 x)m))'(1 4 8 16 32 64))

Ungolfed:

(define (f m)
  (findf (λ (x) (> (expt 2 x) m))          ; find first function
         '(1 4 8 16 32 64)))

अन्य संस्करण:

(define (f1 m)
  (for/last ((i '(1 4 8 16 32 64))         ; using for loop, taking last item
             #:final (> (expt 2 i) m))     ; no further loops if this is true
    i))

और स्ट्रिंग लंबाई का उपयोग करना:

(define (f2 m)
  (for/last
      ((i '(1 4 8 16 32 64))
       #:final (<= (string-length
                    (number->string m 2))  ; convert number to binary string
                   i))
    i))

परिक्षण:

(f 0)
(f 1)
(f 2)
(f 15)
(f 16)
(f 123)
(f 260)
(f 131313)
(f 34359750709)

आउटपुट:

— rnso
स्रोत

1

ऑक्टेव, 40 36 31 29 बाइट्स

साधारण अनाम फ़ंक्शन। यह माना जाता है कि इनपुट मूल्य एक पूर्णांक है - अंत में चेतावनी देखें।

@(a)(b=2.^[0 2:6])(a<2.^b)(1)

कोड निम्नानुसार काम करता है:

पहले अनुमत बिट लंबाई (1,4,8,16,32,64) का एक सरणी बनाया और बचाया जाता है b।
अगला हम इनपुट संख्या को संग्रहीत करने के लिए आवश्यक बिट्स की संख्या को देखते हैं, जो aप्रत्येक कंटेनर के अधिकतम आकार के साथ तुलना करके bदेखते हैं कि कौन से काफी बड़े हैं।
हम फिर कंटेनर के आकार को bफिर से निकालने के लिए परिणामी सूचकांक वेक्टर का उपयोग करते हैं ।
अंत में हम परिणामी सरणी में पहला तत्व लेते हैं जो सबसे छोटा कंटेनर संभव होगा।

आप इसे यहाँ ऑनलाइन कोशिश कर सकते हैं ।

बस निम्नलिखित कोड चलाएं, और फिर करें ans(x)।

इसके साथ एकमात्र चेतावनी यह है कि डिफ़ॉल्ट रूप से स्थिरांक के लिए दोहरी परिशुद्धता का उपयोग किया जाता है, जिसका अर्थ है कि यह केवल दोहरे परिशुद्धता फ्लोट द्वारा उच्चतम मूल्य के प्रतिनिधित्व वाले अंकों के साथ काम करता है जो कि 2 ^ 64 से कम है।

यह सुनिश्चित करके तय किया जा सकता है कि फ़ंक्शन को आपूर्ति की जाने वाली संख्या एक डबल के बजाय एक पूर्णांक है। यह उदाहरण के लिए फ़ंक्शन को कॉल करके प्राप्त किया जा सकता है ans(uint64(x)):।

— टॉम बढ़ई
स्रोत

1

PHP, 49 46 44 बाइट्स

echo(2**ceil(log(log(1+$argn,2),2))-2?:2)+2;

इस तरह से चलाएं:

echo 16 | php -R 'echo(2**ceil(log(log(1+$argv[1],2),2))-2?:2)+2;';echo

व्याख्या

echo                       # Output the result of the expression
  (
    2**                    # 2 to the power
      ceil(log(            # The ceiling of the power of 2 of bitsize
        log(1+$argn,2),    # Number of bits needed
        2
      ))
      - 2 ?:               # Subtract 2 (will be added back again)
      2;                   # If that results in 0, result in 2 (+2=4).
  ) + 2                    # Add 2.

बदलाव

$r=असाइनमेंट से छुटकारा पाने के लिए 3 बाइट्स सहेजे
उपलब्ध -Rकराने के लिए उपयोग करके 2 बाइट्स की बचत की$argn

— aross
स्रोत

1

सीजेएम , 18 बाइट्स

2ri2b,2mLm]_({)}|#

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

व्याख्या

2                   Push 2
 ri                 Read an integer from input
   2b,              Get the length of its binary representation
      2mLm]         Take the ceiling of the base-2 log of the length
           _(       Duplicate it and decrement it
             {)}|   Pop the top element, if it's 0, increment the next element
                     Effectively, if ceil(log2(input)) was 1, it's incremented to 2,
                     otherwise it stays the same.
                 #  Raise 2 to that power

— बिजनेस कैट
स्रोत

0

सी, 71 52 बाइट्स

i;f(long long n){for(i=1;n>>i;i*=2);return i-2?i:4;}

— Steadybox
स्रोत

(1<<15)+1के हस्ताक्षरित व्यवहार के कारण इसे अधिक या अधिक तोड़ना नहीं होगा long long? जिस प्रकार से आप वास्तव में चाहते हैं वह uint64_tआवश्यक है #include <stdint.h>जो कि तुलना में अभी भी एक हारे हुए है unsigned long long! हेडर सी में गोल्फिंग के प्रतिबंध हैं।

— dmckee 20

@ डिकी मुझे लगता है कि यह इसे तोड़ सकता है, लेकिन यह कम से कम मेरे कंप्यूटर पर काम करने लगता है। एक उदाहरण नहीं मिला जो काम नहीं करेगा। मैं का उपयोग करने के बारे में सोचा unsigned long longया uint64_t, लेकिन जब से यह काम करने के लिए लगता है long longमैं इसके साथ चला गया।

— 20

0

QBIC , 27 बाइट्स

:~a<2|_Xq]{~a<2^t|_Xt\t=t*2

व्याख्या

:        Get cmd line parameter N, call it 'a'
~a<2     IF 'a' is 0 or 1 (edge case)
|_Xq]    THEN quit, printing 1 ('q' is auto-initialised to 1). ']' is END-IF
{        DO - infinite loop
    2^t  't' is our current number of bits, QBIC sets t=4 at the start of the program.
         2^t gives the maximum number storable in t bytes.
 ~a<     IF the input fits within that number,
|_Xt     THEN quit printing this 't'
\t=t*2   ELSE jump to the next bracket (which are spaced a factor 2 apart, from 4 up)
         DO-loop is auto-closed by QBIC.

— steenbergh
स्रोत

0

पाइके, 13 बाइट्स

7Zm@2-#2R^<)h

यहाँ कोशिश करो!

7Zm@          -   [set_bit(0, i) for i in range(7)] <- create powers of 2
    2-        -  ^.remove(2)
      #    )h - filter(^, V)[0]
       2R^    -   2 ** i
          <   -  input < ^

— नीला
स्रोत

0

PHP, 43 बाइट्स

for(;1<<2**$i++<=$argn;);echo 2**$i-=$i!=2;

के साथ भागो echo <number> | php -R '<code>'।

इनपुट से बड़ा $iहोने तक लूप्स 2**(2**$i)। (Tweak: <<बजाय **पैरेंस को खत्म करने के)
लूप के बाद, $ i एक बहुत अधिक है; इसलिए इसे आउटपुट की गणना करने से पहले एक गिरावट आती है
- लेकिन इसके लिए नहीं $i==2।

— टाइटस
स्रोत

एक बिट, एक कुतरना या बाइट?

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

05AB1E , 10 बाइट्स

व्याख्या

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

जे, 19 बाइट्स

पायथन, 53 50 49 बाइट्स

गणितज्ञ, 44 39 38 बाइट्स

पिप , 19 बाइट्स

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

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

गणितज्ञ, ४६ ४३ ३ by बाइट्स

जूलिया, 40 बाइट्स

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

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

जावा, 143 बाइट्स।

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

रूबी, 39 36 बाइट्स

जावा 8, 65 55 बाइट्स

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

बैश, 49 बाइट्स 48 बाइट्स

ढेर, 34 30 बाइट्स

व्याख्या

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

रैकेट 45 बाइट्स

ऑक्टेव, 40 36 31 29 बाइट्स

PHP, 49 46 44 बाइट्स

व्याख्या

बदलाव

सीजेएम , 18 बाइट्स

सी, 71 52 बाइट्स

QBIC , 27 बाइट्स

पाइके, 13 बाइट्स

PHP, 43 बाइट्स