Розглянемо таку послідовність:

0 1 3 2 5 4 8 6 7 12 9 10 11 17 13 14 15 16 23 ...

Виглядає досить без візерунка, правда? Ось як це працює. Починаючи з 0, підскакуйте nцілі числа, nпочинаючи з 1. Ось наступне число в послідовності. Потім додайте будь-які цифри, "пропущені", які ще не були помічені у порядку зростання. Потім приріст nі стрибок з останнього доданого числа. Повторіть цю схему.

Так, наприклад, коли ми добираємось 11, ми знаходимося n=5. Ми збільшуємо nбути n=6, стрибати до 17, потім додати , 13 14 15 16так як ті , які ще не були видні. Наступний наш стрибок - n=7значить, наступний елемент у послідовності 23.

Змагання

Задавши введення x, виведіть xтретій термін цієї послідовності, перші xчлени послідовності або побудуйте нескінченний список термінів послідовності. Можна вибрати 0- або 1-індексацію.

I / O та правила

• Введення та вихід можуть бути надані будь-яким зручним методом .
• Вхідні дані та вихідні дані можуть вважатись відповідними типу рідного номера вашої мови.
• Прийнятна або повна програма, або функція. Якщо функція, ви можете повернути вихід, а не надрукувати його.
• Стандартні лазівки заборонені.
• Це код-гольф, тому діють усі звичайні правила гольфу, і найкоротший код (у байтах) виграє.

JavaScript (ES7), 41 байт

Повертає n-й додаток послідовності, індексований 0.

n=>(d=(n--*8-23)**.5)%1?n:'121'[n]^n-~d/2

Спробуйте в Інтернеті!

Як?

Основна справа: $n > 3$

Перші чотири члени послідовності є особливими, тому давайте відкладемо їх поки що.

Для послідовність виглядає так:$n > 3$

 n  | [4] 5 [6] 7 8 [ 9] 10 11 12 [13] 14 15 16 17 [18] 19 20 21 22 23 [24] 25 26 27 ...
----+------------------------------------------------------------------------------------
a(n)| [5] 4 [8] 6 7 [12]  9 10 11 [17] 13 14 15 16 [23] 18 19 20 21 22 [30] 24 25 26 ...
----+------------------------------------------------------------------------------------
 k  |  2  -  3  - -   4   -  -  -   5   -  -  -  -   6   -  -  -  -  -   7   -  -  - ...

Ми можемо помітити, що насправді є дві перемежовані підрядки:

• Більшість значень належать до підпорядку для якого у нас просто є:$A$

  $$A(n) = n - 1$$

• Деякі інші значення належать до під послідовності (виділеної дужками на наведеній вище діаграмі), індекси якої відповідають арифметичній послідовності 3, 3, 4, 6, 9, 13, 18, 24 ... і для якої ми маємо:$B$

  $$B(n,k) = n + k - 1$$

  де є індексом в основний послідовності , і до є індексом в суб-послідовності B .$n$$k$$B$

Показники в основній послідовності задаються:$B$

З огляду на , ми знаємо, що відповідний член у головній послідовності належить B, якщо n - ціле рішення квадратичного рівняння:$n$$B$$n$

дискримінант якого:

і чиє позитивне рішення:

Ми очікуємо - ціле число. Звідси тест:$\sqrt{\Delta}$

(d = (n-- * 8 - 23) ** .5) % 1

Особливі випадки: $0 \le n \le 3$

При дискримінант є негативним, і його квадратний корінь призводить до NaN . При n = 3 дискримінант дорівнює 1 . Таким чином, ці перші чотири члени послідовності вважаються належними до підпослідовності B .$n < 3$$n = 3$$1$$B$

Якщо ми просто застосуємо нашу стандартну формулу n - ~ d / 2 , ми отримаємо:

замість:

Ось чому ми XOR ці результати з відповідно.$0,1,2\text{ and }1$

Лушпиння , 12 байт

Θṁṙ_1C+ḣ2tNN

Спробуйте в Інтернеті!

Виходи як нескінченний список. Ось версія , яка друкує перший N .

Пояснення

Θṁṙ_1C + ḣ2tNN - Повна програма. Не приймає вводу, виводить на STDOUT.
         tN - Побудуйте нескінченний список натуральних чисел, починаючи з 2.
      + ḣ2 - І додайте до нього [1, 2]. Врожайність [1,2,2,3,4,5,6,7,8,9,10,11, ...].
     CN - Виріжте нескінченний список натуральних чисел на шматки цих
               розміри. Урожайність [[1], [2,3], [4,5], [6,7,8], [9,10,11,12], ...].
 ṁ - Надайте на карту і вирівняйте результати після цього.
  ṙ_1 - Обертайте кожного праворуч на 1 одиницю.
               Врожайність [1,3,2,5,4,8,6,7,12,9,10,11, ...]
