Последовательность содержит десятичное представление двоичных чисел вида:, 10101...где n-й член имеет n битов.

Последовательность, вероятно, проще всего объяснить, просто показывая отношения между двоичным и десятичным представлениями чисел:

0       ->  0
1       ->  1
10      ->  2
101     ->  5
1010    ->  10
10101   ->  21
101010  ->  42

Вызов:

Возьмите входное целое число nи верните первые n чисел в последовательности. Вы можете выбрать последовательность 0 или 1.

Тестовые случаи:

n = 1   <- 1-indexed
0

n = 18
0, 1, 2, 5, 10, 21, 42, 85, 170, 341, 682, 1365, 2730, 5461, 10922, 21845, 43690, 87381

Пояснения приветствуются, как всегда.

Это OEIS A000975 .

Python 2 , 36 байт

lambda n:[2**i*2/3for i in range(n)]

Попробуйте онлайн! Пояснение: двоичное представление ,так что просто остается умножить его на соответствующую степень 2 и взять целую часть.$\frac{2}3$0.101010101...

05AB1E , 4 байта

2 байта сохранены с помощью трюка Нила 2/3

Lo3÷

Попробуйте онлайн!

объяснение

L      # push range [1 ... input]
 o     # raise 2 to the power of each
  3÷   # integer division of each by 3

05AB1E , 6 байтов

TRI∍ηC

Попробуйте онлайн!

объяснение

T        # push 10
 R       # reverse it
  I∍     # extend to the lenght of the input
    η    # compute prefixes
     C   # convert each from base-2 to base-10

Желе , ... 4 байта

Спасибо миль за -1 байт!

ḶḂḄƤ

Попробуйте онлайн!

Объяснение:

Ḷ     Ḷowered range, or UnḶength. Get [0, 1, 2, 3, ..., n-1]
 Ḃ    Ḃit. Get the last bit of each number. [0, 1, 0, 1, ...]
   Ƥ  for each Ƥrefixes [0], [0, 1], [0, 1, 0], [0, 1, 0, 1], ...
  Ḅ   convert it from Ḅinary to integer.

Желе , 4 байта

Версия Джонатана Аллана.

Ḷ€ḂḄ

Попробуйте онлайн!

Ḷ     Ḷowered range, or UnḶength.
 €    Apply for €each. Automatically convert the number n
      to the range [1,2,..,n]. Get [[0],[0,1],[0,1,2],..].
  Ḃ   Ḃit. Get the last bit from each number.
      Current value: [[0],[0,1],[0,1,0],..]
   Ḅ  Convert each list from Ḅinary to integer.

Версия, основанная на трюке Нила 2/3, дает 5 байтов, см. Историю изменений.

MATL , 5 байтов

:WI/k

На основании ответа Нейла .

объяснение

:       % Implicit input, n. Push range [1 2 ... n]
W       % 2 raised to that, element-wise. Gives [2 4 ...2^n] 
I       % Push 3
/       % Divide, element-wise
k       % Round down, element-wise. Implicit display

Попробуйте онлайн!

MATL , 9 байт

:q"@:oXBs

Попробуйте онлайн!

объяснение

:       % Implicit input n. Range [1 2 ... n]
q       % Subtract 1, element-wise: gives [0 1 ... n-1]
"       % For each k in [0 1 ... n-1]
  @     %   Push k
  :     %   Range [1 2 ... k]
  o     %   Modulo 2, element-wise: gives [1 0 1 ...]
  XB    %   Convert from binary to decimal
  s     %   Sum. This is needed for k=0, to transform the empty array into 0
        % Implicit end. Implicit display

Python 2 , 45 37 36 байт

^{-3 байта благодаря user202729
-1 байт благодаря mathmandan}

s=0
exec"print s;s+=s+~s%2;"*input()

Попробуйте онлайн!

Python 3, 68 61 54 48 43 байта

c=lambda x,r=0:x and[r]+c(x-1,2*r+~r%2)or[]  

