कार्य

संख्याओं के सेट का पता लगाएं जैसे कि बाइनरी प्रतिनिधित्व में 1कम से कम एक द्वारा अलग किए गए दो या अधिक रन होते हैं 0।

उदाहरण के लिए, उन संख्याओं के लिए जो 4 बिट लंबी हैं:

 0 0000        (no ones)
 1 0001        (only one run)
 2 0010        (only one run)
 3 0011        (only one run)
 4 0100        (only one run)
 5 0101 Valid
 6 0110        (only one run)
 7 0111        (only one run)
 8 1000        (only one run)
 9 1001 Valid
10 1010 Valid
11 1011 Valid
12 1100        (only one run)
13 1101 Valid
14 1110        (only one run)
15 1111        (only one run)

इनपुट

रेंज में कुछ इनपुट के माध्यम से एप्लिकेशन को एक पूर्णांक प्रदान किया जाता है 3 .. 32। यह बिट्स की अधिकतम संख्या को दर्शाता है।

के इनपुट nइंगित करता है कि संख्या की जांच की जानी चाहिए।0 .. 2ⁿ-1

उत्पादन

मानदंडों को पूरा करने वाले सभी नंबरों की एक सीमांकित (आपकी पसंद) सूची। संख्याओं को संख्यात्मक क्रम में प्रस्तुत किया जाना है। एक अतिरिक्त ट्रेलिंग सीमांकक स्वीकार्य है। डेटा संरचना संलग्नक (जैसे []और समान) भी स्वीकार्य हैं।

उदाहरण

Input: 3
Output: 5

Input: 4
Output: 5, 9, 10, 11, 13

Input: 5
Output: 5, 9, 10, 11, 13, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 29

यह कोड-गोल्फ है - कम से कम बाइट्स जीत के साथ जवाब।

code-golf binary

मुझे लगता है कि आप n = 5 के लिए 23 से चूक गए।

— xnor

@xnor आप सही हैं। धन्यवाद, और हाँ, यह भी A094695 के बराबर नहीं है। हम्म। oeis.org/A101082 बनाम oeis.org/A166934

@VTCAKAVSMoACE हाँ। यदि कोई \nपरिसीमन कर रहा है और \nअंतिम पंक्ति पर डाल रहा है , तो अनुगामी के ,साथ सीमांकित ,भी स्वीकार्य होना चाहिए। अपडेट किया गया।

1

क्या इनपुट सूची प्रारूप में हो सकता है [1, 2, 3]?

— kirbyfan64sos

@ kirbyfan64sos हाँ। अपडेट किया गया।

7

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

f<2r.BT8U^2Q

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

विचार

किसी भी सकारात्मक संख्या का द्विआधारी प्रतिनिधित्व हमेशा 1 एस के रन से शुरू होता है , संभवतः अन्य के द्वारा, 0 एस और 1 एस के वैकल्पिक रन के साथ । यदि कम से कम तीन अलग-अलग रन हैं, तो उनमें से दो को 1 एस के रन होने की गारंटी है ।

कोड

              (implicit) Store the evaluated input in Q.
         ^2Q  Calculate 2**Q.
f       U     Filter; for each T in [0, ..., 2**Q-1]:
    .BT         Compute T's binary representation.
   r   8        Perform run-length encoding.
                This returns a list of character/run-length pairs.
 <2             Discard the trailing two pairs.
                This returns a non-empty array if there are more than 2 runs.
              Keep T if the array was truthy (non-empty).

— डेनिस
स्रोत

22

अजगर, ४ 48

lambda n:[i for i in range(2**n)if'01'in bin(i)]

मैं बहुत हद तक इस पर काबू पा चुका था। हमें केवल यह जांचने की आवश्यकता है कि बाइनरी विस्तार में क्या है '01'।

लोगों के दो रन होने के लिए, दाईं ओर के एक से पहले होना चाहिए 0। यदि केवल एक ही रन है, तो कोई भी अग्रणी 0नहीं होगा, इसलिए ऐसा नहीं होगा।

पुराना उत्तर:

lambda n:[i for i in range(2**n)if len(set(bin(i).split('0')))>2]

अजगर बाइनरी प्रतिनिधित्व यहाँ बहुत अच्छी तरह से काम करता है। एक बाइनरी नंबर की तरह लिखा जाता है bin(9)=='0b10110'। की '0'सूची में परिणामों पर विभाजन

0किसी भी लगातार दो के बीच 0और किसी भी अंतिम के दाईं ओर , प्रारंभिक के बाईं ओर खाली तार0
पत्र bएक या एक से अधिक अग्रणी लोगों द्वारा पीछा किया गया
रन जो 1अग्रणी नहीं हैं

पहली दो श्रेणियां हमेशा मौजूद रहती हैं, लेकिन अंतिम केवल तभी मौजूद होती है जब एक रन 1होता है जिसमें अग्रणी नहीं होता है '1', और ऐसा केवल तभी होता है जब एक से अधिक रन हों 1। इसलिए, यह जाँचने के लिए पर्याप्त है कि सूची में 2अलग-अलग तत्व हैं या नहीं।

पायथन 3.5 के {*_}स्थान पर अनपैक करके 2 वर्ण बचाता है set(_)।

— XNOR
स्रोत

/01/इसके बजाय उपयोग करने के विचार के लिए धन्यवाद /10+1/। मैंने पर्ल में इसका फायदा उठाया ।

— msh210

13

रूबी, 44 40 38 वर्ण

^{पार किया गया 44 अभी भी नियमित है 44 ;;}

->n{(0..2**n).select{|x|/01/=~'%b'%x}}

एक अनाम फ़ंक्शन (proc, वास्तव में) जो एक पूर्णांक लेता है और एक सरणी देता है।

~~रेगेक्स का उपयोग करता है /10+1/: ए 1, कम से कम एक 0, और फिर दूसरा 1।~~ @ हिस्टोक्रेट बताते हैं कि अगर 01स्ट्रिंग में कहीं भी है, तो उससे पहले कहीं होना चाहिए 1।

— Doorknob
स्रोत

1

एक प्रारूप स्ट्रिंग का उपयोग करना यहां थोड़ा कम है /10+1/=~'%b'%x:। इसके अलावा, आप एक समावेशी रेंज ( 0..2**n) का उपयोग करके एक चरित्र को बचा सकते हैं क्योंकि 2**nकभी भी कई रन नहीं होंगे।

— हिस्टोक्रैट

