Il tuo compito oggi è applicare un'onda a una matrice di numeri. Un'onda ha questo aspetto: [1, 0, -1, 0, 1, 0, -1, 0, 1...]applicarla a un determinato array significa sommare i primi elementi, i secondi elementi, ecc.

Più precisamente:

Il tuo programma o funzione riceverà una matrice di numeri interi. Deve stampare o restituire un array di dimensioni uguali con l' 1aggiunta del 1o, 5o, 9o, ecc. Elemento dell'array originale, -1aggiunto al 3o, 7o, 11o, ecc. Elemento dell'array originale e il resto degli elementi dovrebbe essere lasciato intatto.

È garantito che l'array di input abbia almeno un elemento.

Casi test:

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]

Questo è code-golf , vince il codice più corto!

Gelatina , 5 byte

Jı*Ċ+

Provalo online!

Come funziona

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 byte

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

Non esiste "Provalo online!" collegamento perché tutto l'interprete LOGO online non supporta l'elenco dei modelli.

Questo è un elenco di modelli (equivalente della funzione lambda in altre lingue).

Uso:

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

( invokechiama la funzione, prstampa il risultato)

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

Spiegazione (già abbastanza comprensibile):

 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 byte

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

Provalo online! (esegue tutti i casi di test)

Spiegazione:

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 byte

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

Il calcolo procede in questo modo:

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

L'ultimo bit sfrutta il fatto che in JS, un numero negativo quando modulato manterrà il suo segno negativo (cioè -5 % 3 -> -2, invece di 1come sarebbe in Python).

Mathematica, 26 23 22 byte

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

Provalo online!(Mathics)

Nota: il collegamento TIO è per la versione a 23 byte, la versione a 22 byte non è compatibile con Mathics.

Python 2 , 40 byte

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

Provalo online!

MATL , 11 8 byte

Jyn:^Yj+

Provalo su MATL Online!

Spiegazione

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 byte

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

Provalo online!

eh sono sicuro che sia troppo lungo

modificare

So che una soluzione a 5 byte è possibile ma il mio wifi sembra iniziare a tagliarmi, quindi domani giocherò a golf. Se qualcuno pubblica la soluzione Jelly corta prima che io possa giocare a golf, va bene per me; Terrò questo qui come riferimento per quanto sono cattivo a Jelly per un altro modo di farlo. Voglio dire, potrei solo guardare il link che Phoenix ha pubblicato nei commenti, ma dato che sto ancora imparando, non voglio guardare la soluzione fino a quando non l'ho capito da solo. Questo potrebbe costarmi la reputazione ma l'apprendimento è quello per cui sono qui :)))

R , 29 24 byte

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

Provalo online!

Python 2 , 50 42 byte

^{8 byte salvati grazie a @Sisyphus!}

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

Provalo online!

53 byte

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

Provalo online!

Haskell , 26 byte

@Mego mi ha battuto per questa soluzione

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

Provalo online!

Questo è ciò in cui Haskell è eccezionale. Questo dichiara una funzione senza punti che comprime l'input con un elenco infinito.

Haskell , 56 byte

Ecco una soluzione che utilizza numeri complessi. Non molto competitivo a causa dell'importazione ma mai meno interessante.

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

Provalo online!

Mathematica, 19 byte

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

Spiegazione

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=1appare al di fuori della funzione, il che va bene per questo meta consenso .

J, 12 byte

+1 0 _1 0$~#

Provalo online!

Poiché l'operatore di forma J si $riempie ciclicamente, quando lo modelliamo in base alla lunghezza #dell'input, fa esattamente quello che vogliamo e possiamo semplicemente aggiungerlo all'input]

C ++, 93 85 83 63 byte

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

-8 byte, grazie a questa risposta , ho scoperto che i parametri lambda possono essereauto e puoi passare con il parametro corretto, funzionerà

-2 byte grazie a Nevay

-2 byte grazie a Zacharý

Ho rimosso l' vectorinclusione. Dovrai passare come argomento per wa container che rispetti le seguenti condizioni:

• Fai chiamare un metodo size senza argomenti
• Ho sovraccaricato l'operatore di sottoscrizione

I contenitori STL che rispettano le seguenti condizioni sono array, vector, string, map,unordered_map , e forse altri

Se l'output mediante la modifica di argomenti non è consentito, allora:

C ++, 112 110 byte

#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 byte

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

Provalo online!

Dyalog APL, 13 byte

⊢+1 0 ¯1 0⍴⍨≢

Provalo online!

Come?

1 0 ¯1 0 - l'array [1, 0, -1, 0]

⍴⍨≢ - rimodellare la lunghezza dell'input, ciclica

⊢+ - somma vettorializzata con l'input

Perl 6 , 28 byte

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

Provalo online!

1+0i, * × i ... *produce un elenco infinito dei numeri 1, i, -1, -iripetuti in un ciclo. Questi numeri vengono compressi con addizione ( Z+) con l'elenco di input ( $_), quindi vengono estratti i componenti reali dei numeri complessi risultanti ( ».re).

D, 56 byte

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

Provalo online!

Questa è una porta della risposta C ++ di HatsuPointerKun , quindi non dimenticartene!

Japt , 11 10 byte

Sfrutta il wrapping dell'indice di Japt.

Ë+[1TJT]gE

Provalo

Spiegazione

Input implicito di array U.

Ë

Mappa sull'array.

+

All'elemento corrente aggiungi ...

gE

L'elemento nell'indice corrente ( E) ...

[1TJT]

Nella matrice [1,0,-1,0].

In realtà , 11 byte

;r⌠╦½*C≈⌡M¥

Provalo online! (esegue tutti i casi di test)

Spiegazione:

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

.e+bss^.j)k

Provalo online!

CJam , 15 byte

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

Provalo online!

Math.JS , 34 byte

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

spiegato

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.

Provalo online!

8 ° , 96 63 byte

Codice

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

Questo codice lascia l'array risultante su TOS

Utilizzo ed esempi

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]

Spiegazione

Usiamo cos (x) per ottenere la giusta sequenza [1,0, -1,0]. L'indice di ciascun elemento dell'array viene moltiplicato per 90 gradi e quindi viene passato alla funzione cos () per ottenere il "fattore d'onda" desiderato da aggiungere all'elemento corrispondente.

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

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

Provalo online!

Usa una semplice lambda. Modifica l'array originale e restituisce l'output tramite riferimento.

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!