Дано 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звідти і налаштувався.

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

Математика, 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порозрядне AND, і |є логічним АБО (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 надсилатиме попередження про присвоєння чогось, що не є змінною, але лише якщо увімкнено попередження.

Єдине, що має нижчий пріоритет, ніж :це Y- оператор yank. * Він присвоює значення свого операнда yзмінній та передає його через незмінене; таким чином , ми можемо усунути зовнішні дужки , як добре смикати значення , а не його в дужках: YaBA2|1+:--a//4*2.

_{* rint Pі Output мають той самий пріоритет, що і ank Y, але тут не корисні.}

Желе , 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) насправді конкурує і коротша, ніж деякі інші відповіді. Досі не вдається перемогти фактичні мови для гри в гольф, як Jelly та подібні (duhuh .. який сюрприз ..>.>; 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 .

Складено , 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 завдяки Деннісу . Дух поплавкові перетворення.

Використовує підхід Python 2 @ xnor.

Редагувати : > _>

CJam , 16 байт

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

Вхід на основі 1.

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

Пояснення

Ось розбивка коду зі значеннями на стеку для кожного входу від 1до 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)
Спробуйте

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

(Натхненний кількома відповідями)
Спробуйте

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

Спробуй це

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

Спробуй це

Розширено:

{  # 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 ≡ 1 mod 4; (x + 1) / 2, якщо x ≡ 2 mod 4; - (x + 1) / 2, якщо x ≡ 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 ≡ 1 mod 2; (x + 2) / 2, якщо x ≡ 2 mod 4; (x-2) / 2, якщо x ≡ 0 mod 4

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

Тепер, коли у нас є спосіб відхилити непарні входи з шляху, ми переходимо до модів (додаючи заперечення назад згодом). Я зробив випадок непарного введення за замовчуванням, тому ми почнемо з.5(Ans+1) .

Щоб виправити випадок парного введення, просто додайте його до числа в круглих дужках, але лише тоді, коли x ≡ 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 'Jelly 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.