@ हिस्टोक्रेट हुह, मुझे कभी नहीं पता था कि आप स्ट्रिंग और रेगेक्स के क्रम को फ्लिप कर सकते हैं =~। धन्यवाद!

— डॉकर्नोब

1

रुको, वास्तव में रेगेक्स /01/ठीक वैसे ही काम करता है। यदि कोई है 01, तो कहीं बाईं ओर 1 होना चाहिए।

— हिस्टोक्रैट

@ हिस्टोक्रेट ओह, यह चतुर है! जो दो पात्रों को बचाता है।

— डोरकनब

7

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

n->filter(i->ismatch(r"01",bin(i)),1:2^n)

यह एक अनाम फ़ंक्शन बनाता है जो पूर्णांक को स्वीकार करता है और एक सरणी देता है। यह हिस्टोक्रेट्स के रेगेक्स ट्रिक (डॉर्कनोब के उत्तर में प्रयुक्त) का उपयोग करता है, जहां 01केवल एक पूर्ववर्ती 1 होने पर मेल होगा।

Ungolfed:

function f(n::Int)
    # Take the integers from 1 to 2^n and filter them down to
    # only those such that the binary representation of the integer
    # matches the regex /01/.
    filter(i -> ismatch(r"01", bin(i)), 1:2^n)
end

— एलेक्स ए।
स्रोत

हिस्टोक्रेट की चाल, मेरी नहीं। :)

— दरवाज़े

@ डॉर्कनोब ओह हे, अब आप दोनों को श्रेय मिलता है। :)

— एलेक्स ए।

6

मतलाब, 79 68 64 59

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

@(n)find(arrayfun(@(k)sum(~~diff(dec2bin(k)+0))>1,1:2^n-1))

पुराने संस्करणों:

k=1:2^input('')-1;k(arrayfun(@(k)sum(~~diff(dec2bin(k)+0))>1,k))

for k=1:2^input('')-1;if sum(~~diff(dec2bin(k)+0))>1;disp(k);end;end

for k=1:2^input('')-1;if sum(~~conv(dec2bin(k)+0,[-1,1],'v'))>1;disp(k);end;end

— flawr
स्रोत

6

जावास्क्रिप्ट (ईएस 7), 89 85 72 69 62 बाइट्स

जेएस में पवित्र गाय बनाना, आसान नहीं है। ~~शायद यह एक वास्तविक forलूप के साथ छोटा होगा ।~~ नहीं, मैंने झूठ बोला; यह वास्तव में थोड़ा लंबा है। ओह अच्छा। मुझे लगता है कि मुझे बचाए गए 27 बाइट्स के लिए बस निपटना होगा। (Mwr247 के लिए 7 धन्यवाद!)

x=>[for(a of Array(1<<x).keys())if(/01/.test(a.toString(2)))a]

फ़ायरफ़ॉक्स के नवीनतम संस्करणों में ठीक से काम करता है, लेकिन शायद किसी अन्य ब्राउज़र में नहीं। कोशिश करके देखो:

<!--                               Try the test suite below!                              --><strong id="bytecount" style="display:inline; font-size:32px; font-family:Helvetica"></strong><strong id="bytediff" style="display:inline; margin-left:10px; font-size:32px; font-family:Helvetica; color:lightgray"></strong><br><br><pre style="margin:0">Code:</pre><textarea id="textbox" style="margin-top:5px; margin-bottom:5px"></textarea><br><pre style="margin:0">Input:</pre><textarea id="inputbox" style="margin-top:5px; margin-bottom:5px">5</textarea><br><button id="testbtn">Test!</button><button id="resetbtn">Reset</button><br><p><strong id="origheader" style="font-family:Helvetica; display:none">Original Code Output:</strong><p><div id="origoutput" style="margin-left:15px"></div><p><strong id="newheader" style="font-family:Helvetica; display:none">New Code Output:</strong><p><div id="newoutput" style="margin-left:15px"></div><script type="text/javascript" id="golfsnippet">var bytecount=document.getElementById("bytecount");var bytediff=document.getElementById("bytediff");var textbox=document.getElementById("textbox");var inputbox=document.getElementById("inputbox");var testbtn=document.getElementById("testbtn");var resetbtn=document.getElementById("resetbtn");var origheader=document.getElementById("origheader");var newheader=document.getElementById("newheader");var origoutput=document.getElementById("origoutput");var newoutput=document.getElementById("newoutput");textbox.style.width=inputbox.style.width=window.innerWidth-50+"px";var _originalCode="x=>[for(a of Array(1<<x).keys())if(/01/.test(a.toString(2)))a]";function getOriginalCode(){if(_originalCode!=null)return _originalCode;var allScripts=document.getElementsByTagName("script");for(var i=0;i<allScripts.length;i++){var script=allScripts[i];if(script.id!="golfsnippet"){originalCode=script.textContent.trim();return originalCode}}}function getNewCode(){return textbox.value.trim()}function getInput(){try{var inputText=inputbox.value.trim();var input=eval("["+inputText+"]");return input}catch(e){return null}}function setTextbox(s){textbox.value=s;onTextboxChange()}function setOutput(output,s){output.innerHTML=s}function addOutput(output,data){output.innerHTML+='<pre style="background-color:'+(data.type=="err"?"lightcoral":"lightgray")+'">'+escape(data.content)+"</pre>"}function getByteCount(s){return(new Blob([s],{encoding:"UTF-8",type:"text/plain;charset=UTF-8"})).size}function onTextboxChange(){var newLength=getByteCount(getNewCode());var oldLength=getByteCount(getOriginalCode());bytecount.innerHTML=newLength+" bytes";var diff=newLength-oldLength;if(diff>0){bytediff.innerHTML="(+"+diff+")";bytediff.style.color="lightcoral"}else if(diff<0){bytediff.innerHTML="("+diff+")";bytediff.style.color="lightgreen"}else{bytediff.innerHTML="("+diff+")";bytediff.style.color="lightgray"}}function onTestBtn(evt){origheader.style.display="inline";newheader.style.display="inline";setOutput(newoutput,"");setOutput(origoutput,"");var input=getInput();if(input===null){addOutput(origoutput,{type:"err",content:"Input is malformed. Using no input."});addOutput(newoutput,{type:"err",content:"Input is malformed. Using no input."});input=[]}doInterpret(getNewCode(),input,function(data){addOutput(newoutput,data)});doInterpret(getOriginalCode(),input,function(data){addOutput(origoutput,data)});evt.stopPropagation();return false}function onResetBtn(evt){setTextbox(getOriginalCode());origheader.style.display="none";newheader.style.display="none";setOutput(origoutput,"");setOutput(newoutput,"")}function escape(s){return s.toString().replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;")}window.alert=function(){};window.prompt=function(){};function doInterpret(code,input,cb){var workerCode=interpret.toString()+";function stdout(s){ self.postMessage( {'type': 'out', 'content': s} ); }"+" function stderr(s){ self.postMessage( {'type': 'err', 'content': s} ); }"+" function kill(){ self.close(); }"+" self.addEventListener('message', function(msg){ interpret(msg.data.code, msg.data.input); });";var interpreter=new Worker(URL.createObjectURL(new Blob([workerCode])));interpreter.addEventListener("message",function(msg){cb(msg.data)});interpreter.postMessage({"code":code,"input":input});setTimeout(function(){interpreter.terminate()},1E4)}setTimeout(function(){getOriginalCode();textbox.addEventListener("input",onTextboxChange);testbtn.addEventListener("click",onTestBtn);resetbtn.addEventListener("click",onResetBtn);setTextbox(getOriginalCode())},100);function interpret(code,input){window={};alert=function(s){stdout(s)};window.alert=alert;console.log=alert;prompt=function(s){if(input.length<1)stderr("not enough input");else{var nextInput=input[0];input=input.slice(1);return nextInput.toString()}};window.prompt=prompt;(function(){try{var evalResult=eval(code);if(typeof evalResult=="function"){var callResult=evalResult.apply(this,input);if(typeof callResult!="undefined")stdout(callResult)}}catch(e){stderr(e.message)}})()};</script>

स्निपेट का विस्तार करें

^{( इस पेज से लिया गया स्निपेट )}

सुझावों का स्वागत है!

— ETHproductions
स्रोत

आप उपयोग कर सकते हैं .keys()के बजाय .fill()और aके बजाय i62 के लिए मेरा टाई:x=>[for(a of Array(1<<x).keys())if(/01/.test(a.toString(2)))a]

— Mwr247

@ Mwr247 धन्यवाद! मुझे आश्चर्य है कि अगर यह 62 के तहत संभव है ... :)

