Compito

Trova l'insieme di numeri in modo tale che la rappresentazione binaria contenga due o più sequenze 1separate da almeno una 0.

Ad esempio, per i numeri lunghi 4 bit:

 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)

Ingresso

Un numero intero fornito all'applicazione tramite alcuni input nell'intervallo 3 .. 32. Questo rappresenta il numero massimo di bit da contare fino a.

L'immissione di nindica che i numeri devono essere esaminati.0 .. 2n-1

Produzione

Un elenco delimitato (a scelta) di tutti i numeri che soddisfano i criteri. I numeri devono essere presentati in ordine numerico. Un delimitatore finale aggiuntivo è accettabile. []Sono anche accettabili allegati di strutture dati (ad es. E simili).

Esempio

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

Questo è code-golf : vince la risposta con il minor numero di byte.

Pyth, 12 byte

f<2r.BT8U^2Q

Provalo online.

Idea

La rappresentazione binaria di un numero positivo inizia sempre con una corsa di 1 s, eventualmente seguito da altri, alternando percorsi di 0 s e 1 s. Se ci sono almeno tre corse separate, due di esse sono garantite per 1 s.

Codice

              (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).

Python, 48

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

Lo avevo ampiamente pensato. Dobbiamo solo verificare se l'espansione binaria contiene '01'.

Perché ci siano due serie di quelle, quella a destra deve essere preceduta da a 0. Se c'è solo una corsa, non ci sarà nessun vantaggio 0, quindi non accadrà.

Vecchia risposta:

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

La rappresentazione binaria di Python funziona molto bene qui. Un numero binario è scritto come bin(9)=='0b10110'. Suddivisione dei '0'risultati in un elenco di

• Stringhe vuote a sinistra dell'iniziale 0, tra due consecutivi 0, e a destra di qualsiasi finale0
• La lettera bseguita da una o più lettere principali
• Esecuzioni 1che non stanno conducendo

Le prime due categorie esistono sempre, ma l'ultima esiste solo se esiste una corsa 1che non contiene il comando iniziale '1', e quindi solo se c'è più di una corsa di 1. Quindi, è sufficiente verificare se l'elenco contiene più di 2elementi distinti.

Python 3.5 salva 2 caratteri disimballando {*_}al posto di set(_).

Rubino, 44 40 38 caratteri

^{barrato 44 è ancora regolare 44;}

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

Una funzione anonima (proc, in realtà) che accetta un numero intero e restituisce un array.

Usa la regex /10+1/: a 1, almeno una 0e poi un'altra 1. @histocrat sottolinea che se si 01trova in un punto qualsiasi della stringa, deve esserci un punto 1prima.

Julia, 43 41 byte

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

Ciò crea una funzione senza nome che accetta un numero intero e restituisce un array. Usa il trucco regex degli istocrati (usato nella risposta di Doorknob), dove 01corrisponderà solo se c'è un precedente 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

Matlab, 79 68 64 59

L'idea è interpretare il numero binario come array di zero e uno e quindi calcolare la differenza assoluta tra ciascuna coppia di vicini. Se abbiamo due o più volte una differenza di 1, allora ovviamente ne abbiamo due o più. Nota che funziona solo se rappresentiamo il numero binario senza zeri iniziali.

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

Vecchie versioni:

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

JavaScript (ES7), 89 85 72 69 62 byte

Vacca sacra, creare gamme in JS non è facile. Forse sarebbe più breve con un forciclo reale . No, ho mentito; in realtà è un po 'più lungo. Oh bene. Immagino che dovrò accontentarmi di 27 byte salvati. (7 grazie a Mwr247!)

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

Funziona correttamente nelle ultime versioni di Firefox, ma probabilmente non in nessun altro browser. Provalo:

<!--                               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>

^{(Snippet tratto da questa pagina )}

Suggerimenti benvenuti!

Haskell, 68 61 53 byte

Miglioramento di Damien

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

Storia:

Questo risolve il bug (Switched == e =, e quadrato invece della potenza di due). E sostituisci true con 2> 1 e false con 1> 2. Anche grazie a sottolineare che 2 ^ x è sempre fallito. Grazie a Thomas Kwa e nimi

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]

Originariamente

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

Se deve essere un programma completo,

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)]

APL, 34 27 byte

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

Questo crea una funzione monadica senza nome che accetta un numero intero sulla destra e restituisce un array.

Spiegazione:

                     }¨⍳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

Risparmiato 7 byte grazie a Dennis!

R, 55 47 byte

