Ваша задача сегодня - применить волну к массиву чисел. Волна выглядит так: [1, 0, -1, 0, 1, 0, -1, 0, 1...]применение ее к данному массиву означает сложение первых элементов, вторых элементов и т. Д.

Точнее:

Ваша программа или функция получит массив целых чисел. Он должен печатать или возвращать массив одинакового размера с 1добавлением 1-го, 5-го, 9-го и т. Д. Элемента исходного массива, -1добавлением 3-го, 7-го, 11-го и т. Д. Элемента исходного массива и остальных элементов. следует оставить нетронутым

Входной массив гарантированно имеет хотя бы один элемент.

Тестовые случаи:

Input                               | Output
[0]                                 | [1]
[-1]                                | [0]
[-4, 3, 0, 1, 7, 9, 8, -2, 11, -88] | [-3, 3, -1, 1, 8, 9, 7, -2, 12, -88]
[0, 0, 0, 0, 0]                     | [1 ,0 ,-1 ,0 ,1]
[1, 1]                              | [2, 1]

Это код-гольф , самый короткий код выигрывает!

Желе , 5 байт

Jı*Ċ+

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

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

Jı*Ċ+  Main link. Argument: A (array)

J      Indices; yield [1, ..., len(A)].
 ı*    Elevate the imaginary unit to the power 1, ..., len(A), yielding
       [0+1i, -1+0i, 0-1i, 1+0i, ...].
   Ċ   Take the imaginary part of each result.
    +  Add the results to the corresponding elements of A.

LOGO , 18 байт

