La séquence Baum-Sweet (A086747 avec une torsion)

Prenez un entier positif net imprimez les entiers de 1 à n pour lesquels la séquence Baum-Sweet renvoie vrai. La séquence Baum-Sweet devrait retourner la fausse si la représentation binaire du nombre contient un nombre impair de zéros consécutifs n'importe où dans le nombre, et vrai sinon. Pour plus d'informations, cliquez sur le lien. Voici quelques exemples:

1 -> 1 -> Truthy
2 -> 10 -> Falsy
3 -> 11 -> Truthy
4 -> 100 -> Truthy (Even run of zeros)

Voici un exemple donné n=32

Étape 1: La séquence Baum-Sweet visualisée pour n=32

1               1 (1)
1 0             0 (2)
11              1 (3)
1 00            1 (4)
1 0 1           0 (5)
11 0            0 (6)
111             1 (7)
1 000           0 (8)
1 00 1          1 (9)
1 0 1 0         0 (10)
1 0 11          0 (11)
11 00           1 (12)
11 0 1          0 (13)
111 0           0 (14)
1111            1 (15)
1 0000          1 (16)
1 000 1         0 (17)
1 00 1 0        0 (18)
1 00 11         1 (19)
1 0 1 00        0 (20)
1 0 1 0 1       0 (21)
1 0 11 0        0 (22)
1 0 111         0 (23)
11 000          0 (24)
11 00 1         1 (25)
11 0 1 0        0 (26)
11 0 11         0 (27)
111 00          1 (28)
111 0 1         0 (29)
1111 0          0 (30)
11111           1 (31)
1 00000         0 (32)

Donc, après avoir calculé la séquence de Baum-Sweet pour n, prenez les nombres qui étaient véridiques pour la séquence et recueillez-les pour le résultat final. Car n=32nous aurions:

[1, 3, 4, 7, 9, 12, 15, 16, 19, 25, 28, 31]

Comme réponse finale.

Il s'agit du code-golf , le nombre d'octets le plus court gagne.

05AB1E , 10 9 octets

Un octet enregistré grâce à Adnan

ƒNb00¡SP–

Essayez-le en ligne!

Explication

ƒ          # for N in [0 ... input]
 Nb        # convert N to binary
   00¡     # split at "00"
      S    # convert to list of digits
       P   # product of list
        –  # if 1, print N

JavaScript (ES6), 70 68 63 octets

g=n=>n?g(n-1).concat(/0/.test(n.toString(2).split`00`)?[]:n):[]

console.log(g(1000).join(", "))

Solution récursive légèrement plus intéressante:

n=>[...Array(n+1).keys()].filter(f=n=>n<2?n:n%4?n&f(n>>1):f(‌​n/4))

67 octets grâce à @Neil.

g est la fonction à appeler.

Python 2, 62 octets

g=lambda n:n*[0]and g(n-1)+[n]['0'in`bin(n)[1:].split('00')`:]

Vérifie les exécutions impaires de 1 dans la représentation binaire en se séparant 00et en vérifiant s'il reste des zéros dans la représentation sous forme de chaîne de la liste résultante. Chose ennuyeuse, les nombres binaires commencent par 0b, qui a un zéro qui doit être supprimé pour éviter un faux positif.

L'énumération se fait par récurrence.

Frapper, 58, 46 octets

MODIFICATIONS:

• Remplacée bc avec dc (Thx @Digital Trauma!)
• Commencez par 1;

Golfé

seq $1|sed 'h;s/.*/dc -e2o&p/e;s/00//g;/0/d;x'

Tester

>./baum 32
1 
3
4
7 
9
12
15
16
19
25
28
31

Expliqué

coquille

seq $1 #generate a sequence of integers from 1 to N, one per line
|sed   #process with sed

sed

h                #Save input line to the hold space
s/.*/dc -e2o&p/e #Convert input to binary, with dc
s/00//g          #Remove all successive pairs of 0-es
/0/d             #If there are still some zeroes left
                 #(i.e. there was at least one odd sequence of them)
                 #drop the line, proceed to the next one
x                #Otherwise, exchange the contents of the hold 
                 #and pattern spaces and (implicitly) print

Essayez-le en ligne!

Lot, 143 octets

@for /l %%i in (1,1,%1)do @call:c %%i
@exit/b
:c
@set/ai=%1
:l
@if %i%==1 echo %1&exit/b
@set/ar=%i%%%4,i/=4-r%%2*2
@if %r% neq 2 goto l

Perl 6 , 40 octets

{grep {.base(2)!~~/10[00]*[1|$]/},1..$_}

Essayez-le

