अगले 1-विरल बाइनरी नंबर का पता लगाएं

Question

एक सकारात्मक पूर्णांक N K -sparse है यदि इसके बाइनरी प्रतिनिधित्व में किसी भी दो लगातार 1 s के बीच कम से कम K 0s हैं।

तो, 1010101 नंबर 1-विरल है, जबकि 101101 नहीं है।

आपका कार्य दिए गए इनपुट नंबर के लिए अगला 1-विरल नंबर ढूंढना है। उदाहरण के लिए, यदि इनपुट 12 है ( 0b1100) आउटपुट 16 ( 0b10000) होना चाहिए और यदि इनपुट 18 ( 0b10010) आउटपुट 20 ( 0b10100) होना चाहिए ।

सबसे छोटा कार्यक्रम या फ़ंक्शन (बाइट्स में) जीतता है! मानक खामियों को दूर किया।

Comments

"अगले" के रूप में "अगले उच्चतम" या "कम से कम पूर्ण अंतर" के रूप में?

— फ्यूजएक्सएक्सएल

"अगला" के रूप में "अगले उच्चतम" में।

— आर्टिकुनो

इनपुट की किस सीमा को संभालने की आवश्यकता है?

— mbomb007

मैं मानने जा रहा हूं कि नकारात्मक संख्याओं की आवश्यकता नहीं है।

— mbomb007 19

@ आर्टिकुनो क्या हम एक फ़ंक्शन बना सकते हैं, या क्या इसे पूरा कार्यक्रम होना चाहिए? कार्य बहुत मानक हैं।

— mbomb007

Answer 1

अजगर, 9 बाइट्स

• @Alephalpha से x & (x*2) != 0एल्गोरिथ्म उधार लेना
• @ जेक्यूब से पाइर बॉयलरप्लेट उधार लेना

पायथ में मेरा पहला प्रयास:

f!.&TyThQ

इसे यहाँ आज़माएँ

               implicit: Q = input()            
f      hQ      find the first integer T >= Q + 1, 
               that satisfies the condition:
 !.&TyT        T & (T * 2) is 0

Answer 2

CJam, 14 11 बाइट्स

3 बाइट्स ने डिजिटलट्रूमा को धन्यवाद दिया।

l~{)___+&}g

इसका परीक्षण यहां करें।

व्याख्या

l~          "Read and eval input.";
  {      }g "Do while...";
   )_       "Increment and duplicate (call this x).";
     __+    "Get two more copies and add them to get x and 2x on the stack.";
        &   "Take their bitwise AND. This is non-zero is as long as x's base-2
             representation contains '11'.";

यह स्टैक पर अंतिम संख्या छोड़ता है जो प्रोग्राम के अंत में स्वचालित रूप से मुद्रित होता है।

Answer 3

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

यह एक पूर्ण अजगर कार्यक्रम है जो n में पढ़ता है, और उत्तर प्रिंट करता है। मुझे लगता है कि यह पठनीयता उप-प्रतियोगिता में काफी अच्छा करता है।

n=input()+1
while'11'in bin(n):n+=1
print n

परीक्षण के परिणाम:

$ echo 12 | python soln.py 
16
$ echo 18 | python soln.py 
20

Answer 4

पायथ, 12 11 बाइट्स

f!}`11.BThQ

इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर ।

               implicit: Q = input()            
f        hQ    find the first integer T >= Q + 1, 
               that satisfies the condition:
 !}`11.BT         "11" is not in the binary representation of T

Comments

