Учитывая N, выведите N-й член этой бесконечной последовательности:

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ... etc.

N может быть 0 или 1 по вашему желанию.

Например, если 0-индексированные затем входы 0, 1, 2, 3, 4должны производить соответствующие выходы -1, 2, -2, 1, -3.

Если 1-индексированных затем входы 1, 2, 3, 4, 5должны производить соответствующие выходы -1, 2, -2, 1, -3.

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

1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 ...

и переставить каждую пару нечетных чисел, чтобы окружить четные числа чуть выше

1 2 2 1 3 4 4 3 5 6 6 5 7 8 8 7 9 10 10 9 11 12 12 11 ...

и, наконец, отрицая каждый второй термин, начиная с первого

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ...

Самый короткий код в байтах побеждает.

Python 2 , 23 байта

lambda n:~n/2+n%2*(n|2)

Нечетные входные данные дают примерно n/2, четные примерно -n/2. Итак, я начал с -n/2+n%2*nнастройки и оттуда.

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

Mathematica, 29 байт

((#~GCD~4/. 4->-2)+#)/2(-1)^#&

Чистая функция, принимающая вход с 1 индексом. За исключением знаковых переменных (-1)^#, последовательность вдвое ближе к входу, разность циклически равна 1, 2, 1, -2. Приятно #~GCD~4, что наибольший общий делитель входного и 4, 1, 2, 1, 4 циклически; поэтому мы просто вручную заменяем 4->-2и называем это днем. Мне нравится этот подход, потому что он избегает большинства многосимвольных команд Mathematica.

Пип , 24 22 байта

v**a*YaBA2|1+:--a//4*2

Принимает 1-индексированный ввод в качестве аргумента командной строки. Попробуйте онлайн или подтвердите 1-20 .

объяснение

Заметьте, что последовательность может быть получена путем объединения трех других последовательностей, одна с нулевым индексом и другие с одним индексом:

• Начните с 0 0 0 0 2 2 2 2 4 4 4 4= a//4*2(0-проиндексировано);
• Add 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, где BAэто побитовое И, и |логическое ИЛИ (1-индексированное);
• Умножьте сумму на -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(1-индексированный).

Если мы начнем с a1-индексированной части, мы можем сначала вычислить 1-индексированные части (считывая выражение слева направо), а затем уменьшить aдля 0-индексированной части. Используя встроенную переменную v=-1, мы получаем

v**a*((aBA2|1)+--a//4*2)

Чтобы побрить еще два байта, мы должны использовать некоторые приемы манипулирования предшествованием. Мы можем устранить внутренние скобки, заменив +в +:(эквивалент +=в большом количестве языков). Любой оператор вычисления и назначения имеет очень низкий приоритет, поэтому aBA2|1+:--a//4*2эквивалентен (aBA2|1)+:(--a//4*2). Pip выдаст предупреждение о назначении чего-то, что не является переменной, но только если у нас включены предупреждения.

Единственное , что это более низкий приоритет , чем :IS Y, оператор дергать * Он присваивает значение своего операнда к. yПеременной и передает ее через неизменными; таким образом , мы можем устранить внешние скобки , как хорошо дергать значение , а не его в скобках: YaBA2|1+:--a//4*2.

_{* Print и utput Oимеют тот же приоритет, что и Yank, но здесь они бесполезны.}

Желе , 8 7 байт

H^Ḃ~N⁸¡

При этом используется алгоритм из моего ответа на Python , который был значительно улучшен @GB .

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

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

H^Ḃ~N⁸¡  Main link. Argument: n

H        Halve; yield n/2. This returns a float, but ^ will cast it to int.
  Ḃ      Bit; yield n%2.
 ^       Apply bitwise XOR to both results.
   ~     Take the bitwise NOT.
    N⁸¡  Negate the result n times.

Java 8, 19 байт

n->~(n/2)+n%2*(n|2)

Java 7, 47 37 байт

int c(int n){return~(n/2)+n%2*(n|2);}

Впервые Java (8) фактически конкурирует и короче, чем некоторые другие ответы. Тем не менее, не могу превзойти настоящие языки игры в гольф, такие как желе и тому подобное (духух ... какая неожиданность ..>.>; P)

0-индексированный
порт из ответа @Xnor 's Python 2 .
-10 байт благодаря @GB

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

Желе , 15 12 11 байт

Ḷ^1‘ż@N€Fị@

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

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

Ḷ^1‘ż@N€Fị@  Main link. Argument: n

Ḷ            Unlength; yield [0, 1, 2, 3, ..., n-1].
 ^1          Bitwise XOR 1; yield [1, 0, 3, 2, ..., n-1^1].
   ‘         Increment; yield [2, 1, 4, 3, ..., (n-1^1)+1].
      N€     Negate each; yield [-1, -2, -3, -4, ..., -n].
    ż@       Zip with swapped arguments; 
             yield [[-1, 2], [-2, 1], [-3, 4], [-4, 3], ..., [-n, (n-1^1)+1]].
        F    Flatten, yield [-1, 2, -2, 1, -3, 4, -4, 3, ..., -n, (n-1^1)+1].
         ị@  At-index with swapped arguments; select the item at index n.

RProgN 2 , 31 25 22 байта

nx=x2÷1x4%{+$-1x^*}#-?

Разъяснения

nx=                         # Convert the input to a number, set x to it.
   x2÷                      # Floor divide x by 2.
      1                     # Place a 1 on the stack.
       x4%{       }#-?      # If x%4 is 0, subtract 1 from x//2, otherwise...
           +                # Add the 1 and the x together.
            $-1             # Push -1
               x^           # To the power of x.
                 *          # Multiply x//2+1 by -1^x. (Invert if odd, do nothing if even)

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

Рубин, 26 23 18 байт

->n{~n/2+n%2*n|=2}

0 на основе

-3 байта крадут идею -1 ^ n у Грега Мартина , Денниса и, возможно, кого-то еще, тогда -5 байтов крадут идею n | 2 у xnor .

Stacked , 30 28 байтов

:2%([:2/\4%2=tmo+][1+2/_])\#

Попробуйте онлайн! Возвращает функцию, которая в соответствии с мета-консенсусом. , Принимает ввод с вершины стека.

Используя тот же подход, что и ответ RProgN 2 .

В качестве альтернативы 46 байтов. Попробуйте онлайн! :

{!()1[::1+,:rev,\srev\,\2+]n*@.n 1-#n 2%tmo*_}

Этот генерирует диапазон, затем выбирает и отменяет член соответственно.

Python 2 ,  44  33 27 байт

lambda n:(-1)**n*~(n/2^n%2)

Спасибо @GB за отыгрывание 6 байтов!

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

05AB1E, 8 байтов

2‰`^±¹F(

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

объяснение

2‰          divmod by 2
  `         flatten list
   ^        XOR
    ±       NOT
     ¹F(    Push 1st argument, loop N times, negate

Желе , 9 8 байт

|2×Ḃ+H~$

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

-1 спасибо Денису . Дух плавают преобразования.

Использует подход @ xnor's Python 2.

РЕДАКТИРОВАТЬ : > _>

CJam , 16 байтов

{_(_1&)^2/)W@#*}

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

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

объяснение

Вот разбивка кода со значениями в стеке для каждого ввода от 1to 4. Первые несколько команд влияют только на два младших значащих бита, n-1поэтому после 4этого этот материал просто повторяется циклически, а результаты увеличиваются на 2 из-за деления на два.

Cmd             Stack: [1]       [2]       [3]       [4]
_    Duplicate.        [1 1]     [2 2]     [3 3]     [4 4]
(    Decrement.        [1 0]     [2 1]     [3 2]     [4 3]
_    Duplicate.        [1 0 0]   [2 1 1]   [3 2 2]   [4 3 3]
1&   AND 1.            [1 0 0]   [2 1 1]   [3 2 0]   [4 3 1]
)    Increment.        [1 0 1]   [2 1 2]   [3 2 1]   [4 3 2]
^    XOR.              [1 1]     [2 3]     [3 3]     [4 1]
2/   Halve.            [1 0]     [2 1]     [3 1]     [4 0]
)    Increment.        [1 1]     [2 2]     [3 2]     [4 1]
W    Push -1.          [1 1 -1]  [2 2 -1]  [3 2 -1]  [4 1 -1]
@    Rotate.           [1 -1 1]  [2 -1 2]  [2 -1 3]  [1 -1 4]
#    -1^n.             [1 -1]    [2 1]     [2 -1]    [1 1]
*    Multiply.         [-1]      [2]       [-2]      [1]

Perl 6 ,  55 27 24  22 байта

{(-1,2,-2,1,{|($^a,$^b,$^c,$^d Z+ -2,2,-2,2)}...*)[$_]}

(Вдохновленный zipWithответом на Haskell )
Попробуйте

{+^($_ div 2)+$_%2*($_+|2)}

(Вдохновлено несколькими ответами)
Попробуйте

{+^($_+>1)+$_%2*($_+|2)}

Попытайся

{+^$_+>1+$_%2*($_+|2)}

Попытайся

Expanded:

{  # bare block lambda with implicit parameter ｢$_｣

    +^          # numeric binary invert the following
      $_ +> 1   # numeric bit shift right by one
  +
      $_ % 2    # the input modulo 2
    *
      ($_ +| 2) # numeric binary inclusive or 2
}

(Все основаны на 0)

Haskell , 37 36 байт

(([1,3..]>>= \x->[-x,x+1,-x-1,x])!!)

Попробуйте онлайн! Это анонимная функция, которая принимает одно число в nкачестве аргумента и возвращает 0-индексированный nэлемент последовательности.

Haskell, 56 байт

f n=concat(iterate(zipWith(+)[-2,2,-2,2])[-1,2,-2,1])!!n

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

Perl 5 47 + 1 (для флага) = 48 байт

print(((sin$_%4>.5)+1+2*int$_/4)*($_%4&1?1:-1))

Старая подача 82 байта

@f=(sub{-$_[0]},sub{$_[0]+1},sub{-$_[0]-1},sub{$_[0]});print$f[$_%4](1+2*int$_/4)

Беги так:

perl -n <name of file storing script>  <<<  n

JavaScript (ES7), 28 байт

n=>(n+2>>2)*2*(-1)**n-!(n&2)

1-индексироваться. Я еще не посмотрел никаких других ответов, поэтому не знаю, является ли это лучшим алгоритмом, но подозреваю, что нет.

JavaScript, 28 22 байта

Спасибо @ETHproductions за игру в 6 байтов

x=>x%2?~x>>1:x%4+x/2-1

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

постоянный ток , 98 байт

?sa0sb1sq[lq1+dsqla!<i3Q]sf[lb1-lfx]su[lblfx]sx[lb1+dsblfx]sj[lqdd4%d0=u1=j2%1=xljxlfx]dsix_1la^*p

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

затем вывод (-1)^n * a_n, а не непосредственное вычисление n'-го элемента. В любом случае, это 1индексируется.

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

R, 38 байт

function(n)floor(n/2+1-2*!n%%4)*(-1)^n

объяснение

floor(n/2+1)                ->  1 2  2 3  3 4  4 5...
floor(n/2+1-2*!n%%4)        ->  1 2  2 1  3 4  4 3... (subtract 2 where n%%4 == 0)
floor(n/2+1-2*!n%%4)*(-1)^n -> -1 2 -2 1 -3 4 -4 3... (multiply odd n by -1)

TI-Basic (TI-84 Plus CE), 31 байт

.5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4)))i^(2Ans

TI-Basic - это токенизированный язык, и каждый используемый здесь токен составляет один байт, за исключением remainder(двух.

Это использует 1-индексированную версию.

Объяснение:

Существует шаблон, который повторяется каждые четыре числа. В версии с 1 индексом это: - (x + 1) / 2, (x + 1) / 2, - (x + 1) / 2, (x-1) / 2 для входного значения x. Это можно представить как кусочно-определенную функцию.

f (x) = - (x + 1) / 2, если x mod 1 mod 4; (x + 1) / 2, если x mod 2 mod 4; - (x + 1) / 2, если x mod 3 mod 4; (x-1) / 2, если x ≡ 0 mod 4

Поскольку части «x 1 mod 4» и «x 3 mod 4» одинаковы, мы можем объединить их в «x 1 mod 2».

Теперь есть кусочная функция:

f (x) = - (x + 1) / 2, если x mod 1 mod 2; (x + 2) / 2, если x mod 2 mod 4; (x-2) / 2, если x ≡ 0 mod 4

Здесь я начинаю разбивать его на настоящие команды. Поскольку значение является положительным для четных индексов и отрицательным для нечетных, мы можем использовать (-1) ^ x. Однако в TI-Basic i^(2X(5 байт) короче(-1)^Ans (6 байт). Обратите внимание, что круглые скобки обязательны из-за порядка операций.

Теперь, когда у нас есть способ отменить нечетные входы, мы переходим к модам (добавляя отрицание обратно позже). Я сделал случай нечетного ввода по умолчанию, поэтому мы начнем с .5(Ans+1).

Чтобы исправить случай четного ввода, просто добавьте единицу к числу в скобках, но только тогда, когда x mod 0 mod 2. Это может быть представлено как .5(Ans+1+remainder(Ans+1,2))или .5(Ans+1+not(remainder(Ans,2))), но они имеют одинаковое количество байтов, поэтому не имеет значения, какой именно.

Чтобы исправить случай ввода, кратного 4, нам нужно вычесть 3 из числа в скобках, а также еще 1, потому что все кратные 4 являются четными, что добавило бы один из нашего предыдущего шага, так что теперь мы имеем .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))) .

Теперь, просто прикоснитесь к определяющей знак части до конца, чтобы получить полную программу.

Befunge 93, 25 байт

Нулевой индексированные

&4/2*1+&4%3%!!+&2%2*1-*.@

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

Номер дан ((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)

QBIC , 53 байта

b=1:{[b,b+3|~b=a|_x(-(b%2)*2+1)*(q+(b%4>1)*-1)]]q=q+2

Объяснение:

b=1     Set b to a starting value of 1
        QBIC would usually use the pre-initialised variable q, but that is already in use
:       Get an input number from the cmd-line, our term to find
{       Start an infinite loop
[b,b+3| FOR-loop: this runs in groups of 4, incrementing its own bounds between runs
~b=a|   If we've reached the term requested
_x      QUIT the program and print:

(-(b%2)*2+1)   The b%2 gives a 1 or a 0, times 2 (2,0), negged (-2,0) and plus one (-1,1)
*              That gives us the sign of our term. Now the value:
(q+(b%4>1)*-1) This is q + 1 if the inner loop counter MOD 4 (1,2,3,0...) is 2 or 3.
]       Close the IF that checks the term
]       Close the FOR-loop
q=q+2   And raise q by 2 for the next iteration of the DO-loop.

Мудрый , 19 байт

::>!:><^^~![!-!-~]|

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

Это всего лишь порт ответа @Dennis 'Welly на Wise.

Q, 52 байта

{(1 rotate(,/){x,(-)x}each 1_((_)x%4)+til 3)x mod 4}

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

1. Получает номер блока т.е. какой блок [-x x + 1 - (x + 1) x] в последовательности содержит индекс.
2. Получает индекс значения в блоке на основе индекса значения во всей последовательности.
3. Создает блок.
4. Индексирует в него через индекс, полученный на шаге 2.