Зворотні дельти масиву

Ваше завдання - задати масив підписаних 32-бітових цілих чисел, перекомпілювати його з його оберненими дельтами. Наприклад, список

1  3  4  2  8

вміщує дельти:

  2  1 -2  6

які потім заперечуються, даючи:

 -2 -1  2 -6

і перекомпільовано, отримуючи:

1 -1 -2  0 -6

як кінцевий результат.

Введення-виведення

Вам буде наданий список / масив / таблиця / кортеж / стек / тощо. підписаних цілих чисел як введення через будь-який стандартний метод введення.

Ви повинні вивести змінені дані ще раз у будь-якій прийнятній формі, дотримуючись описаного вище методу дельта інверсії.

Ви отримаєте N входів, 0 < N < 10де кожне число потрапляє в діапазон-1000 < X < 1000

Випробування

5 6 7 8          -> 5 4 3 2
1 3 4 2 8        -> 1 -1 -2 0 -6
32 18 25 192 199 -> 32 46 39 -128 -135

Примітки

• Ви не обмежені методом на основі дельти: якщо ви можете розробити більш простий метод (який не повинен бути занадто важким) , ви можете використовувати його.
• Як зазначено вище, ви завжди отримаєте щонайменше 1 вхід і не більше 9.
• Перше число виводу завжди повинно бути першим номером вводу, якщо це не так, ваш метод неправильний.
• Приймається лише стандартний вихідний вихід
• Застосовуються стандартні лазівки
• Це код-гольф , тому виграє найменший байт!
• Веселіться!

У нас є переможець.

Dennis «s Jelly Відповідь на крихітному 3 Bytes взяв додому золото, з - за того , що я перебуваю під враженням , він не може бути побитий.

Я був дуже розчарований, що мені не вдалося побачити відповідь, засновану на оригінальній специфікації, однак, згодом, можливо, я поставив щедрість саме тому.

Желе , 7 3 байти

ḤḢ_

Спробуйте в Інтернеті!

Фон

Дельти (a, b, c, d) - b - a , c - b , d - c . Кумулятивно відновлюючи (a, b - a, c - b, d - c) відніманням g виходить a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c , і 2a - c - (d - c) = 2a - d , тому правильний результат - (2a - a, 2a - b, 2a - c, 2a - d) .

Як це працює

ḤḢ_  Main link. Argument: A (array)

Ḥ    Unhalve; multiply all integers in A by 2.
 Ḣ   Head; extract first element of 2A.
  _  Subtract the elements of A from the result.

Python 2, 30 байт

lambda x:[x[0]*2-n for n in x]

Перевірте це на Ideone .

Як це працює

Дельти (a, b, c, d) - b - a , c - b , d - c . Кумулятивно відновлюючи (a, b - a, c - b, d - c) відніманням g виходить a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c , і 2a - c - (d - c) = 2a - d , тому правильний результат - (2a - a, 2a - b, 2a - c, 2a - d) .

Математика, 8 байт

2#-{##}&

Безіменна функція, що приймає невизначену кількість аргументів. Для цього використовується "простий" спосіб: заперечує весь список і додає вдвічі більше (оригінальний) перший елемент.

Називається наприклад, наприклад 2#-{##}&[1,3,4,2,8]; повертає список типу {1,-1,-2,0,-6}.

JavaScript (ES6), 21

Thx @Dennis

l=>l.map(v=>l[0]*2-v)

05AB1E , 4 байти

¬·s-

Спробуйте в Інтернеті! або як тестовий набір

Пояснення

¬     # head of input list
 ·    # multiplied by 2
  s   # swap with input list
   -  # subtract

Пітон, 44 байти

lambda l:[l[0]]+[x-(x-l[0])*2for x in l[1:]]

Для цього використовується "Найпростіший метод".

Pyth, 5 байт

-LyhQ

Інтернет-перекладач!

R, 23 18 17 байт

x=scan();2*x[1]-x

автоматична векторизація та друк за замовчуванням на допомогу!

Рубін, 23 байти

->l{l.map{|x|l[0]*2-x}}

Не особливо оригінально.

