Странно четный, положительно отрицательный

36

Учитывая 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 ...

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

Кальвин Хобби
источник
A001057 без начального нуля?
devRicher
@devRicher нет, абсолютные значения там идут, 1,1,2,2,3,3,4,4,...но здесь это 1,2,2,1,3,4,4,3,....
Мартин Эндер
6
Не могли бы вы предоставить закрытую форму для этой последовательности или хотя бы что-то более конкретное, чем первые несколько терминов
0
Это уравнение для n-го члена никогда не приводит к отрицательному значению ... что-то не так с ним.
Волшебная Осьминог Урна
1
@ 0 'Я добавил то, что думаю, интуитивно, глядя на это, хотя и не в закрытом виде. Частично задача состоит в том, чтобы выяснить, что такое шаблон и как его перевести в математику и код.
Увлечения Кэлвина

Ответы:

32

Python 2 , 23 байта

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

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

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

XNOR
источник
1
Объяснение? :)
MildlyMilquetoast
17

Mathematica, 29 байт

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

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

Грег Мартин
источник
9

Пип , 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, но здесь они бесполезны.

DLosc
источник
9

Желе , 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.
Деннис
источник
Я думаю, что это самые стандартные символы ASCII, которые я видел в представлении Jelly. Я вижу только двух персонажей, которые меня раздражают (не считая ¡)
Esolanging Fruit
google.com/…
Деннис,
9

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

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

Кевин Круйссен
источник
2
Вам не нужна троичная проверка, если вы поставили (n / 2) в скобках.
ГБ
1
@ GB Ах, вот в чем проблема .. Спасибо. Теперь я чувствую себя глупо ..>.>
Кевин Круйссен
О, нам разрешено только определения функций для Java?
Cruncher
@Cruncher Если в вопросе не указано иное, по умолчанию используется полная программа или функция . Так что да, можно просто опубликовать метод в Java или лямбду в Java 8 (я добавил эквивалент Java 8 в моем ответе выше).
Кевин Круйссен,
1
@EricDuminil По умолчанию используется программа или функция , если в запросе не указано иное.
Кевин Круйссен
8

Желе , 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.
Деннис
источник
Я знал , что было бы желе ответ около 10
Cruncher
Я увидел это сразу после публикации этого комментария. Мне действительно нужно выучить Jelly на днях ... Забавно, если вы посмотрите на историю вопросов на этом SE. Раньше был весь GolfScript, затем CJam вступил во владение, и теперь это Jelly.
Cruncher
6

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)

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

Ataco
источник
Хороший подход! +1
Р. Кап
6

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

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

0 на основе

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

гигабайт
источник
5

Stacked , 30 28 байтов

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

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

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


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

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

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

Конор О'Брайен
источник
4

05AB1E, 8 байтов

2‰`^±¹F(

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

объяснение

2‰          divmod by 2
  `         flatten list
   ^        XOR
    ±       NOT
     ¹F(    Push 1st argument, loop N times, negate
mbomb007
источник
Вау, я люблю это, но ¹F(кажется дорогим для "если странно, отрицать".
Волшебный Осьминог Урна
@carusocomputing Да, но это самое короткое из известных мне. Аналогичный ответ Денниса в Jelly также имеет 3 байта для этой части. Это все еще короче, чем дубликаты, пуш паритет, если отрицание.
mbomb007
Я пытался в течение 15 минут обыграть его, единственное, что приблизилось, было еще одно 3-байтовое решение для силы n, для силы 1/n.
Волшебный Осьминог Урна
4

Желе , 9 8 байт

|2×Ḃ+H~$

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

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

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

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

Эрик Аутгольфер
источник
3
Как только вы думаете, что выигрываете, Деннис придет и победит вас.
HyperNeutrino
|2×Ḃ+H~$сохраняет байт. tio.run/nexus/jelly#AR0A4v//fDLDl@G4gitIfiT/…
Деннис
@ Денис Я думал, что это будет плевать на ошибку.
Эрик Outgolfer
3

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]
Мартин Эндер
источник
2

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)

Брэд Гилберт b2gills
источник
Хорошая подача!
CraigR8806
2

Haskell , 37 36 байт

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

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

Laikoni
источник
1

Haskell, 56 байт

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

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

Blex
источник
1

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
CraigR8806
источник
Вы можете сохранить один байт, используя print +((и удаляя финал ). И еще два, используя sayи -E. А также еще один, делая ($_%4&1||-1)вместо троичного.
simbabque
1

JavaScript (ES7), 28 байт

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

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

ETHproductions
источник
1

JavaScript, 28 22 байта

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

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

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

fənɛtɪk
источник
Хм ... будет f=x=>x%2?~x>>1:x/2+x%4-1работать?
ETHproductions
По какой-то причине я оставил f = перед анонимной функцией: P
fəˈnɛtɪk
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индексируется.

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

Р. Кап
источник
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)
user2390246
источник
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))) .

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

pizzapants184
источник
0

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.
steenbergh
источник
0

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.
Дэниэл Плейнвью
источник