64-बिट पूर्णांक में अग्रणी शून्य की संख्या ज्ञात करें

18

मुसीबत:

64-बिट हस्ताक्षरित पूर्णांक में अग्रणी शून्य की संख्या ज्ञात करें

नियम:

  • इनपुट को स्ट्रिंग के रूप में नहीं माना जा सकता है; यह कुछ भी हो सकता है जहां गणित और बिटवाइज़ ऑपरेशन एल्गोरिथ्म चलाते हैं
  • भाषा की परवाह किए बिना, संख्या के 64-बिट हस्ताक्षरित पूर्णांक प्रतिनिधित्व के खिलाफ आउटपुट को मान्य किया जाना चाहिए
  • डिफ़ॉल्ट कोड गोल्फ नियम लागू होते हैं
  • बाइट्स में सबसे छोटा कोड जीतता है

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

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

input                output   64-bit binary representation of input (2's complement)
-1                   0        1111111111111111111111111111111111111111111111111111111111111111
-9223372036854775808 0        1000000000000000000000000000000000000000000000000000000000000000
9223372036854775807  1        0111111111111111111111111111111111111111111111111111111111111111
4611686018427387903  2        0011111111111111111111111111111111111111111111111111111111111111
1224979098644774911  3        0001000011111111111111111111111111111111111111111111111111111111
9007199254740992     10       0000000000100000000000000000000000000000000000000000000000000000
4503599627370496     11       0000000000010000000000000000000000000000000000000000000000000000
4503599627370495     12       0000000000001111111111111111111111111111111111111111111111111111
2147483648           32       0000000000000000000000000000000010000000000000000000000000000000
2147483647           33       0000000000000000000000000000000001111111111111111111111111111111
2                    62       0000000000000000000000000000000000000000000000000000000000000010
1                    63       0000000000000000000000000000000000000000000000000000000000000001
0                    64       0000000000000000000000000000000000000000000000000000000000000000
code-golf  math  restricted-source  binary  bitwise 
— डेव
स्रोत
13
PPCG में आपका स्वागत है! "इनपुट को स्ट्रिंग के रूप में नहीं माना जा सकता" के पीछे क्या कारण है ? यह उन सभी भाषाओं को अयोग्य घोषित करता है जो 64-बिट पूर्णांक को संभाल नहीं सकती हैं और अधिक उत्तर देने की संभावना नहीं है जो पूर्णांक लेती हैं, क्योंकि यह वैसे भी उपलब्ध होने पर सीधा रास्ता है।
— अरनौलद
1
क्या हम Falseइसके बदले लौट सकते हैं 0?
— जो राजा
4
@Arnauld यहां और अन्य साइटों पर पहले से ही समान प्रश्न हैं जो विशेष रूप से स्ट्रिंग-आधारित समाधानों के लिए कहते हैं, लेकिन ऐसा कुछ भी नहीं है जो प्रश्न को गणित और तार्किक संचालन के लिए खोलता है। मेरी आशा है कि इस समस्या के विभिन्न दृष्टिकोणों का एक गुच्छा देखें जो पहले से कहीं और उत्तर नहीं हैं। क्या यह सब-समावेशी होने के लिए स्ट्रिंग समाधानों के लिए खोला जाना चाहिए?
— डेव
4
X86 और ARM सहित कई सीपीयू के पास इसके लिए विशिष्ट निर्देश हैं (x86 वास्तव में कई हैं)। मैंने हमेशा सोचा है कि प्रोग्रामिंग भाषाएं इस सुविधा को उजागर नहीं करती हैं क्योंकि अधिकांश प्रोग्रामिंग भाषाओं में आज आप विधानसभा निर्देशों को लागू नहीं कर सकते हैं।
— स्लीपबेटमैन
1
@ user202729 मुझे लगता है कि मैंने इसे खराब तरीके से लिखा है: 'संख्या की 64-बिट हस्ताक्षरित पूर्णांक प्रतिनिधित्व के खिलाफ आउटपुट को मान्य किया जाना चाहिए, भाषा की परवाह किए बिना' मेरा क्या मतलब है कि यह प्रश्न शून्य की संख्या के रूप में शून्य की संख्या को परिभाषित करता है। 64-बिट हस्ताक्षरित पूर्णांक में। मुझे लगता है कि मैंने हस्ताक्षरित बनाम अहस्ताक्षरित पूर्णांकों को समाप्त करने के लिए उस बाधा को बनाया।
— डेव

जवाबों:

41

लिनक्स पर x86_64 मशीन भाषा, 6 बाइट्स

0:       f3 48 0f bd c7          lzcnt  %rdi,%rax
5:       c3                      ret

lzcntनिर्देश के साथ Haswell या K10 या उच्चतर प्रोसेसर की आवश्यकता होती है ।

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

— ceilingcat
स्रोत
20
बिलिन्स ने फिर से हड़ताल की
— लोगन डे
1
मैं इस्तेमाल किए गए कॉलिंग कन्वेंशन को निर्दिष्ट करने की सलाह देता हूं (हालांकि आपने लिनक्स पर कहा था)
— q Wr
@qwr यह SysV कॉलिंग कन्वेंशन की तरह दिखता है क्योंकि पैरामीटर% rdi में पारित किया गया है और इसे% rax में लौटाया गया है।
— लॉगर्न
24

हेक्सागोनी , 78 70 बाइट्स

2"1"\.}/{}A=<\?>(<$\*}[_(A\".{}."&.'\&=/.."!=\2'%<..(@.>._.\=\{}:"<><$

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

क्या व्यावहारिक भाषा के लिए यह चुनौती बहुत तुच्छ नहीं है? ;)

साइड की लंबाई 6. मैं इसे एक साइड की लंबाई 5 षट्भुज में फिट नहीं कर सकता।

व्याख्या

— user202729
स्रोत
3
मुझे "स्पष्टीकरण" पर वास्तव में बहुत हंसी आई। : डी
— एरिक डुमिनील
1
मुझे लगता है कि आपके पास नकारात्मक संख्या / शून्य से अधिक ओवरलेप किया जा सकता है। मैं उस विषमता 2 ^ 64 गणना को न करके साइड प्रोग्राम 5 में एक समान प्रोग्राम फिट करने में कामयाब रहा । यह स्पष्ट रूप से अभी तक अच्छी तरह से गोल्फ नहीं है, हालांकि!
— FryAmTheEggman
@fry आह सही, ऋणात्मक संख्याओं में हमेशा 0 अग्रणी शून्य होते हैं ... जो निश्चित रूप से छोटे कार्यक्रम की ओर ले जाते हैं क्योंकि 2 ^ 64 उत्पन्न होता है।
— user202729
12

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

lambda n:67-len(bin(-n))&~n>>64

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

एक्सप्रेसन &दो भागों का बिटवाइस है:

67-len(bin(-n)) & ~n>>64

67-len(bin(-n))गैर नकारात्मक इनपुट के लिए सही जवाब देता है। यह बिट की लंबाई लेता है, और 67 से घटाता है, जो -0bउपसर्ग की क्षतिपूर्ति करने के लिए 64 से 3 अधिक है । यह नकार उस चाल का n==0उपयोग करने के लिए समायोजित करने के लिए एक चाल है -जो सामने एक संकेत का उत्पादन नहीं करता है ।

& ~n>>64जवाब के बजाय हो बनाता है 0नकारात्मक के लिए n। जब n<0, ~n>>640 (64-बिट पूर्णांकों पर) के बराबर होता है, तो यह देता है 0। जब n>=0, ~n>>64मूल्यांकन -1और करने &-1का कोई प्रभाव नहीं है।

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

f=lambda n:n>0and~-f(n/2)or(n==0)*64

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

अंकगणितीय विकल्प।

— XNOR
स्रोत
9

जावा 8, 32 26 बाइट्स।

Long::numberOfLeadingZeros

बिल्ट एफटीडब्ल्यू।

-6 बाइट्स केविन क्रूज़सेन को धन्यवाद

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

— lukeg
स्रोत
आह, के बारे में पूरी तरह से भूल गया numberOfLeadingZeros.. आप इसे 28 बाइट्स btw के लिए गोल्फ कर सकते हैं:n->n.numberOfLeadingZeros(n)
— केविन क्रूज़सेन
2
वास्तव में, Long::numberOfLeadingZerosऔर भी छोटा है (26 बाइट्स)।
— केविन क्रूज़सेन
6
वाह, यह बहुत बार नहीं होता है कि जावा पायथन को हरा देता है। बधाई!
— एरिक डुमिनील
9

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

__builtin_clzl

टियो पर ठीक काम करता है

सी (जीसीसी) , 35 29 बाइट्स

f(long n){n=n<0?0:f(n-~n)+1;}

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

6 बाइट्स के लिए डेनिस से

सी (gcc) संकलक झंडे, डेविड फ़ॉस्टर द्वारा 29 बाइट्स

-Df(n)=n?__builtin_clzl(n):64

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

— l4m2
स्रोत
3
यह देखते हुए कि यह केवल 64-बिट मशीनों (या LP64 / ILP64 / etc। ABI के साथ कोई अन्य) के लिए है
— रुस्लान
1
Geez, जो कि GCC के__builtin_clzl किसी भी उपयोग से कम है, जिसके साथ मैं ऊपर आ सकता हूं ।
— डेविड फ़ॉस्टर
@Ruslan: अच्छा बिंदु, सिस्टम पर जहां long32 बिट्स (विंडोज़ x64 सहित) हैं, आपको ज़रूरत है __builtin_clzll(लंबे समय तक अहस्ताक्षरित)। godbolt.org/z/MACCKf । (इंटेल intrinsics के विपरीत, GNU सी builtins आपरेशन एक मशीन अनुदेश के साथ संभव किया जा रहा है की परवाह किए बिना समर्थन कर रहे 32-बिट x86 पर, एक शाखा या cmov को clzll compiles क्या करना है। lzcnt(low half)+32या lzcnt(high half)या। bsrयदि lzcntउपलब्ध नहीं है।
— पीटर Cordes
परीक्षण मामलों में "0" शामिल है लेकिन __builtin_clz(l)(l)शून्य के लिए अपरिभाषित व्यवहार है: "यदि x 0 है, तो परिणाम अपरिभाषित है।"
— MCCCS
1
@MCCCS यदि यह काम करता है, तो यह मायने रखता है। इसीलिए मैं अंतिम उत्तर भी रखता हूं
— l4m2
6

पर्ल 6 , 35 28 26 बाइट्स

-2 बाइट्स nwellnhof के लिए धन्यवाद

{to .fmt("%064b")~~/^0*/:}

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

अनाम कोड ब्लॉक जो एक नंबर लेता है और एक नंबर लौटाता है। यह संख्या को एक बाइनरी स्ट्रिंग में परिवर्तित करता है और अग्रणी शून्य को गिनता है। यह नकारात्मक संख्याओं के लिए काम करता है क्योंकि पहला वर्ण -उदा है -00000101, इसलिए कोई अग्रणी शून्य नहीं हैं।

स्पष्टीकरण:

{                        }  # Anonymous code block
    .fmt("%064b")           # Format as a binary string with 64 digits
                 ~~         # Smartmatch against
                   /^0*/    # A regex counting leading zeroes
 to                     :   # Return the index of the end of the match
— मजाक कर रहा है
स्रोत
6

जावास्क्रिप्ट (Node.js) , 25 बाइट्स

BigInt शाब्दिक के रूप में इनपुट लेता है।

f=x=>x<0?0:x?f(x/2n)-1:64

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

या 0 के बजाय झूठी वापसी करके 24 बाइट्स ।0

— Arnauld
स्रोत
n=>n<1?0:n.toString(2)-64एक ही प्रदर्शन नहीं करेंगे?
— इस्माइल मिगेल
@IsmaelMiguel मुझे लगता है कि आप का मतलब है n=>n<1?0:n.toString(2).length-64, लेकिन यह वैसे भी काम नहीं करेगा। यह होगा , मुझे लगता है।
— अरनौलड
1
@IsmaelMiguel कोई चिंता नहीं। :) यह वास्तव में .toString()काम करने के लिए दृष्टिकोण के लिए संभव है , लेकिन हम अभी भी इनपुट के रूप में एक BigInt शाब्दिक की जरूरत है। अन्यथा, हमारे पास केवल 52 बिट्स मंटिसा हैं, जिससे अमान्य परिणाम सामने आते हैं जब परिशुद्धता खो जाती है ।
— अरनौलड
1
तथ्य यह है कि BigInt प्रत्यय एक ही चरित्र है क्योंकि आपका पैरामीटर बहुत भ्रामक है ...
— नील
1
PPCG पर @Neil अपठनीय कोड ?? यह नहीं हो सकता! फिक्स्ड! : पी
— अरनौलड
5

जे , 18 बाइट्स

0{[:I.1,~(64$2)#:]

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

जे , 19 बाइट्स

1#.[:*/\0=(64$2)#:]

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

स्पष्टीकरण:

                #:  - convert 
                  ] - the input to
          (64$2)    - 64 binary digits
         =          - check if each digit equals 
        0           - zero
   [:*/\            - find the running product
1#.                 - sum
— गैलेन इवानोव
स्रोत
1
1#.[:*/\1-_64{.#:(17) करीब है, लेकिन नकारात्मक संख्याओं के लिए काम नहीं करता है :(
— कॉनर ओ'ब्रायन
@Conor O'Brien अच्छा तरीका भी!
— गैलन इवानोव
4

05AB1E , 10 9 बाइट्स

·bg65αsd*

I / O दोनों पूर्णांक हैं

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

स्पष्टीकरण:

·         # Double the (implicit) input
          #  i.e. -1 → -2
          #  i.e. 4503599627370496 → 9007199254740992
 b        # Convert it to binary
          #  i.e. -2 → "ÿ0"
          #  i.e. 9007199254740992 → 100000000000000000000000000000000000000000000000000000
  g       # Take its length
          #  i.e. "ÿ0" → 2
          #  i.e. 100000000000000000000000000000000000000000000000000000 → 54
   65α    # Take the absolute different with 65
          #  i.e. 65 and 2 → 63
          #  i.e. 65 and 54 → 11
      s   # Swap to take the (implicit) input again
       d  # Check if it's non-negative (>= 0): 0 if negative; 1 if 0 or positive
          #  i.e. -1 → 0
          #  i.e. 4503599627370496 → 1
        * # Multiply them (and output implicitly)
          #  i.e. 63 and 0 → 0
          #  i.e. 11 and 1 → 11
— केविन क्रूज़सेन
स्रोत
4

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

एक गलती को हाजिर करने के लिए धन्यवाद xnor !

f n|n<0=0|1>0=sum.fst.span(>0)$mapM(pure[1,0])[1..64]!!n

बहुत अधिक मेमोरी आवंटित कर सकते हैं, इसे ऑनलाइन प्रयास करें!

शायद आप इसे एक छोटे से निरंतर परीक्षण करना चाहते हैं: 8-बिट आज़माएं!

व्याख्या

mapM(pure[0,1])[1..64]इनपुट को बाइनरी में बदलने के लिए उपयोग करने के बजाय , हम उपयोग करेंगे mapM(pure[1,0])[1..64]जो अनिवार्य रूप से उल्टे तार उत्पन्न करता है{0,1}64lexicographic क्रम में। तो हम सिर्फ योग कर सकते हैं1s- उपसर्ग का उपयोग करके sum.fst.span(>0)।

— ბიმო
स्रोत
3

पॉवरशेल, 51 बाइट्स

param([long]$n)for(;$n-shl$i++-gt0){}($i,65)[!$n]-1

टेस्ट स्क्रिप्ट:

$f = {

param([long]$n)for(;$n-shl$i++-gt0){}($i,65)[!$n]-1

}

@(
    ,(-1                   ,0 )
    ,(-9223372036854775808 ,0 )
    ,(9223372036854775807  ,1 )
    ,(4611686018427387903  ,2 )
    ,(1224979098644774911  ,3 )
    ,(9007199254740992     ,10)
    ,(4503599627370496     ,11)
    ,(4503599627370495     ,12)
    ,(2147483648           ,32)
    ,(2147483647           ,33)
    ,(2                    ,62)
    ,(1                    ,63)
    ,(0                    ,64)
) | % {
    $n,$expected = $_
    $result = &$f $n
    "$($result-eq$expected): $result"
}

आउटपुट:

True: 0
True: 0
True: 1
True: 2
True: 3
True: 10
True: 11
True: 12
True: 32
True: 33
True: 62
True: 63
True: 64
— Mazzy
स्रोत
3

जावा 8, 38 बाइट्स

int f(long n){return n<0?0:f(n-~n)+1;}

इनपुट long(64-बिट पूर्णांक) के रूप में, आउटपुट int(32-बिट पूर्णांक) के रूप में।

@ L4m2 के C (gcc) उत्तर का पोर्ट ।

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

स्पष्टीकरण:

 int f(long n){       // Recursive method with long parameter and integer return-type
   return n<0?        //  If the input is negative:
           0          //   Return 0
          :           //  Else:
           f(n-~n)    //   Do a recursive call with n+n+1
                  +1  //   And add 1

संपादित करें: बिलिन का उपयोग करके 26 बाइट्स हो सकते हैं Long::numberOfLeadingZerosजैसा कि @lukeg के जावा 8 उत्तर में प्रदर्शित किया गया है ।

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

एपीएल + विन, 34 बाइट्स

+/×\0=(0>n),(63⍴2)⊤((2*63)××n)+n←⎕

स्पष्टीकरण:

n←⎕ Prompts for input of number as integer

((2*63)××n) If n is negative add 2 to power 63

(63⍴2)⊤ Convert to 63 bit binary

(0>n), Concatinate 1 to front of binary vector if n negative, 0 if positive

+/×\0= Identify zeros, isolate first contiguous group and sum if first element is zero
— ग्राहम
स्रोत
3

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 42 बाइट्स

x=>x!=0?64-Convert.ToString(x,2).Length:64

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

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 31 बाइट्स

int c(long x)=>x<0?0:c(x-~x)+1;

इससे भी छोटा, @ l4m2 के C (gcc) उत्तर के आधार पर। कभी नहीं पता था कि आप इस तरह के कार्यों की घोषणा कर सकते हैं, धन्यवाद @ दाना!

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

— अज्ञान का अवतार
स्रोत
1
मुझे लगता है कि यह वैध है? tio.run/##ZZA/...
— दाना
3

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

-1 एरिक आउटगॉल्फ द्वारा एक साफ चाल के लिए धन्यवाद (अब गैर-नकारात्मक अब बस है AƑ)

ḤBL65_×AƑ

एक पूर्णांक लिंक एक पूर्णांक (सीमा के भीतर) को स्वीकार करता है जो एक पूर्णांक देता है।

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

10 था ḤBL65_ɓ>-×

यहाँ एक और 10 बाइट समाधान है, जो मुझे पसंद है क्योंकि यह कहता है कि यह "बॉस" है ...

BoṠS»-~%65

यहां टेस्ट-सूट

... BoṠS63r0¤i, BoṠS63ŻṚ¤iया BoṠS64ḶṚ¤iकाम भी करेगा।

एक और 10 बटर (डेनिस से) æ»64ḶṚ¤Äċ0(फिर æ»63r0¤Äċ0और æ»63ŻṚ¤Äċ0भी काम करेंगे)

— जोनाथन एलन
स्रोत
— the
@EriktheOutgolfer मैंने खुद से सोचा "isNonNegative द्वारा गुणा करने के लिए एक गोल्फ रास्ता होना चाहिए" और Ƒबहुत जल्दी, बहुत अच्छा काम करने के बारे में नहीं सोचा था !
— जोनाथन एलन
1
वास्तव में, मैं AƑकाफी कुछ के बारे में अब तक सिद्धांत कर रहा हूं । चेतावनी दी है कि यह सदिश नहीं करता है! ;-) यह वास्तव में "समतल है और फिर जांचें कि क्या सभी तत्व nonnegative हैं"।
— E को ११:१४ बजे आउटगॉल्फ को एरिक
2

पर्ल 5 , 37 बाइट्स

sub{sprintf("%064b",@_)=~/^0*/;$+[0]}

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

या यह 46 बाइट्स यदि "स्ट्रिफ़िकेशन" की अनुमति नहीं है: सब ज़ेड

sub{my$i=0;$_[0]>>64-$_?last:$i++for 1..64;$i}
— केजेटिल एस।
स्रोत
s/length$&/$+[0]/(-3 बाइट्स);)
— दादा
IMO, आपको subपर्ल 5 फ़ंक्शन वाले उत्तरों से कीवर्ड हटाने की अनुमति नहीं है ।
— nwellnhof
मैंने देखा subहै कि अन्य भाषाओं के उत्तरों को हटाने के समान क्या है , perl6, शक्तियां और बहुत कुछ।
— Kjetil S.
Perl6 में, मुझे लगता है कि आपको sub{}एक अनाम (?) उप बनाने की आवश्यकता नहीं है , जो यह बताता है कि यह Perl6 उत्तरों से क्यों छोड़ा गया है। मैं @nwellnhof से सहमत हूं कि आपको हटाने की अनुमति नहीं दी जानी चाहिए sub। (जब मैं अभी भी सक्रिय था, जैसे एक साल पहले या तो, यह नियम था)
— दादा
अब बदल गया है। और शामिल थे $+[0]।
— केजेटिल एस।
2

स्विफ्ट (64-बिट प्लेटफॉर्म पर), 41 बाइट्स

एक क्लोजर घोषित fकरता है जिसे स्वीकार किया जाता है और एक रिटर्न देता है Int। यह समाधान केवल सही ढंग से 64-बिट प्लेटफॉर्म है, जहां काम करता Intहै typealiasके लिए एड Int64। (32-बिट प्लेटफॉर्म पर, Int64क्लोजर के पैरामीटर प्रकार के लिए स्पष्ट रूप से 2 बाइट्स जोड़कर उपयोग किया जा सकता है।)

let f:(Int)->Int={$0.leadingZeroBitCount}

स्विफ्ट में, यहां तक ​​कि मूल पूर्णांक प्रकार मानक पुस्तकालय में घोषित एक सामान्य वस्तु है। इस साधन के Intतरीके और गुण हो सकते हैं, जैसे leadingZeroBitCount(जो मानक पुस्तकालय के FixedWidthIntegerप्रोटोकॉल के अनुरूप सभी प्रकारों पर आवश्यक है)।

— नोनाडा - मोनिका को बहाल करना
स्रोत
दिलचस्प। मुझे जंग की याद दिलाता है। मुझे लगता है कि इसे 20 बाइट्स, .leadingZeroBitCount के रूप में गिना जाना चाहिए
— उज्ज्वल
2

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

f n|n<0=0
f n=1+f(2*n+1)

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

यह मूल रूप से केविन क्रूज़सेन के जावा समाधान के समान है, लेकिन मैंने इसे स्वतंत्र रूप से पाया।

तर्क में Int64-बिट बिल्ड के लिए टाइप होना चाहिए , याInt64 किसी भी चीज़ के लिए ।

व्याख्या

यदि तर्क नकारात्मक है, तो परिणाम तुरंत 0. है, अन्यथा, हम बाएं को शिफ्ट करते हैं , लोगों के साथ भरना , जब तक हम एक नकारात्मक संख्या तक नहीं पहुंचते। उस भरने से हमें 0 के लिए एक विशेष मामले से बचने की सुविधा मिलती है।

बस संदर्भ के लिए, यहाँ स्पष्ट / कुशल तरीका है:

34 बाइट्स

import Data.Bits
countLeadingZeros
— dfeuer
स्रोत
1

स्वच्छ , 103 बाइट्स

उसी का उपयोग करता है सीलिंगकैट के उत्तर के रूप " बिलिन " का ।

f::!Int->Int
f _=code {
instruction 243
instruction 72
instruction 15
instruction 189
instruction 192
}

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

स्वच्छ , 58 बाइट्स

import StdEnv
$0=64
$i=until(\e=(2^63>>e)bitand i<>0)inc 0

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

— Οurous
स्रोत
1

पर्ल 5 -p , 42 बाइट्स

1while$_>0&&2**++$a-1<$_;$_=0|$_>=0&&64-$a

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

एक बिटस्ट्रिंग आधारित समाधान की तुलना में लंबा है, लेकिन एक सभ्य गणित आधारित समाधान है।

— Xcali
स्रोत
अगर मैं गलत नहीं हूँ तो वास्तव में काम नहीं करता
— दादा
@ दादा मैं देखता हूं कि कुछ मामले ऐसे हैं जहां फ्लोटिंग पॉइंट डिवीजन ठीक से काम नहीं करता है। मैंने एक intकॉल किया जिसमें समस्या का समाधान होना चाहिए।
— Xcali
क्षमा करें, मैंने अपना प्रति-अतीत विफल कर दिया, ऐसा प्रतीत होता है। यह वही है जो मैं भेजना चाहता था;)
— दादा
1

एपीएल (एनएआरएस), 15 चार्ट, 30 बाइट्स

{¯1+1⍳⍨⍵⊤⍨64⍴2}

कुछ संख्याओं के लिए परीक्षण करें कि कैसे उपयोग करें:

  f←{¯1+1⍳⍨⍵⊤⍨64⍴2}
  f ¯9223372036854775808
0
  f 9223372036854775807
1
— RosLuP
स्रोत
1

K (ngn / k) , 6 बाइट्स

64-#2\

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

2\ बाइनरी में तर्क को एन्कोड करें

# लंबाई

64- 64 से घटाना

— NGN
स्रोत
# = length... स्ट्रिंग पर आधारित लग रहा है
— टाइटस
2
@ टिट्स 2\ पूर्णांक की एक सूची देता है और #इसकी लंबाई पाता है। कोई तार यहाँ शामिल नहीं हैं।
— NGN
1

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

सकारात्मक संख्याओं का सूत्र सिर्फ है 63-Floor@Log2@#&। रिप्लेसमेंट नियमों का उपयोग शून्य और नकारात्मक इनपुट के विशेष मामलों के लिए किया जाता है।

इनपुट 64-बिट हस्ताक्षरित पूर्णांक नहीं होना चाहिए। यह प्रभावी रूप से इनपुट के फर्श को पूर्णांक में बदलने के लिए ले जाएगा। यदि आप 64-बिट पूर्णांक के लिए सामान्य सीमा के बाहर एक नंबर इनपुट करते हैं, तो यह एक नकारात्मक संख्या लौटाएगा जो बताता है कि इस पूर्णांक को संग्रहीत करने के लिए कितने और बिट्स की आवश्यकता होगी।

63-Floor@Log2[#/.{_?(#<0&):>2^63,0:>.5}]&

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

@ LegionMammal978 का समाधान 28 बाइट्स पर थोड़ा कम है। इनपुट एक पूर्णांक होना चाहिए। प्रलेखन के अनुसार: " BitLength[n]प्रभावी रूप से एक प्रभावी संस्करण है Floor[Log[2,n]]+1।" यह शून्य के मामले को स्वचालित रूप से सही ढंग से रिपोर्टिंग करता है0 बजाय है -∞।

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 28 बाइट्स

Boole[#>=0](64-BitLength@#)&

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

— केली लोवदर
स्रोत
1
Boole[#>=0](64-BitLength@#)&28 बाइट्स में एक छोटा सा छोटा है। यह आपके जैसी ही मूल अवधारणा का उपयोग करता है, लेकिन लागू होता है BitLengthऔर Boole।
— लीजनमोनमल 978
मैं पूरी तरह से BitLength के बारे में भूल गया!
— केली लोल्डर
1

bitNumber - math.ceil (math.log (संख्या) / math.log (2))

उदा। 64 बिट संख्या: 9223372036854775807 math.ceil (math.log (9223372036854775807) / math.log (2)) ANS: 63

— user90293
स्रोत
अगर आप इसमें भाषा का नाम जोड़ सकते हैं, तो यह बहुत अच्छा होगा, क्योंकि लोगों के वोट के जवाब नीचे होने की संभावना है, जिसमें भाषा का नाम शामिल नहीं है
— जोनो 2906
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.