Perl 6 ,  40  16 байт

{[\+] .[0],|.rotor(2=>-1).map({[-] @_})}

{.map(.[0]*2-*)}

Розширено:

{ # bare block lambda with single implicit parameter ｢$_｣ ( input is a List )

  [\[+]]  # triangle reduce the following using ｢&infix:<+>｣

    .[0], # the first value

    |(    # Slip this list into outer one ( Perl 6 doesn't auto flatten )

      .rotor( 2 => -1 ) # take the input 2 at a time, backing up 1
      .map({ [-] @_ })  # reduce the pairs using ｢&infix:<->｣

    )
}

{ # bare block lambda with single implicit parameter ｢$_｣ ( input is a List )

  .map(          # map over the inputs
    .[0] * 2 - * # take the first value multiply by 2 and subtract the current value
    #          ^- this makes the statement a WhateverCode, and is the input
  )
}

Мозг-Флак , 76 байт

([][()]){{}(({})<(({}){}[{}]<>)<>>)([][()])}{}({}<<>([]){{}({}<>)<>([])}<>>)

Спробуйте в Інтернеті!

Пояснення:

Part 1:
(      )                                        # Push:
 []                                             # the height of the stack
   [()]                                         # minus 1
        {                                  }    # While the height - 1 != 0:
         {}                                     # Pop the height
           (({})<                               # Hold onto the top value, but put it back.
                                                # This ensures that the top value is always
                                                # what was the first element of input
                 (            )                 # Push:
                  ({}){}                        # Top * 2
                        [{}]                    # minus the next element
                            <> <>               # onto the other stack

                                 >)             # Put back the element we held onto.
                                   (      )     # Push:
                                    []          # The height of the stack
                                      [()]      # Minus 1  
                                            {}  # Pop the counter used for the height
Part 2:
({}<                                            # Hold onto the top element.
                                                # This was the first number for input
                                                # so it needs to end up on top
    <>                                          # Switch stacks
      ([])                                      # Push the height of the stack
          {              }                      # While the height != 0:
           {}                                   # Pop the height
             (    )                             # Push:
              {}                                # The top element of this stack
                <>                              # onto the other stack
                   <>                           # and switch back
                     ([])                       # Push the new height of the stack
                          <>                    # After every element has switched stacks
                                                # (which reverses their order),
                                                # switch stacks
                            >)                  # Push the first element back on

Haskell, 20 19 байт

f(x:r)=x:map(2*x-)r

Те саме рішення, що і Денніс, дякую за вашу ідею 2a - x .

Збережено один байт завдяки Крістіану Сіверсу.

Пайк, 5 4 байти

h}m-

Спробуйте тут!

PHP, 48 байт

for(;''<$c=$argv[++$i];)echo-$c+2*$a=$a??$c,' ';

Використання техніки від Денніса. Використовуйте як:

php -r "for(;''<$c=$argv[++$i];)echo-$c+2*$a=$a??$c,' ';" 1 3 4 2 8

55-байтна версія без Денніса:

for(;''<$c=$argv[++$i];$l=$c)echo$a+=($l??$c*2)-$c,' ';

APL, 8 байт

+\⊃,2-/+

Пояснення:

+\           ⍝ running sum of
  ⊃          ⍝ first item of list
   ,         ⍝ followed by
    2-/      ⍝ differences between every pair in
       +     ⍝ input list

Тестові приклади:

      ( +\⊃,2-/+ ) ¨ (5 6 7 8) (1 3 4 2 8) (32 18 25 192 199)
┌───────┬────────────┬──────────────────┐
│5 4 3 2│1 ¯1 ¯2 0 ¯6│32 46 39 ¯128 ¯135│
└───────┴────────────┴──────────────────┘

Лабіринт , 34 байти

