Tarefa

Encontre o conjunto de números de modo que a representação binária contenha duas ou mais execuções 1separadas por pelo menos uma 0.

Por exemplo, para os números com 4 bits:

 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)

Entrada

Um número inteiro fornecido ao aplicativo por meio de alguma entrada no intervalo 3 .. 32. Isso representa o número máximo de bits a serem contados.

A entrada de nindica que os números precisam ser examinados.0 .. 2n-1

Saída

Uma lista delimitada (à sua escolha) de todos os números que atendem aos critérios. Os números devem ser apresentados em ordem numérica. Um delimitador à direita extra é aceitável. Os gabinetes de estrutura de dados (por exemplo, []e similares) também são aceitáveis.

Exemplo

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

Isso é código-golfe - a resposta com a menor quantidade de bytes ganha.

Pitão, 12 bytes

f<2r.BT8U^2Q

Experimente online.

Idéia

A representação binária de qualquer número positivo sempre começa com uma sequência de 1 s, possivelmente seguido por outras, alternando pistas de 0 s e 1 s. Se houver pelo menos três execuções separadas, é garantido que duas delas sejam de 1 s.

Código

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

Eu tinha pensado muito nisso. Só precisamos verificar se a expansão binária contém '01'.

Para que haja duas execuções de uma, a da direita deve ser precedida por a 0. Se houver apenas uma corrida, não haverá líderes 0, e isso não acontecerá.

Resposta antiga:

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

A representação binária do Python funciona muito bem aqui. Um número binário é escrito como bin(9)=='0b10110'. Divisão nos '0'resultados em uma lista de

• Seqüências de caracteres vazias à esquerda da inicial 0, entre duas consecutivas 0e à direita de qualquer final0
• A carta bseguida por um ou mais líderes
• Execuções de 1que não estão liderando

As duas primeiras categorias sempre existem, mas a última só existe se houver uma execução 1que não contenha a liderança '1'e, portanto, somente se houver mais de uma execução 1. Portanto, basta verificar se a lista contém mais do que 2elementos distintos.

O Python 3.5 salva 2 caracteres descompactando {*_}no lugar de set(_).

Ruby, 44 40 38 caracteres

^{riscado 44 ainda é regular 44;}

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

Uma função anônima (proc, na verdade) que pega um número inteiro e retorna uma matriz.

Usa a regex /10+1/: a 1, pelo menos uma 0e depois outra 1. @histocrat ressalta que, se 01houver algum lugar na string, deve haver um 1lugar antes dela.

Julia, 43 41 bytes

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

Isso cria uma função sem nome que aceita um número inteiro e retorna uma matriz. Ele usa o truque de regex dos histocratas (usado na resposta da maçaneta da porta), onde 01só corresponderá se houver um 1 anterior.

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

A idéia é interpretar o número binário como matriz de zeros e uns e calcular a diferença absoluta entre cada par de vizinhos. Se tivermos duas ou mais vezes a diferença de 1, obviamente teremos uma sequência de duas ou mais. Observe que isso só funciona se representarmos o número binário sem zeros à esquerda.

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

Versões antigas:

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 bytes

Caramba, criar intervalos em JS não é fácil. Talvez fosse mais curto com um forloop real . Não, eu menti; na verdade é um pouco mais. Ah bem. Acho que vou ter que me contentar com 27 bytes salvos. (7 agradecimentos a Mwr247!)

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

Funciona corretamente nas versões mais recentes do Firefox, mas provavelmente não em nenhum outro navegador. Experimente:

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

^{(Trecho extraído desta página )}

Sugestões são bem-vindas!

Haskell, 68 61 53 bytes

Melhoria de Damien

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

História:

Isso corrige o erro (Comutado == e = e quadrado em vez da potência de dois). E substitua true por 2> 1 e false por 1> 2. Também graças a salientar que 2 ^ x sempre falha. Obrigado 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]

Originalmente

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 tiver que ser programa 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 bytes

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

Isso cria uma função monádica sem nome que aceita um número inteiro à direita e retorna uma matriz.

Explicação:

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

Economizou 7 bytes graças a Dennis!

R, 55 47 bytes

(com alguma ajuda de @ Alex.A)

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

R não possui uma função integrada para exibir números convertidos de uma maneira conveniente, então estou usando R.utils::intToBinisso, enquanto todo o resto é basicamente apenas relatar o local da expressão de expressão regular correspondente e imprimir em STDOUT enquanto separado por um espaço.

CJam, 14

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

3 bytes mais curtos, graças a Dennis. Experimente online

