दूसरा शून्य खोजें

Question

चुनौती

32-बिट दो के पूरक प्रारूप में एक पूर्णांक को देखते हुए , बाइनरी प्रतिनिधित्व में दूसरे सबसे महत्वपूर्ण शून्य अंक के सूचकांक को वापस लौटाएं , जहां 0कम से कम महत्वपूर्ण बिट का प्रतिनिधित्व करता है, और 31सबसे महत्वपूर्ण बिट का प्रतिनिधित्व करता है।

यदि कोई दूसरा शून्य नहीं है, तो आप 0, किसी भी नकारात्मक संख्या, किसी भी गलत मूल्य को वापस कर सकते हैं या अपनी भाषा में इस तरह से त्रुटि की रिपोर्ट कर सकते हैं।

यदि आप चाहें तो आप 1-इंडेक्सिंग का उपयोग कर सकते हैं, लेकिन नीचे दिए गए परीक्षण मामले 0-इंडेक्सिंग का उपयोग करेंगे।

यदि आप चाहें, तो आप अहस्ताक्षरित पूर्णांक का उपयोग कर सकते हैं; यदि आप करते हैं, तो आपको रेंज में पूर्णांकों को संभालना होगा [0, 2^32)। यदि आप हस्ताक्षर किए गए पूर्णांक का उपयोग करते हैं, तो आपको सीमा में पूर्णांक को संभालना होगा [-2^31, 2^31)। यहां परीक्षण के मामलों में हस्ताक्षर किए गए पूर्णांक का उपयोग किया जाएगा, लेकिन ध्यान दें कि -x(हस्ताक्षरित) 2^32 - x(अहस्ताक्षरित) है।

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

0 (0b00) -> 1
1 (0b001) -> 2
10 (0b1010) -> 2
11 (0b01011) -> 4
12 (0b1100) -> 1
23 (0b010111) -> 5
-1 (0b11..11) -> कोई नहीं
-2 (0b11..10) -> कोई नहीं
-4 (0b11..00) -> 1
-5 (0b11..1011) -> कोई नहीं
-9 (0b11..10111) -> कोई नहीं
2 ^ 31-2 (0b0111..1110) -> 31

स्कोरिंग

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम उत्तर जीतता है!

Comments

क्या हम इसके बजाय एक अहस्ताक्षरित पूर्णांक का उपयोग कर सकते हैं?

— लीकी नून

हाँ, जब तक आप रेंज में पूर्णांकों को संभालते हैं, तब तक आप कर सकते हैं [0, 2^32)।

— संगीतज्ञ ५२३

क्या हम पूर्णांक या स्ट्रिंग 0b...को इनपुट के रूप में ले रहे हैं ?

— द लीथेलकोडर

@JonathanAllan मुझे नहीं लगता है, क्योंकि मुझे मेरे जेली के उत्तर पर सुधार दिया 2^32-1गया था क्योंकि मुझे वापस नहीं जाना चाहिए था 33।

— एरिक आउटगॉल्फ जूल

@JonathanAllan एरिक का जवाब सही है। मैंने यह चुनौती देने की युक्ति को अद्यतन कर दिया है कि आपको 32-बिट पूर्णांकों को संभालना चाहिए, चाहे आप उन्हें हस्ताक्षरित या अहस्ताक्षरित करने के लिए चुनें

— Musicman523

Answer 1

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

lambda n:[i for i in range(32)if n|1<<i>n][1]

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

0-इंडेक्सिंग, अहस्ताक्षरित संख्याओं का उपयोग करता है, और बिना किसी दूसरे शून्य पर एक त्रुटि फेंकता है।

बस गैर-सेट बिट्स के सूचकांकों की सूची बनाता है, सबसे कम से उच्चतम तक, और दूसरी प्रविष्टि लौटाता है।

Comments

PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!

— आउटगोल्फ जूल १17 ’

