Inverse Deltas eines Arrays

Ihre Aufgabe ist es, ein Array von 32-Bit-Ganzzahlen mit Vorzeichen zu erhalten und es mit seinen inversen Deltas neu zu kompilieren. Zum Beispiel die Liste

1  3  4  2  8

hält die Deltas:

  2  1 -2  6

die dann negiert werden und ergeben:

 -2 -1  2 -6

und neu kompiliert, was ergibt:

1 -1 -2  0 -6

als Endergebnis.

Input-Output

Sie erhalten eine Liste / array / table / tuple / stack / etc. von vorzeichenbehafteten ganzen Zahlen als Eingabe über eine beliebige Standardeingabemethode.

Sie müssen die geänderten Daten erneut in einer akzeptablen Form ausgeben, indem Sie der obigen Delta-Inversionsmethode folgen.

Sie erhalten N Eingänge, bei 0 < N < 10denen jede Zahl in den Bereich fällt-1000 < X < 1000

Testfälle

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

Anmerkungen

• Sie sind nicht auf die Delta-basierte Methode beschränkt: Wenn Sie die einfachere Methode (die nicht zu schwer sein sollte) herausfinden können , können Sie sie verwenden.
• Wie oben angegeben, erhalten Sie immer mindestens 1 Eingang und nicht mehr als 9.
• Die erste Nummer der Ausgabe muss immer die erste Nummer der Eingabe sein. Ist dies nicht der Fall, ist Ihre Methode falsch.
• Es wird nur die Standardeingabe Ausgabe akzeptiert
• Es gelten Standardlücken
• Das ist Code-Golf , also gewinnt die niedrigste Byte-Anzahl!
• Habe Spaß!

Wir haben einen Sieger.

Dennis 's Jelly Answer bei einem Tiny 3 Bytes hat das Gold mit nach Hause genommen, da ich den Eindruck habe, dass es nicht zu schlagen ist.

Ich war ein wenig enttäuscht, dass ich keine Antwort auf die ursprüngliche Spezifikation erhalten habe, aber ich kann später genau das belohnen.

Gelee , 7 3 Bytes

ḤḢ_

Probieren Sie es online!

Hintergrund

Die Deltas von (a, b, c, d) sind b - a , c - b und d - c . Die kumulative Reduktion von (a, b - a, c - b, d - c) durch Subtraktion ergibt a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c und 2a - c - (d - c) = 2a - d , also ist das korrekte Ergebnis (2a - a, 2a - b, 2a - c, 2a - d) .

Wie es funktioniert

ḤḢ_  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 Bytes

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

Teste es auf Ideone .

Wie es funktioniert

Die Deltas von (a, b, c, d) sind b - a , c - b und d - c . Die kumulative Reduktion von (a, b - a, c - b, d - c) durch Subtraktion ergibt a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c und 2a - c - (d - c) = 2a - d , also ist das korrekte Ergebnis (2a - a, 2a - b, 2a - c, 2a - d) .

Mathematica, 8 Bytes

2#-{##}&

Unbenannte Funktion mit einer unbestimmten Anzahl von Argumenten. Dies geschieht auf "einfache" Weise: Negiert die gesamte Liste und fügt das doppelte (ursprüngliche) erste Element hinzu.

Genannt zum Beispiel wie 2#-{##}&[1,3,4,2,8]; liefert eine Liste wie{1,-1,-2,0,-6} .

JavaScript (ES6), 21

Danke @Dennis

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

05AB1E , 4 Bytes

¬·s-

Probieren Sie es online! oder als Testsuite

Erläuterung

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

Python, 44 Bytes

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

Dies verwendet die "Einfachere Methode".

Pyth, 5 Bytes

-LyhQ

Online-Dolmetscher!

R, 23 18 17 Bytes

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

automatische Vektorisierung und Standarddruck zur Rettung!

Ruby, 23 Bytes

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

Nicht besonders originell.

Perl 6 ,  40  16 Bytes

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

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

Erweitert:

{ # 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 Bytes

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

Probieren Sie es online!

Erläuterung:

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 bis 19 Bytes

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

Gleiche Lösung wie Dennis, danke für deine Idee von 2a - x.

Dank Christian Severs ein Byte gespart.

Pyke, 5 4 Bytes

h}m-

Probieren Sie es hier aus!

PHP, 48 Bytes

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

Mit der Technik von Dennis. Verwenden Sie wie:

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

Nicht-Dennis 55-Byte-Version:

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

APL, 8 Bytes

+\⊃,2-/+

Erläuterung:

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

Testfälle:

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

Labyrinth , 34 Bytes

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

Probieren Sie es online!

Verwendet @Dennis 's (2a - a, 2a - b, 2a - c, 2a - d)Ansatz.

Die gelben Kacheln sind für den Kontrollfluss. In dieser 2D-Programmiersprache beginnt das Programm mit der obersten linken Kachel, die sich nach Osten bewegt, um zu beginnen. An Kreuzungen wird die Richtung durch das Vorzeichen der Oberseite des Hauptstapels bestimmt. Leere Fliesen sind Wände.

Grün

Dieser Abschnitt speichert 2a auf dem Hilfsstapel.

• ? Holen Sie sich die erste Zahl und schieben Sie sie an die Spitze des Hauptstapels
• : Duplizieren Sie die Oberseite des Stapels
• _2 Schieben Sie zwei nach oben auf den Stapel
• *Pop y, Pop x, Pushx*y
• } Bewegen Sie die Oberseite des Hauptstapels an die Oberseite des Hilfsstapels.
• _ Schieben Sie die Null auf den Stapel

Orange

