Umgekehrte Deltas eines Arrays

Eine Fortsetzung der inversen Deltas eines Arrays

Ihre Aufgabe ist es, ein Array von vorzeichenbehafteten 32-Bit-Ganzzahlen mit umgekehrten Deltas neu zu kompilieren.

Beispiel

Die Liste,

18  19  17  20  16

hat die Deltas:

   1  -2   3  -4

was umgekehrt ergibt:

  -4   3  -2   1

dann, wenn neu kompiliert, mit Ausbeuten:

18  14  17  15  16

Welches sollte Ihr Rückgabewert sein.

Das Neukompilieren besteht darin C, den ersten Wert des Arrays zu übernehmen. In diesem Fall 18und Anwenden der Deltas in der richtigen Reihenfolge. So 18 + -4gibt 14, 14 + 3gibt 17und so weiter.

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-Umkehrmethode folgen.

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

Testfälle

1 2 3 4 5      -> 1 2 3 4 5
18 19 17 20 16 -> 18 14 17 15 16
5 9 1 3 8 7 8  -> 5 6 5 10 12 4 8
6 5 4 1 2 3    -> 6 7 8 5 4 3

Anmerkungen

• Wie oben angegeben, erhalten Sie immer mindestens 1 Eingang und nicht mehr als 9.
• Die erste und letzte Nummer Ihrer Ausgabe stimmen immer mit der der Eingabe überein.
• Es wird nur die Standardeingabe Ausgabe akzeptiert
• Es gelten Standardlücken
• Das ist Code-Golf , also gewinnt die niedrigste Byte-Anzahl!
• Habe Spaß!

Und der Gewinner ist...

Dennis! Wer zuerst den ersten Platz belegte, schlug sich dann mit einer kürzeren Lösung und sicherte sich sowohl den ersten als auch den zweiten Platz!

Lobende Erwähnung an ais523 mit ihrem Jelly, dass Dennis, wenn er nicht direkt vor ihnen reingekommen wäre, den zweiten Platz gehalten hätte.

Gelee , 5 Bytes

.ịS_Ṛ

Dies verwendet den Algorithmus aus Glen O's Julia-Antwort .

Probieren Sie es online!

Wie es funktioniert

.ịS_Ṛ  Main link. Argument: A (array)

.ị     At-index 0.5; retrieve the values at the nearest indices (0 and 1). Since
       indexing is 1-based and modular, this gives the last and first element.
  S    Compute their sum.
    Ṛ  Yield A, reversed.
   _   Subtract the result to the right from the result to the left.

Gelee , 6 Bytes

I;ḢṚ+\

Probieren Sie es online!

Wie es funktioniert

I;ḢṚ+\  Main link. Argument: A (array)

I       Increments; compute the deltas of A.
  Ḣ     Head; yield the first element of A.
 ;      Concatenate the results to both sides.
   Ṛ    Reverse the resulting array.
    +\  Compute the cumulative sum of the reversed array.

Julia, 24 Bytes

!x=x[end]+x[]-reverse(x)

Dies ist der "clevere" Weg, um das Problem zu lösen. Die negative Umkehrung des Arrays hat die "Deltas" umgekehrt, und dann müssen Sie nur die Tatsache beheben, dass es an den falschen Stellen beginnt / endet.

Schneemann 1.0.2, 72 Bytes

