Baum-Sweet序列（带有扭曲的A086747）

接受一个正整数，n并打印从1到n的整数，其中Baum-Sweet序列将其返回true。该鲍姆甜顺序应该返回falsy如果数字的二进制表示包含奇数个连续零的数目的任何地方，并truthy否则。有关更多信息，请单击链接。这里有几个例子：

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]

作为最终答案。

这是代码高尔夫球，最短字节数获胜。

05AB1E，10 9字节

多亏了Adnan，节省了一个字节

ƒ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的奇数行。令人讨厌的是，二进制数以开头0b，其中有一个零，需要将其删除以避免误报。

枚举是通过递归向下进行的。

重击 58，46字节

编辑：

• 用dc代替bc（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)

感谢@xnor打高尔夫球20（！）个字节！

返回无序列表。这非常有效：输入100,000的 TIO大约需要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将十进制转换为二进制向量。因此执行游程长度编码以检查值== 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字节

有点实验后，我意识到我可以做相当多的比我原来的更好的解决方案，通过使用类似的技术批量的答案是尼尔想出了。

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

在线尝试！

与我最初的解决方案一样，有两个循环-外循环迭代要测试的数字，而内循环测试每个数字的位序列。测试的工作方式是一次检查两个位（当前值的模4）。如果等于2，我们将得到一个零的奇数序列，并且可以中止内部循环并继续下一个数字。

如果模4不等于2，我们需要继续测试其余位，因此我们将已经测试的位上移。这是通过将值来完成，让我们把它叫做ñ通过2+2*!(n%2)。这意味着如果第一位是1，我们将被2除（删除该1位），但是如果它是0，则我们将被4除，因此我们将始终丢弃零对。

如果最终降到零，则意味着没有零位的奇数序列，因此我们将数字写出。

Visual Basic（.net 4.5）163字节

第一次在这里回答，所以我确定我搞砸了。让我知道，我会解决。甚至允许使用Visual Basic Lambda吗？

感谢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字节

这并不像我想的那样打高尔夫，但是我认为使用Regex是一个很可爱的解决方案，尽管它从未使用过。

打高尔夫球：

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 | 1而不是00，并在replaceAll和isEmpty之间删除“ .replace（“ 1”，“”）“来保存14个字节！

编辑2：通过将i设置为Integer并使用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；否则，返回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计算输入的二进制数字列表#。Split将该列表分为相同元素的序列，采用Casesmatch {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:]为just-删除了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

效率极低。在线尝试！

Ruby，54 53 48字节

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

我不认为正则表达式会变得如此基本。

编辑1：切换为拒绝以消除对-1的求反。

编辑2：切换match至=~-5。

C＃159 157 155个字节

使用TuukkaX，节省了2 x 2个字节。

注意：以相反的顺序打印出整数。

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"&]&

Ruby，53字节

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

果冻15 13 10字节

在查看其他答案后节省了两个字节，另外3个字节归功于Dennis

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)