धन्यवाद! मैं अभी भी पायथन में गोल्फिंग प्रवृति के लिए वास्तव में नया हूं, इसलिए मुझे खुशी है कि इस कोड को तुरंत नीचे नहीं लाया गया।

— अर्नोल्ड पामर

महान :) n = 2147483647 के बारे में क्या?

— mdahmoune

@mdahmoune 2 ** 31-1 को 32 बिट्स में द्विआधारी प्रतिनिधित्व के बाद से त्रुटि का सामना करना चाहिए 0b0111111111111111111111111111111111 है, जिसमें दूसरा नहीं है 0. जब तक मैं कुछ याद नहीं कर रहा हूं ...

— पामर

Answer 2

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

0-आधारित इंडेक्स देता है, या -1यदि कोई दूसरा शून्य नहीं मिलता है।

n=>31-Math.clz32((n=~n^~n&-~n)&-n)

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

let f =

n=>31-Math.clz32((n=~n^~n&-~n)&-n)

console.log(f(0))       // -> 1
console.log(f(1))       // -> 2
console.log(f(10))      // -> 2
console.log(f(11))      // -> 4
console.log(f(12))      // -> 1
console.log(f(23))      // -> 5
console.log(f(-1))      // -> None
console.log(f(-2))      // -> None
console.log(f(-4))      // -> 1
console.log(f(-5))      // -> None
console.log(f(-9))      // -> None
console.log(f(2**31-2)) // -> 31

वैकल्पिक अभिव्यक्ति

n=>31-Math.clz32((n=~n^++n&-n)&-n)

---

पुनरावर्ती संस्करण, 42 बाइट्स

0-आधारित इंडेक्स देता है, या falseयदि कोई दूसरा शून्य नहीं मिलता है।

f=(n,p=k=0)=>n&1||!k++?p<32&&f(n>>1,p+1):p

कैसे?

f=(n,p=k=0)=>                               // given n, p, k
             n&1||                          // if the least significant bit of n is set
                  !k++?                     // or this is the 1st zero (k was not set):
                       p<31&&               //   return false if p is >= 31
                             f(n>>1,p+1)    //   or do a recursive call with n>>1 / p+1
                                        :p  // else: return p

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

f=(n,p=k=0)=>n&1||!k++?p<32&&f(n>>1,p+1):p

console.log(f(0))       // -> 1
console.log(f(1))       // -> 2
console.log(f(10))      // -> 2
console.log(f(11))      // -> 4
console.log(f(12))      // -> 1
console.log(f(23))      // -> 5
console.log(f(-1))      // -> None
console.log(f(-2))      // -> None
console.log(f(-4))      // -> 1
console.log(f(-5))      // -> None
console.log(f(-9))      // -> None
console.log(f(2**31-2)) // -> 31

नील द्वारा सुझाए गए वैकल्पिक संस्करण, 41 बाइट्स

0-आधारित इंडेक्स लौटाता है, या बहुत अधिक पुनरावृत्ति त्रुटि फेंकता है यदि कोई दूसरा शून्य नहीं मिलता है।

f=(n,c=1)=>n%2?1+f(~-n/2,c):c&&1+f(n/2,0)

Comments

41-बाइट पुनरावर्ती संस्करण:f=(n,c=1)=>n%2?1+f(~-n/2,c):c&&1+f(n/2,0)

— नील

Answer 3

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

|‘‘&~l2

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

अगर यह दूसरा शून्य नहीं है, तो यह सीमा [1,31] में कुछ उत्पन्न नहीं करता है। इसमें शामिल हैं 32 33और (-inf+nanj)। मुझे लगता है कि कुछ समझ में आता है।

यह गणना करता है log(((x|(x+1))+1)&~x)/log(2)।

Comments

-inf+nanjमुझे नहीं लगता था कि यह भी मौजूद हो सकता है

— लुइस मेंडो

