क्या यह संख्या -2: (बहुत) हार्ड मोड की सटीक शक्ति है

Question

यह हाल की चुनौती का एक संस्करण है क्या यह संख्या -2 की पूर्णांक शक्ति है? समस्या की दिलचस्प प्रकृति को उजागर करने और चुनौती को और अधिक कठिन बनाने के लिए डिज़ाइन किए गए मानदंडों के एक अलग सेट के साथ। मैंने इसमें कुछ विचार रखा है ।

टोबी द्वारा अद्भुत रूप से लिंक किए गए प्रश्न में बताई गई चुनौती है:

यह निर्धारित करने के चतुर तरीके हैं कि क्या पूर्णांक 2 की एक सटीक शक्ति है। यह अब एक दिलचस्प समस्या नहीं है, इसलिए यह निर्धारित करें कि क्या दिया गया पूर्णांक -2 की सटीक शक्ति है । उदाहरण के लिए:

-2 => yes: (-2)¹
-1 => no
0 => no
1 => yes: (-2)⁰
2 => no
3 => no
4 => yes: (-2)²

नियम:

• एक पूर्णांक 64 बिट्स, हस्ताक्षरित, दो का पूरक है। यह एकमात्र डेटा प्रकार है जिसके साथ आप काम कर सकते हैं।
• आप केवल निम्न कार्यों का उपयोग कर सकते हैं। इनमें से प्रत्येक एक ऑपरेशन के रूप में गिना जाता है।
  • n << k, n >> k: वाम / सही पारी nसे kबिट्स। साइन बिट को राइट शिफ्ट में बढ़ाया गया है।
  • n >>> k: राइट शिफ्ट लेकिन साइन बिट का विस्तार न करें। 0 के शिफ्ट में हैं।
  • a & b, a | b, a ^ b: बिटवाइस और, या, XOR।
  • a + b, a - b, a * b: जोड़ें, घटाना, गुणा।
  • ~b: बिटवेट इनवर्ट।
  • -b: दो का पूरक निषेध।
  • a / b, a % bफूट डालो (पूर्णांक भागफल, 0 की ओर दौर), और सापेक्ष।
    • ऋणात्मक संख्याओं का मोडुलो C99 में निर्दिष्ट नियमों का उपयोग करता है : (a/b) * b + a%bबराबर होगा a। तो 5 % -3है 2, और -5 % 3है -2:
    • 5 / 3है 1, के रूप 5 % 3में 2, 1 * 3 + 2 = 5।
    • -5 / 3है -1, -5 % 3है -2, के रूप में -1 * 3 + -2 = -5।
    • 5 / -3है -1, 5 % -3है 2, के रूप में -1 * -3 + 2 = 5।
    • -5 / -3है 1, -5 % -3है -2, 1 * -3 + -2 = -5 के रूप में।
    • ध्यान दें कि पायथन के //फ्लोर डिवीजन ऑपरेटर यहां विभाजन की संपत्ति के "गोल की ओर 0" को संतुष्ट नहीं करता है, और पायथन के %ऑपरेटर आवश्यकताओं को पूरा नहीं करता है, या तो।
  • असाइनमेंट को ऑपरेशन के रूप में नहीं गिना जाता है। सी के रूप में, असाइनमेंट के बाद असाइनमेंट लेफ्ट-हैंड साइड के मूल्य का मूल्यांकन a = (b = a + 5)करता bहै : सेट करता है a + 5, फिर एक ऑपरेशन के रूप में सेट aहोता है b, और गिनता है।
  • यौगिक असाइनमेंट का उपयोग किया जा सकता a += bहै a = a + bऔर एक ऑपरेशन के रूप में गिना जा सकता है ।