(con l'aiuto di @ Alex.A)

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

R non ha una funzione integrata per visualizzare i numeri convertiti in un modo conveniente, quindi lo sto usando R.utils::intToBinper questo, mentre tutto il resto è praticamente solo riportare la posizione dell'espressione regex abbinata e stampare su STDOUT mentre separati da un spazio.

CJam, 14

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

3 byte in meno grazie a Dennis. Provalo online

JavaScript (ES6), 69 68 67 62 byte

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

Oggi ho scoperto un nuovo modo più breve per riempire dinamicamente le matrici senza l'uso di riempimento o mappa. Fare x=>[...Array(x).keys()]restituirà un array di intervallo da 0 a x. Se si desidera definire il proprio intervallo / valori, utilizzare x=>[...Array(x)].map((a,i)=>i), poiché è solo qualche byte più lungo.

Java, 214 165 155 154 148 141 110 byte

Questa presentazione sfrutta il fatto che una rappresentazione di stringa binaria di un numero in Java non ha mai uno zero iniziale. Se la stringa "01" appare nella rappresentazione binaria di un numero, è necessario contrassegnare la seconda occorrenza del numero "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
}

Output del programma (ricordare, i delimitatori finali sono accettabili):

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, 

C (gcc) , 111 99 byte

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;}

Provalo online!

12 byte rasati grazie a @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);
  }
}

La funzione ffsl () fornisce l'indice del primo bit impostato in un intero lungo. Quindi passiamo da i = 12 ^ number_of_bits. Abbiamo impostato xlo ispostamento a destra fino a quando non abbiamo rimosso tutti i bit zero consecutivi sull'estremità meno significativa. Quindi, spostiamo a xdestra fino a quando non abbiamo rimosso tutti i 1 bit consecutivi all'estremità meno significativa. Se il risultato è ancora diverso da zero, abbiamo trovato una corrispondenza.

JavaScript (ES6) 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>

K5, 19 byte

Questo funziona secondo principi simili a quelli della soluzione di Dennis, ma con meno builtin da sfruttare.

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

Innanzitutto, genera una serie di x-tuple binarie ( +!x#2), quindi per ogni tupla trova ogni punto in cui una cifra non corrisponde alla precedente se trattiamo il -1 ° elemento dell'elenco come 0 per questo scopo ( ~0=':'). Le nostre soluzioni sono dove due è inferiore alla somma di ogni conteggio delle esecuzioni. ( &2<+/').

Mostrare ogni passaggio intermedio è più chiaro:

  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

E tutti insieme:

  {&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)

Pip, 13 + 1 = 14 byte

Prende input dalla riga di comando e utilizza il -sflag per gli spazi tra i numeri di output.

01NTB_FI,2**a

Abbastanza semplice: costruisci range(2**a)e filtra lambda _: "01" in toBinary(_). Ero abbastanza felice di pensare l' 01idea in modo indipendente. Non sono necessarie virgolette 01perché scansiona come un valore letterale numerico (numeri e stringhe sono dello stesso tipo in Pip).

Julia, 40 byte

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

Questo utilizza un approccio un po 'diverso rispetto all'altra soluzione Julia - piuttosto che fare una ricerca di stringa per "01" nella stringa di bit, usa un po' di matematica per determinare se il numero soddisfa la condizione.

i$i>>1ne avrà uno solo nei punti in cui la cifra cambia da zero a uno o da uno a zero. Pertanto, devono essercene almeno tre per ipassare da zero a uno abbastanza volte. count_onestrova il numero di quelli e quindi filterrimuove quelli che non ne hanno abbastanza.

C ++, 197 188 141 byte

Nota: questo è stato scritto e testato utilizzando MSVC ++ 2013. Sembra che #includeing<iostream> includa tutte le intestazioni C necessarie per farlo funzionare. Sembra anche che il codice non sia più veramente C ++, ma la compilazione usando C ++ consente quel trucco dell'intestazione che riduce le dimensioni del codice rispetto a includere un sacco di più intestazioni C.

L'uso di printfanziché coutsalva anche un paio di byte.

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);
  }
}

Perl 5, 55 53 49 47 41 bytes

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

54 52 48 46 40 bytes, plus one for the -E flag instead of -e.

Thanks to xnor for the hint about using /01/ instead of /10+1/, which saved two bytes.

Thanks to Dennis for the advice to use <> instead of $ARGV[0], which saved six bytes.

C, 84 81 bytes

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

