Tâche

Recherchez l'ensemble de nombres de telle sorte que la représentation binaire contient deux ou plusieurs exécutions 1séparées par au moins une 0.

Par exemple, pour les nombres de 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)

Contribution

Un entier fourni à l'application via une entrée dans la plage 3 .. 32. Cela représente le nombre maximal de bits à compter.

L'entrée de nindique que les chiffres doivent être examinés.0 .. 2n-1

Sortie

Une liste délimitée (au choix) de tous les numéros répondant aux critères. Les chiffres doivent être présentés dans l'ordre numérique. Un délimiteur de fin supplémentaire est acceptable. Les enceintes de structure de données (par exemple []et similaires) sont également acceptables.

Exemple

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

C'est le code-golf - la réponse avec le moins d'octets gagne.

Pyth, 12 octets

f<2r.BT8U^2Q

Essayez-le en ligne.

Idée

La représentation binaire de tout nombre positif commence toujours par une séquence de 1 s, éventuellement suivie par d'autres séquences alternées de 0 s et de 1 s. S'il y a au moins trois cycles séparés, deux d'entre eux sont garantis comme des cycles de 1 s.

Code

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

J'avais largement réfléchi à cela. Nous avons juste besoin de vérifier si l'expansion binaire contient '01'.

Pour qu'il y ait deux séries d'unités, celle de droite doit être précédée d'un 0. S'il n'y a qu'un seul run, il n'y aura pas de premier 0, donc ça n'arrivera pas.

Ancienne réponse:

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

La représentation binaire Python fonctionne très bien ici. Un nombre binaire s'écrit comme bin(9)=='0b10110'. Fractionnement des '0'résultats dans une liste de

• Chaînes vides à gauche de l'initiale 0, entre deux consécutives 0et à droite de toute finale0
• La lettre bsuivie d'un ou plusieurs principaux
• Des pistes 1qui ne mènent pas

Les deux premières catégories existent toujours, mais la dernière n'existe que s'il y en a une 1qui ne contient pas le début '1', et donc seulement s'il y en a plus d'une 1. Il suffit donc de vérifier si la liste contient plus que 2des éléments distincts.

Python 3.5 enregistre 2 caractères en déballant {*_}à la place de set(_).

Rubis, 44 40 38 caractères

^{barré 44 est toujours régulier 44;}

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

Une fonction anonyme (proc, en fait) qui prend un entier et retourne un tableau.

Utilise l'expression régulière /10+1/: a 1, au moins une 0, puis une autre 1. @histocrat souligne que si 01est n'importe où dans la chaîne, il doit y avoir un 1quelque part avant.

Julia, 43 41 octets

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

Cela crée une fonction sans nom qui accepte un entier et renvoie un tableau. Il utilise l'astuce regex des histocrates (utilisée dans la réponse de Doorknob), où 01ne correspondra que s'il y a un 1 précédent.

Non golfé:

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'idée est d'interpréter le nombre binaire comme un tableau de zéros et de uns, puis de calculer la différence absolue entre chaque paire de voisins. Si nous avons deux ou plusieurs fois une différence de 1, alors nous avons évidemment une série de deux ou plus. Notez que cela ne fonctionne que si nous représentons le nombre binaire sans zéros de tête.

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

Anciennes versions:

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 octets

Holy Cow, créer des gammes dans JS n'est pas facile. Ce serait peut-être plus court avec une forboucle réelle . Non, j'ai menti; c'est en fait un peu plus long. Tant pis. Je suppose que je vais devoir me contenter de 27 octets enregistrés. (7 grâce à Mwr247!)

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

Fonctionne correctement dans les dernières versions de Firefox, mais probablement pas dans aucun autre navigateur. Essaye le:

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

^{(Extrait extrait de cette page )}

Bienvenue suggestions!

Haskell, 68 61 53 octets

Amélioration de Damien

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

Histoire:

Cela corrige le bug (Switched == et =, et carré au lieu de la puissance de deux). Et remplacez true par 2> 1 et false par 1> 2. Merci également de souligner que 2 ^ x est toujours un échec. Merci à Thomas Kwa et 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]

À l'origine

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

S'il doit s'agir d'un programme complet,

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 octets

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

Cela crée une fonction monadique sans nom qui accepte un entier à droite et renvoie un tableau.

Explication:

                     }¨⍳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 octets enregistrés grâce à Dennis!

R, 55 47 octets