• आप पूर्णांक स्थिरांक का उपयोग कर सकते हैं, वे कुछ भी नहीं गिनते हैं।
• संचालन के क्रम को निर्दिष्ट करने के लिए कोष्ठक स्वीकार्य हैं।
• आप कार्यों की घोषणा कर सकते हैं। फ़ंक्शन की घोषणा किसी भी शैली में हो सकती है जो आपके लिए सुविधाजनक है लेकिन ध्यान दें कि 64 बिट पूर्णांक केवल मान्य डेटा प्रकार हैं। फ़ंक्शन की घोषणाओं को संचालन के रूप में नहीं गिना जाता है, लेकिन एक फ़ंक्शन कॉल को एक के रूप में गिना जाता है। इसके अलावा, स्पष्ट होने के लिए: फ़ंक्शंस में कई returnकथन हो सकते हैं और returnकिसी भी बिंदु से अनुमति दी जाती है। returnअपने आप में एक ऑपरेशन के रूप में नहीं गिना जाता।
• आप बिना किसी लागत के चर घोषित कर सकते हैं।
• आप whileलूप का उपयोग कर सकते हैं , लेकिन आप उपयोग नहीं कर सकते हैं ifया for। whileकंडिशन में इस्तेमाल किए गए ऑपरेटर्स आपके स्कोर की ओर गिनते हैं। whileलूप तब तक निष्पादित होते हैं जब तक कि उनकी स्थिति एक शून्य-शून्य मान का मूल्यांकन करती है (भाषाओं में "सत्य" 0 जो इस अवधारणा का एक वैध परिणाम नहीं है)। जल्दी वापसी की अनुमति दी है के बाद से, आप का उपयोग करने की अनुमति है breakऔर साथ ही
• ओवरफ्लो / अंडरफ्लो की अनुमति है और कोई मूल्य क्लैम्पिंग नहीं किया जाएगा। यह माना जाता है कि ऑपरेशन वास्तव में सही ढंग से हुआ था और फिर 64 बिट्स में काट दिया गया था।

स्कोरिंग / जीतना मानदंड:

आपके कोड को एक मान उत्पन्न करना चाहिए जो गैर-शून्य है यदि इनपुट -2 की शक्ति है, और अन्यथा शून्य।

यह परमाणु-कोड-गोल्फ है । आपका स्कोर संचालन की कुल संख्या अपने कोड में पेश (जैसा कि ऊपर बताया गया है), है नहीं कार्य है कि रन-टाइम में क्रियान्वित कर रहे हैं की कुल संख्या। निम्नलिखित कोड:

function example (a, b) {
    return a + ~b;
}

function ispowerofnegtwo (input) {
    y = example(input, 9);
    y = example(y, 42);
    y = example(y, 98);
    return y;
}

5 ऑपरेशन शामिल हैं: फ़ंक्शन में दो, और तीन फ़ंक्शन कॉल।

इससे कोई फर्क नहीं पड़ता है कि आप अपना परिणाम कैसे प्रस्तुत करते हैं, जो भी आपकी भाषा में सुविधाजनक है उसका उपयोग करें, अंततः परिणाम को एक चर में संग्रहीत करें, इसे एक फ़ंक्शन से लौटाएं, या जो भी हो।

विजेता वह पद है जो डेमन्स्ट्रैबली करेक्ट होता है (यदि आवश्यक हो तो एक आकस्मिक या औपचारिक प्रमाण की आपूर्ति करें) और ऊपर वर्णित के रूप में सबसे कम स्कोर है।

बोनस बहुत मुश्किल मोड चुनौती!

पार्टियों में लोगों को प्रभावित करने की संभावित क्षमता को छोड़कर कुछ भी नहीं जीतने के मौके के लिए, whileलूप का उपयोग किए बिना एक उत्तर प्रस्तुत करें ! यदि इनमें से पर्याप्त जमा किया जाता है, तो मैं विजेता समूहों को दो श्रेणियों में विभाजित करने पर विचार कर सकता हूं (साथ और बिना छोरों के)।

---

नोट: यदि आप किसी ऐसी भाषा में समाधान प्रदान करना चाहते हैं जो केवल 32-बिट पूर्णांकों का समर्थन करती है, तो आप ऐसा कर सकते हैं, बशर्ते कि आप पर्याप्त रूप से उचित ठहराएं कि यह स्पष्टीकरण में 64-बिट पूर्णांकों के लिए अभी भी सही होगा।

