Sua tarefa hoje é aplicar uma onda a uma matriz de números. Uma onda se parece com isso: [1, 0, -1, 0, 1, 0, -1, 0, 1...]aplicá-la a uma determinada matriz significa somar os primeiros elementos, os segundos elementos etc.

Mais precisamente:

Seu programa ou função receberá uma matriz de números inteiros. Ele deve imprimir ou retornar uma matriz de tamanho igual, 1adicionada ao 1º, 5º, 9º, etc. elemento da matriz original, -1adicionada ao 3º, 7º, 11º, etc. elemento da matriz original e o restante dos elementos deve ser deixado intocado.

A matriz de entrada é garantida para ter pelo menos um elemento.

Casos de teste:

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]

Este é o código-golfe , o código mais curto vence!

Geléia , 5 bytes

Jı*Ċ+

Experimente online!

Como funciona

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 bytes

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

Não há "Experimente online!" link porque todos os intérpretes on-line do LOGO não oferecem suporte à lista de modelos.

Essa é uma lista de modelos (equivalente à função lambda em outros idiomas).

Uso:

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

( invokechama a função, primprime o resultado)

impressões [-3 3 -1 1 8 9 7 -2 12 -88].

Explicação (já bastante compreensível):

 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 bytes

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

Experimente online! (executa todos os casos de teste)

Explicação:

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 bytes

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

O cálculo é assim:

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

O último bit aproveitando o fato de que em JS, um número negativo quando modulado retém seu sinal negativo (ou seja -5 % 3 -> -2, em vez de 1como seria em Python).

Mathematica, 26 23 22 bytes

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

Experimente online!(Matemática)

Nota: O link TIO é para a versão de 23 bytes, a versão de 22 bytes não é compatível com matemática.

Python 2 , 40 bytes

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

Experimente online!

MATL , 11 8 bytes

Jyn:^Yj+

Experimente no MATL Online!

Explicação

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]

Gelatina , 16 bytes

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

Experimente online!

heh, tenho certeza que isso é muito longo

Editar

Eu sei que uma solução de 5 bytes é possível, mas meu wifi parece estar começando a me impedir, então jogarei amanhã. Se alguém postar a pequena solução Jelly antes que eu possa jogar isso, tudo bem para mim; Vou manter isso aqui para referência sobre o quão ruim eu sou em Jelly, outra maneira de fazê-lo. Quero dizer, eu poderia apenas olhar para o link que Phoenix postou nos comentários, mas como ainda estou aprendendo, não quero olhar para a solução até que eu tenha descoberto. Isso pode me custar reputação, mas o aprendizado é para isso que estou aqui :)))

R , 29 24 bytes

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

Experimente online!

Python 2 , 50 42 bytes

^{Economizou 8 bytes graças a @Sisyphus!}

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

Experimente online!

53 bytes

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

Experimente online!

Haskell , 26 bytes

@Mego me derrotou nesta solução

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

Experimente online!

É nisso que Haskell é ótimo. Isso declara uma função sem ponto que fecha a entrada com uma lista infinita.

Haskell , 56 bytes

Aqui está uma solução que usa números complexos. Não é muito competitivo por causa da importação, mas nunca é menos legal.

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

Experimente online!

Mathematica, 19 bytes

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

Explicação

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 *)

Nota: i=1aparece fora da função, o que é aceitável para este meta consenso .

J, 12 bytes

+1 0 _1 0$~#

Experimente online!

Como o operador de forma de J $preenche ciclicamente, quando o modelamos no comprimento #da entrada, ele faz exatamente o que queremos, e podemos apenas adicioná-lo à entrada]

C ++, 93 85 83 63 bytes

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

-8 bytes, graças a esta resposta , descobri que os parâmetros lambda podem ser autoe você pode passar com o parâmetro correto, ele funcionará

-2 bytes graças a Nevay

-2 bytes graças a Zacharý

Eu removi a vectorinclusão. Você precisará passar como argumento para o contêiner wa que respeite as seguintes condições:

• Tenha um método chamado size sem argumentos
• Sobrecarregaram o operador subscrito

Containers STL que respeitem as seguintes condições forem array, vector, string, map, unordered_map, e talvez outros

Se a saída modificando argumentos não for permitida, então:

C ++, 112 110 bytes

#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;}

Pari / GP , 30 bytes

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

Experimente online!

Dyalog APL, 13 bytes

⊢+1 0 ¯1 0⍴⍨≢

Experimente online!

Quão?

1 0 ¯1 0 - a matriz [1, 0, -1, 0]

⍴⍨≢ - remodelar para o comprimento da entrada, cíclico

⊢+ - soma vetorializada com a entrada

Perl 6 , 28 bytes

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

Experimente online!

1+0i, * × i ... *produz uma lista infinita dos números 1, i, -1, -irepetidos em um ciclo. Esses números são compactados com adição ( Z+) com a lista de entrada ( $_) e, em seguida, os componentes reais dos números complexos resultantes são extraídos ( ».re).

D, 56 bytes

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

Experimente online!

Esta é uma porta da resposta C ++ de HatsuPointerKun , por isso não as esqueça!

Japt , 11 10 bytes

Aproveita o empacotamento de índice do Japt.

Ë+[1TJT]gE

Teste-o

Explicação

Entrada implícita da matriz U.

Ë

Mapa sobre a matriz.

+

Para o elemento atual, adicione ...

gE

O elemento no índice atual ( E) ...

[1TJT]

Na matriz [1,0,-1,0].

Na verdade , 11 bytes

;r⌠╦½*C≈⌡M¥

Experimente online! (executa todos os casos de teste)

Explicação:

;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 bytes

.e+bss^.j)k

Try it online!

CJam, 15 bytes

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

Try it online!

Math.JS, 34 bytes

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

Explained

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.

Try it Online!

8th, 96 63 bytes

Code

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

This code leaves resulting array on TOS

Usage and examples

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]

Explanation

We use cos(x) in order get the right sequence [1,0,-1,0]. Each array element's index is multiplied by 90 degrees and then it is passed to cos() function to get the desired "wave factor" to be added to the corresponding item.

: 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 bytes

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

Try it online!

Uses a simple lambda. Modifies the original array and returns the output through reference.

05AB1E, 16 bytes

vy3L2.SR0¸«Nè+})

Try it online!

3L2.SR0¸« is the shortest thing I can think of for sin(x % 4) in 05AB1E.

Ruby, 38 bytes

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

Try it online!