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]

최종 답변으로.

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

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

자바 스크립트 (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 호출 할 함수입니다.

파이썬 2, 62 바이트

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

분할 00하여 결과 목록의 문자열 표현에 0이 남아 있는지 확인 하여 이진 표현에서 1의 홀수 실행을 확인합니다. 성가 시게, 이진수는로 시작 0b하는데, 0은 가양 성을 피하기 위해 제거해야합니다.

열거는 반복하여 수행됩니다.

세게 때리다, 58, 46 바이트

EDITS :

• 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

펄 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이진 문자열의도되고 다음, (정규식을 의미하는 것은 빈 문자열로 그들을 분할이) 0될 것입니다 -notin소위, 결과 Where절은 사실이며, 숫자가 선택됩니다. 이 숫자는 파이프 라인에 남아 있으며 출력은 암시 적입니다.

파이썬 2 , 67 47 바이트

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

@xnor 덕분에 20 (!) 바이트를 골라냅니다!

순서가없는 목록을 반환합니다. TIO에서 입력 100,000 은 약 40ms가 소요됩니다.

온라인으로 사용해보십시오!

Mathematica, 59 바이트

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

Mathematica 답변 번호 4 ...

MATL , 12 11 바이트

:"@BY'og)?@

온라인으로 사용해보십시오!

설명

숫자가 유효한지 감지하기 위해 이진수로 변환하고 실행 길이 인코딩을 적용하고 홀수 길이의 실행 만 유지하며 0의 실행이 지속되지 않는지 확인합니다.

:       % 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함수를 사용하여 miscFuncs10 진수에서 이진 벡터로 변환합니다. 따라서 값을 확인하기 위해 런 렝스 인코딩을 수행 == 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이면 홀수의 시퀀스가 ​​0이며 내부 루프를 중단하고 다음 숫자로 진행할 수 있습니다.

모듈로 4가 2가 아닌 경우 나머지 비트를 계속 테스트해야하므로 이미 테스트 된 비트를 위로 이동합니다. 이것은 값을 나누어 수행, 호출 할 수 없음 으로, 2+2*!(n%2). 즉, 첫 번째 비트가 1이면 2로 나눕니다 (1 비트를 떨어 뜨림). 0이면 4로 나눕니다. 따라서 항상 0의 쌍을 버립니다.

우리가 결국 0으로 내려 가면, 그것은 0 비트의 홀수 시퀀스가 ​​없었 음을 의미하므로 숫자를 씁니다.

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

자바 144 130 128 바이트

이것은 내가 생각하는 것만 큼 골프는 아니지만 Regex를 사용하지는 않았지만 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 대신 정규식 00 | 1을 만들고 replaceAll과 isEmpty 사이에서 ".replace ("1 "," ")"를 제거하여 14 바이트를 절약 할 수있었습니다!

편집 2 : 나는 정수를 만들고 i.toString으로 Integer.toString을 참조하여 2 바이트를 절약 할 수있었습니다.

클로저, 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연속적인 0을 찾는 데 사용 하고, 모듈로 -2 길이를 a에 매핑하고 , 세트에서 set숫자 1가 발견 되면 버립니다 .

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

수학, 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결과 를 반환 하십시오.

파이썬 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문자열의 시작 부분에 남지만 실제로 계산에 영향을 미치지 않는다는 것을 깨달았습니다. :)

파이썬, 142 바이트

이것은 주로 파이썬을 골프 연습하는 것입니다.

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

수학, 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 바이트를 절약했습니다 .Dennis 덕분에 또 다른 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)