Спасибо user202729 за помощь в сохранении 19 байтов и ов за помощь в сохранении 6 байтов.

Попробуйте онлайн

Шелуха , 7 байт

mḋḣ↑Θݬ

Попробуйте онлайн!

На основе 1, поэтому ввод n дает первые n результатов.

объяснение

     ݬ   The infinite list [1, 0, 1, 0, 1, ...]
    Θ     Prepend a zero.
   ↑      Take the first n elements.
  ḣ       Get the prefixes of that list.
mḋ        Interpret each prefix as base 2.

APL (Dyalog Unicode) , 11 байтов ^SBCS

Предполагается ⎕IO( я ndex O rigin) 0, что по умолчанию во многих системах. Функция анонимного молчаливого префикса. 1-индексироваться.

(2⊥⍴∘1 0)¨⍳

Попробуйте онлайн!

⍳ ɩ ndices 0 ... п-1

(… )¨ Применить следующую молчаливую функцию к каждому

 ⍴∘1 0 циклически изменить список [1,0]до такой длины

 2⊥ преобразовать из base-2 (двоичного) в нормальное число

Perlv5.10 -n , 24 + 1 байт

-3 байта благодаря Науэлю Фуйе !

say$v=$v*2|$|--while$_--

Попробуйте онлайн!

Та же логика, что и в моей версии Ruby, но короче, потому что perl более лаконичен. По какой-то странной причине printне стоит использовать разделитель (черт возьми!), Поэтому мне пришлось использовать sayfrom v5.10;для того, чтобы это запустилось, я не уверен, как это забить, поэтому я оставляю это сейчас ?. ..

объяснение

say    # Like shouting, but milder.
  $v = $v*2 | $|-- # Next element is this element times 2 bitwise-OR
                   # with alternating 0 1 0 1..., so 0b0, 0b1, 0b10, 0b101...
                   # $. is OUTPUT_AUTOFLUSH, which is initially 0 and
                   #   setting all non-zero values seem to be treated as 1
  while $_-- # do for [input] times

Haskell , 33 байта

l=1:0:l
($scanl((+).(2*))0l).take

Попробуйте онлайн!

APL (Дьялог) , 7 байт

⌊3÷⍨2*⍳

Попробуйте онлайн!

APL (Дьялог) , 11 байт

(2⊥2|⍳)¨1+⍳

Попробуйте онлайн!

Использует ⎕IO←0.

C , 81 55 59 байт

1 проиндексировано.

i,j;f(c){for(i=j=0;i<c;)printf("%d ",i++&1?j+=j+1:(j+=j));}

Полная программа, меньше гольфа:

i;j;main(c,v)char**v;{c=atoi(*++v);for(;i<c;i++)printf("%d ",i&1?j+=j+1:(j+=j));}

Попробуйте онлайн!

РЕДАКТИРОВАТЬ 2: Я был при условии, что функции не должны были быть повторно использованы теперь, когда я думаю об этом, имеет смысл, что они должны быть повторно использованы: P

РЕДАКТИРОВАТЬ: я был под неправильным представлением, что я должен был включить всю программу в ответ, оказывается, мне нужна была только функция, которая делает это. Это мило.

Я прилично уверен, что смогу сбрить несколько байтов здесь и там. Я уже использовал несколько трюков. Большая часть программы посвящена получению аргумента и превращению его в int. Это мой первый кодовый гольф. Если я делаю что-то не так, скажите мне: P

Haskell , 47 40 53 49 44 40 34 байта

-4 байта благодаря пользователю 202729
-6 байтов благодаря лайкони

(`take`l)
l=0:[2*a+1-a`mod`2|a<-l]

Попробуйте онлайн!

Рубин , 26 байт

->n{(1..n).map{|i|2**i/3}}

Попробуйте онлайн!

Бьет все старые рубиновые ответы.

объяснение

1/3в двоичном виде выглядит так 0.01010101..., так что если вы умножите его на степени двух, вы получите:

n| 2^n/3
-+---------
1|0.1010101...
2|01.010101...
3|010.10101...
4|0101.0101...
5|01010.101...
6|010101.01...

Но Руби записывает числа на деление, давая мне последовательность, которая мне нужна.

J , 9 байт

[:#.\2|i.

Как это работает?

i. - список 0..n-1

2| - список предметов мод 2

\ - все префиксы

#. - в десятичной

[: - закрывает вилку (так как у меня четное число (4) глаголов)

Попробуйте онлайн!

Сетчатка , 28 байт

)K`0
"$+"+¶<`.+
$.(*__2*$-1*

Попробуйте онлайн!

На основе 0, поэтому вход n дает первое n + 1 результаты.

объяснение

Использует рекурсию из OEIS:

a(n) = a(n-1) + 2*a(n-2) + 1

Давайте пройдемся по программе:

)K`0

Это постоянный этап: он отбрасывает ввод и устанавливает рабочую строку в 0качестве начального значения последовательности. )Обертывает эту стадию в группе. Эта группа сама по себе ничего не делает, но почти каждый этап (включая групповые этапы) записывает свой результат в журнал, и нам потребуется две копии 0этого журнала для работы программы.

"$+"+¶<`.+
$.(*__2*$-1*

Здесь есть куча настроек: "$+"+оборачивает сцену в цикл. Значение "$+"рассматривается как замена и $+относится к входу программы, т.е. n . Это означает, что цикл запущен n раз.

Затем ¶<оборачивает каждую итерацию в выходной этап, который печатает входные данные этапа с завершающим переводом строки (поэтому первая итерация печатает ноль, вторая итерация печатает результат первой итерации и т. Д.).

Сам этап заменяет всю рабочую строку с подстановкой в ​​последней строке. Тот использует неявные закрывающие скобки и неявные аргументы для оператора повторения *, так что на самом деле это сокращение от:

$.($&*__2*$-1*_)

Материал внутри скобок можно разбить на три части:

• $&*_: дает строку из (n-1) _ s.
• _: дает сингл _.
• 2*$-1*_: дает строку 2 * a (n-1) _ . $-1Относится к результату предпоследнего в журнале результата, т.е. итерации цикла до последнего. Вот почему нам нужно было сначала скопировать ноль в журнале, иначе это будет относиться к вводу программы на первой итерации.

Затем $.(…)измеряет длину полученной строки. Другими словами, мы вычислили a(n) = a(n-1) + 1 + 2*a(n-2), пройдя через унарный (хотя на самом деле это не так:$.(…) он ленив и фактически не оценивает его содержимое, если он может определить результирующую длину непосредственно с помощью арифметики, так что это даже довольно эффективно).

Результат последней итерации цикла ( n + 1- й элемент последовательности) печатается из-за неявного вывода Retina в конце программы.

Brain-Flak , 36 байт

{([()]{}<((({}<>)<>){}([{}]()))>)}<>

Попробуйте онлайн!

Объяснение:

Следующее число в последовательности получается с помощью n*2+1или n*2+0.

{([()]{}< Loop input times
  (
   (({}<>)<>){} Copy n to other stack; n*2
   ([{}]())  i = 1-i
  ) push n*2 + i
>)} End loop
<> Output other stack

Рубин 42 41 43 41 37 35 31 33 30 байт

-2 байта благодаря Unihedron

-3 байта благодаря ГБ

->x{a=0;x.times{a-=~a+p(a)%2}}

Попробуйте онлайн!

> <> , 22 + 3 (-v флаг) байта

0:nao::1+2%++$1-:?!;$!

Попробуйте онлайн!

объяснение

Стек инициализируется с помощью счетчика цикла.

0:nao                  : Push 0 to the stack, duplicate and print with a new line.
                         [7] -> [7, 0]
     ::1+              : Duplicate the stack top twice more then add 1 to it.
                         [7, 0] -> [7, 0, 0, 1]
         2%++          : Mod the stack top by 2 then add all values on the stack bar the loop counter.
                         [7, 0, 0, 1] -> [7, 1]
             $1-:?!;$! : Swap the loop counter to the top, minus 1 from it and check if zero, if zero stop the program else continue.

Java 8, 115 81 80 52 байта

n->{for(int i=2;n-->0;i*=2)System.out.println(i/3);}

Порт ответа @Neil 's Python 2 .
1 индексируется и выводится напрямую, каждое значение в отдельной строке.

Объяснение:

Попробуйте онлайн.

n->{                           // Method with integer parameter and no return-type
  for(int i=2;                 //  Start integer `i` at 2
      n-->0;                   //  Loop `n` times:
      i*=2)                    //    Multiply `i` by 2 after every iteration
    System.out.println(i/3);}  //   Print `i` integer-divided by 3 and a new-line

Старый 80-байтовый ответ:

n->{String t="",r=t;for(Long i=0L;i<n;)r+=i.parseLong(t+=i++%2,2)+" ";return r;}

1-индексированный ввод и разделенный пробелами String вывод

Объяснение:

Попробуйте онлайн.

n->{                             // Method with integer parameter and String return-type
  String t="",r=t;               //  Temp and result-Strings, both starting empty
  for(Long i=0L;i<n;)            //  Loop from 0 to `n` (exclusive)
    r+=                          //   Append the result-String with:
       i.parseLong(        ,2);  //    Binary to integer conversion
                   t+=           //     append the temp-String with:
                      i  %2      //      current index `i` modulo-2
                       ++        //      and increase `i` by one afterwards
       +" ";                     //    + a space
  return r;}                     //  Return the result-String

Perl 6 ,  35 30 27 25  20 байт

{[\~](0,+!*...*)[^$_]».&{:2(~$_)}}

Попробуйте (35)

{(0,{$_*2+|($+^=1)}…*)[^$_]}

Попробуйте (30)

{(⅓X*(2,4,8…2**$_))».Int}

Попробуйте (30)

{(⅔,* *2…*)[^$_]».Int}

Попробуйте (27)

{((2 X**1..$_)X/3)».Int}

Попробуйте (25)

{(2 X**1..$_)Xdiv 3}

Попробуйте (20)

Expanded:

{
 (
  2                  # 2
    X**              # cross to the power of
       1..$_         # Range from 1 to the input (inclusive)
            )

             Xdiv    # cross using integer divide
                  3  # by 3
}

Python 2 , 33 байта

s=2
exec"print s/3;s*=2;"*input()

Попробуйте онлайн!

Python 2 , 34 байта

f=lambda n:n*[f]and[2**n/3]+f(n-1)

Попробуйте онлайн!

Возвращает в обратном порядке.

C, 47 46 байтов

a;f(n){for(a=0;n--;a+=a-~a%2)printf("%d ",a);}

Аккумулятор aначинается с нуля. На каждом шаге мы удваиваем его ( a+=a) и добавляем единицу, если предыдущий младший бит был равен нулю ( !(a%2)или эквивалентно,-(~a)%2 ).

Тестовая программа

#include <stdlib.h>
#include <stdio.h>

int main(int argc, char **argv)
{
    while (*++argv) {
        f(atoi(*argv));
        puts("");
    }
}

Полученные результаты

$ ./153783 1 2 3 4 5 6
0 
0 1 
0 1 2 
0 1 2 5 
0 1 2 5 10 
0 1 2 5 10 21 

Джапт , 10 9 7 6 байт

Все полученные независимо от других решений.

1-индексироваться.

õ!²mz3

Попытайся

объяснение

õ        :[1,input]
 !²      :Raise 2 to the power of each
   m     :Map
    z3   :Floor divide by 3

Попытайся

7-байтовая версия

õ_ou ì2

Попытайся

õ            :[1,input]
 _           :Pass each through a function
   o         :[0,current element)
    u        :Modulo 2 on above
      ì2     :Convert above from base-2 array to base-10

9-байтовая версия

õ_îA¤w)n2

Попытайся

õ            :[1,input]
 _           :Pass each through a function
   A         :10
    ¤        :Convert to binary
     w       :Reverse
  î          :Repeat the above until it's length equals the current element
      )      :Close nested methods
       n2    :Convert from binary to base-10

