Odwrotne delty tablicy

Twoim zadaniem jest, z uwagi na tablicę 32-bitowych liczb całkowitych, ponowne skompilowanie go z odwrotnymi deltami. Na przykład lista

1  3  4  2  8

trzyma delty:

  2  1 -2  6

które są następnie negowane, dając:

 -2 -1  2 -6

i ponownie skompilowano, uzyskując:

1 -1 -2  0 -6

jako wynik końcowy.

Wejście wyjście

Otrzymasz listę / tablicę / tabelę / krotkę / stos / itp. liczb całkowitych ze znakiem jako danych wejściowych dowolną standardową metodą wprowadzania.

Zmodyfikowane dane należy ponownie wyprowadzić w dowolnej akceptowalnej formie, zgodnie z powyższą metodą inwersji delta.

Otrzymasz N danych wejściowych, w 0 < N < 10których każda liczba mieści się w zakresie-1000 < X < 1000

Przypadki testowe

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

Notatki

• Nie jesteś ograniczony do metody opartej na delcie: jeśli możesz wypracować łatwiejszą metodę (która nie powinna być zbyt trudna) , możesz jej użyć.
• Jak wspomniano powyżej, zawsze otrzymasz co najmniej 1 wkład, a nie więcej niż 9.
• Pierwsza liczba danych wyjściowych musi zawsze być pierwszą liczbą danych wejściowych, jeśli tak nie jest, metoda jest niepoprawna.
• Akceptowane jest tylko standardowe wyjście wejściowe
• Obowiązują standardowe luki
• To jest golf golfowy , więc wygrywa najmniejsza liczba bajtów!
• Baw się dobrze!

Mamy zwycięzcę.

Dennis „s Jelly odpowiedzi na maleńkim 3 bajty podjęła domu złoto, ze względu na fakt, że jestem pod wrażeniem, że nie może być pobity.

Byłem lekko rozczarowany, że nie zobaczyłem odpowiedzi opartej na oryginalnej specyfikacji, jednak później mogę rzucić na to nagrodę.

Galaretka , 7 3 bajty

ḤḢ_

Wypróbuj online!

tło

Delty (a, b, c, d) to b - a , c - b i d - c . Łączne zmniejszenie (a, b - a, c - b, d - c) przez odjęcie g daje a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c i 2a - c - (d - c) = 2a - d , więc poprawny wynik to (2a - a, 2a - b, 2a - c, 2a - d) .

Jak to działa

ḤḢ_  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 bajtów

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

Przetestuj na Ideone .

Jak to działa

Delty (a, b, c, d) to b - a , c - b i d - c . Łączne zmniejszenie (a, b - a, c - b, d - c) przez odjęcie g daje a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c i 2a - c - (d - c) = 2a - d , więc poprawny wynik to (2a - a, 2a - b, 2a - c, 2a - d) .

Mathematica, 8 bajtów

2#-{##}&

Nienazwana funkcja pobierająca nieokreśloną liczbę argumentów. Wykorzystuje to „łatwy” sposób: neguje całą listę i dodaje dwukrotnie (oryginalny) pierwszy element.

Nazywany na przykład jak 2#-{##}&[1,3,4,2,8]; zwraca listę jak {1,-1,-2,0,-6}.

JavaScript (ES6), 21

Thx @Dennis

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

05AB1E , 4 bajty

¬·s-

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

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

Python, 44 bajty

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

Wykorzystuje to „łatwiejszą metodę”.

Pyth, 5 bajtów

-LyhQ

Tłumacz online!

R, 23 18 17 bajtów

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

automatyczna wektoryzacja i domyślny wydruk na ratunek!

Rubinowy, 23 bajty

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

Niezbyt oryginalny.

Perl 6 ,  40  16 bajtów

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

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

Rozszerzony:

{ # 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
  )
}

Brain-Flak , 76 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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 bajtów

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

Takie samo rozwiązanie jak Dennis, dziękuję za pomysł 2a - x .

Oszczędność jednego bajtu dzięki Christianowi Seversowi.

Pyke, 5 4 bajtów

h}m-

Wypróbuj tutaj!

PHP, 48 bajtów

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

Wykorzystując technikę Dennisa. Użyj jak:

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

Wersja 55-bajtowa inna niż Dennis:

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

APL, 8 bajtów

+\⊃,2-/+

Wyjaśnienie:

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

Przypadki testowe:

      ( +\⊃,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│
└───────┴────────────┴──────────────────┘

Labirynt , 34 bajty

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

Wypróbuj online!

Używa @Dennis „s (2a - a, 2a - b, 2a - c, 2a - d)podejście.

Żółte kafelki służą do kontroli przepływu. W tym języku programowania 2D program rozpoczyna się od lewego górnego kafelka przesuwającego się na wschód, aby rozpocząć. Na skrzyżowaniach kierunek określa znak górnej części głównego stosu. Puste płytki to ściany.

Zielony

Ta sekcja oszczędza 2a do stosu pomocniczego.

• ? Zdobądź pierwszy numer i pchnij go na szczyt głównego stosu
• : Zduplikuj górę stosu
• _2 Pchnij dwa na szczyt stosu
• *Pop y, pop x, pushx*y
• } Przenieś górę głównego stosu na szczyt stosu pomocniczego.
• _ Przesuń zero na górę stosu

Pomarańczowy