Dieser Abschnitt subtrahiert 2a von der aktuellen Zahl, negiert das Ergebnis, gibt das Ergebnis aus, erhält das nächste Zeichen (den Begrenzer), beendet, wenn EOF, gibt eine neue Zeile aus, erhält die nächste Zahl.

• "Noop. Wenn Sie von Norden kommen, ist die Spitze des Stapels Null und das Programm wird nach Süden fortgesetzt. Wenn Sie von Westen kommen, ist der obere Teil des Stapels einer und das Programm dreht sich nach rechts (weiter nach Süden).
• ;Werfen Sie die Oberseite des Stapels weg. Da die Null oder Eins nur für den Kontrollfluss verwendet wird, müssen diese verworfen werden
• { Bewegen Sie die Oberseite des Zusatzstapels (2a) zur Oberseite des Hauptstapels
• : Duplizieren Sie die Oberseite des Hauptstapels
• } Bewegen Sie die Oberseite des Hauptstapels an die Oberseite des Hilfsstapels
• -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`
• ! Legen Sie den oberen Rand des Stapels ab und geben Sie ihn als Zahl aus
• , Drücken Sie das nächste Zeichen (das das Trennzeichen sein wird) oder das negative Zeichen, wenn EOF
• )Erhöhen Sie die Oberseite des Stapels. Wenn das letzte Zeichen EOF ist, ist die Oberseite des Stapels jetzt Null, und das Programm fährt direkt mit dem @Befehl und dem Beenden fort. Wenn das letzte Zeichen ein Delimeter war, ist die Oberseite des Stapels positiv und das Programm biegt nach rechts ab und fährt nach Osten zum fort\
• \ Geben Sie eine neue Zeile aus
• ? Holen Sie sich die nächste Nummer
• _1 Schieben Sie eine nach oben, um an der Kreuzung nach rechts abzubiegen

Labyrinth , 24 Bytes

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

Eingabe- und Ausgabeformat sind Zeilenvorschub-getrennte Listen (obwohl das Eingabeformat tatsächlich viel flexibler ist). Das Programm bricht mit einem Fehler ab.

Probieren Sie es online!

Bei dieser Byteanzahl gibt es zwei andere Lösungen, die im Grunde gleich funktionieren, aber einen etwas anderen Steuerungsfluss verwenden.

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

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

Erläuterung

Der Anweisungszeiger (IP) bewegt sich in der ersten Zeile nach Osten, aber alle Befehle vor dem ?sind grundsätzlich keine Befehle für den globalen Status, da wir nirgendwo Befehle für die Stapeltiefe verwenden. Der Code beginnt also wirklich ?in westlicher Richtung, da sich die IP dreht, wenn sie die Sackgasse erreicht.

Der Code beginnt daher mit dem folgenden linearen Codebit:

?:}:+}

Dies setzt uns einfach mit einer Kopie von ein 2a, um die [2a - a, 2a - b, 2a - c, ...]Formel zu verwenden.

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

Wir betreten nun die Hauptschleife des Programms und verwenden einen ziemlich üblichen Trick, um eine einzelne Codezeile zu durchlaufen:

<...>

Beachten Sie, dass der Stapel leer ist, wenn wir die Taste drücken, <damit wir wissen, dass wir dort Nullen erhalten. Der <dreht dann die gesamte Zeile nach links und nimmt die IP mit, so dass wir folgendes erhalten:

...><

Die IP muss sich dann nach links bewegen, wo die >Linie wieder an ihren ursprünglichen Platz verschoben wird (um sie für die nächste Iteration vorzubereiten). Dann wird die Zeile einfach von rechts nach links ausgeführt, sodass eine einzelne Schleifeniteration wie folgt lautet:

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

Der Haken bei der Arbeit mit einer Schleife dieses Typs ist, dass Sie mit keiner Form der bedingten Ausführung arbeiten können, da Labyrinth keine Möglichkeit hat, Code zu überspringen. Deshalb beenden wir das Programm mit einer Division durch Null, wenn wir EOF drücken. Hier ist eine Aufschlüsselung jeder Schleifeniteration.

{:   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 Bytes

Als unbenanntes Lambda, das seine Eingabe ändert:

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

Mit der Technik von Dennis. Funktioniert für jeden Container wie int[]odervector<int> .

Verwendung:

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

Eingabeformat: [1 2 3 4]. Verwendet die einfache Formel.

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

Erläuterung:

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

Entschuldigung für den fehlenden Testlink. Ich denke, SE mag es nicht, wenn es Links mit Klammern enthält.

Aufdringlich , 9 Bytes

{&}2*K~-_

Geben Sie Argumente als durch Komma getrennt Werte auf cmd line: $ pushy invdeltas.pshy 1,3,4,2,8. Hier ist die Aufschlüsselung mit Beispielstapel:

           % 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

Hinweis: Dies können 8 Byte sein, wenn die Rückwärtsausgabe zulässig ist: @&2*K~-_

Perl, 26 + 3 ( -plaFlag) = 29 Bytes

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

oder

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

Verwenden von:

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

Dyalog APL , 5 Bytes

-+2×⊃

Dies ist ein 5-Zug, der wie zwei verschachtelte 3-Züge ("Gabeln") analysiert wird: -+(2×⊃)

liest sich wie folgt: die Negation ( -) des gesamten Arrays plus ( +) zweimal ( 2×) das erste Element ( ⊃)

ised, 11 Bytes

2*$1_0-$1

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

(edit: korrigiert durch Diebstahl der Algebra von Dennis)

Wunder , 17 Bytes

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

Ich bin mir nicht sicher, warum ich das nicht früher gepostet habe. Verwendung:

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

Besser lesbar:

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