Baum-Sweetシーケンス（A086747ツイスト付き）

正の整数nを受け取り、Baum-Sweetシーケンスがtrueを返す1〜nの整数を出力します。Baum-Sweetシーケンスは、数値のバイナリ表現に数値の任意の場所に奇数の連続したゼロが含まれている場合は偽を返し、それ以外の場合は真実を返します。詳細については、リンクをクリックしてください。次に例を示します。

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

以下に例を示します n=32

ステップ1：視覚化されたBaum-Sweetシーケンス 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)

そのため、nのBaum-Sweetシーケンスを計算した後、シーケンスの真理である数値を取得し、最終結果のためにそれらを収集します。以下のためのn=32私たちが持っているでしょう：

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

最後の答えとして。

これはcode-golfで、最短のバイトカウントが優先されます。

05AB1E、10 9バイト

Adnanのおかげで1バイト節約

ƒNb00¡SP–

オンラインでお試しください！

説明

ƒ          # 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バイト

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

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

少し興味深い再帰的なソリューション：

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

@Neilのおかげで67バイト。

g 呼び出す関数です。

Python 2、62バイト

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

00結果のリストの文字列表現にゼロが残っているかどうかをチェックすることにより、バイナリ表現で1の奇数の実行をチェックします。厄介なことに、2進数はで始まりますが0b、これにはゼロがあり、誤検出を防ぐために削除する必要があります。

列挙は下に再帰的に行われます。

バッシュ、 58、46バイト

編集：

• bcをdcに置き換え（Thx @Digital Trauma！）
• 1から始めます。

ゴルフ

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

テスト

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

説明した

シェル

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

オンラインでお試しください！

バッチ、143バイト

@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バイト

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

それを試してみてください

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

（文字クラスに[]使用される、非キャプチャグループに<[]>使用されます）

PowerShell、79 61バイト

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

オンラインでお試しください！

今朝、私は-split手術のやり方を変えるためにインスピレーションを得ましたが、それはxnorの答えがどのように構築されるかと似ていることがわかります。

1入力から入力までループし$args[0]、Where-Object演算子を使用して適切な数値を引き出します|?{...}。句は単純なブール値です。これ0が-notinの結果であることを確認しています(...)。

括弧の中では[convert]::、現在の数値$_ ToStringを基数とともに2（つまり、バイナリ文字列に変換して）います。次に-split、正規表現の文字列1|00-これは貪欲な一致であり、文字列の配列になります（たとえば、などに100010なります'','','0','','0'）。

したがって、0バイナリ文字列内のsのすべての実行が偶数である場合（正規表現によって空文字列に分割されていることを意味0する場合）-notin、結果が得られるため、Where句がtrueになり、番号が選択されます。これらの数値はパイプラインに残り、出力は暗黙的です。

Pythonの2、67の 47バイト

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

20（！）バイトのゴルフをする@xnorに感謝します！

順序付けられていないリストを返します。これは非常に効率的です。TIOでは100,000を入力すると約40ミリ秒かかります。

オンラインでお試しください！

Mathematica、59バイト

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

Mathematica回答番号4 ...

MATL、12 11バイト

:"@BY'og)?@

オンラインでお試しください！

説明

数値が有効かどうかを検出するために、これはバイナリに変換し、ランレングスエンコーディングを適用し、奇数長のランのみを保持し、ゼロのランが残っていないかどうかをチェックします。

:       % 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バイト

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

stdinから入力を読み取りbin、miscFuncsパッケージの関数を使用して10進数から2進数のベクトルに変換します。その結果、ランレングスエンコーディングを実行して値をチェックし== 0、長さが奇数です。

積み上げ、69バイト

ここで試してみてください！

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

または、67バイトで競合しない：

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

そして、49バイトでさらに競合しない：

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

すべてが入力をTOSとして受け取り、出力をTOSに残します。

説明

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

関数：

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

非競合の説明：

上記と同じですが、いくつかの重要な違いがあります。

:>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バイト

少し実験を重ねた結果、Neilが思いついたバッチアンサーに似た手法を使用することで、元のソリューションよりもかなり良いことができることに気付きました。

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

オンラインでお試しください！