Ta sekcja odejmuje 2a od bieżącej liczby, neguje wynik, wypisuje wynik, pobiera następny znak (delimetr), wychodzi, jeśli EOF, wypisuje nowy wiersz, dostaje następną liczbę.

• "Noop. Jeśli nadchodzi z północy, górna część stosu będzie wynosić zero, a program będzie kontynuowany na południe. Jeśli nadchodzi z zachodu, górna część stosu będzie równa jeden, a program skręci w prawo (dalej na południe)
• ;Odrzuć wierzch stosu. Ponieważ zero lub jeden służy tylko do sterowania przepływem, musimy je odrzucić
• { Przesuń górną część stosu pomocniczego (2a) na górę głównego stosu
• : Duplikuj górę głównego stosu
• } Przenieś górę głównego stosu na szczyt stosu pomocniczego
• -Pop y, pop x, pushx-y
• \`` Negate the top of the stack. This and the previous three operations have the effect of- (x-2a) = 2a-x`
• ! Pop u góry stosu i wyślij go jako liczbę
• , Naciśnij następny znak (który będzie ogranicznikiem) lub znak ujemny, jeśli EOF
• )Zwiększ górną część stosu. Jeśli ostatnim znakiem jest EOF, wówczas górna część stosu będzie wynosić zero, a program przejdzie prosto do @wyjścia i zakończy działanie. Jeśli ostatnim znakiem był ogranicznik, górna część stosu będzie dodatnia, powodując, że program skręci w prawo i będzie kontynuował wschód\
• \ Wyjście nowego wiersza
• ? Uzyskaj następny numer
• _1 Popchnij jeden na górę stosu, aby skręcić w prawo na skrzyżowaniu

Labirynt , 24 bajty

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

Format wejściowy i wyjściowy są listami oddzielnymi od kanału (chociaż format wejściowy jest w rzeczywistości o wiele bardziej elastyczny). Program kończy się z błędem.

Wypróbuj online!

Mam dwa inne rozwiązania przy tej liczbie bajtów, które działają w zasadzie tak samo, ale używają nieco innego przepływu sterowania.

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

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

Wyjaśnienie

Wskaźnik instrukcji (IP) zaczyna przesuwać się na wschód wzdłuż pierwszego wiersza, ale wszystkie polecenia poprzedzające w ?zasadzie nie działają w stanie globalnym, ponieważ nigdzie nie używamy poleceń głębokości stosu. Tak więc kod naprawdę zaczyna się na ?zachodzie, ponieważ IP zmienia się, gdy uderza w ślepy zaułek.

Dlatego kod zaczyna się od następującego liniowego bitu kodu:

?:}:+}

To po prostu konfiguruje nam kopię 2ado użycia [2a - a, 2a - b, 2a - c, ...]formuły.

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

Teraz wchodzimy do głównej pętli programu, używając dość standardowej sztuczki, aby przejść przez jedną linię kodu:

<...>

Zauważ, że stos będzie pusty za każdym razem, gdy trafimy, <więc wiemy, że otrzymamy tam zera. <Następnie obraca się cała linia lewo, biorąc IP z nim, dzięki czemu otrzymujemy w ten sposób:

...><

IP musi następnie przejść w lewo, gdzie >przesuwa linię z powrotem do pierwotnego miejsca (aby przygotować ją do następnej iteracji). Następnie linia jest po prostu wykonywana od prawej do lewej, więc iteracja pojedynczej pętli jest następująca:

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

Problemem podczas pracy z tego typu pętlą jest to, że nie można pracować z żadną formą wykonania warunkowego, ponieważ Labirynt nie ma możliwości pominięcia kodu. Dlatego zakończymy program dzieleniem przez zero, gdy uderzymy w EOF. Oto podział każdej iteracji pętli.

{:   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 bajtów

Jako nienazwana lambda modyfikująca dane wejściowe:

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

Wykorzystując technikę Dennisa. Działa dla każdego pojemnika, takiego jak int[]lub vector<int>.

Stosowanie:

#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 bajtów

Format wejściowy: [1 2 3 4]. Korzysta z prostej formuły.

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

Wyjaśnienie:

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

Przepraszamy za brak linku testowego. Sądzę, że SE nie lubi linków ze wspornikami w środku.

Pushy , 9 bajtów

{&}2*K~-_

Daj argumentów jako oddzielone przecinkami wartości w cmd linii: $ pushy invdeltas.pshy 1,3,4,2,8. Oto podział z przykładem stosu:

           % 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

Uwaga: może to być 8 bajtów, jeśli dozwolone jest wyjście wstecz: @&2*K~-_

Perl, 26 + 3 ( -plaflaga) = 29 bajtów

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

lub

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

Za pomocą:

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

Dyalog APL , 5 bajtów

-+2×⊃

jest to 5-pociąg, analizuje jak dwa zagnieżdżone 3-pociągi („widelce”): -+(2×⊃)

brzmi: negacja ( -) całej tablicy plus ( +) dwukrotnie ( 2×) pierwszy element ( ⊃)

Ised, 11 bajtów

2*$1_0-$1

Wezwanie: ised --l 'file with input.txt' '2*$1_0-$1

(edycja: poprawione przez kradzież algebry od Dennisa)

Cud , 17 bajtów

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

Nie jestem pewien, dlaczego nie opublikowałem tego wcześniej. Stosowanie:

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

Bardziej czytelny:

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