यह (-inf+nanj)एक इनपुट के लिए आउटपुट नहीं करता है 2147483647जिसमें 31 1s का द्विआधारी प्रतिनिधित्व है, इसलिए 32-बिट हस्ताक्षरित संकेतन में कोई दूसरा शून्य नहीं है (यही कारण है कि यह मेरा और एरिक के उत्तरों से बहुत छोटा है)।

— जोनाथन एलन

वास्तव में, यह कब उत्पन्न होता है (-inf+nanj)?

— जोनाथन एलन

... आह मुझे लगता है कि यह काम किया है, आप हस्ताक्षरित विकल्प का उपयोग कर रहे हैं?

— जोनाथन एलन

Answer 4

जावा, ... 194 191 186 बाइट्स

static int f(int n){char[] c=Integer.toBinaryString(n).toCharArray();int j=0,o=2^32-2,i=c.length,l=i-1;if(n<0|n>o)return 0;for(;j<2&i>0;j+=c[--i]==48?1:0);if(j==2)return l-i;return 0;}

-159 बाइट्स छोटे चर नामों का उपयोग
करने और व्हॉट्सएप -25 बाइट्स को हटाने के लिए , छोटे चर लेने के बाद और @KevinCruijssen टिप्स
-18 बाइट्स के लिए धन्यवाद , अधिक व्हाट्सएप , फ़ंक्शन नाम
-3 बाइट्स, @KevinCruijssen के लिए धन्यवाद, स्थिति -5 बाइट्स छोटा।
, @Arnold Palmer, @KevinCruijssen, लूप को छोटा करने के लिए धन्यवाद

Ungolfed

public static int getPosSecondZero2(int number){
    int overflow = 2^32-2;
    if(number < 0 || number > overflow){
        return 0;
    }    
    String binaryString = Integer.toBinaryString(number);   
    char[] binaryCharArray = binaryString.toCharArray();    
    int count = 0;
    int idx = binaryCharArray.length;
    int length = binaryCharArray.length -1;
    while(count < 2 && idx>0){
        idx--;
        if(binaryCharArray[idx] == '0'){
            count++;
        }   
    }
    if(count == 2)
        return length-idx;
    return 0;
}

Comments

PPCG में आपका स्वागत है! वहाँ कुछ चीजें आप गोल्फ कर सकते हैं: static हटाया जा सकता है; if(n<0||n>o){return 0;}हो सकता है if(n<0|n>o)return 0;(के |बजाय ||और कोष्ठक नहीं); bs, bsaआदि सभी एकल वर्ण हो सकते हैं (कोड-गोल्फ में मल्टी-बाइट चर / विधि के नाम का उपयोग कभी न करें); आप intइस तरह से एस को जोड़ सकते हैं int o=2^32-2,c=0,i=x.length,l=i-1;:। और गोल्फ के लिए कुछ और चीजें हैं। जावा में गोल्फिंग के लिए टिप्स और सभी भाषाओं में गोल्फ के लिए युक्तियाँ पढ़ने के लिए दिलचस्प हो सकती हैं। फिर से स्वागत है, और अपने प्रवास का आनंद लें! :)

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

मुझे लगता है कि अभी भी कुछ जोड़े हैं जिन्हें आप अपने चर घोषणाओं में हटा सकते हैं। स्वागत हे! :)

— संगीतकार ५२३

@ musicman523 धन्यवाद, हाँ यह तय है। 194 अब के लिए :)

— 0x45

if(c[i]=='0'){j++;}if(c[i]==48)j++;-3 बाइट्स के लिए अभी भी गोल्फ हो सकता है :) संपादित करें: या बेहतर अभी तक: -8 बाइट्स के लिए while(j<2&&i>0){i--;if(c[i]=='0'){j++;}}हो सकता है for(;j<2&i>0;j+=c[i--]==48?1:0);।

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