{
  grep            # find all of them
  {
    .base(2)      # where the binary representation
    !~~           # does not match
    /
      10          # ｢10｣
      [ 00 ]*     # followed by an even number of ｢0｣s
      [ 1 | $ ]   # either at end or before a ｢1｣
    /
  }, 1 .. $_      # from one to the input
}

( []sont utilisés pour le regroupement sans capture, avec <[]>pour les classes de caractères)

PowerShell , 79 61 octets

1..$args[0]|?{0-notin([convert]::ToString($_,2)-split'1|00')}

Essayez-le en ligne!

J'ai eu l'inspiration ce matin pour changer la façon -splitdont j'exécute l' opération, puis je vois que c'est similaire à la façon dont la réponse de xnor est construite, alors, je suppose que les grands esprits pensent de la même façon?

Nous effectuons une boucle du 1haut vers l'entrée $args[0]et utilisons un Where-Objectopérateur pour extraire les nombres appropriés |?{...}. La clause est une simple valeur booléenne - nous nous assurons que 0c'est -notinle résultat de (...).

À l'intérieur des parens, nous avons [convert]::le nombre actuel $_ ToStringavec la base 2(c'est-à-dire, le transformer en une chaîne binaire). Nous avons ensuite -splitla chaîne sur l'expression régulière 1|00- c'est une correspondance gourmande, et se traduit par un tableau de chaînes (par exemple, 100010se transformerait en '','','0','','0'et ainsi de suite).