JavaScript (ES6), 69 68 67 62 bytes

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

Hoje, descobri uma nova maneira mais curta de preencher matrizes dinamicamente sem o uso de preenchimento ou mapa. Doing x=>[...Array(x).keys()]retornará uma matriz do intervalo de 0 a x. Se você deseja definir seu próprio intervalo / valores, use x=>[...Array(x)].map((a,i)=>i), pois são apenas mais alguns bytes.

Java, 214 165 155 154 154 148 141 110 bytes

Esta submissão explora o fato de que uma representação de cadeia binária de um número em Java nunca possui um zero inicial. Se a cadeia "01" aparecer na representação binária de um número, isso deve marcar a segunda ocorrência do número "1".

Golfe:

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
}

Saída do programa (lembre-se, delimitadores à direita são aceitáveis):

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 bytes

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

Experimente online!

12 bytes raspados de graças 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);
  }
}

A função ffsl () fornece o índice do primeiro bit definido em um número inteiro longo. Então, passamos de i = 12 ^ number_of_bits. Definimos o deslocamento xpara a idireita até removermos todos os zero bits consecutivos na extremidade menos significativa. Então, mudamos para a xdireita até removermos todos os 1 bits consecutivos no final menos significativo. Se o resultado ainda for diferente de zero, encontramos uma correspondência.

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 bytes

Isso opera de acordo com princípios semelhantes aos da solução de Dennis, mas com menos recursos internos para aproveitar.

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

Primeiro, gere uma série de tuplas x binárias ( +!x#2) e, em seguida, para cada tupla, encontre todos os pontos em que um dígito não corresponde ao anterior, se tratarmos o -1º elemento da lista como 0 para essa finalidade ( ~0=':'). Nossas soluções são onde duas é menor que a soma de cada contagem de execução. ( &2<+/')

Mostrar cada etapa intermediária é mais claro:

  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 todos juntos:

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

Pega a entrada da linha de comando e usa o -ssinalizador para espaços entre os números de saída.

01NTB_FI,2**a

Bem direto: crie range(2**a)e filtre lambda _: "01" in toBinary(_). Fiquei muito feliz em pensar na 01ideia de forma independente. Não são necessárias aspas 01porque ele digitaliza como um literal numérico (números e seqüências de caracteres são do mesmo tipo no Pip).

Julia, 40 bytes

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

Isso usa uma abordagem um pouco diferente da outra solução Julia - em vez de fazer uma pesquisa por "01" na cadeia de bits, usa alguma matemática para determinar se o número satisfaz a condição.

i$i>>1terá somente nos locais onde o dígito muda de zero para um ou de um para zero. Como tal, deve haver pelo menos três para ialternar entre zero e uma vez o suficiente. count_oneslocaliza o número de unidades e filterremove as que não têm número suficiente.

C ++, 197 188 141 bytes

Nota: isso foi escrito e testado usando o MSVC ++ 2013. Parece que o #includeing <iostream>inclui todos os cabeçalhos C necessários para fazer esse trabalho. Parece também que o código não é mais verdadeiramente C ++, mas a compilação usando C ++ permite esse truque de cabeçalho que reduz o tamanho do código em comparação com a inclusão de vários cabeçalhos em C.

Usar em printfvez de couttambém salva alguns bytes.

Golfe:

#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, mais um para o -Esinalizador em vez de -e.

Obrigado ao xnor pela dica sobre o uso do /01/invés de /10+1/, que salvou dois bytes.

Agradecemos a Dennis pelo conselho de usar, em <>vez de $ARGV[0], que salvou seis 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;}

Isso se baseia nos comentários que fiz em outra resposta C a esta pergunta sobre a possibilidade de usar operadores bit a bit simples. Ele funciona alternando todos os 0 bits à direita para 1 na instrução i | (i-1). Em seguida, alterna todos os 1 bits finais para 0 usando k & (k + 1). Isso resultará em zero se houver apenas uma execução de unidades e diferente de zero. Eu suponho que o comprimento seja de 64 bits, mas poderia corrigir isso às custas de três bytes usando 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);
    }
}

Pitão, 20 17 16 bytes

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

Demonstração ao vivo.

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]

Eu acho que isso poderia ser um pouco de golfe.

TI-BASIC, 34 32 30 bytes

Para uma calculadora da série TI-83 + / 84 +.

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

Para que um número contenha duas execuções de 1s, ele deve conter duas 10 s quando colocamos um zero à direita na representação binária.