Θ - Додайте 0. Урожайність [0,1,3,2,5,4,8,6,7,12,9,10,11, ...]

Haskell , 43 байти

0:1:3:2:5!3
a!n=a:[a-n+2..a-1]++(a+n)!(n+1)

Спробуйте в Інтернеті!

Визначає нескінченний список:

  0:1:3:2:(5!3)
≡ 0:1:3:2:5:4:(8!4)
≡ 0:1:3:2:5:4:8:6:7:(12!5)
≡ 0:1:3:2:5:4:8:6:7:12:9:10:11:(17!6)
≡ 0:1:3:2:5:4:8:6:7:12:9:10:11:17:13:14:15:16:(23!7) …

Желе , 15 байт

+‘ɼṪRṙ-œ|@
0Ç¡ḣ

Це повна програма, яка, задаючи n , друкує перші n елементів послідовності.

Спробуйте в Інтернеті!

Як це працює

0Ç¡ḣ        Main link. Argument: n

0           Set the return value to 0.
 Ç¡         Call the helper link n times, first with argument 0, then n-1 times
            with the previous return value as argument.
   ḣ        Head; extract the first n items of the last return value.


+‘ɼṪRṙ-œ|@  Helper link. Argument: A (array)

 ‘ɼ         Increment the value in the register (initially 0) and yield it.
+           Add that value to all items in the sequence.
   Ṫ        Tail; extract the last item.
    R       Range; map k to [1, .., k].
     ṙ-     Rotate -1 units to the left, yielding [k, 1, ..., k-1].
       œ|@  Perform multiset union of A and the previous return value.

C (gcc), 73 67 64 байт

t,d;f(x){for(t=4,d=2;d<x;t+=d++)x-t||(d+=x+=d);t=x<4?x^x/2:x-1;}

Спробуйте в Інтернеті!

Визначає функцію, fяка приймає 0-індексує nі виробляє nth число в послідовності.

Ми можемо проаналізувати послідовність так:

f(n)  = n   where n = 0, 1

f(2)  = 3   // 2 and 3 are swapped
f(3)  = 2

f(4)  = 5   // (+2,+3)
f(6)  = 8   // (+3,+4)
f(9)  = 12  // (+4,+5)
f(13) = 17  // (...)
...

f(n)  = n-1 // for all cases not yet covered

Спочатку обробляємо середній розділ:

for(t=4,d=2;d<x;t+=d++)x-t||(d+=x+=d);

Зауважте, що аргументи зліва (4, 6, 9, 13, ...) слідують шаблону: спочатку додайте два, потім додайте три, потім додайте чотири тощо. Починаємо з t=4і додаємо d(що починається з 2) кожної ітерації циклу, збільшуючись dу процесі.

Тіло петлі цікавіше. Пам'ятайте, що ми хочемо скласти карту 4 - 5, 6 - 8, 9 - 12 тощо; це просто додавання, d-1якщо xє t. Однак ця логіка виходить перед останнім випадком, f(n) = n - 1тому ми знаємо, що ми збираємось відняти 1 наприкінці. Тому ми можемо просто додати dif x == t( x-t||(x+=d)). Тим НЕ менше, ми також повинні вийти з циклу відразу ж після цього - тому ми додамо , що до dотримати абсурдний вигляд d+=x+=d, який завжди зробить d<xстан терпіти невдачу.

Це охоплює все, крім перших чотирьох значень. Дивлячись на них у двійковій формі, ми отримуємо:

00 -> 00
01 -> 01
10 -> 11
11 -> 10

Отже, ми хочемо перевернути останній шматочок, якщо 2 <= x < 4. Це здійснюється за допомогою x^x/2. x/2дає другий найменш значущий біт, тому XORing цього з оригінальним номером перевертає останній біт, якщо число 2 або 3.

Желе ,  13  10 байт

-3 Завдяки Деннісу (використовуйте 0-індексацію, щоб зберегти 2 від встановлення сукупної суми та остаточного зменшення)

Ḷ»2Äi+_>2$

Монадична посилання, що приймає ціле число, 0 -вкладене n , яке повертає ціле число, a (n)

Спробуйте в Інтернеті! Або подивіться тестовий набір

Perl 5 з -pl, 70 байт

$"="|";push@f,$;=$f[-1]+$-++,grep!/^(@f|$;)$/,0..$;for 0..$_;$_=$f[$_]

Спробуйте в Інтернеті!

MATL , 22 байти

1y:"t0)@+h5M:yX-h]qw:)

Виводить перші nчлени послідовності.

Спробуйте в Інтернеті!