आप बदल कर एक चरित्र को बचा सकता है "11"में `11।

— orlp

@orlp धन्यवाद, इस पर ध्यान देना चाहिए था।

— जेक्यूब

Answer 5

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

मार्टिन ब्यूटनर को 11 बाइट्स धन्यवाद दिया।

#+1//.i_/;BitAnd[i,2i]>0:>i+1&

Comments

क्या आप कृपया विवरण जोड़ सकते हैं?

— mbomb007 19

Answer 6

पर्ल, 31

#!perl -p
sprintf("%b",++$_)=~/11/&&redo

या कमांड लाइन से:

 perl -pe'sprintf("%b",++$_)=~/11/&&redo' <<<"18"

Answer 7

एपीएल, 18 बाइट्स

1∘+⍣{~∨/2∧/⍺⊤⍨⍺⍴2}

यह एक मौनिक कार्य का मूल्यांकन करता है। इसे यहाँ आज़माएँ। उपयोग:

   1∘+⍣{~∨/2∧/⍺⊤⍨⍺⍴2} 12
16

व्याख्या

1∘+                    ⍝ Increment the input ⍺
   ⍣{            }     ⍝ until
     ~∨/               ⍝ none of
        2∧/            ⍝ the adjacent coordinates contain 1 1 in
           ⍺⊤⍨⍺⍴2      ⍝ the length-⍺ binary representation of ⍺.

Answer 8

जे, 20 अक्षर

एक संज्ञा क्रिया। नियमों का पालन करने के लिए निश्चित।

(+1 1+./@E.#:)^:_@>:

व्याख्या

सबसे पहले, यह रिक्त स्थान के साथ क्रिया है और फिर थोड़ा कम गोल्फ है:

(+ 1 1 +./@E. #:)^:_@>:
[: (] + [: +./ 1 1 E. #:)^:_ >:

पढ़ें:

    ]                             The argument
      +                           plus
        [: +./                    the or-reduction of
               1 1 E.             the 1 1 interval membership in
                      #:          the base-2 representation of the argument,
[: (                    )^:_      that to the power limit of
                             >:   the incremented argument

तर्क प्लस 1 1आधार -2 में अंतराल सदस्यता के अंतराल को घटाता है या बढ़ाता है, जो कि बढ़े हुए तर्क पर लागू शक्ति सीमा तक है।

मैं मूल रूप से गणना करता हूं यदि 1 1इनपुट के बेस -2 प्रतिनिधित्व में होता है। यदि ऐसा होता है, तो मैं इनपुट बढ़ाता हूं। यह एक शक्ति-सीमा के तहत रखा गया है, जिसका अर्थ है कि यह तब तक लागू होता है जब तक कि परिणाम किसी भी अधिक नहीं बदलता।

Comments

अच्छा एल्गोरिथ्म! एपीएल में इसकी लंबाई समान है {⍵+∨/2∧/⍵⊤⍨⍵⍴2}⍣=:।

— जर्गर्ब

@randomra आह, मैं देख रहा हूँ।

— फ़ूजएक्सएक्सएल

Answer 9

जावास्क्रिप्ट, 25 19

इस तथ्य का उपयोग करते हुए कि, 1-विरल बाइनरी संख्या के लिए x&2*x == 0:

f=x=>x++&2*x?f(x):x

Answer 10

जावास्क्रिप्ट (ईएस 6), 39 43

कोई regexp, कोई तार, पुनरावर्ती:

R=(n,x=3)=>x%4>2?R(++n,n):x?R(n,x>>1):n

Iterative संस्करण:

F=n=>{for(x=3;x%4>2?x=++n:x>>=1;);return n}

यह बहुत सरल है, बस 11 के अनुक्रम को खोजने के लिए सही बदलाव का उपयोग करना। जब मुझे लगता है, तो अगले नंबर पर जाएं। पुनरावर्ती संस्करण सीधे पुनरावृत्तियों से लिया गया है।

अनगढ़ और अधिक स्पष्ट। गोल्फ के लिए, पेचीदा हिस्सा आंतरिक और बाहरी छोरों को मिला रहा है (शुरुआत में x से 3 तक init)

F = n=>{
  do {
    ++n; // next number
    for(x = n; x != 0; x >>= 1) {
      // loop to find 11 in any position
      if ((x & 3) == 3) { // least 2 bits == 11
        break;
      }
    }
  } while (x != 0) // if 11 was found,early exit from inner loop and x != 0
  return n
}

Comments

यह %4>2नंबर थ्योरी से कुछ टोना-टोटका जैसा लगता है, क्या आप समझा सकते हैं || एक लिंक प्रदान करें?

— याकूब

@ जैकोब (x% 4> 2) बस ((x & 3) == 3) है, लेकिन ऑपरेटर पूर्वता के साथ JS है आप 2 कोष्ठक से बचें

— edc65

जितना मैंने सोचा था, उतना आसान है। अब ungolfed संस्करण के साथ यह स्पष्ट है। धन्यवाद!

— याकूब

Answer 11

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

f=input()+1
while f&2*f:f+=1
print f

x & 2*x == 01-विरल संख्या के लिए तर्क का उपयोग किया ।
@Nick और @CarpetPython को धन्यवाद।

Comments

क्यों होता है पतन? यह पूरी तरह से ठीक काम करता है, और अच्छी तरह से गोल्फ भी है।

— ETHproductions

PPCG, btw, और अच्छा पहला जवाब में आपका स्वागत है! मैं आपको साइट पर चुनौतियों का जवाब देना जारी रखने के लिए प्रोत्साहित करता हूं :-)

— ETHproductions

Answer 12

जावास्क्रिप्ट, 75 66 62 बाइट्स

4 बाइट्स के लिए 9 बाइट्स और Pietu1998 को बचाने के लिए मार्टिन ब्यूटनर को धन्यवाद!

function n(a){for(a++;/11/.test(a.toString(2));a++);return a;}

यह कैसे काम करता है: यह एक forलूप से शुरू होता है a + 1जब तक कि वर्तमान संख्या 1-विरल नहीं होती है, और यदि ऐसा है, तो लूप बाधित होता है और यह वर्तमान संख्या को लौटाता है। यह जांचने के लिए कि क्या कोई संख्या 1-विरल है, यह इसे बाइनरी में परिवर्तित करता है और जाँचता है कि इसमें शामिल नहीं है या नहीं 11।

गैर-गोल्फ कोड:

function nextOneSparseNumber(num) {
    for (num++; /11/.test(num.toString(2)); num++);
    return num;
}

Answer 13

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

n->(while contains(bin(n+=1),"11")end;n)

यह एक अनाम फ़ंक्शन बनाता है जो एकल पूर्णांक को इनपुट के रूप में स्वीकार करता है और अगले उच्चतम 1-विरल पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक नाम दें, जैसे f=n->..., और करें f(12)।

असंगठित + स्पष्टीकरण:

function f(n)

    # While the string representation of n+1 in binary contains "11",
    # increment n. Once it doesn't, we've got the answer!

    while contains(bin(n += 1), "11")
    end

    return(n)
end

उदाहरण:

julia> f(12)
16

julia> f(16)
20

सुझाव और / या प्रश्नों का हमेशा की तरह स्वागत है!

Answer 14

> <> (मछली) , 31 + 3 = 34 बाइट्स

1+:>:  4%:3(?v~~
;n~^?-1:,2-%2<

उपयोग:

>python fish.py onesparse.fish -v 12
16

-vझंडे के लिए 3 बाइट्स जोड़े गए ।

Answer 15

जावास्क्रिप्ट (ईसीएमएस्क्रिप्ट 6), 40

पुनरावर्तन द्वारा:

g=x=>/11/.test((++x).toString(2))?g(x):x

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

बिना तीर के कार्य।

function f(x){return/11/.test((++x).toString(2))?f(x):x}

Answer 16

स्काला, 65 बाइट्स

(n:Int)=>{var m=n+1;while(m.toBinaryString.contains("11"))m+=1;m}

(यदि एक नामित फ़ंक्शन की आवश्यकता है, तो समाधान 69 बाइट्स होगा)

Answer 17

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

इसे यहाँ आज़माएँ: http://repl.it/gpu/2

लैम्ब्डा रूप में (गोल्फ के लिए xnor के लिए धन्यवाद):

f=lambda x:1+x&x/2and f(x+1)or-~x

मानक फ़ंक्शन सिंटैक्स एक बार के लिए एक लैम्ब्डा से कम निकला!

def f(x):x+=1;return x*(x&x*2<1)or f(x)

Comments

आप लैम्बडा को एक से 33 बाइट्स तक छोटा कर सकते हैं f=lambda x:1+x&x/2and f(x+1)or-~x:। यह पता चला है कि आप बाएं के बजाय बिट-शिफ्ट दाईं ओर हैं, आप x/2इसके बजाय उपयोग कर सकते हैं (x+1)/2क्योंकि अंतर हमेशा शून्य बिट्स में होता है x+1। कल्पना हालांकि एक कार्यक्रम के लिए पूछती है।

— xnor

मैंने पूछा और उन्होंने कहा कि हम कार्य कर सकते हैं। अधिकांश उत्तर पहले से ही हैं।

— mbomb007

Answer 18

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

इस उत्तर में विधि का उपयोग करता है

n->{for(;(n++&2*n)>0;);return n;}

TIO

Answer 19

रूबी, ४४

->(i){loop{i+=1;break if i.to_s(2)!~/11/};i}

सुंदर बुनियादी। एक अनंत लूप के साथ एक लंबो और बाइनरी प्रतिनिधित्व का परीक्षण करने के लिए एक रेगेक्सपी। मैं चाहता हूं कि loopउपज और सूचकांक संख्या।

Comments

@ mbomb007 किया। पारितोषिक के लिए धन्यवाद।

— अधिकतम

Answer 20

मतलाब ( 77 74 बाइट्स)

m=input('');for N=m+1:2*m
if ~any(regexp(dec2bin(N),'11'))
break
end
end
N

टिप्पणियाँ:

• यह परीक्षण संख्या लिए पर्याप्त m+1करने के लिए 2*mहै, जहां mइनपुट है।
• ~any(x)है trueअगर xसब शून्य होता है या यदि xरिक्त है

Answer 21

सी (32 बाइट्स)

f(int x){return 2*++x&x?f(x):x;}

एक ही एल्गोरिथ्म के पुनरावर्ती कार्यान्वयन के रूप में कई अन्य जवाब।

Answer 22

पर्ल, 16 बाइट्स

संयोजन x&2*xविभिन्न जवाब से (मुझे लगता है कि निक के पहले) के साथ nutki की redo पैदावार:

perl -pe'++$_&2*$_&&redo'

स्ट्रॉबेरी 5.26 में परीक्षण किया गया।

Answer 23

जाप, 8 बाइट्स

_&ZÑ}fUÄ

इसे ऑनलाइन चलाएं।

Answer 24

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

‘&Ḥ¬Ɗ1#

एक एकल, गैर-नकारात्मक पूर्णांक को स्वीकार करने वाला एक पूर्ण कार्यक्रम जो एक सकारात्मक पूर्णांक को प्रिंट करता है (एक मोनडिक लिंक के रूप में यह एक एकल सकारात्मक पूर्णांक युक्त सूची देता है)।

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

कैसे?

शुरू v=n+1, और वेतन वृद्धि, vहर बिट को एक स्थान और बिट-वार और के साथ शिफ्ट करने के लिए vऔर उसके बाद तार्किक परीक्षण करने के लिए अगर v1-स्पार्स नहीं मिलता है जब तक कि ऐसा एक नंबर नहीं मिलता है।

‘&Ḥ¬Ɗ1# - Main Link: n   e.g. 12
‘       - increment           13
     1# - 1-find (start with that as v and increment until 1 match is found) using:
    Ɗ   -   last three links as a dyad:
  Ḥ     -   double v
 &      -   (v) bit-wise AND (with that)
   ¬    -   logical NOT (0->1 else 1)
        - implicit print (a single item list prints as just the item would)

Answer 25

स्टैक्स , 5 बाइट्स

╦>ù╤x

इसे चलाएं और डीबग करें

यह इस प्रक्रिया का उपयोग करके काम करता है। स्टैक के ऊपर से इनपुट शुरू होता है।

• वृद्धि और प्रतिलिपि दो बार।
• स्टैक के शीर्ष पर रोकें।
• स्टैक पर बिटवाइज़-और शीर्ष दो तत्व।
• यदि परिणाम सत्य है (गैर-शून्य) पूरे कार्यक्रम को दोहराएं।