इसके अलावा: कुछ भाषा-विशिष्ट सुविधाओं को बिना किसी लागत के अनुमति दी जा सकती है यदि वे नियमों से नहीं बचते हैं, लेकिन उपरोक्त नियमों के अनुसार व्यवहार करने में आपकी भाषा के साथ ज़बरदस्ती करना आवश्यक है । उदाहरण के लिए (contrived), मैं एक मुफ्त की अनुमति देता हूँ 0while छोरों की तुलना न के बराबर होती है , जब पूरी तरह से शर्त पर लागू होती है, एक ऐसी भाषा के लिए एक वर्कअराउंड के रूप में, जिसमें "सच्चाई" 0 है। इस प्रकार की चीजों का लाभ उठाने के स्पष्ट प्रयासों की अनुमति नहीं है - उदाहरण के लिए "सत्य" 0 या "अपरिभाषित" मूल्यों की अवधारणा उपरोक्त नियमों में मौजूद नहीं है, और इसलिए वे पर निर्भर नहीं हो सकते हैं।

Comments

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— डेनिस

@hvd यदि आप इसे पढ़ते हैं: आपको अपने उत्तर को पूरी तरह से हटा देना चाहिए! यह सही है, भले ही m ^= s यह अभी भी प्रभावशाली है, और मुझे लगता है कि इसे और भी बेहतर बनाने के लिए प्रतिस्थापन बनाने के लिए पूरी तरह से ठीक होगा।

— जेसन सी

यह कैसे अनुमति देने के लिए समझ में आता है whileऔर breakनहीं है if? if (x) { ... }के बराबर है while (x) { ... break; }।

— R ..

@ आर .. यह 100% समझ में नहीं आता ( breakऔर शुरुआती रिटर्न अफसोसजनक हिस्सा है) और भविष्य की चुनौतियों के लिए नियमों में सीखी गई एक लंबी कहानी और सबक है। हमेशा "बोनस" संस्करण होता है! :)

— जेसन C

क्यों ifऔर forकैसे अस्वीकृत हैं? int x=condition; while (x) { ... x=0; }नि: शुल्क है, बस अधिक कोड। सी-स्टाइल के साथ एक ही बात for।

— क्वर्टी

Answer 1

सी ++, 15 ऑपरेशन

मुझे पता नहीं है कि whileछोरों को अनुमति क्यों दी जाती है क्योंकि वे पूरी चुनौती को नष्ट कर देते हैं। यहाँ एक उत्तर बिना किसी के है:

int64_t is_negpow2(int64_t n) {
    int64_t neg = uint64_t(n) >> 63; // n >>> 63
    n = (n ^ -neg) + neg; // if (n < 0) n = -n;
    int64_t evenbits = n & int64_t(0xaaaaaaaaaaaaaaaaull >> neg);
    int64_t n1 = n - 1;
    int64_t pot = n & n1;
    int64_t r = pot | (n1 >> 63) | evenbits;
    return ~((r | -r) >> 63); // !r
}

Comments

whileलूप्स पूरी चुनौती को नष्ट क्यों करते हैं ?

— श्री एक्सकोडर

@ Mr.Xcoder क्योंकि चुनौती इसे सरल बिटवाइज़ ऑपरेशंस के साथ whileकरने की है और हर तरह से इसके खिलाफ जाती है।

— orlp

मेरा मतलब है, जब तक आप लूप नहीं बनाते हैं, एक स्थिर nया कुछ के लिए लूप में निष्पादित संख्याओं को गुणा करने की संख्या को कई गुना बढ़ा देता है।

— मैजिक ऑक्टोपस Urn

मैंने यहाँ इस बारे में एक टिप्पणी की ।

— जेसन सी

@JasonC ऐसा इसलिए है क्योंकि मुझे साइन बिट के बिना एक सही बदलाव का उपयोग करना चाहिए। मैंने कोड को संपादित किया (यह उपयोग करता है, uint64_tक्योंकि यह केवल साइन एक्सटेंशन के बिना सही बदलाव प्राप्त करने का एकमात्र तरीका है।)

— orlp

Answer 2

पायथन 2 , 3 ऑपरेशन