私の元のソリューションと同様に、2つのループがあります。外側のループはテストする数値を反復処理し、内側のループは各数値のビットシーケンスをテストします。テストの動作方法は、一度に2ビット（現在の値のモジュロ4）を調べることです。2に等しい場合、ゼロの奇数シーケンスがあり、内部ループを中止して次の番号に進むことができます。

モジュロ4が2に等しくない場合、残りのビットのテストを続行する必要があるため、既にテストされたビットをシフトアップします。これは、値を除算することによって行われ、それをnで呼び出すことができます2+2*!(n%2)。つまり、最初のビットが1の場合、2で除算（その1ビットをドロップ）しますが、0の場合、4で除算するため、常にゼロのペアをドロップします。

最終的にゼロになった場合、それはゼロビットの奇数シーケンスがなかったことを意味するため、数値を書き出します。

Visual Basic（.net 4.5）163バイト

ここで最初に答えてください。だから私は何かを台無しにしたと確信しています。お知らせください。修正します。Visual Basicラムダも許可されていますか？

連続ゼロの削除のアイデアを提供してくれたMamaFunRollに感謝

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

R（32）出力

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

Java、144 130 128バイト

これは考えられるほどゴルフではありませんが、正規表現を使用したことがないにもかかわらず、正規表現を使用するのはかわいい解決策だと思いました。

ゴルフ：

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

ゴルフをしていない：

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
}

編集： 00の代わりに正規表現00 | 1を作成し、replaceAllとisEmptyの間に ".replace（" 1 "、" "）"を削除することにより、14バイトを節約できました！

編集2： iを整数にしてi.toStringでInteger.toStringを参照することで2バイト節約できました。

Clojure、103バイト

私はこれが最短の方法ではないと思います...

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

re-seq連続したゼロを見つけるために使用し、モジュロ2の長さをaにマッピングし、セットからset数値1が見つかった場合にそれらを破棄します。

ワンダー、38バイト

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

使用法：

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

説明

より読みやすい：

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

rng 1 +1 #0：1から入力までの範囲。

fltr@ ...：次の述語によるフィルター範囲。

bn #0：現在のアイテムをバイナリに変換します。（これには一流の0b）。

Rstr #["00"]：の発生を再帰的に除去します 00文字列内のします。

len iO 0：の量を数える 0文字列内 sます。

=1：量が1に等しいかどうかを確認します。0枝刈り後の文字列の唯一の左側が先頭にある0b場合、これはtrueを返します。それ以外の場合、これはfalseを返します。

ルビー、 78 69 68バイト

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

古いバージョン：

->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バイト

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

数値内の連続した数字の各実行に対して、{その実行の共通の数字に加えて（長さが奇数の場合は1、長さが偶数の場合は2）}を計算します。回答のいずれかが{1}の場合、番号はシーケンスに含まれていません。

Mathematica、75バイト

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

#~IntegerDigits~2入力の2進数のリストを計算します#。Splitそのリストを同一の要素の実行に分け、Casesその一致{0..}を取得しLength、それぞれの要素を取得しEvenQ、長さを取得しAnd、結果を返します。

Python 3、86 82バイト

進行中のゴルフ...

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

ジャストに変更bin(x)[2:]することで4バイトオフbin(x)-これ0bは文字列の先頭に残りますが、実際には計算に影響しないことに気付きました:)

Python、142バイト

これは主に私の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)]

ゼリー、10バイト

2ṗx"`ḂḄf@R

ひどく非効率的。オンラインでお試しください！

ルビー、54 53 48バイト

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

これの正規表現が非常に基本的なものになるとは思いませんでした。

編集1： -1の否定を取り除くために拒否に切り替えました。

編集2： -5に切り替えmatchまし=~た。

C＃159 157 155バイト

TuukkaXのおかげで2 x 2バイトを節約できました。

注：intを逆の順序で出力します。

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

説明：

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バイト

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

同じ長さ：

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

ルビー、53バイト

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

ゼリー、15 13 10バイト

他の回答を見た後、2バイト節約しました。デニスのおかげでさらに3バイト節約しました

Bœṣ0,0Ȧµ€T

説明

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)