Chuỗi Baum-Sweet (A086747 với một Twist)

Lấy một số nguyên dương nvà in các số nguyên từ 1 đến n mà chuỗi Baum-Sweet trả về đúng. Trình tự Baum-ngọt nên trở falsy nếu biểu diễn nhị phân của số chứa một số lẻ của số không liên tiếp bất cứ nơi nào trong số, và truthy khác. Để biết thêm thông tin, nhấp vào liên kết. Dưới đây là một vài ví dụ:

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

Đây là một ví dụ được đưa ra n=32

Bước 1: Trình tự Baum-Sweet được hình dung cho 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)

Vì vậy, sau khi tính toán chuỗi Baum-Sweet cho n, hãy lấy các số là trung thực cho chuỗi và thu thập chúng cho kết quả cuối cùng. Vì n=32chúng ta sẽ có:

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

Như câu trả lời cuối cùng.

Đây là mã golf , số byte ngắn nhất sẽ thắng.

05AB1E , 10 9 byte

Đã lưu một byte nhờ Adnan

ƒNb00¡SP–

Hãy thử trực tuyến!

Giải trình

ƒ          # 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 byte

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

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

Giải pháp đệ quy thú vị hơn một chút:

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

67 byte nhờ @Neil.

g là chức năng để gọi.

Python 2, 62 byte

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

Kiểm tra các lần chạy lẻ của 1 trong biểu diễn nhị phân bằng cách tách 00và kiểm tra xem có bất kỳ số 0 nào còn lại trong biểu diễn chuỗi của danh sách kết quả hay không. Khó chịu, số nhị phân bắt đầu bằng 0b, có số 0 cần được loại bỏ để tránh dương tính giả.

Việc liệt kê được thực hiện bằng cách đệ quy xuống.

Bash, 58, 46 byte

CHỈNH SỬA:

• Thay thế bc bằng dc (Thx @Digital Trauma!)
• Bắt đầu với 1;

Chơi gôn

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

Kiểm tra

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

Giải thích

vỏ

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

quyến rũ

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

Dùng thử trực tuyến!

Mẻ, 143 byte

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

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

Thử nó

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

( []được sử dụng để phân nhóm không bắt giữ, <[]>được sử dụng cho các lớp ký tự)

PowerShell , 79 61 byte

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

Hãy thử trực tuyến!

Tôi đã có cảm hứng sáng nay để thay đổi cách tôi thực hiện -splitthao tác, sau đó thấy rằng nó tương tự như cách câu trả lời của xnor được xây dựng, vì vậy, tôi đoán những bộ óc vĩ đại có nghĩ giống nhau không?

Chúng tôi lặp từ 1lên đến đầu vào $args[0]và sử dụng một Where-Objecttoán tử để lấy ra các số thích hợp |?{...}. Mệnh đề là một giá trị Boolean đơn giản - chúng tôi đảm bảo rằng đó 0là-notin kết quả của (...).

Bên trong các parens, chúng ta [convert]::là số hiện tại $_ ToStringvới cơ sở 2(nghĩa là biến nó thành một chuỗi nhị phân). Chúng tôi sau đó -splitlà chuỗi trên regex 1|00- đây là một trận đấu tham lam và kết quả là một chuỗi các chuỗi (ví dụ, 100010sẽ biến thành '','','0','','0'và tiếp tục).

Do đó, nếu mọi lần chạy 0s trong chuỗi nhị phân đều chẵn (nghĩa là regex đã tách chúng thành chuỗi rỗng), thì đó 0sẽ là -notinkết quả, vì vậy Wheremệnh đề là đúng và số được chọn. Những con số này được để lại trên đường ống và đầu ra là ẩn.

Python 2 , 67 47 byte

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

Cảm ơn @xnor đã chơi hết 20 byte (!)!

Trả về một danh sách không có thứ tự. Nó khá hiệu quả: 100.000 đầu vào mất khoảng 40 ms trên TIO.

Hãy thử trực tuyến!

Toán học, 59 byte

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

Toán học trả lời số 4 ...

MATL , 12 11 byte

:"@BY'og)?@

Hãy thử trực tuyến!

Giải trình

Để phát hiện xem một số có hợp lệ hay không, số này chuyển thành nhị phân, áp dụng mã hóa độ dài chạy, chỉ giữ các lần chạy có độ dài lẻ và kiểm tra xem có tồn tại số 0 nào không.

:       % 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 byte

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

Đọc đầu vào từ stdin và sử dụng binhàm từ miscFuncsgói để chuyển đổi từ vectơ thập phân sang nhị phân. Do đó, thực hiện mã hóa độ dài chạy để kiểm tra giá trị == 0và độ dài là số lẻ.

Xếp chồng lên nhau , 69 byte

Hãy thử nó ở đây!

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

Hoặc, không biên dịch ở 67 byte:

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

Và, thậm chí nhiều hơn nữa không biên dịch ở 49 byte:

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

Tất cả lấy đầu vào là ĐKDV và để lại đầu ra trên ĐKDV.

Giải trình

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

Chức năng:

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

Giải thích về việc không soạn thảo:

Nó giống như trên, với một vài điểm khác biệt chính:

:>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 byte

Sau một chút thử nghiệm, tôi nhận ra rằng tôi có thể làm tốt hơn một chút so với giải pháp ban đầu của mình bằng cách sử dụng một kỹ thuật tương tự như câu trả lời Batch mà Neil nghĩ ra.

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

Hãy thử trực tuyến!

