Baum-Tatlı Dizisi (A086747, Bükülmüş)

Pozitif bir tamsayı alın nve Baum-Sweet sekansının doğru geldiği 1'den n'ye tamsayıları yazdırın. Baum-Sweet dizisi, sayının ikili gösterimi sayının herhangi bir yerinde tek bir ardışık sıfır sayısı ve aksi takdirde truthy içeriyorsa sahte olmalıdır . Daha fazla bilgi için bağlantıya tıklayın. İşte birkaç örnek:

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

İşte verilen bir örnek n=32

Adım 1: için görselleştirilen Baum-Sweet dizisi 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)

Bu nedenle, n için Baum-Sweet dizisini hesapladıktan sonra, dizilim için sıradışı olan sayıları alın ve bunları nihai sonuç için toplayın. Çünkü n=32biz olurdu:

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

Son cevap olarak.

Bu kod golf , en kısa bayt sayısı kazanıyor.

05AB1E , 10 9 bayt

Adnan sayesinde bir bayt kaydedildi

ƒNb00¡SP–

Çevrimiçi deneyin!

açıklama

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

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

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

Biraz daha ilginç özyinelemeli çözüm:

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

@Neil sayesinde 67 bayt.

g çağırılacak işlevdir.

Python 2, 62 bayt

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

İkili gösterimde 1'lerin tek sıralı çalıştırmalarını 00denetleyerek ve böylelikle ortaya çıkan listenin string gösteriminde sıfır olup olmadığını kontrol ederek denetler. Can sıkıcı biçimde, 0byanlış bir pozitif oluşumu önlemek için kaldırılması gereken sıfır olan ikili sayılarla başlar .

Numaralandırma, özyinelemeden yapılır.

Bash, 58, 46 bayt

DÜZENLEMELER:

• Dc ile değiştirilen bc (Thx @Digital Trauma!)
• 1 ile başlayın;

golfed

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

Ölçek

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

Açıklaması

kabuk

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

Çevrimiçi Deneyin!

Toplu iş, 143 bayt

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

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

Dene

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

( []yakalamayan gruplama <[]>için, karakter sınıfları için kullanılır)

PowerShell , 79 61 bayt

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

Çevrimiçi deneyin!

Bu sabah -splitoperasyonu nasıl uygulayacağımı değiştirmek için ilham aldım , sonra xnor'ın cevabının nasıl yapıldığına benzer olduğunu görelim, bu yüzden sanırım harika beyinler de öyle düşünüyor?

Girişten 1girişe geçiyoruz ve uygun sayıları bulmak $args[0]için bir Where-Objectoperatör kullanıyoruz |?{...}. Fıkra basit Boolean değeri - biz sağlamak ediyoruz 0olduğu -notinsonuçları (...).

Parensin içinde, taban ile [convert]::o anki sayı (yani, onu ikili bir dizgeye çeviririz). Daha sonra , regex'deki dize - bu açgözlü bir eşleşmedir ve bir dizi diziyle sonuçlanır (örneğin, buna dönüşür ).$_ ToString2-split1|00100010'','','0','','0'

Bu nedenle, 0ikili dizideki her bir s dizisi eşitse (regex'in onları boş dizgelere böldüğü anlamına gelir), o 0zaman -notinsonuç olacaktır , yani Wherecümle doğrudur ve sayı seçilir. Bu numaralar boru hattında bırakılır ve çıktı gizlidir.

Python 2 , 67 47 bayt

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

20 (!) Baytlık golf atmaya @xnor teşekkürler!

Sırasız bir liste döndürür. Oldukça verimli: 100.000 girişi TIO'da yaklaşık 40 ms sürüyor.

Çevrimiçi deneyin!

Mathematica, 59 bayt

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

Mathematica 4 numaralı cevabı ...

MATL , 12 11 bayt

:"@BY'og)?@

Çevrimiçi deneyin!

açıklama

Bir sayının geçerli olup olmadığını saptamak için bu ikiliye dönüştürür, çalışma uzunluğu kodlaması uygular, yalnızca tek uzunluktaki akışları tutar ve sıfır çalışmalarının devam edip etmediğini kontrol eder.

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

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

Stdin'den girdi okur ve ondalık sayıdan ikili vektöre dönüştürmek için binişlevi miscFuncspaketten kullanır . Sonuç olarak, değerleri kontrol etmek için çalıştırma uzunluğu kodlaması yapar == 0ve uzunlukları tekdir.

Yığılmış , 69 bayt

Burada dene!

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

Veya, 67 baytta rekabetçi olmayan:

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

Ve hatta 49 baytta daha rekabetçi olmayan:

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

Hepsi TOS olarak girdi alır ve TOS'ta çıktı bırakır.

açıklama

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

İşlev:

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

Rekabet etmeyenlerin açıklaması:

Birkaç anahtar fark ile, yukarıdaki ile aynı:

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

Biraz deneme yaptıktan sonra , Neil’in geldiği Batch cevabına benzer bir teknik kullanarak orijinal çözümümden biraz daha iyi yapabileceğimin farkına vardım .

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

Çevrimiçi deneyin!

Orijinal çözümümde olduğu gibi, iki döngü vardır - test etmek istediğimiz sayılar üzerinde yinelenen dış döngü ve her sayı için bit sırasını test eden bir iç döngü. Testin işleyişi, bir seferde iki bitin incelenmesidir (mevcut değerin modulo 4'ü). Eğer 2'ye eşitse, garip bir sıfırlar dizisine sahibiz ve iç çevrimi iptal edip bir sonraki sayıya geçebiliriz.

Modulo 4, 2'ye eşit değilse, kalan bitleri test etmeye devam etmemiz gerekir, bu yüzden zaten test edilmiş olan bitleri yükseltiriz. Bu değerine bölünmesiyle yapılır, arama sağlar n tarafından, 2+2*!(n%2). Bu, eğer ilk bit 1 ise, 2'ye böleriz (o 1 biti düşürürsek), ama eğer 0 ise, 4'e böleriz, bu yüzden daima sıfır çiftleri bırakırız.

Sonunda sıfıra düşersek, bu sıfır bitlik herhangi bir garip dizinin olmadığı anlamına gelir, bu yüzden sayıyı yazarız.

Visual Basic (.net 4.5) 163 bayt

İlk önce buraya cevap verin, bu yüzden bir şeyi batırdığımdan eminim. Bana haber ver ve tamir edeceğim. Visual Basic lambdalarına izin bile veriliyor mu?

MamaFunRoll'a ardışık sıfırlama fikri için teşekkürler

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) çıkış

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

Java, 144 130 128 Bayt

Bu düşündüğüm kadar golf değil, ama bir daha kullanmamış olmama rağmen Regex kullanmanın hoş bir çözüm olacağını düşündüm.

golfed:

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
}