Пояснення

1         % Push 1
y         % Implicit input: n. Duplicate from below
":        % For each k in [1 2 ... n]
  t0)     %   Duplicate sequence so far. Get last entry, say m
  @+      %   Add k: gives m+k
  h       %   Concatenate horizontally
  5M      %   Push m+k again
  :       %   Range [1 2 ... m+k]
  y       %   Duplicate from below
  X-      %   Set difference
  h       %   Concatenate horizontally
]         % End
q         % Subtract 1, element-wise
w         % Swap. Brings original copy of n to the top
:)        % Keep the first n entries. Implicit display

Haskell , 51 байт

0:1:do(a,b)<-zip=<<(1:)$scanl(+)3[2..];b:[a+1..b-1]

Спробуйте в Інтернеті!

Трохи довше, ніж відповідь Лінн Хаскелл , але різний підхід може бути цікавий.

Рубін , 73 байти

f=->x,l,n{!l[x]&&(i=l[-1];f[x,l+[i+n]+([*(i+1...i+n)]-l),n+1])||l[0...x]}

Спробуйте в Інтернеті!

Рекурсивна функція, яка повертає перші x числа списку.

QBasic, 58 байт

DO
b=r+j
?b
r=b
FOR x=a+1TO b-1
?x
r=x
NEXT
a=b
j=j+1
LOOP

Виходи нескінченно. Ви можете додатиSLEEP 1 внутрішній цикл або зробити його LOOP WHILE b<100чи щось подібне, щоб побачити результати.

Це в основному реалізує специфікацію. Зауважте, що числа, за які ми повернемось, завжди будуть числами між останнім перехідним числом до числа, яке перейшло до цього. Тому ми зберігаємо ці межі як aі, bі використовуємо FORцикл для друку всіх цифр між ними.

05AB1E , 14 байт

0)sƒ¤N+LÁ«}Ùs£

Спробуйте в Інтернеті!

R , 70 байт

function(e){for(i in 1:e)F=c(setdiff((F+i):1-1,F),F[1]+i,F);rev(F)[e]}

Спробуйте в Інтернеті!

• 1-індексований
• -4 байти, використовуючи Fконстанту завдяки пропозиції @JAD
• -5 байт перевертає список завдяки пропозиції @Giuseppe
• -2 байти видалення непотрібних дужок для циклу завдяки пропозиції @JAD
• -2 байти, використовуючи setdiffзамістьx[x %in% y]

Попередня версія (79 байт)

Python 2 , 123 байт

def f(z):[s.extend([s[-1]+n]+[x for x in range(s[-1]+1,s[-1]+n)if not x in s]) for n in range(1,z)if len(s)<z];return s    

Спробуйте в Інтернеті!

Дано вхід x, виведіть перші x умови послідовності,

Я вивчаю Python, і це завдання робить речі цікавішими.

Редагувати: поголіть пробіл

Желе , 16 байт

RÄṬŻk²Ḋ$ṙ€-Ø.;Fḣ

Спробуйте в Інтернеті!

На один байт довше, ніж існуюча відповідь «Желе», але це, можливо, може бути небагато. RÄṬŻk²Ḋ$може бути, коротше.

18 байт

RÄṬŻk²Ḋ$‘ṙ€1FŻŻỤ’ḣ

Більш довгі, але різні.

Рубін , 63 байти

->x,n=0{n+=1while 0>d=n*n+n<=>2*x-6;[0,1,3,2][x]||[x+n,x-1][d]}

Спробуйте в Інтернеті!

0-індексований. Можливо, може бути гольф вниз.

Perl 6 , 52 байти

(0,{((^max @_)∖@_).min.?key//(1+@_[*-1]+$++)}...*)

Спробуйте в Інтернеті!

Це генераторне вираження за допомогою ...оператора. Він шукає прогалини в попередній послідовності @_через ((^max @_)∖@_).min.?key:

      @_  # prior sequence values         [0,1,3]
  max @_  # largest prior sequence value       3
 ^        # the Range 0..max @_            0,1,2
(       )∖@_  # set subtract prior seq     -0,1  -> (2=>True)
            .min  # smallest unseen value  2=>True
                .?key  # set yields pairs  2

?Необхідно для початкового значення , яке не має .key. Якщо пропусків не знайдено, він додає n (тут у $змінній) до останнього значення у списку, плюс одне для виключення на 0 помилок.

Пітон 3 , 104 байти

def f(x):
 n=a=0
 l=list(range(x*x))
 while n<x:print(l[a+n],*l[a+2-(n<3):a+n],end=' ');a=a+n-(a>0);n+=1

Спробуйте в Інтернеті!

Дано вхід x, виведіть перші x "послідовності"