(Вызов из многопользовательской игры (столкновение кода) на сайте codingame.com )

Соревнование

Найдите n-й член следующей последовательности: 1, 1, 2, 1, 2, 3, 1, 2, 3, 4...или, чтобы сделать его более очевидным,{1}, {1,2}, {1,2,3}, {1,2,3,4}...

Последовательность состоит из объединенных диапазонов от 1 до x , начиная с 1, вплоть до бесконечности.

Правила / IO

Ввод и вывод могут быть в любом формате, если они различимы. Ввод может быть взят из любого подходящего источника: STDIN, файла и т. Д.

Ввод может быть 0- или 1-индексирован, а выбранная индексация должна быть упомянута в посте.

Вам нужно будет обработать по крайней мере до результата 255 включительно (то есть максимальный вход с индексом 0 равен 32640). Все, что с этим связано, должно быть обработано, если ваш язык поддерживает это.

Так code-golfвыигрывает самый короткий байт!

Контрольные примеры (индексация на основе 0)

0 -> 1
1 -> 1
5 -> 3
10 -> 1
59 -> 5
100 -> 10
1001 -> 12

05AB1E , 5 байтов

Программа 0-проиндексирована, код:

ÌLL¹è

Объяснение:

Ì       # Double increment the input
 LL     # List of list on the input
   ¹è   # Get nth element

Использует кодировку CP-1252 . Попробуйте онлайн!

Haskell , 27 26 байтов

([z|k<-[1..],z<-[1..k]]!!)

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

Спасибо @DanD. за -1 байт!

Это анонимная функция, создавая бесконечную последовательность ап только возвращая nего -ю элемент: [[1..k]| k<-[1..]]производит бесконечный список список: [[1],[1,2],[1,2,3],[1,2,3,4],...]. Чтобы объединить их, мы можем написать, [z|k<-[1..],z<-[1..k]]что приводит к [1,1,2,1,2,3,1,2,3,4,...]и, наконец, (...!!)принимает ввод n(бессмысленное обозначение) и возвращает n-ое слагаемое (на основе 0).

JavaScript, 29 28 байт

-1 байт благодаря Арно!

f=(n,m)=>n++<m?n:f(n+~m,-~m)

Использует рекурсивную формулу с 0 индексами, найденную в OEIS.

При вызове с 1 аргументом, как и ожидалось, значение по умолчанию второго m,, будет undefined. Однако -~undefinedвозвращает 1, что позволяет нам m = 1переходить рекурсия без явного в списке аргументов (спасибо @Arnauld!)

Тестовый фрагмент:

f=(n,m)=>n++<m?n:f(n+~m,-~m)

let examples = [0, 1, 5, 10, 15, 1000];

examples.forEach(function log(x) {
    console.log(x, " => ", f(x))
});

В качестве альтернативы, для одного и того же числа байтов мы можем использовать функцию карри следующим образом:

f=n=>m=>n++<m?n:f(n+~m)(-~m)

Вы можете вызвать это с помощью f(5)()- она ​​возвращает функцию, которая при вызове возвращает результат, как описано в этом мета-посте .

Желе , 5 байтов, 1-индексированный

RRF³ị

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

Объяснение:

                                      (Assume N = 4 for the examples)
R      Generate a list of 1 to N      [1, 2, 3, 4]
 R     Generate new lists for each item on the previous list, with that item as N
                                      [[1], [1,2], ...]
  F    Flatten that list              [1, 1, 2, 1, 2, 3 ...]
   ³ị  Use the input number (³) as index (ị) on the list. 
       This is one-based:             [1, 1, 2, 1, 2, 3 ...] 
                                                ^

Октава, 39 байт

@(z)z-(n=ceil((8*z+1)^.5/2-.5))*(n-1)/2

1 основанный индекс

Объяснение:

Рассмотрим эту последовательность:

1   1   2   1   2   3   1   2   3   4   1   2   3   4   5

если мы посчитаем количество элементов подпоследовательностей мы имеем

1   2        3          4               5         

поэтому, используя формулу Гаусса для треугольного числа, мы можем сформировать формулу для z:

z=n*(n+1)/2

это квадратное уравнение, если мы решим его для п мы имеем

n=(sqrt(8*z+1)-1)/2

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

Haskell, 25 24 байта

(!!)$[1..]>>= \x->[1..x]

Пример использования: ((!!)$[1..]>>= \x->[1..x]) 10-> 1. Попробуйте онлайн! ,

Сопоставляет анонимную функцию make-a-list-from-1-to-x \x->[1..x](встроенная длина на enumFromTo 1один байт) с бесконечным списком [1..]и объединяет полученные списки в один список. !!выбирает n-й элемент.

