30

एक प्रोग्राम लिखें जो जाँचता है कि पूर्णांक 2 की शक्ति है।

नमूना इनपुट:

नमूना उत्पादन:

Yes

नमूना इनपुट:

नमूना उत्पादन:

No

नियम:

का प्रयोग न करें +, -आपरेशनों।
नंबर प्राप्त करने के लिए किसी प्रकार की इनपुट स्ट्रीम का उपयोग करें। इनपुट को शुरू में एक चर में संग्रहीत नहीं माना जाता है।
सबसे छोटा कोड (बाइट्स में) जीतता है।

आप किसी भी सच्चाई / झूठी प्रतिक्रिया (उदाहरण के लिए, true/ false) का उपयोग कर सकते हैं । आप मान सकते हैं कि इनपुट संख्या इससे अधिक है 0।

— gthacoder
स्रोत

1

क्या इसे "हाँ" के बजाय "हाँ" और "असत्य" के बजाय "सत्य" के आउटपुट की अनुमति है?

— प्रोग्रामफॉक्स

2

हां, आप किसी भी सकारात्मक / नकारात्मक प्रतिक्रिया का उपयोग कर सकते हैं। प्रश्न अद्यतन है।

— gthacoder

1

predसमारोह, जब एक पूर्णांक n के लिए आवेदन किया, रिटर्न n - 1. इस जैसे कार्यों हैं, जो मना ऑपरेटर चारों ओर पतली धर कर रहे हैं, भी मना किया?

— वेन कॉनराड

1

@ गोयन गोल्फ की तरह ), या अधिकांश सी-आधारित भाषाओं की तरह --।

— दरवाज़े

2

मुझे पता है कि भविष्य में अब हम 3 साल हैं, लेकिन "+/- ऑपरेटरों" गैर-अवलोकन योग्य है, या बहुत कम से कम कमजोर रूप से परिभाषित किया गया है।

— 22

13

GolfScript, 6 चार्ट, कोई कमी नहीं

~.3/&!

यहाँ एक समाधान है जो किसी भी रूप x & (x-1)में विधि का उपयोग नहीं करता है । इसके बजाय उपयोग करता है । ;-) आउटपुट झूठा है, अगर सच है।x & (x/3)01

स्पष्टीकरण:

~ इसे एक नंबर में बदलने के लिए इनपुट स्ट्रिंग को निकालता है,
.इसे डुप्लिकेट करता है (बाद के लिए &),
3/ इसे तीन से विभाजित करता है (नीचे छोटा करता है),
& मूल के साथ बिटविंड और विभाजित मूल्य की गणना करता है, जो शून्य होगा यदि और केवल तभी इनपुट शून्य या दो की शक्ति है (अर्थात सबसे अधिक एक बिट सेट है), और
! तार्किक रूप से यह नकारात्मक है, शून्य को एक और अन्य सभी मानों को शून्य में मैप करना।

टिप्पणियाँ:

स्पष्ट नियमों के अनुसार, शून्य एक वैध इनपुट नहीं है , इसलिए यह कोड ठीक है, भले ही यह 1इनपुट शून्य होने पर आउटपुट करता है।
यदि गोल्फस्क्रिप्ट डिक्रीमेंट ऑपरेटर (की अनुमति है, तो एडिट्स द्वारा पोस्ट किया गया 5-चरित्र समाधान पर्याप्त है। हालांकि, यह नियमों की भावना के खिलाफ जाना प्रतीत होता है , अगर पत्र नहीं।~.(&!
मैं x & (x/3)ट्रिक के साथ सालों पहले फन विथ पर्ल मेलिंग लिस्ट में आया था। (मुझे यकीन है कि मैं इसे खोजने वाला पहला नहीं हूं, लेकिन मैंने इसे स्वतंत्र रूप से आविष्कार किया था।) यहां मूल पोस्ट का लिंक दिया गया है , जिसमें एक प्रमाण भी शामिल है कि यह वास्तव में काम करता है।

— इल्मरी करोनें
स्रोत

मुझे लगता है कि यह वास्तव में थोड़ा मूर्खतापूर्ण है, गोल्फस्क्रिप्ट एक सटीक समाधान को लिखने की अनुमति देता है जिसे ओपी वास्तव में नियमों को तोड़ने के बिना बाहर करना चाहता था।

— टिम सेगिन

1

@ समय: ठीक है, यहाँ एक के बाद गिरावट है। ;)

— इल्मरी करोनें

यह कैसे काम कर सकता है? उदाहरण के लिए 7/3 = 2 (0010), 7 & 2 = 0111 & 0010 = 0010जो कि स्पष्ट रूप से अंतिम बिट 1 नहीं है

— phuclv

@ LưuV LnhPhúc: नहीं, लेकिन दूसरा बिट है। बाइनरी में 3 से लंबे समय तक विभाजन करने की कोशिश करें और यह बहुत स्पष्ट है कि हमेशा ऐसा क्यों होता है यदि लाभांश में एक से अधिक बिट सेट हैं।

— इल्मरी करोनें

आह, मैंने इसे "2 से विभाज्य"

— phuclv

15

एपीएल (7)

हाँ, यह 7 बाइट्स है । उस क्षण के लिए मान लें कि मैं यूनिकोड के बजाय आईबीएम कोडपेज 907 का उपयोग कर रहा हूं और फिर प्रत्येक वर्ण बाइट है :)

0=1|2⍟⎕

अर्थात 0 = mod(log(input(),2),1)

— मारीनस
स्रोत

बस सोच रहा था, अगर आप इसे 0 या एक नकारात्मक संख्या दें तो क्या होगा?

— aditsu

@aditsu I को पता है कि अनंत 1 मोड क्या है, लेकिन यह निश्चित रूप से शून्य नहीं होना चाहिए ।

— टिम सेगिन

1

@TimSeguine Mathematica मुझे देता है Indeterminateजब मैं कोशिश करता हूं।

— लेजियन मम्मल 978

7

GolfScript, 11 (1 के लिए) (सच) और 0 (झूठे)

.,{2\?}%?0>

नंबर को स्टैक पर रखें और फिर चलाएं।

GolfScript, 22 (हाँ / नहीं के लिए)

.,{2\?}%?0>'Yes''No'if

मैं प्यार करता हूँ कि रूपांतरण करने 1/ 0करने के लिए Yes/ Noचुनौती खुद के रूप में ज्यादा के रूप में लेता है कोड: डी

चेतावनी: अत्यधिक अक्षम;) यह 10000 तक की संख्या के लिए ठीक काम करता है, लेकिन एक बार जब आप उच्च प्राप्त करते हैं तो आप मामूली अंतराल को नोटिस करना शुरू करते हैं।

स्पष्टीकरण:

.,: में बदल जाता nहै n 0..n( .डुप्लिकेट, ,0..n रेंज)
{2\?}: 2 की शक्ति को
%: मानचित्र "2 की शक्ति" से अधिक "0..n" तो यह बन जाता है n [1 2 4 8 16 ...]
?0>: यह देखने के लिए जांचता है कि क्या सरणी में संख्या है (0 इंडेक्स से अधिक है)

— Doorknob
स्रोत

1

हां / नहीं के लिए 1 बाइट छोटा .,{2\?}%?0<'YesNo'3/=:; मुझे भी लगता है कि आप "स्टैक पर नंबर डालें" पूछकर धोखा दे रहे हैं, आपको इसकी शुरुआत ए से करनी चाहिए ~।

— aditsu

1

1 पर फेल, जो 2 ^ 0 है

— जोआचिम इस्कसन

6

गणितज्ञ २ 28

Numerator[Input[]~Log~2]==1

2 की पूर्णांक शक्तियों के लिए, आधार 2 लॉग का अंश 1 होगा (जिसका अर्थ है कि लॉग एक इकाई अंश है)।