— ETHproductions

6

हास्केल, 68 61 53 बाइट्स

डेमियन से सुधार

g x|x`mod`4==1=x>4|2>1=g$x`div`2
a x=filter g[1..2^x]

इतिहास:

यह बग को ठीक करता है (स्विच == और =, और दो की शक्ति के बजाय वर्ग)। और सत्य को 2> 1 से बदलें और झूठ को 1> 2 से। यह भी धन्यवाद कि 2 ^ x हमेशा विफल रहता है। थॉमस क्वा और निम्मी को धन्यवाद

g x|x<5=1>2|x`mod`4==1=2>1|2>1=g$x`div`2
a x=filter g[1..2^x]

मौलिक रूप से

g x|x<5=False|x`mod`4=1==True|2>1=g$x`div`2
a x=filter g[1..(x^2-1)]

अगर इसे पूरा कार्यक्रम बनाना है,

g x|x<5=False|x`mod`4==1=True|2>1=g$x`div`2
main=interact$show.a
a x=filter g[1..2^(read x)]

— Akangka
स्रोत

1

ओम् का नाम या फ़ंक्शन लिखने के लिए निर्दिष्ट नहीं किए जाने के बाद से लंबोदर ठीक हैं। वैसे, PPCG में आपका स्वागत है!

— lirtosiast

1

मुझे लगता है कि आप का मतलब है 1..(2^x-1)जो सिर्फ 1.. (2^x)2 ^ x के बाद से हमेशा विफल हो सकता है।

— lirtosiast

आप स्थिरांक Falseऔर उसके Trueसाथ 1>2और बदल सकते हैं 1<2। चारों ओर कोष्ठकों की कोई आवश्यकता नहीं है 2^x-1। (BTW: आपके पास एक टाइपो है: यह होना चाहिए 4==1=True)।

— nimi

टाइपो सुधार के लिए धन्यवाद। मेरे समय में देर रात थी।

— अक्काका

अच्छी चाल! मुझे लगता है कि आप जी को कम कर सकते हैं: gx | x mod4 == 1 = x> 4 | 2> 1 = g $ x div2

— डेमियन

5

एपीएल, 34 27 बाइट्स

{0~⍨{⍵×2<+/2≢/⍵⊤⍨⍵/2}¨⍳2*⍵}

यह एक अनाम मानदंड फ़ंक्शन बनाता है जो दाईं ओर पूर्णांक को स्वीकार करता है और एक सरणी देता है।