This is based on the comments I made on another C answer to this question about the possibility of using simple bitwise operators. It works by switching all trailing 0 bits to 1 in the statement i|(i-1). Then it switches all trailing 1 bits to 0 using k&(k+1). This will result in a zero if there is only one run of ones and non-zero otherwise. I do make the assumption that long is 64-bit but could correct this at the expense of three bytes by using int64_t instead.

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);
    }
}

Pyth, 20 17 16 bytes

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

Live demo.

Python 2.7, 89 bytes

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

I think this could be golfed a bit.

TI-BASIC, 34 32 30 bytes

For a TI-83+/84+ series calculator.

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

For a number to contain two runs of 1s, it must contain two 10s when we tack a trailing zero onto the binary representation.

Rather than generate the binary representation and check for a 10, we test pairs of bits mathematically by using remainder by 4 (int(4fPart(), which will give 2 where there is a 10. Because we don't care about order, randIntNoRep( is the shortest way to generate the list of exponents.

We use log( to check for the number of runs:

• If there are at least 2 runs, then the log( is positive, and the number is displayed.

• If there is one run, then the log( is 0, and the number is not displayed.

• If there are no runs (which first happens at X=2^Ans), then log( throws an ERR:DOMAIN, stopping the output at exactly the right point.

We use e^(Ans as the ending argument of the For( loop—it's always greater than 2^Ans, but e^( is a single token, so it's one byte shorter.

Input/output for N=4:

4:prgmRUNSONES
               5
               9
              10
              11
              13

Then the calculator throws an error; the error screen looks like this:

ERR:DOMAIN
1:Quit
2:Goto

When 1 is pressed, the home screen is displayed again:

4:prgmRUNSONES
               5
               9
              10
              11
              13
           Error

TI calculators store all numbers in a BCD float with 14 digits of precision, not an int or binary float. Therefore, divisions by powers of two greater than 2^14 may not be exact. While I have verified that the trickiest numbers, 3*2^30-1 and 2^32-1, are handled correctly, I have not ruled out the possibility of rounding errors. I would however be surprised if there were errors for any input.

• this doesnt beat flawr's answer but i couldnt resist the charm of the question

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

execution

4

ans =

5

ans =

9    10    11

ans =

13

principle

• The series of numbers are a result of consequent strip of 1's, which does mean f(n,l)=2^l+2^(l+1)+....2^n

Any number taken from the interval ]f(n,l),f(n,l)+2^(l-1)[ where l>1 verifies this condition, so the outcome is a result of the negation of this series in terms of 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

My program prints the range between each two lines (if exists)

Edit: unfortunately that doesnt make it golfed more but i wanted to add another approach of proceding this idea

after a period of struggle i succeded to find a mathematical representation for this series which is:

2^l(0+1+2^1+...2^k) with l+k < n

=2^l(2^k-1)

score=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))

C, 103 102 bytes

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);}

Expanding (actually contracting) on G.Sliepen entry, taking advantage of xnor remark on the 01 pattern in the binary representation, but using only standard functions and some bit twiddling.

Ungolfed version:

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)
            ;
    }
}

The inner loop scans i for the binary pattern 01 by iteratively shifting x to the right as long as it has 3 bits left. printf returns the number of characters printed, hence never 0, so the inner loop test fails after the printf, avoiding the need for a break statement.

C++, 129 128 bytes

Adapting the same idea, the C++ variant is here:

#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);}

Technically, I should make i a long long to ensure 64 bit operation and compute upto 2^32 for an extra 5 bytes, but modern platforms have 64 bit ints.

JavaScript ES6, 60 bytes

Code

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

Try it online!

Explanation

[...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

C (sort of - compiles with warnings in GCC) - 103

This uses no library functions of any kind except printf. You can see by looking at this that no effort has been spared to make it standards compliant or avoid UB.

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;}}

To make it compliant you would need to do lots of things like including stdio.h which would be against the spirit of making it as small as possible.

If anyone has suggestions for making it shorter please let me know.

PowerShell, 80 bytes

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

Python, 44 Bytes

Okay, this could probably be shorter but it's my first codegolf:

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

Think this answers the question, please don't down vote if it doesn't, just post whats wrong with it below.

another different matlab answer of good score.

matlab 60(57)

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

execution

>> @(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

• The idea is picking up numbers x where the binary representation of -(x)+1 doesnt contain only one occurence of 1

example:

0000111 is rejected because ~x=1111,~x+1=00001 contains one digit=1

0100111 is accepted because ~x=1011,~x+1=0111 contains many 1's