def f(n):
 while n>>1:
  while n&1:return 0
  n=n/-2
 return n

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

संचालन कर रहे हैं >>, &, /।

विचार -2 को बार-बार विभाजित करना है। -2 श्रृंखला की शक्तियां 1: तक नीचे -8 -> 4 -> -2 -> 1। यदि हम 1स्वीकार करते हैं, तो स्वीकार करें। यदि हम मारने से पहले एक विषम संख्या मारते हैं 1, तो अस्वीकार करें। हमें भी अस्वीकार करने की आवश्यकता है 0, जो हमेशा के लिए अपने आप चला जाता है।

while n>>1:लूप जब तक n0 या 1. जब पाश टूटता है, है nही दिया जाता है, और 1एक Truthy उत्पादन और है 0एक Falsey एक। लूप के अंदर, हम बार-बार लागू होते हैं n -> n/-2और किसी भी विषम को अस्वीकार करते हैं n।

चूँकि /केवल कभी मूल्यों पर भी इसका उपयोग किया जाता है, इसलिए इसका गोल व्यवहार कभी भी खेल में नहीं आता है। तो, यह कोई फर्क नहीं पड़ता कि पायथन कल्पना से अलग है।

Comments

अच्छा लगा। एल्गोरिथ्म में चालाक तर्क और बिट संचालन में सशर्त संयोजन के अच्छे काम। इसके अलावा, पुष्टि कर सकते हैं, कार्यान्वयन सी। में काम करता है

— जेसन सी

while n&1इसके बजाय क्यों if n&1?

— मार्क रैनसम

@MarkRansom चुनौती की अनुमति नहीं देता है if।

— xnor

अहा, वह चूक गया। बहुत चतुर प्रतिस्थापन।

— मार्क रैनसम

@EvSunWoodard स्कोरिंग कोड में ऑपरेटरों की संख्या है, निष्पादन के दौरान उन्हें कॉल की संख्या नहीं है, जो इनपुट पर निर्भर करता है: "यह परमाणु-कोड-गोल्फ है। आपका स्कोर आपके कोड में मौजूद संचालन की कुल संख्या है। । "

— xnor

Answer 3

जंग, 14 12 ऑपरेशन (लूप नहीं)

अनुकूलन की आवश्यकता है ( -O) या -C overflow-checks=noआतंक के बजाय अतिप्रवाह घटाव को सक्षम करने के लिए।

fn is_power_of_negative_2(input: i64) -> i64 {
    let sign = input >> 63;
    // 1 op
    let abs_input = (input ^ sign) - sign;
    // 2 ops
    let bad_power_of_two = sign ^ -0x5555_5555_5555_5556; // == 0xaaaa_aaaa_aaaa_aaaa
    // 1 op
    let is_not_power_of_n2 = abs_input & ((abs_input - 1) | bad_power_of_two);
    // 3 ops 
    let is_not_power_of_n2 = (is_not_power_of_n2 | -is_not_power_of_n2) >> 63;
    // 3 ops 
    input & !is_not_power_of_n2
    // 2 ops
}

(स्पष्ट करने के लिए: !xहै बिटवाइज़-नहीं , यहाँ नहीं तार्किक-नहीं)

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

#[test]
fn test_is_power_of_negative_2() {
    let mut value = 1;
    for _ in 0 .. 64 {
        assert_ne!(0, is_power_of_negative_2(value), "wrong: {} should return nonzero", value);
        value *= -2;
    }
}

#[test]
fn test_not_power_of_negative_2() {
    for i in &[0, -1, 2, 3, -3, -4, 5, -5, 6, -6, 7, -7, 8, 1<<61, -1<<62, 2554790084739629493, -4676986601000636537] {
        assert_eq!(0, is_power_of_negative_2(*i), "wrong: {} should return zero", i);
    }
}

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

---