(avec l'aide de @ Alex.A)

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

R n'a pas de fonction intégrée pour afficher les nombres convertis d'une manière pratique, donc j'utilise R.utils::intToBinpour cela, alors que tout le reste est à peu près simplement signaler l'emplacement de l'expression d'expression rationnelle correspondante et imprimer sur STDOUT tout en étant séparé par un espace.

CJam, 14

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

3 octets plus court grâce à Dennis. Essayez-le en ligne

JavaScript (ES6), 69 68 67 62 octets

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

Aujourd'hui, j'ai découvert un nouveau moyen plus court de remplir dynamiquement des tableaux sans utiliser de remplissage ou de carte. Faire x=>[...Array(x).keys()]retournera un tableau de plage de 0 à x. Si vous souhaitez définir votre propre plage / valeurs, utilisez x=>[...Array(x)].map((a,i)=>i), car elle ne fait que quelques octets de plus.

Java, 214 165 155 154 154 148 141 110 octets

Cette soumission exploite le fait qu'une représentation sous forme de chaîne binaire d'un nombre en Java n'a jamais de zéro de tête. Si la chaîne "01" apparaît dans la représentation binaire d'un nombre, cela doit marquer la deuxième occurrence du nombre "1".

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

Non golfé:

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
}

Sortie du programme (rappelez-vous, les délimiteurs de fin sont acceptables):

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 octets

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

Essayez-le en ligne!

12 octets rasés grâce à @ceilingcat!

Non golfé:

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 fonction ffsl () vous donne l'index du premier bit qui est défini dans un entier long. Nous bouclons donc de i = 1à 2 ^ nombre_de_bits. Nous avons défini xle idécalage vers la droite jusqu'à ce que nous ayons supprimé tous les bits zéro consécutifs à l'extrémité la moins significative. Ensuite, nous décalons vers la xdroite jusqu'à ce que nous ayons supprimé tous les bits 1 consécutifs à l'extrémité la moins significative. Si le résultat n'est toujours pas nul, nous avons trouvé une correspondance.

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 octets

Cela fonctionne selon des principes similaires à ceux de la solution de Dennis, mais avec moins de fonctionnalités intégrées à exploiter.

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

Tout d'abord, générez une série de x-tuples binaires ( +!x#2), puis pour chaque tuple, trouvez chaque point qu'un chiffre ne correspond pas au précédent si nous traitons le -1e élément de la liste comme 0 à cet effet ( ~0=':'). Nos solutions sont là où deux est inférieur à la somme de chaque nombre d'exécutions. (&2<+/' ).

Montrer chaque étape intermédiaire est plus clair:

  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

Et tous ensemble:

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

Prend l'entrée de la ligne de commande et utilise l' -sindicateur pour les espaces entre les numéros de sortie.

01NTB_FI,2**a

Assez simple: construire range(2**a)et filtrer lambda _: "01" in toBinary(_). J'étais assez content de penser l' 01idée de façon indépendante. Aucun guillemet n'est nécessaire 01car il scanne comme un littéral numérique (les nombres et les chaînes sont du même type dans Pip).

Julia, 40 octets

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

Cela utilise une approche quelque peu différente de l'autre solution Julia - plutôt que de faire une recherche de chaîne pour "01" dans la chaîne de bits, elle utilise des mathématiques pour déterminer si le nombre satisfait la condition.

i$i>>1n'en aura que dans les endroits où le chiffre passe de zéro à un, ou de un à zéro. En tant que tel, il doit y en avoir au moins trois pour ibasculer entre zéro et une fois suffisamment. count_onestrouve le nombre de ceux, puis filtersupprime ceux qui n'en ont pas assez.

C ++, 197 188 141 octets

Remarque: cela a été écrit et testé à l'aide de MSVC ++ 2013. Il semble que #includeing<iostream> inclut tous les en-têtes C nécessaires pour que cela fonctionne. Il semble également que le code ne soit plus vraiment C ++, mais la compilation à l'aide de C ++ permet cette astuce d'en-tête qui réduit la taille du code par rapport à l'inclusion de plusieurs en-têtes C.

Utiliser printfau lieu de coutpermet également d'économiser quelques octets.

Golfé:

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

Non golfé:

#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 octets

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

54 52 48 46 40 octets, plus un pour le -Edrapeau au lieu de -e.

Merci à xnor pour l'astuce d'utiliser /01/au lieu de /10+1/, qui a économisé deux octets.

Merci à Dennis pour les conseils à utiliser <>au lieu de $ARGV[0], ce qui a permis d'économiser six octets.

C, 84 81 octets

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

Ceci est basé sur les commentaires que j'ai faits sur une autre réponse C à cette question sur la possibilité d'utiliser de simples opérateurs au niveau du bit. Il fonctionne en commutant tous les bits de fin 0 à 1 dans l'instruction i | (i-1). Ensuite, il passe tous les bits de fin 1 à 0 en utilisant k & (k + 1). Cela se traduira par un zéro s'il n'y a qu'une seule série de uns et différent de zéro sinon. Je fais l'hypothèse que long est 64 bits, mais je pourrais corriger cela au détriment de trois octets en utilisant int64_t à la place.

Non golfé

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 octets

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

Démo en direct.

Python 2.7, 89 octets

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

Je pense que cela pourrait être un peu joué au golf.

TI-BASIC, 34 32 30 octets

Pour une calculatrice de la série TI-83 + / 84 +.

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

Pour qu'un nombre contienne deux séries de 1, il doit contenir deux 10s lorsque nous plaçons un zéro de fin sur la représentation binaire.