Haskell , 52 байта

(`take`map a[0..])
a 0=0
a 1=1
a n=a(n-1)+2*a(n-2)+1

Попробуйте онлайн!

MATL , 7 байт

:&+oRXB

Попробуйте онлайн!

Объяснение:

         % Implicitly grab input, n
:        % Range: 1 2 ... n

 &+      % Add the range to itself, transposed
         % 2 3 4 5 ...
         % 3 4 5 6 ...
         % 4 5 6 7 ...
         % 5 6 7 8 ...

   o     % Parity (or modulus 2)
         % 0 1 0 1 ...
         % 1 0 1 0 ...
         % 0 1 0 1 ...
         % 1 0 1 0 ...

    R    % Upper triangular matrix:
         % 0 1 0 1
         % 0 0 1 0
         % 0 0 0 1
         % 0 0 0 0

    XB   % Convert rows to decimal:
         % [5, 2, 1, 0]
         % Implicitly output

Вывод был бы, 0, 1, 2, 5 ...если бы Pбыл добавлен в конец ( flip), делая его 8 байтов.

Рубин -n ,32 30 + 1 байт

Так как у нас есть ровно 1 строка ввода, $. это божественно удобно!

РЕДАКТИРОВАТЬ: Я удивлен, что мне удалось превзойти себя, но кажется, что использование -nкоторого считается как 1 (по правилу 2 в особых условиях по умолчанию , так как Ruby может быть запущен с ruby -e 'full program'(таким образом -n, 1), все экземпляры getsкоторого используется только один раз, может ударить по гольфу на 1 символ таким образом; я считаю, что это веха для рубина, пожалуйста, говорите, если вы не согласны с этим ходом мыслей, прежде чем я буду неоднократно использовать его в будущем)