Спасибо @flawr за один байт.

Октава , 39 байт

@(n){v=1:n,A=triu(v'+0*v),A(A>0)(n)}{3}

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

Это использует альтернативный подход.

Например, n=1это A=triu(v'+0*v)создает матрицу

1   1   1   1
0   2   2   2
0   0   3   3
0   0   0   4

При удалении всех нулевых элементов и добавлении столбцов A(A>0)мы получаем последовательность:

1   1  2  1  2  3  1  2  3  4

Тогда это просто вопрос извлечения n-й член этой последовательности.

Python , 39 36 байт

-3 байта благодаря Денису!

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

f=lambda n,m=1:n*(n<=m)or f(n-m,m+1)

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

Мы отслеживаем текущий размер "увеличения", используя m. Если nоно меньше или равно m, оно вписывается в текущий «рост», и поэтому мы его возвращаем. Однако, если оно больше чем m, мы mубираем его, затем добавляем 1 к mи рекурсивно вызываем функцию (переходя к следующему повышению).

R, 25 байт

i=scan();sequence(1:i)[i]

Индекс основан на 1.

Pyth , 6 5 байт

1 байт сохранен благодаря @TheBikingviking!

@s._S

При этом используется индексирование на основе 0.

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

объяснение

@          Index with implicit input into
   ._      all prefixes of
     S     1-based range of implicit input
 s         concatenated into an un-nested list

Mathematica, 27 24 байта

Спасибо @MartinEnder за 3 байта!

((r=Range)@r@#<>1)[[#]]&

1-индексироваться. Это выбрасывает ошибки, которые безопасно игнорировать.

объяснение

((r=Range)@r@#<>1)[[#]]&
  r=Range                 (* Store Range function in r *)
           r@#            (* Create list {1..n} *)
 (r      )@               (* For each element, generate {1..n} *)
              <>1         (* Join the lists and append a 1; throws errors *)
(                )[[#]]&  (* Take the nth element *)

брейнф * ск, 78 байт

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

Принимает ввод (на основе 0) и выводит как байтовые значения.

Вы можете проверить это здесь.

Ввод требует \до десятичных чисел (например, \10для 10). Если вывод является печатным символом ASCII, вы должны увидеть его. В противном случае, нажмите Просмотр памяти -> Финальный дамп. Значение, которое было напечатано, находится в 3-й ячейке (ячейка № 2).

Объяснение:

Ячейка 0 (INPUT): является входом и уменьшается на 1 каждый раз через цикл.

Ячейка 1 (RESET): увеличивается на 1 каждый раз, когда она равна TERM. Для этого каждый раз в цикле мы добавляем 1, а если они не равны, мы вычитаем 1.

Ячейка 2 (TERM): увеличивается на 1 в каждом цикле и устанавливается на 0, если соответствует RESET. Для этого я копирую значение обратно из HOLD только в том случае, если эта ячейка не равна RESET.

Ячейка 3 (EQUAL): используется для проверки того, равны ли RESET и TERM.

Ячейка 4 (HOLD): используется для копирования значений RESET и TERM обратно после проверки на равенство.

,>+<              # get input and put a 1 in RESET
[                 # for INPUT to 0
  >[->>+>+<<<]    # copy RESET to EQUAL and HOLD
  >>>[-<<<+>>>]   # copy HOLD back into RESET
  <<+             # add 1 to TERM
  [->->+<<]       # subtract TERM from EQUAL and copy it to HOLD
  >[              # if RESET and TERM were not equal
    <<-           # subtract 1 from RESET
    >>>[-<<+>>]   # copy HOLD back to TERM
    <[-]          # zero out EQUAL
  ]               # end if
  >[-]            # zero out HOLD
  <<<+            # add 1 to RESET (this cancels out the subtraction if
                  #     RESET did not equal TERM)
  <-              # subtract 1 from INPUT
]>>+.             # end for and add 1 because the sequence resets to 1 not 0

Пайк, 6 байт

OmSsQ@

Попробуй это здесь!

O      -    input+2
 mS    -   map(range(1,i+1), range(^))
   s   -  sum(^)
    Q@ - ^[input]

0 индексированные.

R, 43 41 байт

Изменить: Найден более короткий рекурсивный подход с использованием A002262 + 1 (0 проиндексировано):

f=function(n,m=1)`if`(n<m,n+1,f(n-m,m+1))

Старая версия:

n=scan();n-choose(floor((1+sqrt(8*n))/2),2)

1-индексированная формула от OEIS.

Perl 6 , 21 байт

{map(|^*,^∞)[$_]+1}

0 индексированные. Попробуйте онлайн!

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

{                 }  # A lambda.
         ^∞          # Range from 0 to Inf-1. (Same byte count as 0..*, but cooler.)
 map( ^*,  )         # Map each number n to the range 0..(n-1),
     |               # And slip each range into the outer list.
            [$_]     # Index the sequence with the lambda argument.
                +1   # Add 1.

Perl 6 , 21 байт

{[\,](1..*).flat[$_]}

0 индексированные. Попробуйте онлайн!

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

{                   }  # A lambda.
      1..*             # Range from 1 to infinity.
 [ ,](    )            # Fold it with the comma operator,
  \                    # and return all intermediate results, e.g. (1), (1,2), (1,2,3)...
           .flat       # Flatten the sequence.
                [$_]   # Index it with the lambda argument.

Ни одно из этих решений не является таким же коротким, как у JungHawn Min , но они представляют собой альтернативные подходы, что, я думаю, и есть. Обе функции являются безымянными и берут (1-индексированный) положительный целочисленный ввод и возвращают положительное целое число.

Mathematica, 30 байт

-#^2-#&@⌈√(2#)-3/2⌉/2+#&

Фактическая математическая формула для этой функции! Сделано более удобным для чтения (в части перевода символов 3 байта ⌈, √и ⌉):

# - ((#^2 + #) / 2 &)[Ceiling[Sqrt[2 * #] - 3/2]] &

Ceiling[Sqrt[2 * #] - 1/2]говорит нам, к какому подсписку относится входной элемент, из которого мы вычитаем один, чтобы сообщить нам, какой подсписок заканчивается, прежде чем мы попадем на вход; затем ((#^2 + #) / 2 &)вычисляет, сколько элементов встречается во всех подсписках до того, который нам нужен, и вычитаем из входных данных #наш ответ. (Некоторые заметят знакомую формулу (#^2 + #) / 2для #треугольного числа; Ceiling[Sqrt[2 * #] - 1/2]по сути это обратная функция.)

Mathematica, 32 байта

If[#2<=#,#2,#0[#+1,#2-#]]&[1,#]&

Рекурсивное решение, в основном, такое же, как в ответе Билливоба и других.

Brain-Flak , 46 байтов

Ноль индексируется

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

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

Чистый стек, 48 байт

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

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

объяснение

Это модифицированная версия функции по модулю . Вместо того чтобы использовать постоянное число в качестве делителя, оно увеличивает делитель на каждый раз, когда из него вычитается делитель (один раз за итерацию внешнего цикла).

Аннотированный код

(<>())       # Switch to the opposite stack and push 1 (the initial divisor)
{            # (outside loop) While top of stack is not 0...
  (          # Push...
    ({}())   # Push the divisor plus 1
  [()])      # ...minus one (ie push a copy of the original divisor
  {          # (inner loop) While the top of stack does not equal zero
    ({}[()]) # Decrement the top of the active stack
    <>       # Switch stacks
  }{}        # (inside loop) End loop and pop zero off the top of stack)
}            # (outside loop) End loop
<>           # Switch stacks (to the one with the divisor)
([{}()]{})   # Calculate the result

Java 8, 85 73 55 байт

n->f(n,1)+1int f(int n,int m){return n<m?n:f(n-m,m+1);}

0-индексированный рекурсивный подход с формулой, представленной в OEIS :

a(n) = 1 + A002262(n),
A002262 : a(n)=f(n,1)с f(n,m) = if n<m then n else f(n-m,m+1).

Попробуй это здесь.

Старый ответ ( 85 56 байт):

n->{int m=~-(int)Math.sqrt(8*n+1)/2;return n-m*-~m/2+1;}

Использовали другую 0-индексированную формулу, представленную в OEIS :

n-й член есть n - m*(m+1)/2 + 1, где m = floor((sqrt(8*n+1) - 1) / 2).

Попробуй это здесь.

Perl , 30 байт

29 байт кода + -pфлаг.

map{$\-=$c++if$c<++$\}0..$_}{

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

MATL, 8 байт

:"@:]vG)

В этом решении используется индексирование на основе 1

Попробуйте это на MATL Online

объяснение

        Implicitly grab input (N)
:       Create an array from [1...N]
"       For each element (A) in this array...
  @:    Create an array from [1....A]
]       End for loop
v       Vertically concatenate everything on the stack
G       Explicitly grab the input again
)       And use it to index into the vertically concatenated array
        Implicitly display the result

QBIC , 21 байт, 1-индексированный

:[a|[b|~q=a|_Xc\q=q+1

Объяснение:

:      Get 'a' from the cmd line
[a|    FOR (b = 1; b <= a; b++) This creates an outer loop from 1 to N
[b|    FOR (c = 1; c <= b; c++) This creates an iteration, yielding the 1, 12, 123 pattern
       'q' stores how many terms we've seen. It starts at 1 b default.
~q=a   if we are at the desired term (q == a)
|_Xc   Then quit, and print 'c' (the current number in the sequence)
\q=q+1 Else, increase 'q' and run again.

Чуть более интересный подход, но на 10 байт длиннее:

:{~b+q>=a|_xa-b|\b=b+q┘q=q+1

Эта программа непрерывно вычисляет общее количество чисел в этой скобке и всех предыдущих ( 1 at loop 1, 3 at loop 2, 6 at loop 3 ...). Когда этот счетчик превысит искомый индекс N, верните X из текущей скобки, где X - это N минус предыдущее значение счетчика.

Рубин, 30 байтов

->n{(0..n).find{|x|0>=n-=x}+n}

Индексирование на основе 1

R, 37 байт

n=scan();for(i in 2:n)T=c(T,1:i);T[n]

Принимает входные данные nи создает последовательность для первых nпоследовательностей. Это делает его несколько неэффективным при более высоких входах, но это должно быть хорошо. Затем возвращаетn -й элемент, 1-индексированный.

Использует небольшой трюк, начиная с последовательности T, которая является TRUEили 1по умолчанию.

C11, 48 байтов

int f(int x){int q=1;while(x>q)x-=q++;return x;}

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

Также работает на C ++ и Java.

Альтернатива для того же количества байтов:

int f(int x){int q=0;while(x>++q)x-=q;return x;}

мозговой трах, 141 байт

Я знаю, что опаздываю за вознаграждение, но я просто хотел посмотреть, сколько байтов придумал алгоритм, о котором я думал.

Эта программа имеет нулевую индексацию.

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

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

• Выберите динамическую (бесконечную) память , иначе она не будет работать
• Чтобы проверить входные значения> 255, измените размер ячейки (биты) на 16 или 32 .
• Переводчик объясняет, как сделать ввод. Для десятичного ввода используйте \5для ввода 5.
  • Максимальное десятичное значение, с которым вы можете проверить ввод, равно \999
  • Шестнадцатеричный ввод может доходить до размера ячейки.

Объяснение:

Это показывает программу, разбитую по шагам, показывая, что происходит для ввода 5. #размещены в идеальных местах дампа памяти для переводчика.

Вы, вероятно, захотите использовать чекбокс Dump Memory на char:# если используете эту версию. Это удалит память при ударе #, позволяя вам увидеть значение на ленте в случае, если это непечатаемый символ, или посмотреть, что происходит на любом шаге, который вы хотите. Ячейка, на которой находится указатель, будет выделена жирным шрифтом.

,>+<                       (5) 1
[[->>+>+<<<]>>[-<<+>>]       5 1 (0) 5
<[->+>>+<<<]>[-<+>]>>+       5 1 0 5 (2)
[[-<->>+<]>[-<+>]<<<<] (0) 0 4 1 0 3 2 0 0
>>[>>>]                      4 1 0 3 2 0 (0) 0
                             1 1 0 (0) 2 0
>[.#[<<<]]<<<<                4 1 0 (3) 2 0 0 0
<<<[[-]>>>[-<+<<+>>>]<[->+<]<<<<<]>>> (3) 1 0 3 2 0 0 0
[>>>]<<<]>[.#>]

Tape structure:
    (cell_1 cell_2 temp), (cell_1 cell_2 temp), ...

Take Input;
If not zero:
  copy last pair to the right and add one to its cell_2
  subtract each cell_2 from each cell_1 (leaving each cell_2 intact)
  move checking from left to right: 
    If cell_1 is zero and cell_2 isn't:
      print cell_2
    Else:
      copy last cell_1 back, overwriting each previous cell_1
Else:
  right one and print result

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

• Выберите динамическую (бесконечную) память , иначе она не будет работать
• Дамп памяти на символ: #

Заметки:

• Чтобы запустить это на другом интерпретаторе, который не позволяет перемещаться влево от начальной ячейки (именно поэтому я использую динамическую память), вставьте несколько >в начале. Требуемое число может варьироваться в зависимости от входного значения, но равно O (1).

тинилисп (repl), 90 байт (0-индексированный)

(d r(q((n j x)(i n(i(e j x)(r(s n 1)1(s x(s 0 1)))(r(s n 1)(s j(s 0 1))x))j
(q((n)(r n 1 1

Или неконкурентный (с использованием функции, которая была зафиксирована после публикации этого вызова), 80 байтов :

(d r(q((n j x)(i n(i(e j x)(r(s n 1)1(a x 1))(r(s n 1)(a j 1)x))j
(q((n)(r n 1 1

Первая строка определяет вспомогательную функцию r, а вторая строка является неназванной функцией, которая принимает nи возвращает n-й член последовательности. Я указал это как представление repl, потому что repl автоматически заполняет скобки в конце каждой строки, а не только в конце программы. С этими предостережениями приведена версия, измененная для работы в онлайн-режиме Попробовать , и вот версия без присмотра, работающая на входах с 0 по 54.

объяснение

Я буду использовать неконкурентную версию здесь. Разница лишь в том, что официальная версия должна реализовывать сложение в виде двух вычитаний.

(d r           Define r to be:
 (q(           A lambda function (= a list of two elements, quoted to prevent evaluation):
  (n j x)       Arguments n, j (the range counter), and x (the range limit)
  (i n          If n is truthy, i.e. nonzero:
   (i(e j x)     If counter equals limit:
    (r            Call r recursively on:
     (s n 1)       n-1
     1             counter reset to 1
     (a x 1))      limit increased by 1
    (r           Else, call r recursively on:
     (s n 1)       n-1
     (a j 1)       counter increased by 1
     x))           same limit
   j))))        Else, we're done; return the counter value

(q(            Lambda function:
 (n)            Argument n
 (r n 1 1)))    Call r with n, counter = 1, range limit = 1

C 54 байта

Не самое короткое C-решение, но оно имеет преимущество работы в постоянном времени (без циклов, только математика). Используется индексация с нуля:

x;f(n){x=floor(sqrt(8*n+1)-1)/2;return 1+n-x*(x+1)/2;}

Ungolfed:

int f(int n) {
    int x = floor(sqrt(8*n+1)-1)/2; //calculate the number of the current subsequence (zero based)
    return 1+n-x*(x+1)/2;   //x*(x+1)/2 is the zero based index of the `1` starting the subsequence
}

Тест с:

#include <math.h>
#include <assert.h>
#include <stdio.h>

x;f(n){x=floor(sqrt(8*n+1)-1)/2;return 1+n-x*(x+1)/2;}

int main(){
    int i;
    for(i = 0; i < 10; i++) printf("%d ", f(i));
    printf("\n");

    assert(f(0) == 1);
    assert(f(1) == 1);
    assert(f(5) == 3);
    assert(f(10) == 1);
    assert(f(59) == 5);
    assert(f(100) == 10);
    assert(f(1001) == 12);
}

C 103 байта

Для начинающего все нормально, я думаю :).

int main(){int n,c,i,j;scanf("%d",&n);while(c<n){for(i=1;i<=j;i++){c++;if(c==n)printf("%d",i);}j++;}}

или отформатированный путь

#include <stdio.h>

int main() {
    int n,c,i,j;
    scanf("%d",&n);
    while(c<n) 
    {
        for(i=1;i<=j;i++)
        {
            c++;
            if(c==n) printf("%d",i);
        }
        j++;
    }
}

постоянный ток , 21 байт, индексирование на основе 0

?d8*1+v1-2/d1+*2/-1+p

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

Объяснение:

?      Push input number n.
d      Duplicate n at the top of the stack.
8*1+   Replace n at the top of the stack with 8n+1.
v      Replace 8n+1 at the top of the stack with the floor of its square root.
1-2/   Subtract 1, and divide by 2 (ignoring any fractional part).

Вершина стека теперь содержит индекс k наибольшего треугольного числа, которое <= n.

d1+*2/ Compute k(k+1)/2, which is the greatest triangular number <= n.
-      Subtract n-(the greatest triangular number <= n). The first n is on the stack in position 2, because the input number n was duplicated at the top of the stack at the very beginning of the program, and only one of the values was popped and used (until now).
1+     Add 1 because the desired sequence starts over again at 1 (not 0) at every triangular number.
p      Print the answer.

Эта программа постоянного тока может быть преобразована в bash-скрипт конкурентоспособного размера:

Утилиты Bash + Unix, 28 байтов, индексация на основе 0

dc -e"?d8*1+v1-2/d1+*2/-1+p"

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

C, 81 44 байта

прямой итерационный метод, 0 проиндексирован, и с небольшим массажем;

m=1,c=1;f(n){for(;n--;c=c^m?c+1:!!++m);c=c;}

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