((}#0AaGwR#`wRaCaZ`0NdE`aN0AaG:dU,0aA|1aA,nS;aM`0wRaC|#0aA*|:#nA*#;aM*))

Probieren Sie es online!

Dies ist eine Unterroutine, die Eingaben von und Ausgaben für den aktuellen Permavar übernimmt.

((
  }       enable variables b, e, and g
  #       store the input in variable b
  0AaG    remove the first element (take indices > 0)
  wR      wrap the array in another array
  #`wRaC  concatenate with the original input array
  aZ      zip (transpose); we now have pairs of elements
  `0NdE   obtain the number -1 (by decrementing 0)
  `aN     reverse the zipped array
  0AaG    remove first (there is one fewer delta than array elements)
  :       map over the array of pairs:
    dU     duplicate; we now have b=[x,y] e=[x,y]
    ,0aA   move the copy and get the first element; b=x g=[x,y]
    |1aA   get the second element from the copy; b=y g=x
    ,nS    subtract; we now have b=y-x which is returned from the map
  ;aM     (map)
  `0wRaC  prepend a zero (in preparation for the next step)
  |#0aA   get the first element of the original array
  *       store this in the permavar
  |:      map over the array of deltas with 0 prepended:
    #       store the permavar in e
    nA      add the delta and the permavar
    *#      make this the new value of the permavar
  ;aM     (map)
  *       "return" the resulting array from the subroutine
))

JavaScript (ES6), 45 37 Bytes

a=>a.reverse(z=a[0]).map(e=>z+a[0]-e)

Port von @ JHMs Mathematica-Antwort. (Ich bin sicher, dass ich es selbst hätte ableiten können, aber nicht zu dieser Nachtzeit.) Bearbeiten: 8 Bytes dank @ edc65 gespeichert.

Mathematica, 23 Bytes

#&@@#+Last@#-Reverse@#&

Unbenannte Funktion. Das Ergebnis ist einfach: umkehren ((erstes Element) + (letztes Element) - (jedes Element)).

Python 2, 96 74 54 44 Bytes

lambda l:[l[0]+l[-1]-j for j in l][::-1]

Die Eingabe erfolgt als Array in eckigen Klammern. Die Ausgabe erfolgt im gleichen Format.

Vielen Dank an @Kade, dass Sie 22 bis 42 Bytes gespart haben, und zwar mit einer viel einfacheren Methode als bisher!

Vielen Dank an @ Sherlock9 für die Einsparung von 10 Bytes, indem der Indexzähler aus dem Listenverständnis gestrichen wurde!

Großartig, wenn ich jetzt noch Golf spiele, bekomme ich das Problem "durchgestrichen 44 ist immer noch 44". ; _;

05AB1E , 8 Bytes

¬s¤sR(++

Probieren Sie es online!

Übersetzung meiner MATL-Antwort, zweiter Ansatz.

¬    % Implicit input. Head, without consuming the input
s    % Swap
¤    % Tail, without consuming the input
s    % Swap
R(   % Reverse and negate
++   % Add head and tail of input to reversed and negated input. Implicitly display

R, 37-30 Bytes

Bearbeiten: Verwenden Sie jetzt den Ansatz in Glen O Julia Antwort

x=scan();x[1]+tail(x,1)-rev(x)

Alt:

x=scan();cumsum(c(x[1],rev(diff(x))))

Liest Eingaben, berechnet Deltas, verknüpft mit dem ersten Element und berechnet die kumulative Summe.

MATL , 8 Bytes

1)GdPhYs

Probieren Sie es online!

Dies ist die direkte Anwendung der Definition. Betrachten Sie die Eingabe [18 19 17 20 16]als Beispiel.

1)     % Implicit input. Get its first entry
       % STACK: 18
G      % Push input again
       % STACK: 18, [18 19 17 20 16]
d      % Consecutive differences
       % STACK: 18, [1 -2 3 -4]
P      % Reverse
       % STACK: 18, [-4 3 -2 1]
h      % Concatenate
       % STACK: [18 -4 3 -2 1]
Ys     % Cumulative sum. Implicitly display
       % STACK: [18 14 17 15 16]

Anderer Ansatz, gleiche Byteanzahl:

P_G5L)s+

Probieren Sie es einfach aus!

Umgekehrtes und negiertes Array sowie der erste und letzte Eintrag des ursprünglichen Arrays.

P_     % Implicit inut. Reverse and negate
G      % Push input again
5L)s   % Sum of first and last entries
+      % Add to reversed and negated array. Implicitly display

Japt, 8 Bytes

Ô®nUÌ+Ug

Führen Sie es online aus

Pyth - 10 Bytes

sM._+hQ_.+

Test Suite .

아희 (Aheui) , 3 × 21 Zeichen + 2 "\ n" = 65 Bytes

빪쑥쌳텆슉폎귁삯씬희
뿓팤팧쎢싺솎
싺싹삭당뽔

Übernimmt die Eingabe in Stapel 아. Die Ausgabe wird im Stapel 안 gespeichert.

Wenn Sie diesen Code ausprobieren möchten:

벙Fügen Sie am Ende der ersten Zeile dieses Codes die Zeichenlänge (n) -fach hinzu (dh wenn die Eingabe 7 Ganzzahlen ist, fügen Sie sie 7-fach ein). Geben Sie für jede Eingabeaufforderung eine Ganzzahl ein:

어우
우어
빪쑥쌳텆슉폎귁삯씬희
뿓팤팧쎢싺솎
싺싹삭당뽔

Probieren Sie es hier aus! (Kopieren Sie den Code und fügen Sie ihn ein)

Beispiel

Für 1, 2, 3, 4, 5:

어우벙벙벙벙벙
우어
빪쑥쌳텆슉폎귁삯씬희
뿓팤팧쎢싺솎
싺싹삭당뽔

und geben Sie dann 1, 2, 3, 4, und5 (es wird 5 Aufforderungen sein).

Alternative Version (65 Bytes)

빠쑥쌳터슉펴ㅇ삯씬희
뿌파파쎢싺솎
싺싹삭다뽀

C # 42 Bytes

Nimmt ein int[]und gibt ein zurück IEnumerable<int>.

a=>a.Select(v=>a[0]+a.Last()-v).Reverse();

(Dies ist eigentlich nur eine portierte Version von JHMs Version.)

TSQL, 200 Bytes

Tabellenvariable, die als Eingabe verwendet wird

DECLARE @ table(a int, b int identity)

INSERT @ values(5),(9),(1),(3),(8),(7),(8);

WITH c as(SELECT*,rank()over(order by b desc)z FROM @)SELECT g+isnull(sum(-f)over(order
by b),0)FROM(SELECT sum(iif(c.b=1,c.a,0))over()g,d.a-lead(d.a)over(order by d.b)f,c.b
FROM c,c d WHERE c.b=d.z)d

Versuch es

PHP, 60 56 52 Bytes

-4 Bytes dank @ user59178

for($a=$argv;--$argc;)echo$a[1]+end($a)-$a[$argc],_;

Funktioniert mit Befehlszeilenargumenten und verwendet einen Unterstrich als Trennzeichen. Laufen Sie mit
php -r '<code>' <space separated numbers>

Perl 6 ,  48 33  30 Bytes

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

{.reverse.map: {.[0]+.[*-1]-$^a}}

{[R,] .map: {.[0]+.[*-1]-$^a}}

Versuch es

Erweitert:

{  # bare block lambda with implicit parameter ｢$_｣

  [R,]               # reduce the following using the comma operator [R]eversed
                     # (short way to do the same thing as ｢reverse｣)

    .map:            # map the input (implicit method call on ｢$_｣

      {              # bare block lambda with placeholder parameter ｢$a｣

          .[     0 ] # the first value of ｢$_｣ (implicit “method” call)
        + .[ * - 1 ] # add the last value of ｢$_｣ (implicit “method” call)
        -     $^a    # declare the parameter and subtract it from the above
      }
}

Das *-1ist auch ein Lambda-Ausdruck vom Typ WhateverCode, wobei das *der einzige Positionsparameter ist.

Julia 0,4 , 32 Bytes

!x=[x[];x|>diff|>flipud]|>cumsum

Probieren Sie es online!

BASH, 71 Bytes

s=$1
echo $s
for i in `seq ${#@} -1 2`;{
echo $[s=s+${!i}-${@:i-1:1}]
}

C ++ 14, 103 Bytes

Als unbenanntes Lambda, das seine Eingabe haben rbeginmuss rend, backund push_backwie die Container vector, dequeoderlist .

Verwenden Sie den Ansatz von Glen O's Julia-Antwort

[](auto c){decltype(c)d;for(auto i=c.rbegin()-1;++i!=c.rend();)d.push_back(c[0]+c.back()-*i);return d;}

Ungolfed und Nutzung:

#include<iostream>
#include<vector>

//declare generic function, return is deduced automatically
auto f=[](auto c){
  //create fresh container of the same type as input
  decltype(c)d;

  //iterate through the reverse container
  for(auto i=c.rbegin()-1;++i!=c.rend();)
    //add the first and last element minus the negative reverse
    d.push_back(c[0]+c.back()-*i);
  return d;
}
;


int main(){
  std::vector<int> a={18,  19,  17,  20,  16};
  auto b = f(a);
  for(auto&x:b)
    std::cout << x << ", ";
  std::cout<<"\n";
}

Haskell, 33 Bytes

Verwendet die gleiche Logik wie JHM:

f a=map(head a+last a-)$reverse a

Sehr gut lesbar.

Konvex , 10 Bytes

_î\(@¥+¡p;

Probieren Sie es online!

Clojure, 101 Bytes

(fn[c](conj(map #(-(first c)%)(reductions +(reverse(map #(apply - %)(partition 2 1 c)))))(first c))))

So ziemlich folgt die Beschreibung:

(def f (fn[c]
         (conj
           (->> c
                (partition 2 1)
                (map #(apply - %))
                reverse
                (reductions +)
                (map #(-(first c)%)))
           (first c))))

Java 7, 96 Bytes

int[]c(int[]a){int l=a.length,i=1,r[]=a.clone();for(;i<l;r[i]=r[i-1]+a[l-i]-a[l-++i]);return r;}

Erläuterung:

int[] c(int[] a){     // Method with integer-array parameter and integer-array return-type
  int l=a.length,     //  Length of input array
      i=1,            //  Index (starting at 1, although Java is 0-indexed)
      r[]=a.clone();  //  Copy of input array
  for(; i<l;          //  Loop over the array
    r[i] =            //   Replace the value at the current index in the copied array with:
      r[i-1]          //    The previous value in this copied array
      + a[l - i]      //    plus the opposite value in the input array
      - a[l - ++i])   //    minus the value before the opposite value in the input array (and increase the index)
  ;                   //  End the loop (implicit / no body)
  return r;           //  Return the result array
}                     // End of method

Testcode:

Probieren Sie es hier aus.

class M{
  static int[]c(int[]a){int l=a.length,i=1,r[]=a.clone();for(;i<l;r[i]=r[i-1]+a[l-i]-a[l-++i]);return r;}

  public static void main(String[] a){
    System.out.println(java.util.Arrays.toString(c(new int[]{ 18,19,17,20,16 })));
    System.out.println(java.util.Arrays.toString(c(new int[]{ 1,2,3,4,5 })));
    System.out.println(java.util.Arrays.toString(c(new int[]{ 5,9,1,3,8,7,8 })));
    System.out.println(java.util.Arrays.toString(c(new int[]{ 6,5,4,1,2,3 })));
  }
}

Ausgabe:

[18, 14, 17, 15, 16]
[1, 2, 3, 4, 5]
[5, 6, 5, 10, 12, 4, 8]
[6, 7, 8, 5, 4, 3]

APL (Dyalog Unicode) , 11 Byte ^SBCS

Anonyme implizite Präfixfunktion.

+\⊃,∘⌽2-⍨/⊢

Probieren Sie es online!

+\ kumulative Summe von

⊃ das erste Element des Arguments

, gefolgt
∘ von
⌽ der Umkehrung von

2-⍨/ die paarweise Differenz von

⊢ das Argument