Em vez de gerar a representação binária e verificar a 10, testamos pares de bits matematicamente usando o restante por 4 ( int(4fPart(), que fornecerá 2onde existe a 10. Porque nós não nos importamos com ordem, randIntNoRep(é o maneira mais curta de gerar a lista de expoentes.

Usamos log(para verificar o número de execuções:

• Se houver pelo menos 2 execuções, então log(é positivo e o número é exibido.

• Se houver uma execução, então log(será 0 e o número não será exibido.

• Se não houver execuções (o que acontece primeiro em X = 2 ^ Ans), log(lança um ERR: DOMAIN, parando a saída exatamente no ponto certo.

Usamos e^(Anscomo argumento final do For(loop - é sempre maior que 2^Ans, mas e^(é um único token, portanto, é um byte menor.

Entrada / saída para N = 4:

4:prgmRUNSONES
               5
               9
              10
              11
              13

Então a calculadora lança um erro; a tela de erro fica assim:

ERR:DOMAIN
1:Quit
2:Goto

Quando 1 é pressionado, a tela inicial é exibida novamente:

4:prgmRUNSONES
               5
               9
              10
              11
              13
           Error

As calculadoras da TI armazenam todos os números em um flutuador BCD com 14 dígitos de precisão, não um flutuador int ou binário. Portanto, divisões por potências de dois maiores que 2^14podem não ser exatas. Embora tenha verificado que os números mais complicados 3*2^30-1e 2^32-1manipulados corretamente, não descartei a possibilidade de erros de arredondamento. No entanto, ficaria surpreso se houvesse erros para qualquer entrada.

• isso não supera a resposta de flawr, mas eu não pude resistir ao charme da pergunta

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

execução

4

ans =

5

ans =

9    10    11

ans =

13

princípio

• A série de números é o resultado da tira consequente de 1's, o que significa f (n, l) = 2 ^ l + 2 ^ (l + 1) + .... 2 ^ n

Qualquer número retirado do intervalo] f (n, l), f (n, l) + 2 ^ (l-1) [onde l> 1 verifica essa condição, portanto o resultado é resultado da negação desta série em termos de 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...

Qual é o valor de x na equação x + 2 ^ x = 0?

Meu programa imprime o intervalo entre cada duas linhas (se existir)

Edit: infelizmente isso não o torna mais jogado, mas eu queria adicionar outra abordagem para o processo dessa idéia

depois de um período de luta, consegui encontrar uma representação matemática para esta série que é:

2 ^ l (0 + 1 + 2 ^ 1 + ... 2 ^ k) com 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);}

Expandindo (realmente contraindo) na entrada G.Sliepen, aproveitando a observação xnor sobre o 01padrão na representação binária, mas usando apenas funções padrão e algumas correções.

Versão não destruída:

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

O loop interno verifica io padrão binário 01deslocando iterativamente xpara a direita, desde que tenha 3 bits restantes. printfretorna o número de caracteres impressos; portanto, nunca 0, portanto, o teste do loop interno falha após o printf, evitando a necessidade de uma breakdeclaração.

C ++, 129 128 bytes

Adaptando a mesma idéia, a variante C ++ está aqui:

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

Tecnicamente, devo garantir iuma long longoperação de 64 bits e calcular até 2^325 bytes extras, mas as plataformas modernas têm ints de 64 bits.

JavaScript ES6, 60 bytes

Código

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

Experimente online!

Explicação

[...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 (tipo de - compila com avisos no GCC) - 103

Isso não usa funções de biblioteca de qualquer tipo, exceto printf. Você pode ver, olhando para isso, que nenhum esforço foi poupado para torná-lo compatível com os padrões ou evitar 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;}}

Para torná-lo compatível, você precisará fazer várias coisas, incluindo stdio.h, o que seria contrário ao espírito de torná-lo o menor possível.

Se alguém tiver sugestões para torná-lo mais curto, entre em contato.

PowerShell, 80 bytes

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

Python, 44 bytes

Ok, isso provavelmente poderia ser mais curto, mas é o meu primeiro codegolf:

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

Pense que isso responde à pergunta, por favor, não vote abaixo se não, basta postar o que há de errado com isso abaixo.

outra resposta diferente do matlab de boa pontuação.

Matlab 60(57)

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

execução

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

• A idéia é pegar os números x em que a representação binária de - (x) +1 não contém apenas uma ocorrência de1

exemplo:

0000111é rejeitado porque ~ x = 1111, ~ x + 1 = 00001contém um dígito = 1

0100111é aceito porque ~ x = 1011, ~ x + 1 = 0111contém muitos 1's