@ 0x45 मेरा मानना ​​है कि अगर आप बदलेंगे तो @ केविनक्रिजसेन के कोड को for(;j<2&i>0;j+=c[--i]==48?1:0);काम करना चाहिए। त्रुटि iस्ट्रिंग की लंबाई होने से आ रही है, इसलिए शुरू में आप सरणी की सीमा को अनुक्रमित करने का प्रयास कर रहे हैं। यदि आप पूर्व-डिक्रीमेंट करते हैं (जैसा कि अपडेट किए गए स्निपेट में दिखाया गया है), तो पहली बार जब आप इसका उपयोग करते हैं तो यह c[c.length-1]आपके मूल कोड की तरह पहुंच जाएगा ।

— अर्नोल्ड पामर

Answer 5

जावा (ओपनजेडके 8) , 44 38 बाइट्स

i->i.numberOfTrailingZeros(~i&-i-2)&31

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

0 रिटर्न अगर कोई दूसरा शून्य बिट मौजूद नहीं है।

Answer 6

IA-32 मशीन कोड, 14 13 बाइट्स

Hexdump:

F7 D1 0F BC C1 0F B3 C1 0F BC C9 91 C3

Disassembly सूची:

0:  f7 d1                   not    ecx
2:  0f bc c1                bsf    eax,ecx
5:  0f b3 c1                btr    ecx,eax
8:  0f bc c1                bsf    ecx,ecx
b:  91                      xchg   eax, ecx
c:  c3                      ret

में इनपुट प्राप्त करता है ecx; उत्पादन में है al। त्रुटि पर 0 देता है।

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

यदि बिट-स्कैन निर्देश में कोई सेट बिट नहीं मिलता है, तो इंटेल प्रलेखन कहता है कि आउटपुट अपरिभाषित है। हालांकि, व्यवहार में सभी प्रोसेसर इस मामले में गंतव्य रजिस्टर को अपरिवर्तित छोड़ देते हैं (जैसा कि कोडी ग्रे ने नोट किया है, एएमडी प्रलेखन इस व्यवहार को अनिवार्य बताता है)।

तो, निम्नलिखित मामले हैं:

1. कोई शून्य बिट्स (बाइनरी 111 ... 1): ईएक्सएक्स 0 से सेट होता है notऔर 0 रहता है
2. एक शून्य बिट: ecx 0 से सेट है btr और 0 के बाद रहता हैbsf
3. दो शून्य बिट्स: एक्एक्स द्वारा उचित मूल्य पर सेट किया गया है bsf

Comments

यह केवल इंटेल का प्रलेखन है जो कहता है कि 0 पर बिट स्कैन अपरिभाषित हैं। एएमडी के दस्तावेज स्पष्ट रूप से दस्तावेजों को दिखाते हैं कि गंतव्य अपरिवर्तित है। यदि आप इस व्यवहार से बचना चाहते हैं, तो आप सामान्यतः LZCNT या TZCNT प्राप्त करने के लिए REP उपसर्ग जोड़ेंगे, लेकिन इससे बाइट की गिनती बढ़ जाती है, जो कोड गोल्फ के लिए स्वाभाविक रूप से अवांछनीय है।

— कोडी ग्रे

आप वास्तव में यहाँ बहुत अधिक काम कर रहे हैं। चुनौती के लिए आपको उस मामले में भेदभाव करने की आवश्यकता नहीं है जहां कोई शून्य बिट्स नहीं है और वह मामला जहां केवल 1 शून्य बिट है। यह आपको दोनों मामलों में 0 (या किसी भी नकारात्मक मूल्य) को वापस करने की अनुमति देता है। इसलिए, भले ही 1-बाइट SALC+ DECहै बेहद चालाक, आप दूर एक बाइट बस का उपयोग कर जो कुछ भी है द्वारा दाढ़ी कर सकते हैं ECXदूसरे के रूप में BSFअनुदेश। केवल एक चीज की आवश्यकता है ताकि XCHGपरिणाम प्राप्त करने के लिए 1-बाइट हो EAXताकि इसे वापस किया जा सके। दूसरे शब्दों में,not ecx; bsf eax, ecx; btr ecx, eax; bsf ecx, ecx; xchg eax, ecx; ret

— कोडी ग्रे