Düzenleme: Benge yerine 00 | 1 regex yaparak ve 0All ve isEmpty arasında ".replace (" 1 "," ")" kaldırarak 14 bayt kaydedebildi!

Düzenleme 2: 2 bayt'ı, bir Tamsayı yaparak ve Tamsayı.toString'e i.toString ile başvuran olarak kaydedebildim.

Clojure, 103 bayt

Bunun en kısa yol olduğunu sanmıyorum ...

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

re-seqArdışık sıfırları bulmak için kullanır , modulo-2 uzunluklarını a ile eşler, setsayı 1kümesinden çıkarsa onları atar .

Wonder , 38 bayt

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

Kullanımı:

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

açıklama

Daha okunabilir:

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

rng 1 +1 #0: 1'den girişe kadar olan aralık.

fltr@ ...: Aşağıdaki tahmini ile filtre aralığı.

bn #0: Geçerli öğeyi ikiliye dönüştür. (Bu bir lider olacak 0b).

Rstr #["00"]: 00Dizedeki tüm oluşumları yinelemeli olarak budala .

len iO 0: 0Dizedeki s miktarını say .

=1: Miktarın 1'e eşit olup olmadığını kontrol edin. 0Budama sonrası dizede kalan tek şey baş harfinde ise 0b, bu doğru olur; Aksi takdirde, bu yanlış döndürür.

Yakut, 78 69 68 bayt

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

Eski versiyonlar:

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

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

Bir sayıdaki ardışık basamakların her biri için hesaplar, {o çalışmadaki ortak basamak artı (uzunluk tek ise 1, uzunluk çift ise 2)}; Cevaplardan herhangi biri {1} ise, numara sırada değildir.

Mathematica, 75 bayt

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

#~IntegerDigits~2Girişin ikili rakamlarının listesini hesaplar #. SplitBu aynı özdeş unsurların sıralaması içinde, Caseso eşleşmeyi {0..}alın, Lengthher birini alın, EvenQuzunlukları alın ve Andsonuçların iadesini alın .

Python 3, 86 82 bayt

Golf devam ediyor ...

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:]Sadece değiştirerek 4 bayt kapalı Golf bin(x)- Bu 0bdize başında bırakır , ancak bunun aslında hesaplamaları etkilemeyeceğini fark ettim :)

Python, 142 bayt

Bu sadece Python'umda golf oynamak için.

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

Jöle , 10 bayt

2ṗx"`ḂḄf@R

Son derece verimsiz. Çevrimiçi deneyin!

Ruby, 54 53 48 bayt

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

Bunun için regex'in bu kadar basit olacağını düşünmemiştim.

düzenleme 1: -1 için olumsuzlamadan kurtulmak için reddetti.

Düzenleme 2: anahtarlı matchiçin =~-5 için.

C # 159 157 155 bayt

TuukkaX sayesinde 2 x 2 bayt kaydedildi.

Not: Girişleri ters sırada yazdırır.

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

Açıklama:

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 bayt

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

Aynı uzunluk:

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

Ruby, 53 Bayt

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

Jöle, 15 13 10 bayt

diğer cevaplara baktıktan sonra iki bayt kurtardı, Dennis sayesinde bir başka 3 bayt

Bœṣ0,0Ȧµ€T

açıklama

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)