यहां हम प्रकल्पित इनपुट को प्रदर्शित करने के लिए फ़ंक्शन को थोड़ा संशोधित करते हैं। हम शुद्ध फ़ंक्शन को परिभाषित करने के लिए #जगह में Input[]जोड़ते हैं और जोड़ते हैं &। यह वही उत्तर देता है जो उपर्युक्त फ़ंक्शन में उपयोगकर्ता इनपुट को वापस कर दिया जाएगा।

    Numerator[#~Log~2] == 1 &[1024]
    Numerator[#~Log~2] == 1 &[17]

सच्चा
झूठा

एक बार में कई नंबरों का परीक्षण।

    Numerator[#~Log~2] == 1 &&/@{64,8,7,0}

{सच, सच, गलत, गलत}

— DavidC
स्रोत

4

पर्ल 6 (17 अक्षर)

say get.log(2)%%1

इस प्रोग्राम को STDIN getफ़ंक्शन से एक लाइन मिलती है, इस पर बेस 2 ( log(2)) के साथ लघुगणक की गणना करता है, और जाँचता है कि क्या परिणाम 1 से विभाजित होता है ( %%1जहां %%ऑपरेटर द्वारा विभाजित किया गया है)। गोल्फस्क्रिप्ट समाधान के रूप में छोटा नहीं है, लेकिन मुझे यह स्वीकार्य लगता है (गोल्फस्क्रिप्ट वैसे भी सब कुछ जीतता है), लेकिन तेजी से (यहां तक कि यह विचार करते हुए कि पर्ल 6 अभी धीमा है)।

~ $ perl6 -e 'say get.log(2)%%1'
256
True
~ $ perl6 -e 'say get.log(2)%%1'
255
False

— कोनराड बोरोस्की
स्रोत

2

इस चुनौती के लिए मना करने के कारण +और -इसके लिए मनाही है, क्योंकि अगर x & (x - 1)बराबर है 0, तो x2 की शक्ति है।

— ProgramFOX

@ProgramFOX: मैं देख रहा हूं। दिलचस्प ट्रिक

— कोनराड बोरोस्की

1

@प्रोग्रामफ़ॉक्स लेकिन फिर x&~(~0*x)भी काम करता है। वह केवल 2 अक्षर लंबा है।

— orlp

4

ऑक्टेव ( 15 23)

संपादित करें: उपयोगकर्ता इनपुट आवश्यकता के कारण अद्यतन;

~mod(log2(input('')),1)

उपयोगकर्ता इनपुट को एक मान देता है और 1 को सही, 0 को गलत के लिए आउटपुट करता है।

ऑक्टेव में परीक्षण किया, माटलैब में भी काम करना चाहिए।

— जोआचिम इसाकसन
स्रोत

— मटलब में

4

आर, १३ ११

पर्ल समाधान के आधार पर। लौटाता है FALSEया TRUE।

!log2(i)%%1

पैरामीटर iइनपुट चर का प्रतिनिधित्व करता है।

उपयोगकर्ता इनपुट के साथ एक वैकल्पिक संस्करण:

!log2(scan())%%1

— स्वेन होहेंस्टीन
स्रोत

4

GolfScript, 5

सच के लिए आउटपुट 1, झूठ के लिए 0। User3142747 के विचार पर आधारित:

~.(&!

नोट: (गिरावट है, उम्मीद है कि यह गिनती के रूप में नहीं है -:)
अगर यह (और ओपी की टिप्पणियों से पता चलता है कि यह हो सकता है), तो कृपया इसके बजाय इल्मरी करोनन के समाधान को देखें ।
Y / N आउटपुट के लिए, 'NY'1/=अंत में संलग्न करें (7 और बाइट्स)।

— aditsu
स्रोत

4

अजगर, ३१

print 3>bin(input()).rfind('1')

— boothby
स्रोत

31 अगर आप करते हैंbin(input()).rfind('1')<3

— ब्लेंडर

@ ब्लेंडर वेल-स्पॉटेड। मैं इस्तेमाल करता था 2==क्योंकि मुझे लगा कि यह नॉनपोजिटिव नंबरों के लिए भी काम करना चाहिए। यह स्पष्ट रूप से नियमों की आवश्यकता नहीं है, इसलिए ...

— बूथ 39

1

+1। मैं print bin(input()).count('1')<2कुल 31 वर्णों पर पोस्ट करने जा रहा था , लेकिन यह आपके समान है।

— स्टीवन रंबलस्की

4

सी, 48

main(x){scanf("%i",&x);puts(x&~(x*~0)?"F":"T");}

— orlp
स्रोत

अगर नकारात्मक नकारात्मक अनुमति दी जाती है तो कम हो सकती है, अगर नकारात्मक स्थिरांक की अनुमति नहीं है तो यह लंबा है। दो का पूरक मानता है।

— orlp

*बाइनरी की तुलना में अधिक पूर्वता है &, आपको पेरेन्स की आवश्यकता नहीं है। और यदि रिटर्न मान स्वीकार किया जाता है (बस पूछा जाता है) exit(x&x*-1)बहुत कम होगा।

— केविन

एक है -: a x*-1।

— klingt.net

@ klingt.net हाँ, लेकिन यह एक संख्यात्मक स्थिरांक का हिस्सा है। तकनीकी रूप से, जैसा कि अब यह कहा जाता है, केवल ऑपरेटर -ही निषिद्ध है।

— केविन

1

@ klingt.net ने इसे एक ऐसे वर्जन के साथ रिप्लेस किया, जिसमें कोई संकेत नहीं है।

— orlp

4

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

जे, 14 15 वर्ण (आउटपुट 0 या 1)

1=##~#:".1!:1]1

जावास्क्रिप्ट, 76 वर्ण (सही या गलत आउटपुट)

alert((~~prompt()).toString(2).split("").map(Number).filter(Boolean).length)

— जुगनू
स्रोत

यह जोड़ का उपयोग करता है, जो चुनौती से प्रेरित है।

— FUZxxl

हुह। मुझे नहीं पता कि मैं क्या सोच रहा था जब मैंने यह लिखा था ... मैंने इसे अभी तय किया है इसलिए यह वास्तव में नियमों का पालन करता है।

— फायरफली

4

क्लिप , ९ 7 7

!%lnxWO

स्टड से एक नंबर पढ़ता है।

स्पष्टीकरण:

के साथ शुरू करने के लिए, Z= 0, W= 2और O= 1. यह एक दूसरे के लिए Wऔर Oबगल में रखने की अनुमति देता है , जबकि उपयोग 2और 1एक अलग अंतरिक्ष (एक अवांछित अतिरिक्त चरित्र) के बिना नंबर 21 के रूप में व्याख्या की जाएगी। क्लिप में, modulo फ़ंक्शन ( %) गैर-पूर्णांक पर काम करता है, इसलिए, यह पता लगाने के लिए कि क्या कोई मान vपूर्णांक है, तो आप जाँचते हैं कि क्या vmod 1 = 0. क्लिप सिंटैक्स का उपयोग करते हुए, इसे इस रूप में लिखा जाता है =0%v1। हालांकि, चूंकि बूलियन को 1(या कुछ और) के रूप में संग्रहीत किया जाता है और 0, 0यह जाँचना कि क्या कुछ समान है, यह सिर्फ 'नोटिंग' नहीं है। इसके लिए, क्लिप के पास !ऑपरेटर है। मेरे कोड में vहै lnx2। xस्टडिन से एक इनपुट है,nएक स्ट्रिंग को एक संख्या में परिवर्तित करता है और labलॉग बेस bहोता है a। कार्यक्रम इसलिए (और अधिक आसानी से) का अनुवाद करता है 0 = ((log base 2 of parseInt(readLine)) mod 1)।

उदाहरण:

आउटपुट

तथा

आउटपुट

संपादित करें 1: प्रतिस्थापित 0, 1और 2साथ Z, Oऔर W।

संपादित 2: के =Zसाथ बदल दिया !।

इसके अलावा:

अजगर , ५

क्लिप संस्करण को और भी आगे बढ़ाता है, क्योंकि Pyth ने पहले ही मूल्यांकन किए गए इनपुट के लिए Q और केवल सामान्य लॉग (a, b) के बजाय एक log2 (a) फ़ंक्शन किया है।

!%lQ1

— bcsb1001
स्रोत

3

जावास्क्रिप्ट (37)

a=prompt();while(a>1)a/=2;alert(a==1)

सरल स्क्रिप्ट जो केवल 2 बार बार विभाजित होती है और शेष की जांच करती है।

— जोआचिम इसाकसन
स्रोत

1

forलूप के साथ एक ही विचार (37 चार्ट भी)for(i=prompt();i>1;i/=2){}alert(i==1)

— मैथ चिलर

3

गणितज्ञ (21)

IntegerQ@Log2@Input[]

इनपुट के बिना यह थोड़ा छोटा है

IntegerQ@Log2[8]

सच

IntegerQ@Log2[7]

असत्य

— ybeltukov
स्रोत

⌊#⌋==#&@Log2@Input[]

— एलेफाल्फा

1

@alephalpha जो UTF-8 वर्णों के लिए 24 बाइट्स का उपयोग करके समाप्त होता है। एक और 21-बाइट कार्यक्रम है Log2@Input[]~Mod~1==0।

— १

2

जावास्क्रिप्ट, 41 40 अक्षर

l=Math.log;alert(l(prompt())/l(2)%1==0);

यह कैसे काम करता है: आप का उपयोग करके बेस 2 पर लघुगणक लेते हैं l(prompt()) / l(2), और यदि परिणाम modulo 1 शून्य के बराबर है, तो यह 2 की शक्ति है।

उदाहरण के लिए: आधार पर 8 का लघुगणक लेने के बाद 2, आपको मिलता है 3। 3 modulo 10 के बराबर है, इसलिए यह सही है।

बेस 2 पर 7 का लॉगरिदम लेने के बाद, आपको मिलता है 2.807354922057604। 2.807354922057604 modulo 1के बराबर है 0.807354922057604, इसलिए यह गलत है।

— ProgramFOX
स्रोत

आपको किसी नंबर पर इनपुट डालने की आवश्यकता नहीं है; Math.logपहले से ही ऐसा करेंगे : "निम्न में से प्रत्येक मैथ ऑब्जेक्ट फ़ंक्शंस में टॉनम्बर एब्स्ट्रैक्ट ऑपरेटर को उसके प्रत्येक तर्क पर लागू होता है ..."

— अप्सिलर्स

क्या यह संख्यात्मक अशुद्धियों से पीड़ित नहीं है?

— मार्क जेरोनिमस

@MarkJeronimus: मैं वास्तव में नहीं जानता। यह हो सकता है, लेकिन मैं अभी तक एक गलत परिणाम का सामना नहीं किया है।

— प्रोग्रामफॉक्स

2

जावास्क्रिप्ट, 35

बाइट के लिए काम करता है।

alert((+prompt()).toString(2)%9==1)

46 चरित्र संस्करण , 16 बिट संख्या के लिए काम करता है।

x=(+prompt()).toString(2)%99;alert(x==1|x==10)

चाल सबसे गतिशील भाषाओं में काम करती है।

स्पष्टीकरण: संख्या को आधार 2 में परिवर्तित करें, उस स्ट्रिंग को आधार 10 के रूप में व्याख्या करें, अंक योग प्राप्त करने के लिए मोडुलो 9 करें, जो 1 होना चाहिए।

— प्रतिलिपि
स्रोत

क्या बारे में 0x2ff, जो आधार 2 में है 1111111111?

— पीटर टेलर

@PeterTaylor आप सही हैं, निश्चित है

— कॉपी

तो असली बात यह है कि आपके द्वारा किए गए modulo 10 के लिए जाँच शेष है, लेकिन आपने अपने कोड के एक चरित्र को दाढ़ी बनाने के लिए 9 का उपयोग किया है +1!

— गणित चिलर

यह थोथा धोखा है लेकिन एक और तरीका है:alert(!(Number.MAX_VALUE%prompt()))

— प्लूटो

2

पर्ल 5.10+, 13 + 1 = 14 वर्ण

say!($_&$_/3)

मेरे गोल्फस्क्रिप्ट प्रविष्टि के रूप में एक पुराने FWP थ्रेड से एक ही विधि का उपयोग करता है । प्रिंट अगर इनपुट दो की शक्ति है, और एक खाली लाइन अन्यथा।1

साथ चलने की जरूरत है perl -nE; कुल 14 वर्णों के लिए n एक अतिरिक्त शुल्क का खर्च आता है । वैकल्पिक रूप से, यहां एक 18-वर्ण संस्करण है जिसकी आवश्यकता नहीं है n:

say!(($_=<>)&$_/3)

— इल्मरी करोनें
स्रोत

2

अजगर ३, ३,

print(1==bin(int(input())).count('1'))

अजगर, ३२

हालाँकि, कोड हर संस्करण में काम नहीं करता है।

print 1==bin(input()).count('1')

ध्यान दें कि समाधान 0 (प्रिंट फाल्स) के लिए भी काम करता है।

— गारी बी.एन.
स्रोत

Upvoted क्योंकि यह मेरा समाधान भी था।

— जोश कैसवेल

1

क्या होगा अगर आप के ==साथ बदलें &?

— सिमोन 22

@SimonT यह सच नहीं है। '==' के साथ 'और' को प्रतिस्थापित करने पर प्रत्येक संख्या के लिए 1 छपेगा, जिसकी विषम संख्या में '1' बाइनरी प्रतिनिधित्व है। उदाहरण के लिए जाँच करें 7 = 111। 3 = 11 हैं। यह 11 और 1 = 1.

— गारी बीएन

2

रूबी - 17 अक्षर (चौथी कोशिश)

p /.1/!~'%b'%gets

मेरा वर्तमान सबसे अच्छा है, अपने साथ @ स्टेन्सलैग के उत्तर का एक संलयन। नीचे मेरे पिछले प्रयास हैं।

रूबी - 19 अक्षर (तीसरी कोशिश)

p /10*1/!~'%b'%gets

रूबी - 22 अक्षर (दूसरी कोशिश)

p !('%b'%gets)[/10*1/]

रूबी - 24 अक्षर (पहली कोशिश)

p !!('%b'%gets=~/^10*$/)

— OI
स्रोत

आपके कार्यक्रम में अभी भी "+" है

— phuclv

मुझे पता है। : - / मैंने स्पष्टीकरण के लिए कहा है कि क्या '+' और '-' की सख्त मनाही है, या क्या उनका उपयोग इसके अलावा और घटाव के अलावा अन्य संदर्भों में भी किया जा सकता है। मैं फिर से लिखने की प्रक्रिया में हूँ।

— OI

महान सुधार। ऐसा लगता है कि यह अब तक का सबसे अच्छा रूबी परिणाम है। मैंने प्रश्न पाठ में नेताओं की तालिका को अद्यतन किया।

— gthacoder

@gthacoder ने मेरे बाइनरी फॉर्मेटिंग के साथ बस स्टेंडलेग के रेगेक्स को संयोजित किया। निश्चित रूप से सभी क्रेडिट नहीं ले सकते।

— OI

2

के / कोना ( 24 17)

d:{(+/(2_vs x))~1

1 रिटर्न अगर सच है और 0 झूठे हैं तो। 2 की किसी भी शक्ति में 1 के बराबर एक बिट है:

2_vs'_(2^'(!10))
(,1
1 0
1 0 0
1 0 0 0
1 0 0 0 0
1 0 0 0 0 0
1 0 0 0 0 0 0
1 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0 0)

(यह बाइनरी में 2 (0 से 9 तक) की सभी शक्तियों को प्रिंट करता है)

इसलिए मैं बाइनरी अभिव्यक्ति के सभी घटकों को समेटता xहूं और देखता हूं कि क्या यह 1 के बराबर है; यदि हाँ x=2^n, तो अन्यथा नहीं।

... पता था कि मैं इसे छोटा कर सकता हूं

— काइल कानोस
स्रोत

@gthacoder: मैंने कोड को छोटा कर दिया है, आशा है कि आप इसे प्रतिबिंबित करने के लिए मुख्य पोस्ट को अपडेट कर सकते हैं!

— काइल कानोस

क्या यह उपयोग नहीं है? और, सवाल नहीं है, गलत, कि मना?

— zgrep

2

C # (54 अक्षर)

 Math.Log(int.Parse(Console.ReadLine()),2)%1==0?"Y":"N"

— मेरिन नाकामरी
स्रोत

कार्य स्पष्ट रूप से बताता है कि इनपुट एक चर में संग्रहीत नहीं है, इसे किसी प्रकार के इनपुट स्ट्रीम (जैसे स्टडिन) से प्राप्त किया जाना चाहिए, साथ ही, यह कोड-गोल्फ है , अपने कोड को थोड़ा छोटा करने की कोशिश करें, कम से कम व्हाट्सएप को हटाकर

— mniip

मुझे लगता है कि आप सिर्फ मतलब है Int32, नहीं ToInt32...

— क्रिस

य या। क्रिस को इंगित करने के लिए धन्यवाद। पहले यह Convert.ToInt32 था और मैं इसे छोटा करने के लिए इसे Int32.Parse में बदलना चाहता था। : डी

— मेरिन नाकामरी

2

2 कम वर्णों के intबजाय उपयोग करें Int32।

— रिक

2

रेम्बु (9 वर्ण)

z?MOl2A 1

परीक्षा

>> rebmu/args [z?MOl2A 1] 7
== false

>> rebmu/args [z?MOl2A 1] 8 
== true

>> rebmu/args [z?MOl2A 1] 9 
== false

Rebmu Rebol की एक संकुचित बोली है। कोड अनिवार्य रूप से है:

z? mo l2 a 1  ; zero? mod log-2 input 1

विकल्प

14 वर्ण- रेम्बु में 'फटे हुए' बिटवाइस और ~ नहीं है

z?AND~aTIddA 3

Rebol में:

zero? a & to-integer a / 3

— rgchris
स्रोत

1

जीटीबी , 46 बाइट्स

2→P`N[@N=Pg;1P^2→P@P>1E90g;2]l;2~"NO"&l;1"YES"

— Timtech
स्रोत

1

अजगर, ३५

print bin(input()).strip('0')=='b1'

न केवल +/- संचालन का उपयोग करता है, बल्कि किसी भी गणित संचालन को द्विआधारी रूप में परिवर्तित करने से अलग करता है।

अन्य सामान (दिलचस्प है, लेकिन प्रतिस्पर्धा के लिए नहीं):

मेरा एक regexp संस्करण (61) भी है :

import re;print re.match(r'^0b10+$',bin(input())) is not None

(विचार से प्यार है, लेकिन आयात और मैच फ़ंक्शन इसे बहुत लंबा बनाते हैं)

और अच्छा, लेकिन उबाऊ बिटवाइज़ ऑपरेशन संस्करण (31) :

x=input();print x and not x&~-x

(हाँ, यह छोटा है, लेकिन यह उपयोग के लिए ~ -x का उपयोग करता है, जो आता है - ऑपरेशन)

— इवान अनिशचुक
स्रोत

बूथबी के जवाब मेरे पहले के समान विचार का उपयोग करते हैं, लेकिन यह छोटा है :(

— इवान अनिशचुक

1

पायथन 2.7 ( 30 29 39 37)

संपादित करें: उपयोगकर्ता इनपुट आवश्यकता के कारण अद्यतन;

a=input()
while a>1:a/=2.
print a==1

क्रूर बल, = 1 तक विभाजित करने का प्रयास करें (सफलता) या <1 (विफल)

— जोआचिम इसाकसन
स्रोत

1

not a%2के रूप में लिखा जा सकता है a%2==0। दी, यह कई भाषाओं में लंबा होगा, लेकिन पायथन नहीं।

— कोनराड बोरोस्की

@xfix धन्यवाद, परीक्षण और अद्यतन।

— जोकिम इस्कसन

1

या इससे भी बेहतर a%2<1,।

— बूथ 18

आपके पास 2.हटाने के बाद एक जगह है जो एक बाइट को बचाएगा!

— कीर्तन प्रभाकरन '

1

पायथन (33)

print int(bin(input())[3:]or 0)<1

— ब्लेंडर
स्रोत

int(bin(input()*2)[3:])<1केवल 25 वर्णों वाले अजगर के खोल से भी काम करता है।

— गमथ

1

रूबी, 33 , 28 , 25

p /.1/!~gets.to_i.to_s(2)

— steenslag
स्रोत

1

APL (0/1 के लिए 12, हाँ / नहीं के लिए 27)

≠/A=2*0,ιA←⍞

या, अगर हमें टेक्स्ट आउटपुट करना चाहिए:

3↑(3x≠/A=2*0,ιA←⍞)↓'YESNO '

ए। फॉर्म में पढ़ें एक वेक्टर 0. ए, फिर एक वेक्टर 2 ⁰ ..2 ^ए (हाँ, यह आवश्यक से अधिक तरीका है), फिर एक वेक्टर उन में से प्रत्येक के साथ तुलना करता है (जिसके परिणामस्वरूप 0 का वेक्टर सबसे अधिक होता है) एक 1), फिर एक्सोर कि (एपीएल में कोई एक्सओआर ऑपरेटर नहीं है, लेकिन eans बूलियंस पर लागू एक के रूप में कार्य करेगा।) अब हमारे पास 0 या 1 है।

YES या NO पाने के लिए: 0 या 1 को 3 से गुणा करें, इस अक्षर की संख्या को 'YESNO' से छोड़ें, फिर इस के पहले 3 अक्षरों को लें।

— मार्क प्लॉटनिक
स्रोत

1

सी, 65 बाइट्स

main(k){scanf("%i",&k);while(k&&!(k%2))k/=2;puts(k==1?"T":"F");}

— vershov
स्रोत

main(k){...अंतर्निहित intटाइपिंग पर भरोसा करते हुए , आप 5 वर्णों को काट सकते हैं । यह यूबी हो सकता है, लेकिन यह कोड गोल्फ है। कभी-कभी उत्पादन में ऐसा कुछ उपयोग न करें।

— केविन

1

हास्केल ( 52 50)

k n=elem n$map(2^)[1..n]
main=interact$show.k.read

— जीटा
स्रोत

जांचें कि क्या पूर्णांक + का उपयोग किए बिना 2 की शक्ति है, - संचालन [बंद]

GolfScript, 6 चार्ट, कोई कमी नहीं

एपीएल (7)

GolfScript, 11 (1 के लिए) (सच) और 0 (झूठे)

GolfScript, 22 (हाँ / नहीं के लिए)

गणितज्ञ २ 28

पर्ल 6 (17 अक्षर)

आर, १३ ११

GolfScript, 5

अजगर, ३१

सी, 48

जे, 14 15 वर्ण (आउटपुट 0 या 1)

जावास्क्रिप्ट, 76 वर्ण (सही या गलत आउटपुट)

क्लिप , ९ 7 7

अजगर , ५

गणितज्ञ (21)

जावास्क्रिप्ट, 41 40 अक्षर

जावास्क्रिप्ट, 35

पर्ल 5.10+, 13 + 1 = 14 वर्ण

रूबी - 17 अक्षर (चौथी कोशिश)

रूबी - 19 अक्षर (तीसरी कोशिश)

रूबी - 22 अक्षर (दूसरी कोशिश)

रूबी - 24 अक्षर (पहली कोशिश)

के / कोना ( 24 17)

रेम्बु (9 वर्ण)

जीटीबी , 46 बाइट्स

पायथन (33)

रूबी, 33 , 28 , 25

APL (0/1 के लिए 12, हाँ / नहीं के लिए 27)

हास्केल ( 52 50)