Ainsi, si chaque série de 0s dans la chaîne binaire est même ( ce qui signifie l'expression régulière leur a divisé en plusieurs chaînes vides), puis 0sera -notinle résultat, de sorte que la Whereclause est vrai, et le nombre est sélectionné. Ces chiffres sont laissés sur le pipeline et la sortie est implicite.

Python 2 , 67 47 octets

f=lambda n,k=1:n/k*[1]and[k]+f(n,k-~k)+f(n,4*k)

Merci à @xnor d'avoir joué au golf sur 20 (!) Octets!

Renvoie une liste non ordonnée. C'est assez efficace: l'entrée 100 000 prend environ 40 ms sur TIO.

Essayez-le en ligne!

Mathematica, 59 octets

Select[Range@#,!Or@@OddQ/@Tr/@Split[1-#~IntegerDigits~2]&]&

Réponse mathématique numéro 4 ...

MATL , 12 11 octets

:"@BY'og)?@

Essayez-le en ligne!

Explication

Pour détecter si un nombre est valide, celui-ci est converti en binaire, applique un encodage de longueur d'exécution, conserve uniquement les exécutions de longueur impaire et vérifie si aucune exécution de zéros ne survit.

:       % Take input n implicitly. Push range [1 2 ... n]
"       % For each k in [1 2 ... n]
  @     %   Push k
  B     %   Convert to binary
  Y'    %   Run-length encoding. Pushes array of values and array of run-lengths
  o     %   Parity. Gives array that contains 0 for even lengths, 1 for odd
  g)    %   Convert to logical and use index into the array of values
  ?     %   If the result does not contain zeros
    @   %     Push k
        %   End
        % End
        % Implicitly display stack 

R, 75 octets

for(i in 1:scan()){x=rle(miscFuncs::bin(i));if(!any(x$l%%2&!x$v))cat(i,"")}

Lit l'entrée de stdin et utilise la binfonction du miscFuncspackage pour convertir du vecteur décimal en vecteur binaire. Effectue donc un codage de longueur d'exécution pour vérifier les valeurs == 0et les longueurs sont impaires.

Empilé , 69 octets

Essayez-le ici!

:>1+[bits{e.b:e b 0#=}chunkby[0 has]filter$sizemap 2%0 eq all]"filter

Ou, non compétitif à 67 octets:

:>1+[bits{e.b:e b 0#=}chunkby[0 has]filter$sizemap even all]"filter

Et, encore plus non compétitif à 49 octets:

:>1+[bits rle{k:k 0=}filter values even all]fkeep

Tous prennent l'entrée comme TOS et laissent la sortie sur TOS.

Explication

:>1+[...]"filter   input: n
:>                 range from [0, n)
  1+               range from [1, n]
    [...]          a function
         "filter   apply to each cell and filter

La fonction:

bits{e.b:e b 0#=}chunkby[0 has]filter$sizemap 2%0 eq all  input: c
bits                                                      convert c to binary
    {e.b:e b 0#=}chunkby                                  split into chunks of contiguous 0s
                        [0 has]filter                     take only chunks with 0s
                                     $sizemap             map each chunk to its size
                                              2%          vectorized modulus 2
                                                0 eq      vectorized equality with 0
                                                     all  all of them are of even lengths

Explication de la non concurrence:

C'est la même chose que ci-dessus, avec quelques différences clés:

:>1+[bits rle{k:k 0=}filter values even all]fkeep   input: y
          rle                                       run length encode y
             {k:k 0=}filter                         keep keys that = 0
                            values                  get those values
                                            fkeep   like `filter`, but is implemented with
                                                    taking `f` as a boolean mask

Befunge, 84 51 49 octets

Après un peu d'expérimentation, j'ai réalisé que je pouvais faire un peu mieux que ma solution d'origine en utilisant une technique similaire à la réponse par lots que Neil a proposée .

<v::\<&1
:_v#:/+2*2!%2:_v#-2%4
:$<@_v#!:-1\+1$<:.

Essayez-le en ligne!

Comme avec ma solution d'origine, il y a deux boucles - la boucle externe itérant sur les nombres que nous voulons tester, et une boucle interne testant la séquence de bits pour chaque nombre. Le fonctionnement du test consiste à examiner deux bits à la fois (modulo 4 de la valeur actuelle). Si c'est égal à 2, nous avons une séquence étrange de zéros et pouvons abandonner la boucle intérieure et passer au numéro suivant.

Si le modulo 4 n'est pas égal à 2, nous devons continuer à tester les bits restants, donc nous remontons les bits qui ont déjà été testés. Cela se fait en divisant la valeur, appelons-la n , par2+2*!(n%2) . Cela signifie que si le premier bit était un 1, nous divisons par 2 (en supprimant ce 1 bit), mais si c'était un 0, nous divisons par 4, donc nous supprimerons toujours des paires de zéros.

Si nous finissons par descendre à zéro, cela signifie qu'il n'y avait pas de séquences impaires de zéro bit, nous écrivons donc le nombre.

Visual Basic (.net 4.5) 163 octets

Répondez d'abord ici, donc je suis sûr que j'ai foiré quelque chose. Faites le moi savoir et je réparerai. Les lambdas Visual Basic sont-ils même autorisés?

Merci à MamaFunRoll pour l'idée de supprimer les zéros consécutifs

Dim R=Sub(m)System.Console.WriteLine(String.Join(",",System.Linq.Enumerable.Range(1, m).Where(Function(s) Not Convert.ToString(s,2).Replace("00","").Contains(0))))

Sorties R (32)

1,3,4,7,9,12,15,16,19,25,28,31

Java, 144 130 128 octets

Ce n'est pas aussi golfé que je pense que cela peut être, mais je pensais que ce serait une solution mignonne d'utiliser une Regex, même si je n'en avais jamais utilisé.

Golfé:

static String a(int n){String s="";for(Integer i=0;i++<n;)if(i.toString(i,2).replaceAll("00|1","").isEmpty())s+=i+" ";return s;}

Non golfé:

static String a(int n){
    String s="";                      //Cheaper than using a list/array
    for(Integer i=0;i++<n;)           //Loop n times
        if(i.toString(i,2)            //Convert int to base 2 string
                .replaceAll("00|1","")//Find and remove ones and consecutive zeroes
                .isEmpty())           //If any chars remain, i is truthy
            s+=i+" ";                 //Append i to the storage string
    return s;                         //Return all values
}

Edit: j'ai pu économiser 14 octets en créant l'expression régulière 00 | 1 au lieu de 00, et en supprimant ".replace (" 1 "," ")" entre replaceAll et isEmpty!

Edit 2: J'ai pu enregistrer 2 octets en faisant i un entier et en référençant Integer.toString avec i.toString.

Clojure, 103 octets

Je ne pense pas que ce soit le chemin le plus court ...

#(remove(fn[v]((set(map(fn[s](mod(count s)2))(re-seq #"0+"(Integer/toString v 2))))1))(range 1(inc %)))

Utilise re-seqpour trouver des zéros consécutifs, mappe leurs longueurs modulo-2 à a set, les élimine si un nombre 1est trouvé dans l'ensemble.

Wonder , 38 octets

@(!>@=1len iO0Rstr#["00"]bn#0)rng1+1#0

Usage:

(@(!>@=1len iO0Rstr#["00"]bn#0)rng1+1#0) 32

Explication

Plus lisible:

@(
  fltr@
    = 1 
      len 
        iO 0 
          Rstr #["00"] 
            bn #0
) rng 1 +1 #0

rng 1 +1 #0: Plage de 1 à l'entrée.

fltr@ ...: Plage de filtrage avec le prédicat suivant.

bn #0: Convertit l'élément actuel en binaire. (Cela aura un début 0b).

Rstr #["00"]: Taille récursivement toutes les occurrences de 00dans la chaîne.

len iO 0: Comptez les quantités de 0s dans la chaîne.

=1: Vérifiez si le montant est égal à 1. Si le seul 0reste dans la chaîne après l'élagage est en tête 0b, cela renvoie vrai; sinon, cela renvoie faux.

Rubis, 78 69 68 octets

->n{(1..n).select{|m|m.to_s(s=2).split(?1).map{|i|s|=i.size};s&1<1}}

Versions plus anciennes:

->n{(1..n).select{|m|m.to_s(2).split(?1).select{|i|i.size%2>0}[0].!}}
->n{(1..n).select{|m|b=z=0;(m.to_s(2)+?1).each_char{|i|z+=i>?0?b|=z:1};b&1<1}}

Mathematica, 81 octets

Select[Range@#,FreeQ[Union@#+Mod[Length@#,2,1]&/@Split[#~IntegerDigits~2],{1}]&]&

Calcule, pour chaque série de chiffres consécutifs d'un nombre, {le chiffre commun de cette série plus (1 si la longueur est impaire, 2 si la longueur est paire)}; si l'une des réponses est {1}, le nombre n'est pas dans la séquence.

Mathematica, 75 octets

Select[Range@#,And@@EvenQ/@Length/@Cases[Split[#~IntegerDigits~2],{0..}]&]&

#~IntegerDigits~2calcule la liste des chiffres binaires de l'entrée #. Splitcette liste en séries d'éléments identiques, prenez la Casescorrespondance {0..}, prenez celle Lengthde chacun, prenez EvenQles longueurs, puis retournez Andles résultats.

Python 3, 86 82 octets

Golf en cours ...

lambda n:[x for x in range(1,n+1)if 1-any(i%2for i in map(len,bin(x).split('1')))]

Golfé de 4 octets en changeant bin(x)[2:]en juste bin(x)- cela laisse 0bau début de la chaîne, mais j'ai réalisé que cela n'affecte pas réellement les calculs :)

Python, 142 octets

C'est principalement juste pour pratiquer le golf sur mon Python.

def o(n):
 r=0
 for i in bin(n)[2:]:
  if i=='1':
   if r&1:return 0
   r=0
  else:r+=1
 return ~r&1
lambda n:[i for i in range(1,n+1)if o(i)]

Gelée , 10 octets

2ṗx"`ḂḄf@R

Terriblement inefficace. Essayez-le en ligne!

Rubis, 54 53 48 octets

->n{(1..n).reject{|x|x.to_s(2)=~/10(00)*(1|$)/}}

Je ne pensais pas que l'expression régulière de cela allait être assez basique.

modifier 1: changé pour rejeter pour se débarrasser de la négation pour -1.

édition 2: basculé matchsur =~-5.

C # 159 157 155 octets

Enregistré 2 x deux octets grâce à TuukkaX.

Remarque: imprime les encres dans l'ordre inverse.

void B(int n){var b=Convert.ToString(n,2);int c=0,i=0;for(;i<b.Length;){if(b[i++]<49)c++;else if(c%2>0)break;}if(c%2<1)Console.WriteLine(n);if(n>1)B(--n);}

Explication:

void B(int n)
{
    // convert our int to a binary string
    var b = Convert.ToString(n, 2);

    // set our '0' counter 'c' and our indexer 'i' 
    int c = 0, i = 0;

    // loop over the binary string, without initialisation and afterthought
    for (; i < b.Length;)
    {
        // check for '0' (48 ASCII) and increment i. increment c if true
        if (b[i++] < 49)
            c++;

        // otherwise check if c is odd, and break if it is
        else if (c%2 > 0)
            break;
    }

    // print the int if c is even
    if (c%2 < 1)
        Console.WriteLine(n);

    // recursively call B again with the next number
    if (n > 1)
        B(--n);
}

Mathematica, 69 octets

Select[Range@#,FreeQ[#~IntegerDigits~2//.{x___,0,0,y___}:>{x,y},0]&]&

La même longueur:

Select[Range@#,#~IntegerString~2~StringDelete~"00"~StringFreeQ~"0"&]&

Rubis, 53 octets

->n{(1..n).each{|n|p n if n.to_s(2).count(?0).even?}}

Gelée, 15 13 10 octets

enregistré deux octets après avoir regardé d'autres réponses, encore 3 octets grâce à Dennis

Bœṣ0,0Ȧµ€T

Explication

Bœṣ0,0Ȧµ€T -Helper link: argument K (integer): ex. 24
B          -Convert K to a list of its binary digits: 24 -> [1,1,0,0,0]
   0,0     -Create a list of two 0's: [0,0]
 œṣ        -Split the binary digits on instances of the sublist: [1,1,0,0,0]-> [[1,1],[0]]
      Ȧ    -Any and All: Check if our list has any falsy values or is empty
       µ   -Take all our previous atoms and wrap them into one monad.
        €  -Map this new monad over a list. Since our input is an integer, this implicitly maps it over the range [1..N] (Like the 'R' atom)
         T -Get the indices of all truthy values (1's)