The Baum-Sweet Sequence (A086747 ที่มีการบิด)

รับจำนวนเต็มบวกnและพิมพ์จำนวนเต็มตั้งแต่ 1 ถึง n ซึ่งลำดับ Baum-Sweet คืนค่าเป็นจริง ลำดับ 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)

ดังนั้นหลังจากคำนวณลำดับ Baum-Sweet สำหรับ n ให้นำตัวเลขที่เป็นจริงสำหรับลำดับและรวบรวมผลสุดท้าย สำหรับ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))

67 ไบต์ขอบคุณ @Neil

g เป็นฟังก์ชั่นในการโทร

Python 2, 62 ไบต์

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

ตรวจสอบการทำงานแบบคี่ของ 1 ในการแทนเลขฐานสองโดยแยก00และตรวจสอบว่าศูนย์ใด ๆ ที่ยังคงอยู่ในการเป็นตัวแทนสตริงของรายการผลลัพธ์ น่ารำคาญตัวเลขไบนารีเริ่มต้นด้วย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(...)

ภายใน parens เรา[convert]::เป็นตัวเลขปัจจุบันที่$_ ToStringมีฐาน2(กล่าวคือแปลงให้เป็นสตริงไบนารี) จากนั้นเราจะ-splitสตริงบน regex 1|00- นี่คือการจับคู่โลภและผลลัพธ์ในอาร์เรย์ของสตริง (ตัวอย่างเช่น100010จะกลายเป็น'','','0','','0'และอื่น ๆ )

ดังนั้นหากทุก ๆ การทำงานของ0s ในสตริงไบนารี่เป็นเลขคู่ (หมายถึง regex แบ่งออกเป็นสตริงว่าง) ดังนั้นผลลัพธ์0จะเป็น-notinผลลัพธ์ดังนั้นWhereประโยคจะเป็นจริงและเลือกหมายเลข ตัวเลขเหล่านั้นจะถูกปล่อยไว้บนไพพ์ไลน์

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ใช้เวลาประมาณ 40 ms บน TIO

ลองออนไลน์!

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

และยิ่ง noncompeting ที่ 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

คำอธิบายของ noncompeting:

เหมือนกับด้านบนมีความแตกต่างที่สำคัญเล็กน้อย:

:>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$<:.

ลองออนไลน์!

เช่นเดียวกับโซลูชันดั้งเดิมของฉันมีสองลูป - ลูปภายนอกวนซ้ำหมายเลขที่เราต้องการทดสอบและลูปภายในทดสอบลำดับบิตสำหรับแต่ละหมายเลข วิธีการทดสอบใช้งานได้โดยการตรวจสอบสองบิตในแต่ละครั้ง (โมดูโล 4 ของค่าปัจจุบัน) หากนั่นเท่ากับ 2 เรามีเลขศูนย์เป็นเลขคี่และสามารถยกเลิกลูปด้านในและไปยังหมายเลขถัดไป

หากโมดูโล 4 ไม่เท่ากับ 2 เราจำเป็นต้องทำการทดสอบบิตที่เหลือต่อไปดังนั้นเราจึงเลื่อนบิตที่ผ่านการทดสอบไปแล้ว สิ่งนี้ทำได้โดยการหารค่าให้เรียกมันว่าnโดย2+2*!(n%2)โดยนี่หมายความว่าถ้าบิตแรกเป็น 1 เราหารด้วย 2 (ลดลง 1 บิต) แต่ถ้ามันเป็น 0 เราหารด้วย 4 ดังนั้นเราจะวางเลขศูนย์สองคู่เสมอ

ถ้าในที่สุดเราถึงศูนย์นั่นหมายความว่าไม่มีเลขคี่ใด ๆ ที่เป็นศูนย์บิตดังนั้นเราจึงเขียนเลข

Visual Basic (.net 4.5) 163 ไบต์

ครั้งแรกที่เคยตอบที่นี่ดังนั้นฉันแน่ใจว่าฉันทำอะไรบางอย่างผิดพลาด แจ้งให้เราทราบและฉันจะแก้ไข Visual Basic lambdas อนุญาตให้ใช้งานได้หรือไม่

ขอบคุณ 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;}

Ungolfed:

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
}

แก้ไข:ฉันสามารถบันทึก 14 ไบต์โดยสร้าง regex 00 | 1 แทน 00 และลบ ".replace (" 1 "," ")" ระหว่าง replaceAll และ isEmpty!

แก้ไข 2:ฉันสามารถบันทึก 2 ไบต์ด้วยการทำให้ฉันเป็นจำนวนเต็มและอ้างอิง Integer.toString ด้วย i.toString

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เพื่อหาค่าศูนย์ติดต่อกันแมปความยาว modulo-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: นับจำนวน0s ในสตริง

=1: ตรวจสอบว่าจำนวนเท่ากับ 1 หรือไม่หากจำนวนที่0เหลืออยู่ในสตริงหลังจากการตัดแต่งอยู่ในอันดับต้น0bๆ สิ่งนี้จะคืนค่าเป็นจริง มิฉะนั้นจะส่งคืนค่าเท็จ

ทับทิม, 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ว่ารายการเข้าสู่การทำงานขององค์ประกอบที่เหมือนใช้Casesที่แข่งขัน{0..}ใช้Lengthของแต่ละของพวกเขาใช้เวลาEvenQของความยาวและจากนั้นกลับมาAndของผล

Python 3, 86 82 bytes

Golfing in progress...

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

Golfed off 4 bytes by changing bin(x)[2:] to just bin(x) - this leaves 0b at the start of the string, but I realised this does not actually affect the calculations :)

Python, 142 bytes

This is mainly just to practice golfing my 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)]

Jelly, 10 bytes

2ṗx"`ḂḄf@R

Terribly inefficient. Try it online!

Ruby, 54 53 48 bytes

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

I didn't think the regex for this was going to be quite so basic.

edit 1: switched to reject to get rid of negation for -1.

edit 2: switched match to =~ for -5.

C# 159 157 155 bytes

Saved 2 x two bytes thanks to TuukkaX.

Note: prints out the ints in reverse order.

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

Explanation:

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 bytes

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

The same length:

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

Ruby, 53 Bytes

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

Jelly, 15 13 10 bytes

saved two bytes after looking at other answers, another 3 bytes thanks to Dennis

Bœṣ0,0Ȧµ€T

Explanation

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)