विचार अगर जाँचना है तो | x | 2 की शक्ति है ( (y & (y - 1)) == 0हमेशा की तरह उपयोग करते हुए )। यदि x 2 की एक शक्ति है, तो हम आगे (1) की जाँच करते हैं जब x >= 0, यह भी 2 की एक शक्ति होनी चाहिए, या (2) जब x < 0, यह 2 की एक विषम शक्ति होनी चाहिए। हम इसकी जाँच &करते हैं " bad_power_of_two"मास्क 0x ... आआआआ जब x >= 0(0 केवल तब पैदा होता है जब यह एक समान शक्ति हो), या 0x ... 5555 जब x < 0।

Comments

मैंने ~((r | -r) >> 63)अपना उत्तर ठीक करने के लिए आपकी चाल चुरा ली ।

— orlp

Answer 4

हास्केल, 2 3 ऑपरेशन

import Data.Bits (.&.)

f 0 = False
f 1 = True
f n | n .&. 1 == 0 = f (n `div` -2)
f n | otherwise    = False

एक पुनरावर्ती कार्य को परिभाषित करता है f(n)। उपयोग किए गए ऑपरेशन फ़ंक्शन कॉल ( f), विभाजन ( div), और बिटवाइज़ और ( .&.) हैं।

तथ्य यह है कि हास्केल कोई पाश बयान है की वजह से कोई छोरों शामिल :-)

Comments

मुझे आश्चर्य नहीं है कि बिना लूप का उपयोग किए हास्केल समाधान "अवसरवादी" नाम के किसी व्यक्ति द्वारा प्रदान किया गया है? =)

— Cort Ammon - मोनिका

मैं बहुत बारे में संकोच f 0, f 1, f n ...यहाँ क्योंकि वे अनिवार्य रूप से कर रहे हैं if'भेस में है, हालांकि उसके बाद फिर से, मैं अनुमति दे दी while+ breakऔर जल्दी returnहै, तो यह उचित लगता है। हालांकि यह अनजाने में व्याख्या के लिए खुले तौर पर छोड़े जा रहे मेरे नियम का लाभ उठाता है, यह एक अच्छा समाधान है।

— जेसन सी

विशेष रूप से |एस हवा में विशेष रूप से ऊपर हैं। उस ने कहा, यह एक विशेष नियम का कम-विवादित तरीके से उल्लंघन करता है: तुलना ==की अनुमति नहीं है। हालांकि, ध्यान रखें कि अगर यह कोड मेरी व्याख्या सही है, बूलियन्स के उपयोग कि यहाँ है उनके स्थान पर मनमाने ढंग से पूर्णांक मूल्यों प्रतिस्थापन परिणाम बदलने के लिए प्रकट नहीं होता है के रूप में स्वीकार्य दिखाई देते हैं, और वे एक अंतिम प्रस्तुति फार्म की अधिक कर रहे हैं।

— जेसन सी

@ जैसनक मैं केवल ==इसलिए उपयोग कर रहा हूं क्योंकि हास्केल में "सत्ची" Intसे Boolया डालने का कोई अन्य तरीका नहीं है । क्या पैटर्न मिलान और पहरेदार "नहीं ifs" नियम का उल्लंघन करते हैं, क्या आपका कॉल ;-)

— अवसरवादी

पैटर्न मिलान के साथ, आप केवल 0 संचालन का उपयोग करके सभी 64-बिट पूर्णांक के लिए परिणामों को हार्डकोड कर सकते हैं।

— xnor

Answer 5

पायथन 3, 10 या 11 9 ऑपरेशन

def g(x):
 while x:
  while 1 - (1 + ~int(x - -2 * int(float(x) / -2))) & 1: x /= -2
  break
 while int(1-x):
     return 0
 return 5  # or any other value

की 5शक्तियों के लिए लौटाता है -2, 0अन्यथा

Comments

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— डेनिस

Answer 6

सी, 5 ऑपरेशन

long long f(long long x){
    x=x ^ ((x & 0xaaaaaaaaaaaaaaaa) * 6);
    while(x){
        while(x&(x-1))
            return 0;
        return 1;
    }
    return 0;
}

सी, 10 ऑपरेशन, बिना छोरों के

long long f(long long x){
    x = x ^ ((x & 0xaaaaaaaaaaaaaaaa) * 6);
    long long t = x & (x-1);
    return (((t-1) & ~t) >> 63) * x;
}