Như với giải pháp ban đầu của tôi, có hai vòng lặp - vòng lặp bên ngoài lặp qua các số chúng tôi muốn kiểm tra và một vòng lặp bên trong kiểm tra chuỗi bit cho mỗi số. Cách kiểm tra hoạt động là bằng cách kiểm tra hai bit tại một thời điểm (modulo 4 của giá trị hiện tại). Nếu bằng 2, chúng ta có một chuỗi số 0 lẻ và có thể hủy bỏ vòng lặp bên trong và chuyển sang số tiếp theo.

Nếu modulo 4 không bằng 2, chúng ta cần tiếp tục kiểm tra các bit còn lại, vì vậy chúng tôi chuyển lên các bit đã được kiểm tra. Điều này được thực hiện bằng cách chia giá trị, hãy gọi nó là n , bởi2+2*!(n%2) . Điều này có nghĩa là nếu bit đầu tiên là 1, chúng ta chia cho 2 (giảm 1 bit đó), nhưng nếu là 0, chúng ta chia cho 4, vì vậy chúng ta sẽ luôn giảm các cặp số không.

Nếu cuối cùng chúng ta xuống 0, điều đó có nghĩa là không có bất kỳ chuỗi lẻ nào của các bit 0, vì vậy chúng ta viết ra số.

Visual Basic (.net 4.5) 163 byte

Lần đầu tiên trả lời ở đây vì vậy tôi chắc chắn rằng tôi đã làm hỏng điều gì đó. Hãy cho tôi biết và tôi sẽ sửa chữa. Visual Basic lambdas thậm chí còn được phép?

Cảm ơn MamaFunRoll vì đã loại bỏ ý tưởng số 0 liên tiếp

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

Đầu ra R (32)

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

Java, 144 130 128 byte

Đây không phải là môn đánh gôn như tôi nghĩ nó có thể, nhưng tôi nghĩ rằng đó là một giải pháp dễ thương để sử dụng Regex, mặc dù chưa bao giờ sử dụng nó.

Chơi gôn

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

Ung dung:

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
}

Chỉnh sửa: Tôi đã có thể lưu 14 byte bằng cách tạo regex 00 | 1 thay vì 00 và xóa ".replace (" 1 "," ")" giữa thay thế AllAll và isEmpty!

Chỉnh sửa 2: Tôi đã có thể lưu 2 byte bằng cách đặt i là Integer và tham chiếu Integer.toString với i.toString.

Clojure, 103 byte

Tôi không nghĩ đây là con đường ngắn nhất ...

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

Sử dụng re-seqđể tìm các số 0 liên tiếp, ánh xạ độ dài modulo-2 của chúng thành a set, loại bỏ chúng nếu 1tìm thấy số từ tập hợp.

Kỳ quan , 38 byte

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

Sử dụng:

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

Giải trình

Dễ đọc hơn:

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

rng 1 +1 #0: Phạm vi từ 1 đến đầu vào.

fltr@ ...: Phạm vi lọc với vị từ sau.

bn #0: Chuyển đổi mục hiện tại thành nhị phân. (Điều này sẽ có một hàng đầu 0b).

Rstr #["00"]: Cắt tỉa đệ quy bất kỳ lần xuất hiện nào 00trong chuỗi.

len iO 0: Đếm số lượng 0s trong chuỗi.

=1: Kiểm tra xem số tiền có bằng 1. Nếu chỉ 0còn lại trong chuỗi sau khi cắt tỉa ở đầu 0b, thì điều này trả về đúng; mặt khác, điều này trả về false.

Hồng ngọc 78 69 68 byte

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

Các phiên bản cũ hơn:

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

Toán học, 81 byte

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

Tính toán, với mỗi lần chạy các chữ số liên tiếp trong một số, {chữ số chung trong lần chạy đó cộng (1 nếu độ dài là số lẻ, 2 nếu độ dài là số chẵn)}; nếu bất kỳ câu trả lời nào là {1} thì số đó không nằm trong chuỗi.

Toán học, 75 byte

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

#~IntegerDigits~2tính toán danh sách các chữ số nhị phân của đầu vào #. Splitliệt kê các thành phần giống hệt nhau, lấy Caseskết quả khớp đó {0..}, lấy Lengthtừng phần tử của chúng, lấy EvenQđộ dài và sau đó trả Andvề kết quả.

Trăn 3, 86 82 byte

Chơi gôn đang diễn ra ...

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

Đánh bại 4 byte bằng cách thay đổi bin(x)[2:]thành chỉ bin(x)- điều này rời khỏi 0bđầu chuỗi, nhưng tôi nhận ra điều này không thực sự ảnh hưởng đến các tính toán :)

Python, 142 byte

Điều này chủ yếu chỉ để thực hành chơi gôn Python của tôi.

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

Thạch , 10 byte

2ṗx"`ḂḄf@R

Không hiệu quả khủng khiếp. Hãy thử trực tuyến!

Ruby, 54 53 48 byte

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

Tôi không nghĩ rằng regex cho việc này sẽ khá cơ bản.

chỉnh sửa 1: chuyển sang từ chối để loại bỏ phủ định cho -1.

chỉnh sửa 2: chuyển matchđến =~cho -5.

C # 159 157 155 byte

Đã lưu 2 x hai byte nhờ TuukkaX.

Lưu ý: in ra các số nguyên theo thứ tự ngược lại.

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

Giải trình:

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

Toán học, 69 byte

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

Độ dài tương tự:

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

Ruby, 53 byte

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

Thạch, 15 13 10 byte

đã lưu hai byte sau khi xem các câu trả lời khác, 3 byte khác nhờ Dennis

Bœṣ0,0Ȧµ€T

Giải trình

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)