यहाँ ऊपर के लिए एक "ऑनलाइन प्रयास करें" लिंक है । चूंकि आप ECXइनपुट रजिस्टर के रूप में उपयोग कर रहे हैं , इसलिए हमें फास्ट कॉलिंग कन्वेंशन का उपयोग करने के लिए जीसीसी को बताना होगा।

— कोडी ग्रे

Answer 7

दिल्लोग एपीएल, 20 बाइट्स

{2⊃(⍳32)/⍨~⌽⍵⊤⍨32⍴2}

1-इंडेक्सिंग का उपयोग करता है, INDEX ERRORकोई दूसरा शून्य नहीं होने की स्थिति में फेंकता है।

कैसे?

⍵⊤⍨- ⍵एक के रूप में सांकेतिक शब्दों में बदलना

32⍴2 - लंबाई 32 के बाइनरी स्ट्रिंग

⌽ - उलटना

~ - नकारात्मक (0 → 1, 1 → 0)

(⍳32)/⍨ - 1-32 की सीमा के साथ संपीड़ित करना (शून्य के सूचकांक को छोड़कर)

2⊃ - दूसरा तत्व चुनें

Comments

आप कहां ( ⍸) का उपयोग करके बहुत सारे बाइट्स बचा सकते हैं

— ट्विन नाइट

@TwiNight मैं उपयोग dyalog 14

— ऊरीएल

TIO की जरूरत है तो Dyalog 16 है

— TwiNight

Answer 8

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

B¬Ṛ;1,1ḣ32TḊḢ

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

1-इंडेक्सिंग का उपयोग करता है, इनपुट के रूप में अहस्ताक्षरित पूर्णांक प्राप्त करता है। 0नहीं मिलने पर लौटा ।

Comments

33इनपुट के लिए यह आउटपुट 4294967295( 2^32-1, 32-बिट अहस्ताक्षरित समतुल्य -1)

— musicman523

@ musicman523 हम्म, कुछ बदबू आ रही है ...

— एरिक द आउटग्राफर

Answer 9

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

,4BUFḣ32¬TḊḢ

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

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

या

32Ḷ2*|€n⁸TḊḢ

उसकी कोशिश करो

कैसे?

1।

,4BUFḣ32¬TḊḢ - Link: number, n   e.g. 14
,4           - pair with 4            [14,4]
  B          - to binary              [[1,1,1,0],[1,0,0]]
   U         - upend                  [[0,1,1,1],[0,0,1]]
    F        - flatten                [0,1,1,1,0,0,1]
     ḣ32     - head to 32             [0,1,1,1,0,0,1] (truncates the right if need be)
        ¬    - not (vectorises)       [1,0,0,0,1,1,0]
         T   - truthy indexes         [1,5,6]
          Ḋ  - dequeue                [5,6]
           Ḣ - head                   5
             -   if the dequeued list is empty the head yields 0

2।

32Ḷ2*|€n⁸TḊḢ - Link: number, n   e.g. 14
32Ḷ          - lowered range of 32    [ 0, 1, 2, 3, 4, 5, ...,31]
   2*        - 2 exponentiated        [ 1, 2, 4, 8,16,32, ...,2147483648]
     |€      - bitwise or for €ach    [15,14,14,14,30,46, ...,2147483662]
        ⁸    - chain's right argument 14
       n     - not equal?             [ 1, 0, 0, 0, 1, 1, ..., 1]
         T   - truthy indexes         [ 1, 5, 6, ..., 32]
          Ḋ  - dequeue                [ 5, 6, ..., 32]
           Ḣ - head                   5
             -   if the dequeued list is empty the head yields 0

Answer 10

x86_64 मशीन कोड, 34 32 बाइट्स

सुनिश्चित नहीं है कि यह सही दृष्टिकोण है, काफी बाइट्स (पता चला है कि यह नहीं है ):