सी, 1 ऑपरेशन

long long f(long long x){
    long long a0=1, a1=-2, a2=4, a3=-8, a4=16, a5=-32, a6=64, a7=-128, a8=256, a9=-512, a10=1024, a11=-2048, a12=4096, a13=-8192, a14=16384, a15=-32768, a16=65536, a17=-131072, a18=262144, a19=-524288, a20=1048576, a21=-2097152, a22=4194304, a23=-8388608, a24=16777216, a25=-33554432, a26=67108864, a27=-134217728, a28=268435456, a29=-536870912, a30=1073741824, a31=-2147483648, a32=4294967296, a33=-8589934592, a34=17179869184, a35=-34359738368, a36=68719476736, a37=-137438953472, a38=274877906944, a39=-549755813888, a40=1099511627776, a41=-2199023255552, a42=4398046511104, a43=-8796093022208, a44=17592186044416, a45=-35184372088832, a46=70368744177664, a47=-140737488355328, a48=281474976710656, a49=-562949953421312, a50=1125899906842624, a51=-2251799813685248, a52=4503599627370496, a53=-9007199254740992, a54=18014398509481984, a55=-36028797018963968, a56=72057594037927936, a57=-144115188075855872, a58=288230376151711744, a59=-576460752303423488, a60=1152921504606846976, a61=-2305843009213693952, a62=4611686018427387904, a63=-9223372036854775807-1, a64=0;
    while(a0){
        long long t = x ^ a0;
        long long f = 1;
        while(t){
            f = 0;
            t = 0;
        }
        while(f)
            return 1;
        a0=a1; a1=a2; a2=a3; a3=a4; a4=a5; a5=a6; a6=a7; a7=a8; a8=a9; a9=a10; a10=a11; a11=a12; a12=a13; a13=a14; a14=a15; a15=a16; a16=a17; a17=a18; a18=a19; a19=a20; a20=a21; a21=a22; a22=a23; a23=a24; a24=a25; a25=a26; a26=a27; a27=a28; a28=a29; a29=a30; a30=a31; a31=a32; a32=a33; a33=a34; a34=a35; a35=a36; a36=a37; a37=a38; a38=a39; a39=a40; a40=a41; a41=a42; a42=a43; a43=a44; a44=a45; a45=a46; a46=a47; a47=a48; a48=a49; a49=a50; a50=a51; a51=a52; a52=a53; a53=a54; a54=a55; a55=a56; a56=a57; a57=a58; a58=a59; a59=a60; a60=a61; a61=a62; a62=a63; a63=a64;
    }
    return 0;
}

Comments

अरे यार, वो आखिरी तो सिर्फ बुराई है। अच्छा लगा।

— जेसन सी

Answer 7

असेंबली, 1 ऑपरेशन

.data

    .space 1         , 1 # (-2)^31
    .space 1610612735, 0
    .space 1         , 1 # (-2)^29
    .space 402653183 , 0
    .space 1         , 1 # (-2)^27
    .space 100663295 , 0
    .space 1         , 1 # (-2)^25
    .space 25165823  , 0
    .space 1         , 1 # (-2)^23
    .space 6291455   , 0
    .space 1         , 1 # (-2)^21
    .space 1572863   , 0
    .space 1         , 1 # (-2)^19
    .space 393215    , 0
    .space 1         , 1 # (-2)^17
    .space 98303     , 0
    .space 1         , 1 # (-2)^15
    .space 24575     , 0
    .space 1         , 1 # (-2)^13
    .space 6143      , 0
    .space 1         , 1 # (-2)^11
    .space 1535      , 0
    .space 1         , 1 # (-2)^9
    .space 383       , 0
    .space 1         , 1 # (-2)^7
    .space 95        , 0
    .space 1         , 1 # (-2)^5 = -32
    .space 23        , 0
    .space 1         , 1 # (-2)^3 = -8
    .space 5         , 0
    .space 1         , 1 # (-2)^1 = -2
    .space 1         , 0