v=0
?1.upto($_){p v=v*2|$.^=1}

Попробуйте онлайн!

объяснение

# while gets(); -- assumed by -n
v=0            # First element of the sequence
?1.upto($_){   # Do from "1" to "$LAST_READ_LINE" aka: Repeat [input] times
  p            # print expression
  v=v*2|$.^=1  # Next element is current element times two
               # bitwise-or 0 or 1 alternating
               # $. = lines of input read so far = 1 (initially)
}
# end           -- assumed by -n

AWK a=0 , 31 байт

{for(;$1--;a=a*2+1-a%2)print a}

Попробуйте онлайн!

Использует формулу, бесстыдно украденную из этого другого ответа Ruby.

Несмотря на то, что не сработало a=0бы (awk рассматривает «пусто» как 0), первый элемент 0 не будет напечатан и вместо этого будет emptyстрокой, которая, хотя я бы сказал, что правильный вывод, вероятно, не пройдет, поэтому есть a=0что быть вставлен в качестве аргумента командной строки.

C, 52 байта

i,k;f(n){for(i=k=0;i<n;k=++i%2+2*k)printf("%d ",k);}

1-индексированных

Попробуйте онлайн!

брейкфук , 40 байт

,[>.>>[>]<[.->[>]+[<]+<]+<[[-<+>]>-<]<-]

Попробуйте онлайн!

0 индексированные. Вводить как код символа, выводить как унарный с нулевыми байтами, разделяющими серии кодов 1 с. Предполагает 8-битные ячейки, если вы не хотите вводить более 255. Предполагается, отрицательные ячейки, хотя это может быть исправлено за счет нескольких байтов.

Ранее 50 байтов

,[[<]>->>[<-<->>>>-<]<[->>++<<]>>+[-<<+>>]<<.<<+>]

Попробуйте онлайн!

Входы как код символа, выходы как код символа. 1-индексироваться. Вероятно, можно немного поиграть в гольф.

@Unihedron указывает, что я забыл указать, что для этого нужны ячейки бесконечного размера, в противном случае он занимает 8-е число.