स्पष्टीकरण:

                     }¨⍳2*⍵}  ⍝ For each integer from 1 to 2^input...
              ⍵⊤⍨⍵/2         ⍝ Get the binary representation as a vector
           2≢/                ⍝ Pairwise non-match, yielding a boolean vector
       2<+/                   ⍝ Check whether the number of trues is >2
     ⍵×                       ⍝ Yield the integer if so, otherwise 0
{0~⍨{                         ⍝ Remove the zeros from the resulting array

डेनिस के लिए धन्यवाद 7 बाइट्स सहेजे गए!

— एलेक्स ए।
स्रोत

4

आर, 55 47 बाइट्स

(@ अलेक्सा की कुछ मदद से)

cat(grep("10+1",R.utils::intToBin(1:2^scan())))

आर में एक सुविधाजनक तरीके से परिवर्तित संख्याओं को प्रदर्शित करने के लिए बनाया गया फ़ंक्शन नहीं है, इसलिए मैं इसके लिए उपयोग कर रहा हूं R.utils::intToBin, जबकि बाकी सभी बहुत अधिक हैं बस मिलान किए गए रेगेक्स अभिव्यक्ति के स्थान की रिपोर्ट करें और एक अलग से अलग करते समय STDOUT पर प्रिंट करें। अंतरिक्ष।

— डेविड अर्नबर्ग
स्रोत

मुझे लगता है कि इसके लिए डिफ़ॉल्ट विभाजक catएक स्थान है, इसलिए आप ,sep=","7 बाइट की बचत करते हुए पूरी तरह से छोड़ सकते हैं ।

— एलेक्स ए।

@AlexA। हाँ, तो क्या मैं एक सेप के रूप में एक जगह का उपयोग कर सकता हूं? मुझे यकीन नहीं था

— डेविड अर्गनबर्ग

1

ओपी ने कहा कि आपकी पसंद का परिसीमन है, इसलिए मुझे लगता है कि एक जगह पर्याप्त उचित लगती है। :)

— एलेक्स ए।

क्या यह वास्तव में बिल्ली के कार्य की आवश्यकता है? इसके बिना, यह आउटपुट टैब सीमांकित होगा। बाएं हाथ का काउंटर UI का हिस्सा है, अगर आप इसे किसी फ़ाइल में लिखते हैं तो इसे शामिल नहीं किया जाएगा, इसलिए यह आउटपुट का हिस्सा नहीं है।

— फ़्रीकव्ड

@fricvd के बिना यह STDOUT पर प्रिंट नहीं होगा, इस साइट के मूर्खतापूर्ण नियमों के बारे में कुछ।

— डेविड अर्नबर्ग

4

CJam, 14

2qi#{2b2,#)},p

3 बाइट्स डेनिस के लिए धन्यवाद। इसे ऑनलाइन आज़माएं

— aditsu
स्रोत

कैसे के बारे में 2be`,2>।

— jimmy23013

2

2be`2>और 2,#)साथ ही काम करना चाहिए। साथ ही, ओपी ने स्पष्ट किया है कि आउटपुट को सूची रूप में मुद्रित किया जा सकता है।

— डेनिस

4

जावास्क्रिप्ट (ईएस 6), 69 68 67 62 बाइट्स

a=>[...Array(1<<a).keys()].filter(i=>/01/.test(i.toString(2)))

आज मैंने एक नया छोटा तरीका खोजा है जो एरियर्स को भरने या मानचित्र के उपयोग के बिना गतिशील रूप से भरने के लिए है। ऐसा करने x=>[...Array(x).keys()]से श्रेणी 0 से x में सरणी वापस आ जाएगी। यदि आप अपनी स्वयं की सीमा / मान को परिभाषित करना चाहते हैं, तो उपयोग करें x=>[...Array(x)].map((a,i)=>i), क्योंकि यह अभी कुछ बाइट्स लंबा है।

— Mwr247
स्रोत

4

जावा, 214 165 155 154 148 141 110 बाइट्स

यह सबमिशन इस तथ्य का फायदा उठाता है कि जावा में एक संख्या के बाइनरी स्ट्रिंग प्रतिनिधित्व में कभी भी अग्रणी शून्य नहीं होता है। यदि स्ट्रिंग "01" एक संख्या के द्विआधारी प्रतिनिधित्व में प्रकट होती है, तो उसे "1" संख्या की दूसरी घटना को चिह्नित करना होगा ।

golfed:

String f(int l){String r="";for(long i=5;i<1L<<l;++i)if(Long.toString(i,2).contains("01"))r+=i+", ";return r;}

Ungolfed:

public class NumbersWithMultipleRunsOfOnes {

  public static void main(String[] a) {
    // @formatter:off
    String[][] testData = new String[][] {
      { "3", "5" },
      { "4", "5, 9, 10, 11, 13" },
      { "5", "5, 9, 10, 11, 13, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 29" }
    };
    // @formatter:on

    for (String[] data : testData) {
      System.out.println("Input: " + data[0]);
      System.out.println("Expected: " + data[1]);
      System.out.print("Actual:   ");
      System.out.println(new NumbersWithMultipleRunsOfOnes().f(Integer.parseInt(data[0])));
      System.out.println();
    }
  }

  // Begin golf
  String f(int l) {
    String r = "";
    for (long i = 5; i < 1L << l; ++i)
      if (Long.toString(i, 2).contains("01")) r += i + ", ";
    return r;
  }
  // End golf
}

कार्यक्रम उत्पादन (याद रखें, अनुगामी परिसीमन स्वीकार्य हैं):

Input: 3
Expected: 5
Actual:   5, 

Input: 4
Expected: 5, 9, 10, 11, 13
Actual:   5, 9, 10, 11, 13, 

Input: 5
Expected: 5, 9, 10, 11, 13, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 29
Actual:   5, 9, 10, 11, 13, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 29,

क्या आप intकाउंटर चर के लिए उपयोग नहीं करते हैं?

— दोष

जावा में सभी पूर्णांक प्रकार अहस्ताक्षरित हैं। 32 बिट पॉजिटिव पूर्णांक के साथ काम करने के लिए, 64 बिट longकी आवश्यकता होती है। इसके अलावा, रैपर क्लास को संदर्भित करने के कारण कोड का आकार intवास्तव में बढ़ जाता Integerहै जो संख्या पार्सिंग करता है। मुझे लगता है कि अंतरिक्ष को बचाने के लिए संभावित स्थान रेगेक्स होगा, लेकिन मेरे परीक्षण से पता चला कि मुझे अग्रणी और अनुगामी होना है.*

ओह ठीक है, लेकिन मुझे लगा कि आप Longरैपर का उपयोग कर सकते हैं int? (वैसे इस मामले में नहीं बल्कि आम तौर पर?)

— दोष

हां, जब एक पैरामीटर के रूप में उपयोग किया जाता है तो intवसीयत को बढ़ावा मिलेगा । इस मामले में हालांकि साइन बिट के कारण वास्तव में उपयोग करने का कोई तरीका नहीं है , और इससे अधिक लंबा है । फिर भी, मैंने जावा के रूप में वर्बोज़ के रूप में कुछ अतिरिक्त स्थान को निचोड़ने के लिए कुछ तरीके खोजे हैं। longLongintIntegerLong

के new Long()बजाय आप का उपयोग कर सकते हैं Long.parseLong()?

— यज्ञपिन

4

सी (जीसीसी) , 111 99 बाइट्स

long i,x;main(a,b)char**b;{for(;++i<1L<<atol(b[1]);x>>ffsl(~x)-1&&printf("%ld,",i))x=i>>ffsl(i)-1;}

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

12 बाइट्स मुंडा @ceilingcat को धन्यवाद!

Ungolfed:

int main(int a, char **b) {
  for(long i = 0, x = 0; ++i < (1LL << atol(b[1])); ) {
    x = i >> (ffsl(i) - 1);
    if (x >> (ffsl(~x) - 1))
      printf("%ld,", i);
  }
}

फ़ंक्शन ffsl () आपको पहले बिट का सूचकांक देता है जो एक लंबे पूर्णांक में सेट किया गया है। इसलिए हम i = 12 ^ नंबर_ऑफ_बिट्स से लूप करते हैं । हम सेट xकरने के लिए iसही जब तक हम कम से कम महत्वपूर्ण अंत पर सब लगातार शून्य बिट्स को हटा दिया है स्थानांतरित कर दिया। तब, हम xसही शिफ्ट करते हैं जब तक कि हमने कम से कम साइनफ़िसेंट अंत में सभी लगातार 1 बिट्स को हटा नहीं दिया। यदि परिणाम अभी भी गैर-शून्य है, तो हमें एक मैच मिला।

— जी। स्लीपेन
स्रोत

2

मुझे कहना होगा कि मुझे वास्तव में पसंद है कि किसी ने "स्ट्रिंग और रेगेक्स में कनवर्ट" दृष्टिकोण के बजाय थोड़ा सा हेरफेर जवाब दिया।

@MichaelT मुझे आश्चर्य है कि अगर केवल आदिम बिटवाइज़ ऑपरेशंस का उपयोग करके एक छोटा सा आईल्यूशन है।

— lirtosiast

@ThomasKwa कोड-चैलेंज के रूप में कुछ करना हो सकता है ।

दिलचस्प। आप इस तरह का परीक्षण भी लिख सकते हैं: if (popcount(i ^ (i*2))>3)और पॉपकाउंट () को बिटवाइज़ एंड्स और शिफ्ट ऑपरेशन की एक श्रृंखला में विस्तारित करें। लेकिन इसका परिणाम काफी लंबा कोड होगा।

— जी। स्लीपेन ने

1

@ThomasKwa y = x | (x-1) सभी सही 0 बिट्स चालू करने के लिए। फिर z = y & (y + 1) सभी अनुगामी 1 बिट्स को बंद करने के लिए। यदि z गैर-शून्य है, तो मूल संख्या में एक से अधिक रन थे।

— अल्काइमर

3

जावास्क्रिप्ट (ईएस 6) 76

f=n=>Array(1<<n).fill().map((_,x)=>/01/.test(x.toString(2))?x+',':'').join``

//TEST
for(i=1;i<16;i++)O.innerHTML+=i+' -> '+f(i)+'\n'

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

@DLosc no, परिणाम कुछ इस तरह होगा,,,,,5,,,,9,10,11,,13,,,,17,18,19,20,21,22,23,,25,26,27,,29,,

— edc65

3

K5, 19 बाइट्स

यह डेनिस के समाधान के समान सिद्धांतों के साथ संचालित होता है, लेकिन कम बिल्डरों के साथ लाभ उठाने के लिए।

{&2<+/'~0=':'+!x#2}

सबसे पहले, बाइनरी x-tuples ( +!x#2) की एक श्रृंखला उत्पन्न करें , फिर प्रत्येक tuple के लिए हर उस बिंदु को खोजें जो एक अंक पिछले से मेल नहीं खाता है यदि हम सूची के -1 तत्व को इस उद्देश्य के लिए 0 मानते हैं ( ~0=':')। हमारे समाधान हैं जहां दो प्रत्येक रन काउंट के योग से कम है। ( &2<+/')।

प्रत्येक मध्यवर्ती कदम स्पष्ट है:

  4#2
2 2 2 2

  !4#2
(0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1)

  +!4#2
(0 0 0 0
 0 0 0 1
 0 0 1 0
 0 0 1 1
 0 1 0 0
 0 1 0 1
 0 1 1 0
 0 1 1 1
 1 0 0 0
 1 0 0 1
 1 0 1 0
 1 0 1 1
 1 1 0 0
 1 1 0 1
 1 1 1 0
 1 1 1 1)

  ~0=':'+!4#2
(0 0 0 0
 0 0 0 1
 0 0 1 1
 0 0 1 0
 0 1 1 0
 0 1 1 1
 0 1 0 1
 0 1 0 0
 1 1 0 0
 1 1 0 1
 1 1 1 1
 1 1 1 0
 1 0 1 0
 1 0 1 1
 1 0 0 1
 1 0 0 0)

  +/'~0=':'+!4#2
0 1 2 1 2 3 2 1 2 3 4 3 2 3 2 1

  2<+/'~0=':'+!4#2
0 0 0 0 0 1 0 0 0 1 1 1 0 1 0 0

  &2<+/'~0=':'+!4#2
5 9 10 11 13

और सभी एक साथ:

  {&2<+/'~0=':'+!x#2}'3 4 5 
(,5
 5 9 10 11 13
 5 9 10 11 13 17 18 19 20 21 22 23 25 26 27 29)

— JohnE
स्रोत

2

पिप, 13 + 1 = 14 बाइट्स

कमांड लाइन से इनपुट लेता है और -sआउटपुट संख्याओं के बीच रिक्त स्थान के लिए ध्वज का उपयोग करता है ।

01NTB_FI,2**a

बहुत सीधा: निर्माण range(2**a)और फ़िल्टर पर lambda _: "01" in toBinary(_)। मैं 01स्वतंत्र रूप से विचार करने के बारे में बहुत खुश था । किसी भी उद्धरण की आवश्यकता नहीं है 01क्योंकि यह एक संख्यात्मक शाब्दिक के रूप में स्कैन करता है (संख्या और तार पिप में एक ही प्रकार हैं)।

— DLosc
स्रोत

2

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

n->filter(i->count_ones(i$i>>1)>2,1:2^n)

यह दूसरे जूलिया समाधान के लिए कुछ हद तक अलग दृष्टिकोण का उपयोग करता है - बिट स्ट्रिंग में "01" के लिए एक स्ट्रिंग खोज करने के बजाय, यह निर्धारित करने के लिए कुछ गणित का उपयोग करता है कि संख्या स्थिति को संतुष्ट करती है या नहीं।

i$i>>1केवल उन्हीं स्थानों पर होंगे जहां अंक शून्य से एक या एक से शून्य में बदल जाता है। जैसे, iशून्य और एक पर्याप्त समय के बीच आगे और पीछे स्विच करने के लिए कम से कम तीन व्यक्ति होने चाहिए । count_onesलोगों की संख्या पाता है, और फिर filterउन लोगों को हटा देता है जिनके पास पर्याप्त नहीं है।

— ग्लेन हे
स्रोत

2

सी ++, 197 188 141 बाइट्स

नोट: यह MSVC ++ 2013 का उपयोग करके लिखा और परीक्षण किया गया था। ऐसा प्रतीत होता है #include आईएनजी<iostream> इस काम बनाने के लिए आवश्यक सी हेडर के सभी शामिल हैं। यह भी प्रतीत होता है कि कोड अब सही मायने में C ++ नहीं है, लेकिन C ++ का उपयोग करके संकलन उस हेडर ट्रिक की अनुमति देता है जो एक गुच्छा अधिक C हेडर शामिल करने की तुलना में कोड आकार को कम करता है।

का उपयोग करते हुए printf बजाय काcout एक युगल बाइट्स बचाता है।

golfed:

#include<iostream>
int main(int a,char**b){char c[34];for(long i=5;i<1L<<atol(b[1]);++i){_ltoa(i,c,2);if(strstr(c,"01"))printf("%ld\n",i);}}

Ungolfed:

#include <iostream>
int main(int a, char **b) {
  char c[34];
  for (long i = 5; i < 1L << atol(b[1]); ++i) {
    _ltoa(i, c, 2);
    if (strstr(c, "01"))
      printf("%ld\n", i);
  }
}

Yoiu '\n'std के बजाय उपयोग कर सकते हैं :: एंडल (सामान्य रूप से), या ','चूंकि कोई विभाजक वैध है और एक अनुगामी ठीक है।

— जी। स्लीपेन ने

रेगेक्स के बजाय, आप इसके साथ कर सकते हैं strstr(c,"01")।

— जी। स्लीपेन ने

@ G.Sliepen धन्यवाद! मैंने ईमानदारी से सिर्फ अपने जावा समाधान की नकल की और सी ++ में बदल दिया, लेकिन सरल समाधान अक्सर सबसे अच्छा होता है। मुझे शायद अब जावा के साथ भी कुछ ऐसा ही करना चाहिए।

दो छोटी त्रुटियां: 1<<atol(b[1])होनी चाहिए 1L<<atol(b[1]), अन्यथा उस अभिव्यक्ति का परिणाम एक हस्ताक्षरित 32 बिट पूर्णांक होगा, जिसका अर्थ है कि कोड केवल 2 ^ 30 तक चलेगा। प्रिंटफ को %ld2 ^ 31 और 2 ^ 32 के बीच संख्याओं को सही ढंग से प्रिंट करने के लिए उपयोग करना चाहिए ।

— जी। स्लीपेन

2

पर्ल 5, 55 53 49 47 41 बाइट्स

sprintf("%b",$_)=~/01/&&say for 0..2**<>

54 52 48 46 40 बाइट्स, इसके अलावा -Eध्वज के लिए एक -e।

के बजाय का उपयोग करने के बारे में संकेत के लिए xnor के लिए धन्यवाद/01//10+1/ , जिसने दो बाइट्स को बचाया।

के बजाय उपयोग करने के लिए सलाह के लिए डेनिस को धन्यवाद , जिसने छह बाइट्स को बचाया।<>$ARGV[0]

— msh210
स्रोत

2

सी, 84 81 बाइट्स

long i,j,k;main(){for(scanf("%ld",&j);++i<1L<<j;k&k+1&&printf("%ld ",i))k=i|i-1;}

यह उन टिप्पणियों पर आधारित है जो मैंने एक और सी पर दिए थे, इस प्रश्न का उत्तर सरल बिटवाइज़ ऑपरेटरों के उपयोग की संभावना के बारे में था। यह कथन I (i-1) में सभी अनुगामी 0 बिट्स को 1 पर स्विच करके काम करता है। तब यह k & (k + 1) का उपयोग करके सभी अनुगामी 1 बिट्स को 0 पर स्विच करता है। यह एक शून्य में परिणाम होगा अगर वहाँ केवल एक ही है और गैर-शून्य अन्यथा। मैं यह अनुमान लगाता हूं कि लंबे समय तक 64-बिट है लेकिन इसके बजाय int64_t का उपयोग करके तीन बाइट्स की कीमत पर इसे ठीक कर सकता है।

Ungolfed

long i,j,k;
main()
{
    for(scanf("%ld",&j);++i<1L<<j;)
    {
        k=i|(i-1);
        if((k&(k+1)) == 0)
            printf("%d ",i);
    }
}

— Alchymist
स्रोत

int64_tकेवल यदि आप परिभाषित किया गया है #include<stdint.h>। 64 बिट ऑपरेशन सुनिश्चित करने के लिए long long5 बाइट की लागत पर टाइप की आवश्यकता होती है ।

— चकरली

ध्यान दें कि आप प्रारूप के long iलिए अपरिभाषित व्यवहार को लागू करते हैं %d। यह भी ध्यान दें कि ()के लिए ज़रूरत से ज़्यादा हैं &और |ऑपरेटरों। इसे ठीक करने से 3 बाइट बचती हैं! long i,j,k;main(){for(scanf("%ld",&j);++i<1L<<j;k&k+1&&printf("%ld ",i))k=i|i-1;}

— चकरली

@chqrlie सभी बहुत अच्छे अंक। धन्यवाद।

— अल्काइमर

1

पायथ, 20 17 16 बाइट्स

f:.BT"10+1"ZU^2Q

लाइव डेमो।

— kirbyfan64sos
स्रोत

आप बस मेल कर सकते हैं "01"। 0 को छोड़कर, बाइनरी रीप्र। हमेशा 1 के साथ शुरू होगा

— डेनिस

1

पायथन 2.7, 89 बाइट्स

print[i for i in range(1,2**input())if[n[:1]for n in bin(i)[2:].split("0")].count("1")-1]

मुझे लगता है कि यह थोड़ा गोल्फ हो सकता है।

— Loovjo
स्रोत

@ mbomb007 मैंने कोशिश की है कि, यह काम नहीं किया।

— लवजो

@ mbomb007 आप पायथन 2.7 का उपयोग कर रहे हैं?

— लवजो

इससे कोई फर्क नहीं पड़ता कि 2.7 का कौन सा संस्करण है? मैं इसे repl.it (2.7.2) पर चलाता हूं और यह काम नहीं करता है, लेकिन Ideone (2.7.10) करता है। यह सिर्फ repl.it में एक बग हो सकता है, हालांकि जरूरी नहीं कि एक संस्करण अंतर।

— mbomb007

आपका प्रोग्राम गलत तरीके 0से आउटपुट में प्रिंट करता है।

— mbomb007

इसके अलावा print[i for i in range(2**input())if[n[:1]for n in bin(i)[2:].split("0")].count("1")-1]दो बाइट्स कम है। लेकिन 0यदि आप उपयोग करते हैं तो फिक्स के साथ समान लंबाई (89) होगी range(1,2**input())।

— mbomb007

1

टीआई-बेसिक, 34 32 30 बाइट्स

एक TI-83 + / 84 + श्रृंखला कैलकुलेटर के लिए।

For(X,5,e^(Ans
If log(sum(2=int(4fPart(X/2^randIntNoRep(1,Ans
Disp X
End

एक नंबर के लिए 1s के दो रन शामिल करने के लिए, इसमें दो 10एस होना चाहिए जब हम द्विआधारी प्रतिनिधित्व पर एक अनुगामी शून्य से निपटते हैं।

बाइनरी प्रतिनिधित्व उत्पन्न करने और ए के लिए जांच करने के बजाय 10, हम गणितीय रूप से बिट्स के जोड़े का परीक्षण 4 (शेष int(4fPart() का उपयोग करके करते हैं , जो 2जहां एक है वहां दे देंगे 10। क्योंकि हम आदेश की परवाह नहीं करते हैं, randIntNoRep(इसलिए यह खर्च करने वालों की सूची तैयार करने का सबसे छोटा तरीका है।

हम log(रन की संख्या की जांच करने के लिए उपयोग करते हैं :

यदि कम से कम 2 रन हैं, तो log(सकारात्मक है, और संख्या प्रदर्शित होती है।
यदि एक रन है, तो log(0 है, और संख्या प्रदर्शित नहीं है।
यदि कोई रन नहीं हैं (जो पहले X = 2 ^ Ans पर होता है), तो log(एक ERR: DOMAIN फेंकता है, जिससे आउटपुट बिल्कुल सही बिंदु पर रुक जाता है।

हम लूप e^(Ansके अंतिम तर्क के रूप में उपयोग करते हैं For(- यह हमेशा की तुलना में अधिक है 2^Ans, लेकिन e^(एक एकल टोकन है, इसलिए यह एक बाइट कम है।

एन = 4 के लिए इनपुट / आउटपुट:

4:prgmRUNSONES
               5
               9
              10
              11
              13

तब कैलकुलेटर एक त्रुटि फेंकता है; त्रुटि स्क्रीन इस तरह दिखता है:

ERR:DOMAIN
1:Quit
2:Goto

जब 1 दबाया जाता है, तो होम स्क्रीन फिर से प्रदर्शित होती है:

4:prgmRUNSONES
               5
               9
              10
              11
              13
           Error

टीआई कैलकुलेटर बीसीडी फ्लोट में सभी नंबरों को 14 अंकों की सटीकता के साथ स्टोर करते हैं, न कि इंट या बाइनरी फ्लोट के। इसलिए, दो से अधिक की शक्तियों द्वारा विभाजन 2^14सटीक नहीं हो सकता है। जबकि मैंने सत्यापित किया है कि मुश्किल संख्याएँ, 3*2^30-1और 2^32-1, सही तरीके से नियंत्रित की जाती हैं, मैंने त्रुटियों को गोल करने की संभावना से इंकार नहीं किया है। मुझे आश्चर्य होगा कि अगर किसी इनपुट के लिए त्रुटियां थीं।

— lirtosiast
स्रोत

आप 32 बाइट्स कैसे गिनते हैं? यह मेरे लिए 70 की तरह दिखता है (न्यूलाइन सहित)।

— msh210

TI-BASIC टोकन है; यह एक मालिकाना चरित्र एन्कोडिंग का उपयोग करता है जिसमें ये सभी कमांड एक-एक बाइट हैं और अन्य दो हैं। इस एन्कोडिंग द्वारा स्कोर करने के लिए सामुदायिक सहमति है- विवरण के लिए meta.codegolf.stackexchange.com/a/4764/39328 देखें।

— lirtosiast

ओह बढ़िया। धन्यवाद FYI करें।

— msh210

1

यह फ्लॉटर के जवाब को हरा नहीं सकता है, लेकिन मैं सवाल के आकर्षण का विरोध नहीं कर सकता

matlab(90)(70)

j=input('');for l=2:j-1,a=1;for k=l:-1:2,a=a+2^k;a:a+2^(k-1)-2,end,end

क्रियान्वयन

4

ans =

9    10    11

ans =

सिद्धांत

संख्याओं की श्रृंखला 1 के परिणामी पट्टी का परिणाम है, जिसका अर्थ है च (n, l) = 2 ^ l + 2 ^ (l + 1) + .... 2 ^ n।

अंतराल से लिया गया कोई भी संख्या] f (n, l), f (n, l) + 2 ^ (l-1) [जहाँ l> 1 इस स्थिति की पुष्टि करता है, इसलिए परिणाम इस श्रृंखला के निषेध का परिणाम है n की शर्तें।

x = 1

x = x + 1 = 01,

x = x + 2 ^ 0 = 11,

x = x + 1 = 001,

x = x + 2 ^ 1 = 011,

x = x + 2 ^ 0 = 111,

x = x + 1 = 0001,

x = x + 2 ^ 2 = 0011,

x = x + 2 ^ 1 = 0111,

x = x + 2 ^ 0 = 0111,

x = x + 1 = 1111...

x + 1, x = x + 2 ^ n, x = x + 2 ^ (n-1) ... x = x + 2 ^ 0

मेरा कार्यक्रम प्रत्येक दो पंक्तियों के बीच की सीमा को प्रिंट करता है (यदि मौजूद है)

संपादित करें: दुर्भाग्य से यह नहीं है कि यह और अधिक गोल्फ बनाता है लेकिन मैं इस विचार को संसाधित करने का एक और दृष्टिकोण जोड़ना चाहता था

संघर्ष की अवधि के बाद मैंने इस श्रृंखला के लिए गणितीय प्रतिनिधित्व पाने के लिए सफलता प्राप्त की:

2 ^ l (0 + 1 + 2 ^ 1 + ... 2 ^ k) के साथ l + k <n

= 2 ^ एल (2 ^ k-1)

स्कोर = 90

@(n)setdiff(0:2^n-1,arrayfun(@(x)2^mod(x,(n+1)-fix(x/(n+1)))*(2^fix(x/(n+1))-1),0:(n+1)^2))

— Abr001am
स्रोत

1

सी, 103 102 बाइट्स

long i,x;main(int a,char**b){for(;++i<1L<<atoi(b[1]);)for(x=i;x>4&&(x%4!=1||!printf("%ld,",i));x/=2);}

G.Sliepen प्रविष्टि पर विस्तार (वास्तव में अनुबंधित), 01द्विआधारी प्रतिनिधित्व में पैटर्न पर xnor टिप्पणी का लाभ उठाते हुए, लेकिन केवल मानक कार्यों और कुछ बिट ट्विडलिंग का उपयोग करते हुए।

Ungolfed संस्करण:

long i, x;
main(int a, char**b) {
    for (; ++i < 1L << atoi(b[1]);) {
        for (x = i; x > 4 && (x % 4 != 1 || !printf("%ld,", i)); x /= 2)
            ;
    }
}

आंतरिक लूप iबाइनरी पैटर्न के लिए 01पुनरावृत्त xरूप से दाईं ओर स्थानांतरित करके स्कैन करता है जब तक कि उसके 3 बिट्स बचे हों। printfमुद्रित वर्णों की संख्या लौटाता है, इसलिए कभी नहीं 0, इसलिए आंतरिक लूप परीक्षण printfएक breakबयान की आवश्यकता से बचने के बाद विफल हो जाता है ।

सी ++, 129 128 बाइट्स

एक ही विचार को अपनाने, सी ++ संस्करण यहाँ है:

#include<iostream>
long i,x;int main(int a,char**b){for(;++i<1L<<atoi(b[1]);)for(x=i;x>4&&(x%4!=1||!(std::cout<<i<<','));x/=2);}

तकनीकी तौर पर, मैं बनाना चाहिए iएक long long64 बिट संचालन को सुनिश्चित करने और तक गणना करने के लिए 2^32एक अतिरिक्त 5 बाइट्स के लिए है, लेकिन आधुनिक प्लेटफार्मों 64 बिट ints की है।

— chqrlie
स्रोत

1

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

कोड

n=>[...Array(1<<n).keys()].filter(g=x=>x>4?x%4==1|g(x>>1):0)

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

व्याख्या

[...Array(1<<n).keys()]                                          Create an array of numbers from 0 to 2^n-1
                       .filter(                                  Find the numbers which meet criteria
                               g=x=>x>4?                  :0     If x is less than or equal to four return zero (false/invalid)
                                        x>4?x%4==1|              If the binary pattern ends with 01 return one (true/valid)
                                                   g(x>>1)       Otherwise bitshift right by one and try again

— fənɛtɪk
स्रोत

0

सी (तरह - जीसीसी में चेतावनी के साथ संकलित) - 103

यह प्रिंटफ को छोड़कर किसी भी प्रकार के पुस्तकालय कार्यों का उपयोग नहीं करता है। आप यह देखकर देख सकते हैं कि इसे मानकों के अनुरूप बनाने या यूबी से बचने के लिए कोई प्रयास नहीं किया गया है।

x,c;main(n,v){n--;for(;c<1<<n;c++)for(v=0;v<32;v++)if(c&1<<v){if(x&&x<v&&printf("%d ",c))break;x=v+1;}}

इसे आज्ञाकारी बनाने के लिए आपको stdio.h सहित बहुत सी चीजें करने की आवश्यकता होगी जो इसे जितना संभव हो उतना छोटा बनाने की भावना के खिलाफ होगा।

अगर किसी के पास इसे छोटा करने के सुझाव हैं तो कृपया मुझे बताएं।

— जेरी यिर्मयाह
स्रोत

0

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

while([Math]::Pow(2,$args[0])-gt$n++){$n|?{[Convert]::ToString($n,2)-match"01"}}

— एंड्रयू
स्रोत

0

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

ठीक है, यह शायद कम हो सकता है लेकिन यह मेरा पहला कोडगोल्फ है:

x=1
while True:
    if '01' in bin(x):
        print(x)
    x+=1

लगता है कि यह सवाल का जवाब देता है, कृपया नीचे मत जाओ अगर यह नहीं है, तो बस इसके साथ गलत क्या है।

— ज़ाचारी स्मिथ
स्रोत

1

आपको प्राप्त करने के लिए इनपुट ( input()आदर्श है) लेने की आवश्यकता है n, और उसके बाद केवल 2^n-1अनिश्चित काल के लिए लूप करने के बजाय गिनती करें । इसके अलावा, आप 4 और 8 के बजाय, नेस्टिंग के लिए 1 और 2 रिक्त स्थान का उपयोग कर सकते हैं, और mapएक सूची समझ का उपयोग करना या शायद आपके कोड को बहुत कम कर देगा।

— Mego

0

अच्छे स्कोर का एक और अलग matlab उत्तर।

matlab 60(57)

@(n)find(mod(log2(bitcmp(1:2^n,fix(log2(1:2^n)+1))+1),1))

क्रियान्वयन

>> @(n)find(mod(log2(bitcmp(1:2^n,fix(log2(1:2^n)+1))+1),1))

ans =

@(n)find(mod(log2(bitcmp(1:2^n,fix(log2(1:2^n)+1))+1),1))

>> ans(5)

ans =

 5     9    10    11    13    17    18    19    20    21    22    23    25    26    27    29

यह विचार संख्या x को उठा रहा है जहां - (x) +1 के बाइनरी प्रतिनिधित्व में केवल एक घटना नहीं है1

उदाहरण:

0000111को अस्वीकार कर दिया जाता है क्योंकि ~ x = 1111, ~ x + 1 = 00001में एक अंक = 1 होता है

0100111स्वीकार किया जाता है क्योंकि ~ x = 1011, ~ x + 1 = 0111में कई 1 होते हैं

— Abr001am
स्रोत

लोगों के कई रन के साथ संख्या

कार्य

इनपुट

उत्पादन

उदाहरण

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

विचार

कोड

अजगर, ४ 48

रूबी, 44 40 38 वर्ण

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

मतलाब, 79 68 64 59

जावास्क्रिप्ट (ईएस 7), 89 85 72 69 62 बाइट्स

हास्केल, 68 61 53 बाइट्स

एपीएल, 34 27 बाइट्स

आर, 55 47 बाइट्स

CJam, 14

जावास्क्रिप्ट (ईएस 6), 69 68 67 62 बाइट्स

जावा, 214 165 155 154 148 141 110 बाइट्स

सी (जीसीसी) , 111 99 बाइट्स

जावास्क्रिप्ट (ईएस 6) 76

K5, 19 बाइट्स

पिप, 13 + 1 = 14 बाइट्स

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

सी ++, 197 188 141 बाइट्स

पर्ल 5, 55 53 49 47 41 बाइट्स

पायथ, 20 17 16 बाइट्स

पायथन 2.7, 89 बाइट्स

टीआई-बेसिक, 34 32 30 बाइट्स

matlab(90)(70)

क्रियान्वयन

सिद्धांत

सी, 103 102 बाइट्स

सी ++, 129 128 बाइट्स

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

कोड

व्याख्या

सी (तरह - जीसीसी में चेतावनी के साथ संकलित) - 103

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

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

matlab 60(57)

क्रियान्वयन