dataZero:
    .space 1         , 0
    .space 1         , 1 # (-2)^0 = 1
    .space 2         , 0
    .space 1         , 1 # (-2)^2 = 4
    .space 11        , 0
    .space 1         , 1 # (-2)^4 = 16
    .space 47        , 0
    .space 1         , 1 # (-2)^6 = 64
    .space 191       , 0
    .space 1         , 1 # (-2)^8
    .space 767       , 0
    .space 1         , 1 # (-2)^10
    .space 3071      , 0
    .space 1         , 1 # (-2)^12
    .space 12287     , 0
    .space 1         , 1 # (-2)^14
    .space 49151     , 0
    .space 1         , 1 # (-2)^16
    .space 196607    , 0
    .space 1         , 1 # (-2)^18
    .space 786431    , 0
    .space 1         , 1 # (-2)^20
    .space 3145727   , 0
    .space 1         , 1 # (-2)^22
    .space 12582911  , 0
    .space 1         , 1 # (-2)^24
    .space 50331647  , 0
    .space 1         , 1 # (-2)^26
    .space 201326591 , 0
    .space 1         , 1 # (-2)^28
    .space 805306367 , 0
    .space 1         , 1 # (-2)^30
    .space 3221225471, 0
    .space 1         , 1 # (-2)^32

.globl isPowNeg2
isPowNeg2:
    movl dataZero(%edi), %eax
    ret

यह देखने के लिए कि नंबर 2 की शक्ति है या नहीं, एक विशाल लुकअप टेबल का उपयोग करता है। आप इसे 64 बिट्स तक विस्तारित कर सकते हैं, लेकिन एक कंप्यूटर को स्टोर करने के लिए ढूंढना जो पाठक के लिए एक अभ्यास के रूप में बचा है :-P

Comments

तालिका को अनुक्रमणित करना अनुमत कार्यों में से एक नहीं है।

— आर ..

इसके अलावा यह स्पष्ट रूप से 64 बिट्स के लिए एक्स्टेंसिबल नहीं है। :-)

— R ..

दरअसल, एक मेज का अनुक्रमण नहीं कर रहा था इरादा मौजूदा नियमों के तहत अनुमति दी जाए। मैंने निर्दिष्ट किया है "आप वैरिएबल घोषित कर सकते हैं" और "आप पूर्णांक शाब्दिकता निर्दिष्ट कर सकते हैं" स्केलर्स के इरादे से, और शब्दार्थ यह एक सरणी है (और पांडित्यपूर्ण रूप से मैं सरणी प्रकारों की अनुमति नहीं देता था और न ही मैंने इनमें से किसी भी प्रकार के अनुक्रमण को अनुमति नहीं दी थी। संचालन हालांकि आप इसे असेंबलर के संदर्भ में "जोड़" कह सकते हैं), लेकिन अवसरवादी होने के नाते आप ... :)

— जेसन सी

Answer 8

सी, 31 ऑपरेशन

लाइव डेमो

मेरा विचार सरल है, यदि यह दो की शक्ति है, तो यदि इसका लॉग सम है तो इसे सकारात्मक होना चाहिए, अन्यथा इसका लॉग विषम होना चाहिए।

int isPositive(int x) // 6
{
    return ((~x & (~x + 1)) >> 31) & 1;
}

int isPowerOfTwo(int x) // 5
{
    return isPositive(x) & ~(x & (x-1));
}

int log2(int x) // 3
{
    int i = (-1);

    while(isPositive(x))
    {
        i  += 1;
        x >>= 1;
    }

    return i;
}

int isPowerOfNegativeTwo(int x) // 17
{
    return (  isPositive(x) &  isPowerOfTwo(x) & ~(log2(x) % 2) )
         | ( ~isPositive(x) & isPowerOfTwo(-x) & (log2(-x) % 2) );
}

Comments

आपने वास्तव में जितना सोचा था उससे बेहतर किया। एक फ़ंक्शन कॉल केवल 1 के रूप में गिना जाता है, फ़ंक्शन में ऑपरेटरों की संख्या के रूप में नहीं। इसलिए, अगर मैंने सही तरीके से (डबल चेक) गिना है, तो आपको isPositive + 5 के लिए 6 की तरह कुछ मिला है। isPowerOfTwo + 3 के लिए log2 + 17 के लिए isPowerOfNegativeTwo = 31.