?:_2*}
@    _
)\?_1"
,    ;
!`-}:{

Спробуйте в Інтернеті!

Використовує @Dennis «и (2a - a, 2a - b, 2a - c, 2a - d)підхід.

Жовті плитки призначені для контролю потоку. У цій 2D мові програмування програма починається в лівій верхній лівій плитці, що рухається на схід, щоб почати. На стиках напрямок визначається знаком верху основної штабелі. Пуста плитка - це стіни.

Зелений

Цей розділ економить 2а до допоміжного стека.

• ? Отримайте перший номер і натисніть на верхню частину основного стека
• : Дублюйте верхню частину стека
• _2 Натисніть два на верхню частину стека
• *Поп y, поп x, поштовхx*y
• } Перемістіть верхню частину основної штабелі до верхньої частини допоміжного штабеля.
• _ Натисніть нуль до верхньої частини стека

Помаранчевий

Цей розділ віднімає 2а від поточного числа, заперечує результат, виводить результат, отримує наступний символ (деліметр), виходить, якщо EOF, виводить новий рядок, отримує наступне число.

• "Noop. Якщо виходите з півночі, верхня частина стека дорівнює нулю, а програма продовжується на південь. Якщо виходите із заходу, верхня частина стека буде одна, і програма поверне праворуч (продовжуючи південь)
• ;Відкиньте верхню частину стека. Оскільки нуль або одиниця використовується тільки для контрольного потоку, нам потрібно їх відкинути
• { Перемістіть верхню частину допоміжної штабелі (2а) до верхньої частини основної штабелі
• : Дублюйте верхню частину основної стеки
• } Перемістіть верхню частину основної штабелі до верхньої частини допоміжного штабеля
• -Поп y, поп x, поштовхx-y
• \`` Negate the top of the stack. This and the previous three operations have the effect of- (x-2a) = 2a-x`
• ! Виконайте верхню частину стеку та виведіть її як число
• , Натисніть наступний символ (який буде роздільником) або негативний, якщо EOF
• )Збільшити верхню частину укладання. Якщо останнім символом є EOF, то верхня частина стека тепер буде нульовою, і програма продовжить прямо до @та до виходу. Якщо останній символ був деліметром, то верхня частина стека буде позитивною, тому програма поверне праворуч і продовжить на схід до\
• \ Виведіть новий рядок
• ? Отримайте наступне число
• _1 Натисніть на одну до верхньої частини штабелі, щоб повернути праворуч на стику

Лабіринт , 24 байти

+:}:?
}
<}}?;%):,\!-{:{>

Формат введення та виведення - це окремі списки каналів (хоча формат введення насправді набагато гнучкіший). Програма закінчується помилкою.

Спробуйте в Інтернеті!

На цьому байті є два інших рішення, які працюють в основному однаково, але використовують дещо інший потік управління.

:+:}:?
{
,}-!
?  {
:";\@

{:+:}:?
_
<>__-?:;%):,\!

Пояснення

Покажчик інструкцій (IP) починає рухатися на схід уздовж першого рядка, але всі команди перед символом в ?основному не мають опори у глобальному стані, оскільки ми ніде не використовуємо команди глибини стека. Таким чином код дійсно починається на ?заході, оскільки IP обертається, коли він потрапляє в глухий кут.

Таким чином, код починається з наступного лінійного біта коду:

?:}:+}

Це просто створює нам копію 2aдля використання [2a - a, 2a - b, 2a - c, ...]формули.

?   Read first integer a.
:}  Move a copy off to the auxiliary stack.
:+  Multiply a by 2 (by adding it to itself).
}   Move that off to the auxiliary stack as well.

Тепер ми вводимо основний цикл програми, використовуючи досить стандартний трюк, щоб провести цикл через один рядок коду:

<...>

Зауважте, що стек буде порожнім, коли ми натискаємо на < потрапимо, щоб ми знали, що там отримаємо нулі. <Потім обертається вся лінія зліва, приймаючи IP з ним, так що ми отримуємо це:

...><

Тоді IP повинен рухатися ліворуч, де > переміщується лінія назад у початкове місце (щоб підготувати її до наступної ітерації). Тоді рядок просто виконується справа наліво, тому одиночна ітерація циклу така:

{:{-!\,:)%;?}}

Під час роботи з циклом такого типу є те, що ви не можете працювати з будь-якою формою умовного виконання, оскільки в Лабіринті немає способу пропустити код. Тому ми припинимо програму діленням на нуль, коли потрапимо на EOF. Ось розбивка кожної ітерації циклу.

{:   Pull 2a back to the main stack and make a copy.
{    Pull the latest value i of the input list back to main as well.
-    Compute 2a-i/
!\   Print it with a trailing linefeed.
,    Read a character. If there are input elements left, this will be some
     form of separator character, and therefore a positive value x. However,
     at the end of the program, this will give -1.
:)   Make an incremented copy.
%    Try to to compute x%(x+1). This will error out at EOF.
;    Discard the result of the division.
?    Read the next input value.
}}   Move that and the remaining copy of 2a back to the auxiliary stack.

C ++ 14, 36 байт

Як безіменна лямбда змінює свій вхід:

[](auto&c){for(auto&x:c)x=2*c[0]-x;}

Використання техніки від Денніса. Працює для будь-якого контейнера, як int[]або vector<int>.

Використання:

#include<iostream>

auto f=
[](auto&c){for(auto&x:c)x=2*c[0]-x;}
;

int main(){
  int a[] = {1,  3,  4,  2,  8};
  f(a);
  for(auto&x:a)
    std::cout << x << ", ";
  std::cout<<"\n";
}

CJam, 16 байт

Формат введення: [1 2 3 4]. Використовується проста формула.

l~_(2*/;a/,@@*.-

Пояснення:

l~_(2*/;a/,@@*.-
l~_                     e#Read input twice into an array. Stack: [1 2 3 4] [1 2 3 4]
   (                    e#Get first element of the array. Stack: [1 2 3 4] [2 3 4] 1
    2*                  e#Multiply by two. Stack: [1 2 3 4] [2 3 4] 2
      /;                e#Discard second element. Stack: [1 2 3 4] 2
        a               e#Wrap into an array. Stack: [1 2 3 4] [2]
         /,             e#Rotate and get length. Stack: [2] [1 2 3 4] 4
           @@           e#Rotate twice. Stack: [1 2 3 4] 4 [2]
            *           e#Repeat len times. Stack: [1 2 3 4] [2 2 2 2]
             .-         e#Vectorized substraction. Stack: [-1 0 1 2]
                        e#Implictly print

Вибачте за тест-посилання. Я думаю, що SE не подобається, що це посилання з дужками всередині.

Пушистий , 9 байт

{&}2*K~-_

Наведіть аргументи у вигляді розділених комами значень у рядку cmd : $ pushy invdeltas.pshy 1,3,4,2,8. Ось розбивка на прикладі стека:

           % Implicit: Input on stack              [1, 3, 4, 2, 8]
{&}        % Copy first item, put at end of stack  [1, 3, 4, 2, 8, 1]
   2*      % Multiply by 2                         [1, 3, 4, 2, 8, 2]
     K~    % Negate everything on stack            [-1, -3, -4, -2, -8, -2]
       -   % Subtract last item from all           [1, -1, -2, 0, -6]
        _  % Print whole stack

Примітка: якщо дозволено зворотний вихід, це може бути 8 байт: @&2*K~-_

Perl, 26 + 3 ( -plaпрапор) = 29 байт

$_="@{[map$F[0]*2-$_,@F]}"

або

$_=join$",map$F[0]*2-$_,@F

Використання:

perl -plae '$_="@{[map$F[0]*2-$_,@F]}"' <<< "32 18 25 192 199"

Діалог APL , 5 байт

-+2×⊃

це 5-поїзд, він розбирає, як два вкладені 3 поїзда ("вилки"): -+(2×⊃)

читає як: заперечення ( -) усього масиву плюс ( +) двічі ( 2×) перший елемент ( ⊃)

об'єм, 11 байт

2*$1_0-$1

Виклик: ised --l 'file with input.txt' '2*$1_0-$1

(редагувати: виправлено крадіжкою алгебри у Денніса)

Диво , 17 байт

@->#@- *2:0#1#0#0

Не впевнений, чому я не публікував це раніше. Використання:

(@->#@- *2:0#1#0#0)[5 6 7 8]

Більше читати:

@(map @
  - (
    * 2 get 0 #1
  ) #0
) #0