Применить волну к массиву

24

Ваша задача сегодня - применить волну к массиву чисел. Волна выглядит так: [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]

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

code-golf  array-manipulation 
— Павел
источник
Несколько неожиданно, многие решения используют магию воображаемых чисел ...
— Павел
2
Это имеет большой смысл, почему мнимые числа были бы полезны, это волновая проблема, и у мнимых чисел есть хорошо документированная история полярных свойств. Мнимые числа могут быть довольно гольфовым способом вычисления синусов и косинусов, особенно для этих типов целочисленных вращений на четверть. Математика это круто ...
— Пшеничный волшебник
3
@WheatWizard Это довольно большая доля, учитывая, что большинство языков не поддерживают мнимые числа.
— Павел

Ответы:

8

Желе , 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.
— Деннис
источник
То же, что и у Лаки
— Павел
1
Любое объяснение?
— Pureferret
1
@Pureferret мнимой части последовательных степеней мнимого числа я добавляются к каждому элементу
— Cœur
@ Cœur это 1, 2, 3 ...или 1, 0, -1, 0 ...?
— Pureferret
1
@Pureferret то же объяснение, что и ответ в MATL или Math.JS или Mathematica или R или ...
— Cœur
14

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
— user202729
источник
Ха, я знал, что кто-то придет с синусоидальным ответом.
— ETHproductions
2
@ETHproductions самый первый ответ, в Mathematica, был основан на Sine, пока он не был проигран. Второй ответ, в R, все еще использует синус.
— Павел
1
@ Phoenix Я в шоке, что я не заметил ...
— ETHproductions
@ETHproductions и .... Синус тоже был вне поля R ответа. Я думаю, что он делает то же самое, что и ответ Mathematica.
— Павел
13

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
— Mego
источник
9

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

— ETHproductions
источник
9

Mathematica, 26 23 22 байта

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

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

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

— user202729
источник
Ниже представлено 19-байтовое решение Mathematica (с 4 байтами инициализации)
— user202729
8

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]
— Луис Мендо
источник
Хм, вы забыли добавить +в объяснение
— caird coinheringaahing
@cairdcoinheringaahing Спасибо, отредактировано
— Луис Мендо
3

Желе , 16 байт

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

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

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

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

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

— HyperNeutrino
источник
LeakyNun сделал это в 5 в чате: Спойлер
— Павел
5
ой .__________.
— HyperNeutrino
— Павел
3

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

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

— musicman523
источник
lambda l:map(sum,zip(l,[1,0,-1,0]*len(l)))для Python 2
— Сизиф
Хорошо, что в Python 3 сохраняются 5 байтов, а в Python 2 - еще 3. Спасибо!
— musicman523
3

Haskell , 26 байтов

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

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

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

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

Haskell , 56 байт

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

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

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

— Мастер пшеницы
источник
2
Ик! Вы ниндзя меня на 20 секунд!
— Мего
Нет смысла иметь два одинаковых решения. Поскольку вы приняли мое улучшение без указания авторства и сделали наши ответы идентичными, удалите ли вы свои?
— Мего
3

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появляется вне функции, что хорошо для этого мета-консенсуса .

— Юнг Хван Мин
источник
Но тогда функция не обязательно может быть повторно использована (если после одного вызова функция iимеет значение, отличное от 1)
— user202729
@ user202729 Мета-консенсус, который я связал, конкретно касается этой проблемы. Можно объявить глобальную переменную вне функции.
— JungHwan Мин
3

J, 12 байт

+1 0 _1 0$~#

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

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

— Ион
источник
Вы можете сохранить байт, опустив первый] (т.
— Е.
@Tikkanz хороший улов. я обновил пост.
— Иона
3

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;}
— HatsuPointerKun
источник
1
Ваш первый один является действительным в / о.
— Павел
1
Вы можете использовать, j%4чтобы сохранить 2 байта.
— Неваи,
1
Я не думаю, что вам нужны парены вокруг j%4.
— Захари
2

Dyalog APL, 13 байт

⊢+1 0 ¯1 0⍴⍨≢

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

Как?

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

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

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

— Уриэль
источник
2

Perl 6 , 28 байт

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

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

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

— Шон
источник
2

Japt , 11 10 байт

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

Ë+[1TJT]gE

Попробуй это

объяснение

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

Ë

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

+

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

gE

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

[1TJT]

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

— мохнатый
источник
1

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.

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

— Ataco
источник
1

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
;
— Chaos Manor
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.