— जेसन

Answer 9

सी, 7 ऑपरेशन

int64_t is_power_of_neg2(int64_t n)
{
    int64_t x = n&-n;
    while (x^n) {
        while (x^-n)
            return 0;
        return x & 0xaaaaaaaaaaaaaaaa;
    }
    return x & 0x5555555555555555;
}

या:

सी, बिना लूप-ए-कंडिशन के 13 ऑपरेशन

int64_t is_power_of_neg2(int64_t n)
{
    int64_t s = ~(n>>63);
    int64_t a = ((n/2)^s)-s;
    int64_t x = n&-(uint64_t)n; // Cast to define - on INT64_MIN.
    return ~(a/x >> 63) & x & (0xaaaaaaaaaaaaaaaa^s);
}

स्पष्टीकरण:

• n&-nसबसे कम सेट की उपज देता है n।
• an/2नकारात्मक रूप से /2अतिप्रवाह के कारण नकारात्मक रूप से नकारात्मक पूर्ण निरपेक्ष मूल्य है ।
• a/xकेवल aदो की सटीक शक्ति होने पर शून्य है; अन्यथा कम से कम एक बिट सेट है, और यह xनकारात्मक परिणाम की तुलना में सबसे कम बिट से अधिक है ।
• ~(a/x >> 63)तब एक बिटमास्क की पैदावार होती है जो सभी में होती है nया -nदो की शक्ति होती है, अन्यथा सभी शून्य।
• ^sयह देखने के nलिए कि क्या इसकी शक्ति है, यह देखने के लिए मास्क पर लागू किया जाता है -2।

Answer 10

PHP, 3 ऑपरेशन

टर्नरी और ifअस्वीकृत हैं; तो दुरुपयोग है while:

function f($n)
{
    while ($n>>1)               # 1. ">>1"
    {
        while ($n&1)            # 2. "&1"
            return 0;
        return f($n/-2|0);      # 3. "/-2" ("|0" to turn it into integer division)
    }
    return $n;
}

1. $n>>1: यदि संख्या 0 या 1 है, तो संख्या लौटाएं
2. $n&1: यदि संख्या विषम है, तो 0 लौटें
3. अन्य परीक्षण $n/-2(इंट कास्ट)

Answer 11

जावास्क्रिप्ट ईएस 6, 7 संचालन

x=>{
  while(x&1^1&x/x){
    x/=-2;x=x|0
  }
  while(x&0xfffffffe)x-=x
  return x
}

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

व्याख्या

while(x&1^1&x/x)

जबकि x! = 0 और x% 2 == 0 4 ops
x / x 1 के बराबर है, जब तक x 0 नहीं है (0/0 NaN देता है जिसका मूल्यांकन गलत है)
और बिटवाइज़ और
x & 1 ^ 1 1 के बराबर है अगर x सम है (x और 1) xor 1

x/=-2;x=x|0

यह प्रश्न 1 ऑप द्वारा परिभाषित विभाजन का रूप है

while(x&0xfffffffe)  

जबकि x! = 1 और x! = 0 1 op
से बाहर निकलने के लिए आवश्यक शर्त x == 0 या x == 1 है क्योंकि ये दोनों रिटर्न वैल्यू हैं और एक अनंत लूप में प्रवेश करना उत्पादक नहीं होगा। यह सैद्धांतिक रूप से हेक्साडेसिमल संख्या को बढ़ाकर अधिक मूल्यों के लिए बढ़ाया जा सकता है। वर्तमान में 32 2 ^ 32-1 तक काम करता है

x-=x

X से 0 से 1 तक सेट करें
जबकि मैं 0 ऑप्स के लिए 0 का उपयोग कर सकता था, मुझे लगा कि किसी भी समय लूप जो किसी अन्य स्टेटमेंट से टूट जाता है, धोखा देने जैसा लगता है।

return x

रिटर्न x (1 अगर -2 की शक्ति, 0 अन्यथा)