Su tarea hoy es aplicar una onda a una serie de números. Una onda se ve así: [1, 0, -1, 0, 1, 0, -1, 0, 1...]aplicarla a una matriz dada significa sumar los primeros elementos, los segundos elementos, etc.

Más precisamente:

Su programa o función recibirá una variedad de enteros. Debe imprimir o devolver una matriz de igual tamaño 1agregada al primer, quinto, noveno, etc. elemento de la matriz original, -1agregada al tercer, séptimo, 11.º, etc. elemento de la matriz original y el resto de los elementos. debe dejarse intacto.

Se garantiza que la matriz de entrada tenga al menos un elemento.

Casos de prueba:

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 es el código de golf , ¡el código más corto gana!

Jalea , 5 bytes

Jı*Ċ+

Pruébalo en línea!

Cómo 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.

LOGOTIPO , 18 bytes

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

No hay un "¡Pruébelo en línea!" enlace porque todos los intérpretes de LOGO en línea no admiten la lista de plantillas.

Esa es una lista de plantillas (equivalente a la función lambda en otros idiomas).

Uso:

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

( invokellama a la función, primprime el resultado)

impresiones [-3 3 -1 1 8 9 7 -2 12 -88].

Explicación (ya bastante comprensible):

 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]

Pruébalo en línea! (ejecuta todos los casos de prueba)

Explicación:

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)

El cálculo es así:

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

El último bit aprovecha el hecho de que en JS, un número negativo cuando se modula conservará su signo negativo (es decir -5 % 3 -> -2, en lugar de 1como sería en Python).

Mathematica, 26 23 22 bytes

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

Pruébalo en línea!(Matemáticas)

Nota: El enlace TIO es para la versión de 23 bytes, la versión de 22 bytes no es compatible con matemáticas.

Python 2 , 40 bytes

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

Pruébalo en línea!

MATL , 11 8 bytes

Jyn:^Yj+

¡Pruébalo en MATL Online!

Explicación

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]

Jalea , 16 bytes

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

Pruébalo en línea!

heh estoy seguro de que esto es demasiado largo

Editar

Sé que es posible una solución de 5 bytes, pero mi wifi parece estar empezando a interrumpirme, así que jugaré golf mañana. Si alguien publica la solución Jelly corta antes de que pueda jugar golf, está bien para mí; Solo mantendré esto aquí como referencia de lo mal que estoy en Jelly jajaja otra forma de hacerlo. Quiero decir, podría mirar el enlace que Phoenix publicó en los comentarios, pero como todavía estoy aprendiendo, no quiero mirar la solución hasta que lo haya descubierto yo mismo. Esto podría costarme reputación, pero el aprendizaje es para lo que estoy aquí :)))

R , 29 24 bytes

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

Pruébalo en línea!

Python 2 , 50 42 bytes

^{¡Guardado 8 bytes gracias a @Sisyphus!}

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

Pruébalo en línea!

53 bytes

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

Pruébalo en línea!

Haskell , 26 bytes

@Mego me ganó a esta solución

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

Pruébalo en línea!

Esto es en lo que Haskell es genial. Esto declara una función sin puntos que comprime la entrada con una lista infinita.

Haskell , 56 bytes

Aquí hay una solución que usa números complejos. No es muy competitivo debido a la importación, pero sin embargo es bastante bueno.

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

Pruébalo en línea!

Mathematica, 19 bytes

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

Explicación

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 fuera de la función, lo cual está bien según este meta consenso .

J, 12 bytes

+1 0 _1 0$~#

Pruébalo en línea!

Debido a que el operador de forma de J se $llena cíclicamente, cuando le damos forma a la longitud #de la entrada, hace exactamente lo que queremos, y simplemente podemos agregarlo a la 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, gracias a esta respuesta , descubrí que los parámetros lambda pueden ser autoy puede pasar con el parámetro correcto, funcionará

-2 bytes gracias a Nevay

-2 bytes gracias a Zacharý

Eliminé la vectorinclusión. Deberá pasar como argumento a un contenedor que respete las siguientes condiciones:

• Tener un método llamado sizesin argumentos
• Han sobrecargado el operador de subíndice

Los contenedores STL que respetan las siguientes condiciones son array,vector , string, map,unordered_map , y tal vez otros

Si la salida mediante la modificación de argumentos no está permitida, entonces:

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]]

Pruébalo en línea!

Dyalog APL, 13 bytes

⊢+1 0 ¯1 0⍴⍨≢

Pruébalo en línea!

¿Cómo?

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

⍴⍨≢ - remodelar a la longitud de la entrada, cíclica

⊢+ - suma vectorizada con la entrada

Perl 6 , 28 bytes

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

Pruébalo en línea!

1+0i, * × i ... *produce una lista infinita de los números 1, i, -1, -irepetidos en un ciclo. Esos números se comprimen con suma ( Z+) con la lista de entrada ( $_), y luego se extraen los componentes reales de los números complejos resultantes ( ».re).

D, 56 bytes

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

Pruébalo en línea!

Este es un puerto de la respuesta C ++ de HatsuPointerKun , ¡así que no te olvides de ellos!

Japt , 11 10 bytes

Aprovecha el ajuste de índice de Japt.

Ë+[1TJT]gE

Pruébalo

Explicación

Entrada implícita de la matriz U.

Ë

Mapa sobre la matriz.

+

Al elemento actual agregue ...

gE

El elemento en el índice actual ( E) ...

[1TJT]

En la matriz [1,0,-1,0].

En realidad , 11 bytes

;r⌠╦½*C≈⌡M¥

Pruébalo en línea!(ejecuta todos los casos de prueba)

Explicación:

;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

Pruébalo en línea!

CJam , 15 bytes

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

Pruébalo en línea!

Math.JS , 34 bytes

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

Explicado

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.

Pruébalo en línea!

8 , 96 63 bytes

Código

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

Este código deja la matriz resultante en TOS

Uso y ejemplos

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]

Explicación

Usamos cos (x) para obtener la secuencia correcta [1,0, -1,0]. El índice de cada elemento de matriz se multiplica por 90 grados y luego se pasa a la función cos () para obtener el "factor de onda" deseado que se agregará al elemento correspondiente.

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

Pruébalo en línea!

Utiliza una lambda simple. Modifica la matriz original y devuelve el resultado mediante referencia.

05AB1E , 16 bytes

vy3L2.SR0¸«Nè+})

Pruébalo en línea!

3L2.SR0¸«es lo más corto que se me ocurre sin(x % 4)en 05AB1E.

Rubí , 38 bytes.

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

Pruébalo en línea!