Baum-Sweet 시퀀스 (트위스트가있는 A086747)

양의 정수 n를 받아 Baum-Sweet 시퀀스가 ​​true를 반환하는 1에서 n까지의 정수를 인쇄합니다. 바움 – 달콤한 순서는 반환해야 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]

최종 답변으로.

이것은 가장 짧은 바이트 수의 코드 골프 입니다.

답변

ƒ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

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

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

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

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

@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

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

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