31 c0 83 c9 ff 89 fa 83 e2 01 83 f2 01 01 d1 7f 09 ff c0 d1 ef eb ee 83 c8 ff 83 f8 1f 7f f8 c3

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

second_zero:
  # Set eax = 0
  xor  %eax, %eax
  # Set ecx = -1
  xor %ecx,%ecx
  not %ecx

  # Loop over all bits
Loop:
  # Get current bit
  mov %edi, %edx
  and $0x1, %edx
  # Check if it's zero and possibly increment ecx
  xor $0x1, %edx
  add %edx, %ecx
  # If ecx > 0: we found the position & return
  jg Return
  # Increment the position
  inc %eax
  # Shift the input and loop
  shr %edi
  jmp Loop

Fix:
  # If there's not two 0, set value to -1
  xor %eax,%eax
  not %eax

Return:
  # Nasty fix: if position > 31 (e.g for -1 == 0b11..11)
  cmp $31, %eax
  jg  Fix

  ret

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

Comments

सभी बिट्स के माध्यम से लूपिंग शायद सही दृष्टिकोण नहीं है, या तो कोड गोल्फिंग के लिए या वास्तविक दुनिया के लिए। असली सफलता निर्देश है कि आप एक बार में सभी 32 (या 64) बिट्स हेरफेर करने की अनुमति से एक का उपयोग किया जाएगा, जैसे BSF, BSR, POPCNT, BT, आदि Anatolyg है इन पंक्तियों के साथ एक समाधान प्रस्तुत । मैंने अभी तक यह निर्धारित नहीं किया है कि क्या इसे हराया जा सकता है। :

— कोडी ग्रे

वैसे, एक रजिस्टर को -1 पर सेट करने के लिए एक संभावित उपयोगी कोड-गोल्फिंग चाल -1 के साथ यह करना है। उदाहरण के लिए, or ecx, -1। यह 3 बाइट्स है, 1 बाइट XOR + NEG से कम है। यह एक अच्छी चाल नहीं है जब गोल्फिंग नहीं की जाती है क्योंकि यह गंतव्य रजिस्टर पर एक झूठी पढ़ने की निर्भरता का परिचय देता है, लेकिन आप बस mov ecx, -15 बाइट्स का उपयोग करेंगे और खर्च करेंगे।

— कोडी ग्रे

Answer 11

8 वें , 149 बाइट्स

2 base swap >s nip decimal s:len 32 swap n:- ( "0" s:<+ ) swap times s:rev null s:/ a:new swap ( "0" s:= if a:push else drop then ) a:each swap 1 a:@

टिप्पणी कोड

: f \ n -- a1 a2 n 

  \ decimal to binary conversion
  2 base swap >s nip decimal     

  \ 32bit formatting (padding with 0)            
  s:len 32 swap n:- ( "0" s:<+ ) swap times  

  \ put reversed binary number into an array 
  s:rev null s:/

  \ build a new array with position of each zero 
  a:new swap ( "0" s:= if a:push else drop then ) a:each

  \ put on TOS the position of the 2nd least least-significant zero digit
  swap 1 a:@
;

उपयोग और उत्पादन

ok> : f 2 base swap >s nip decimal s:len 32 swap n:- ( "0" s:<+ ) swap times s:rev null s:/ a:new swap ( "0" s:= if a:push else drop then ) a:each swap 1 a:@ ;

ok> [0, 1, 10, 11, 12, 23, -1, -2, -4, -5, -9, 2147483646]

ok> ( dup . " -> " .  f . 2drop cr ) a:each
0 -> 1
1 -> 2
10 -> 2
11 -> 4
12 -> 1
23 -> 5
-1 -> null
-2 -> null
-4 -> 1
-5 -> null
-9 -> null
2147483646 -> 31

Answer 12

आर , 66 बाइट्स

w=which.min
x=strtoi(intToBits(scan()));w(x[-w(x)])*any(!x[-w(x)])

स्टड से पढ़ता है; रिटर्न 0कोई दूसरा शून्य और नहीं तो जगह के लिए।

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