Plutôt que de générer la représentation binaire et de vérifier a 10, nous testons mathématiquement des paires de bits en utilisant le reste de 4 ( int(4fPart(), ce qui donnera2 où il y a a 10. Parce que nous ne nous soucions pas de l'ordre, randIntNoRep(est le moyen le plus court de générer la liste des exposants.

Nous utilisons log(pour vérifier le nombre d'exécutions:

• S'il y a au moins 2 exécutions, le log(est positif et le nombre s'affiche.

• S'il y a un essai, le log( est 0 et le nombre ne s'affiche pas.

• S'il n'y a pas de parcours (ce qui se produit d'abord à X = 2 ^ Ans), alors log( lance un ERR: DOMAIN, arrêtant la sortie exactement au bon point.

Nous utilisons e^(Anscomme argument de fin de la For(boucle - il est toujours supérieur à2^Ans , mais e^(c'est un seul jeton, donc c'est un octet plus court.

Entrée / sortie pour N = 4:

4:prgmRUNSONES
               5
               9
              10
              11
              13

Ensuite, la calculatrice lance une erreur; l'écran d'erreur ressemble à ceci:

ERR:DOMAIN
1:Quit
2:Goto

Lorsque vous appuyez sur 1, l'écran d'accueil s'affiche à nouveau:

4:prgmRUNSONES
               5
               9
              10
              11
              13
           Error

Les calculatrices TI stockent tous les nombres dans un flottant BCD avec 14 chiffres de précision, pas un flottant int ou binaire. Par conséquent, les divisions par des pouvoirs de deux supérieurs à 2^14peuvent ne pas être exactes. Même si j'ai vérifié que les nombres les plus délicats 3*2^30-1et 2^32-1sont correctement gérés, je n'ai pas exclu la possibilité d'erreurs d'arrondi. Je serais cependant surpris s'il y avait des erreurs pour toute entrée.

• cela ne bat pas la réponse de flawr mais je ne pouvais pas résister au charme de la 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

exécution

4

ans =

5

ans =

9    10    11

ans =

13

principe

• La série de nombres est le résultat d'une bande de 1 conséquente, ce qui signifie que f (n, l) = 2 ^ l + 2 ^ (l + 1) + .... 2 ^ n

N'importe quel nombre pris dans l'intervalle] f (n, l), f (n, l) + 2 ^ (l-1) [où l> 1 vérifie cette condition, donc le résultat est le résultat de la négation de cette série dans termes 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...

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

Mon programme imprime la plage entre chacune des deux lignes (si elle existe)

Edit: malheureusement, cela ne le rend pas plus golfé mais je voulais ajouter une autre approche de la procédure

après une période de lutte, j'ai réussi à trouver une représentation mathématique pour cette série qui est:

2 ^ l (0 + 1 + 2 ^ 1 + ... 2 ^ k) avec 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 octets

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

Expansion (en fait contractante) sur l'entrée G.Sliepen, profitant de la remarque xnor sur le 01modèle dans la représentation binaire, mais en utilisant uniquement des fonctions standard et un peu de twiddling.

Version non golfée:

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

La boucle interne recherche ile motif binaire 01en se déplaçant itérativement xvers la droite tant qu'il reste 3 bits. printfrenvoie le nombre de caractères imprimés, donc jamais 0, donc le test de la boucle interne échoue après le printf, évitant ainsi la nécessité d'une breakinstruction.

C ++, 129 128 octets

Adaptant la même idée, la variante C ++ est ici:

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

Techniquement, je devrais faire iun long longpour assurer un fonctionnement 64 bits et calculer jusqu'à 2^325 octets supplémentaires, mais les plates-formes modernes ont des entrées 64 bits.

JavaScript ES6, 60 octets

Code

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

Essayez-le en ligne!

Explication

[...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 (en quelque sorte - compile avec les avertissements dans GCC) - 103

Cela n'utilise aucune fonction de bibliothèque d'aucune sorte, sauf printf. Vous pouvez voir en regardant cela qu'aucun effort n'a été épargné pour le rendre conforme aux normes ou éviter l'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;}}

Pour le rendre conforme, vous devrez faire beaucoup de choses comme inclure stdio.h, ce qui serait contraire à l'esprit de le rendre aussi petit que possible.

Si quelqu'un a des suggestions pour le raccourcir, faites-le moi savoir.

PowerShell, 80 octets

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

Python, 44 octets

D'accord, cela pourrait probablement être plus court mais c'est mon premier codegolf:

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

Pensez que cela répond à la question, veuillez ne pas voter contre si ce n'est pas le cas, affichez simplement ce qui ne va pas ci-dessous.

une autre réponse matlab différente de bon score.

matlab 60(57)

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

exécution

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

• L'idée est de prendre des nombres x où la représentation binaire de - (x) +1 ne contient pas une seule occurrence de1

Exemple:

0000111est rejeté car ~ x = 1111, ~ x + 1 = 00001contient un chiffre = 1

0100111est accepté car ~ x = 1011, ~ x + 1 = 0111contient plusieurs 1