[map[?+sin 90*#]?]

Нет "Попробуй онлайн!" ссылка, потому что все онлайн переводчик LOGO не поддерживает список шаблонов.

Это список шаблонов (эквивалент лямбда-функции в других языках).

Использование:

pr invoke [map[?+sin 90*#]?] [-4 3 0 1 7 9 8 -2 11 -88]

( invokeвызывает функцию, prпечатает результат)

отпечатки [-3 3 -1 1 8 9 7 -2 12 -88].

Объяснение (уже довольно понятно):

 map[?+sin 90*#]?       map a function over all the items of the input
              #         the 1-based index of the element in the input
       sin 90*#         equal to the required wave
     ?                  looping variable
     ?+sin 90*#         add the wave to the input

Haskell , 26 байтов

zipWith(+)$cycle[1,0,-1,0]

Попробуйте онлайн! (запускает все тестовые случаи)

Объяснение:

zipWith(+)$cycle[1,0,-1,0]  -- anonymous tacit function
zipWith(+)                  -- pairwise addition between input list
          $cycle[1,0,-1,0]  -- and an infinitely-cycling "wave" list

JavaScript (ES6), 28 байт

a=>a.map((x,i)=>x-(i%4-1)%2)

Расчет идет так:

i%4  -1  %2
0    -1  -1
1     0   0
2     1   1
3     2   0

Последний бит использует тот факт, что в JS отрицательное число при модуляции сохранит свой отрицательный знак (то есть -5 % 3 -> -2вместо того, 1что было бы в Python).

Mathematica, 26 23 22 байта

Im[I^Range@Tr[1^#]]+#&

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

Примечание. Ссылка TIO предназначена для 23-байтовой версии, 22-байтовая версия не совместима с Mathics.

Python 2 , 40 байт

i=2
for x in input():print~-x+i%5%3;i*=2

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

MATL , 11 8 байт

Jyn:^Yj+

Попробуйте это в MATL Online!

объяснение

J     % Push 1j (imaginary unit)
      % STACK; 1j
y     % Implicit input. Duplicate from below
      % STACK: [-4 3 0 1 7 9 8 -2 11 -88], 1j, [-4 3 0 1 7 9 8 -2 11 -88]
n     % Number of elements
      % STACK: [-4 3 0 1 7 9 8 -2 11 -88], 1j, 10
:     % Range
      % STACK: [-4 3 0 1 7 9 8 -2 11 -88], 1j, [1 2 3 4 5 6 7 8 9 10]
^     % Power, element-wise
      % STACK: [-4 3 0 1 7 9 8 -2 11 -88], [1j -1 -1j 1 1j -1 -1j 1 1j -1]
Yj    % Imaginary part
      % STACK: [-4 3 0 1 7 9 8 -2 11 -88], [1 0 -1 0 1 0 -1 0 1 0]
+     % Add, element-wise. Implicit display
      % STACK: [-3 3 -1 1 8 9 7 -2 12 -88]

Желе , 16 байт

-1Jm2$$¦+2Jm4$$¦

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

хе, я уверен, что это слишком долго

редактировать

Я знаю, что 5-байтовое решение возможно, но мой Wi-Fi, кажется, начинает отключать меня, поэтому я буду играть в гольф завтра. Если кто-то опубликует короткое решение Jelly прежде, чем я смогу сыграть в эту игру, это нормально для меня; Я просто оставлю это здесь для справки о том, насколько я плох в Jelly LOL, еще один способ сделать это. Я имею в виду, я мог бы просто посмотреть на ссылку, которую Феникс разместил в комментариях, но, поскольку я все еще учусь, я не хочу смотреть на решение, пока сам не выясню. Это может стоить мне репутации, но обучение - вот для чего я здесь :)))

R , 29 24 байта

(l=scan())+Im(1i^seq(l))

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

Python 2 , 50 42 байта

^{Благодаря @Sisyphus сэкономлено 8 байт!}

lambda l:map(sum,zip(l,[1,0,-1,0]*len(l)))

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

53 байта

lambda l:[int(x+(1j**i).real)for i,x in enumerate(l)]

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

Haskell , 26 байтов

@Mego опередил меня с этим решением

zipWith(+)$cycle[1,0,-1,0]

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

Это то, в чем Хаскелл хорош. Это объявляет бессмысленную функцию, которая упаковывает ввод бесконечным списком.

Haskell , 56 байт

Вот решение, которое использует комплексные числа. Не очень конкурентоспособный из-за импорта, но тем не менее довольно крутой.

import Data.Complex
zipWith((+).realPart.((0:+1)^))[0..]

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

Mathematica, 19 байт

i=1;#+Im[i*=I]&/@#&

объяснение

i=1;#+Im[i*=I]&/@#&
i=1;                 (* set variable i to 1 *)
               /@#   (* iterate through the input: *)
    #+Im[i   ]&      (* add the imaginary component of i... *)
          *=I        (* multiplying i by the imaginary unit each iteration *)

Примечание: i=1появляется вне функции, что хорошо для этого мета-консенсуса .

J, 12 байт

+1 0 _1 0$~#

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

Поскольку оператор формы J $заполняет циклически, когда мы формируем его по длине #ввода, он делает именно то, что нам нужно, и мы можем просто добавить его к входу]

C ++, 93 85 83 63 байта

auto w=[](auto&i){for(int j=0;j<i.size();j+=2)i[j]+=j%4?-1:1;};

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

-2 байта благодаря Nevay

-2 байта благодаря Zacharý

Я удалил vectorвключить. Вам нужно будет передать в качестве аргумента ва-контейнер, соответствующий следующим условиям:

• Вызвать метод sizeбез аргументов
• Перегружены оператор подписки

STL контейнеры , которые соблюдают следующие условия являются array, vector, string, map, unordered_map, и , возможно , другие

Если вывод путем изменения аргументов аргументов не разрешен, то:

C ++, 112 110 байт

#include<vector>
std::vector<int>w(std::vector<int>i){for(int j=0;j<i.size();j+=2)i[j]+=(j%4)?-1:1;return i;}

Пари / ГП , 30 байт

a->[a[x]+imag(I^x)|x<-[1..#a]]

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

Dyalog APL, 13 байт

⊢+1 0 ¯1 0⍴⍨≢

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

Как?

1 0 ¯1 0 - массив [1, 0, -1, 0]

⍴⍨≢ - изменить длину входного сигнала, циклически

⊢+ - векторизованная сумма с входом

Perl 6 , 28 байт

{((1+0i,*×i...*)Z+$_)».re}

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

1+0i, * × i ... *создает бесконечный список чисел, 1, i, -1, -iповторяемых в цикле. Эти числа упаковываются с помощью добавления ( Z+) и ввода ( $_), а затем извлекаются действительные компоненты полученных комплексных чисел ( ».re).

D, 56 байт

void w(T)(T[]i){for(T j;j<i.length;j+=2)i[j]+=j%4?-1:1;}

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

Это порт ответа C ++ от HatsuPointerKun , так что не забывайте о них!

Japt , 11 10 байт

Использует преимущества переноса индекса Japt.

Ë+[1TJT]gE

Попробуй это

объяснение

Неявный ввод массива U.

Ë

Карта над массивом.

+

К текущему элементу добавить ...

gE

Элемент в текущем индексе ( E) ...

[1TJT]

В массиве [1,0,-1,0].

На самом деле , 11 байтов

;r⌠╦½*C≈⌡M¥

Попробуйте онлайн! (запускает все тестовые случаи)

Объяснение:

;r⌠╦½*C≈⌡M¥
;r           range(len(input))
  ⌠╦½*C≈⌡M   for each value in range:
   ˫*C      cos(pi/2*value)
       ≈     floor to integer
          ¥  pairwise addition of the input and the new list

Pyth , 11 байт

.e+bss^.j)k

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

CJam , 15 байтов

l~_,,[1TW0]f=.+

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

Math.JS , 34 байта

f(k)=k.map(j(x,y,z)=x+im(i^y[1]))

Разъяснения

f(k)=k.map(j(x,y,z)=x+im(i^y[1]))
f(k)=                               # Define a function f, which takes argument k.
     k.map(                     )   # Map k to a function
           j(x,y,z)=                # Function j. Takes arguments x, y, and z. Where x is the item, y is the index in the form [i], and z is the original list.
                      im(      )    # The imaginary component of...
                         i^y[1]     # i to the power of the index.
                    x+              # x +, which gives our wave.

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

8-е , 96- 63 байта

Код

a:new swap ( swap 90 * deg>rad n:cos int + a:push ) a:each drop

Этот код оставляет результирующий массив на TOS

Использование и примеры

ok> [0,0,0,0,0] a:new swap ( swap 90 n:* deg>rad n:cos n:int n:+ a:push ) a:each drop .
[1,0,-1,0,1]

ok> [-4,3,0,1,7,9,8,-2,11,-88] a:new swap ( swap 90 * deg>rad n:cos int + a:push ) a:each drop .
[-3,3,-1,1,8,9,7,-2,12,-88]

объяснение

Мы используем cos (x), чтобы получить правильную последовательность [1,0, -1,0]. Индекс каждого элемента массива умножается на 90 градусов, а затем передается функции cos (), чтобы получить желаемый «волновой фактор», который будет добавлен к соответствующему элементу.

: f \ a -- a
  a:new    \ create output array
  swap     \ put input array on TOS
  \ array element's index is passed to cos in order to compute
  \ the "wave factor" to add to each item
  ( swap 90 n:* deg>rad n:cos n:int n:+ 
  a:push ) \ push new item into output array 
  a:each
  drop     \ get rid of input array and leave ouput array on TOS
;

C # (.NET Core) , 50 байтов

n=>{for(int i=0;i<n.Length;i+=2)n[i]+=i%4<1?1:-1;}

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

Использует простую лямбду. Изменяет исходный массив и возвращает вывод по ссылке.

05AB1E , 16 байтов

vy3L2.SR0¸«Nè+})

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

3L2.SR0¸«самая короткая вещь, о которой я могу думать sin(x % 4)в 05AB1E.

Рубин , 38 байт

->a{a.zip([1,0,-1,0].cycle).map &:sum}

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