Deltas inverses d'un tableau

Une suite de deltas inverses d'un tableau

Votre tâche consiste à prendre un tableau d'entiers 32 bits signés, à le recompiler avec ses deltas inversés.

Exemple

La liste,

18  19  17  20  16

a les deltas:

   1  -2   3  -4

qui, inversé, donne:

  -4   3  -2   1

puis une fois recompilé, en utilisant les rendements:

18  14  17  15  16

qui devrait être votre valeur de retour.

La recompilation consiste à prendre le C, qui est la première valeur du tableau. Dans ce cas, 18et appliquez-lui les deltas dans l'ordre. Alors 18 + -4donne 14, 14 + 3donne 17, etc.

Entrée sortie

Vous recevrez une liste / tableau / table / tuple / pile / etc. des entiers signés en entrée via toute méthode d'entrée standard.

Vous devez à nouveau générer les données modifiées sous toute forme acceptable, en suivant la méthode d'inversion delta ci-dessus.

Vous recevrez N entrées 0 < N < 10où chaque numéro se situe dans la plage-1000 < X < 1000

Cas de test

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

Remarques

• Comme indiqué ci-dessus, vous recevrez toujours au moins 1 entrée et pas plus de 9.
• Le premier et le dernier numéro de votre sortie correspondront toujours à celui de l'entrée.
• Seule la sortie d'entrée standard est acceptée
• Des échappatoires standard s'appliquent
• C'est le golf de code , donc le nombre d'octets le plus bas gagne!
• S'amuser!

Et le gagnant est...

Dennis! Qui a d'abord pris la première place, puis s'est battu avec une solution plus courte, se donnant à la fois la première et la deuxième place!

Mention honorable à ais523 avec leur gelée, qui, sans Dennis entrant juste avant eux, aurait occupé la deuxième place.

Gelée , 5 octets

.ịS_Ṛ

Il utilise l'algorithme de réponse Julia Glen O .

Essayez-le en ligne!

Comment ça marche

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

Gelée , 6 octets

I;ḢṚ+\

Essayez-le en ligne!

Comment ça marche

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 octets

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

C'est la façon «intelligente» de résoudre le problème. L'inverse négatif du tableau a les «deltas» inversés, et il vous suffit ensuite de corriger le fait qu'il commence / se termine aux mauvais endroits.

Snowman 1.0.2, 72 octets

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

Essayez-le en ligne!

Il s'agit d'un sous-programme qui prend des entrées et des sorties vers le permavar actuel.

((
  }       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 octets

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

Port de la réponse Mathematica de @ JHM. (Je suis sûr que j'aurais pu le dériver moi-même, mais pas à cette heure de la nuit.) Edit: 8 octets enregistrés grâce à @ edc65.

Mathematica, 23 octets

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

Fonction sans nom. Le résultat est simplement: reverse ((premier élément) + (dernier élément) - (chaque élément)).

Python 2, 96 74 54 44 octets

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

L'entrée est donnée sous la forme d'un tableau entouré de crochets. La sortie est au même format.

Merci à @Kade d'avoir économisé 22 42 octets en utilisant une méthode beaucoup plus simple que ce que je faisais avant!

Merci à @ Sherlock9 d'avoir économisé 10 octets en éliminant le compteur d'index de la compréhension de la liste!

Super, maintenant si je joue au golf, je vais avoir le problème "barré 44 est toujours 44". ; _;

05AB1E , 8 octets

¬s¤sR(++

Essayez-le en ligne!

Traduction de ma réponse MATL, deuxième approche.

¬    % 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 octets

Edit: Maintenant, en utilisant l'approche dans la réponse Julia de Glen O

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

Vieux:

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

Lit l'entrée, calcule les deltas, concatène avec le premier élément et calcule la somme cumulée.

MATL , 8 octets

1)GdPhYs

Essayez-le en ligne!

Il s'agit d'une application directe de la définition. Considérez la saisie [18 19 17 20 16]comme exemple.

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]

Approche différente, même nombre d'octets:

P_G5L)s+

Essayez-le onllne!

Tableau inversé et inversé plus les première et dernière entrées du tableau d'origine.

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 octets

Ô®nUÌ+Ug

Exécutez-le en ligne

Pyth - 10 octets

sM._+hQ_.+

Suite de tests .

아희 (Aheui) , 3 * 21 caractères + 2 "\ n" = 65 octets

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

Suppose l'entrée dans la pile 아. La sortie sera stockée dans la pile 안.

Si vous voulez essayer ce code:

À la fin de la première ligne de ce code, ajoutez la 벙longueur de caractère (n) -times (c'est-à-dire si l'entrée est de 7 entiers, insérez-la 7 fois). Pour chaque invite, tapez un entier:

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

Essayez-le ici! (copiez et collez le code)

Exemple

Pour 1, 2, 3, 4, 5:

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

et puis tapez 1, 2, 3, 4et5 (il y aura 5 invites).

Version alternative (65 octets)

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

C # 42 octets

Prend un int[]et retourne un IEnumerable<int>.

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

(Ce n'est en fait qu'une version portée de la version de JHM ..)

TSQL, 200 octets

Variable de table utilisée comme entrée

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

Essaye le

PHP, 60 56 52 octets

-4 octets grâce à @ user59178

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

fonctionne sur des arguments de ligne de commande, utilise le trait de soulignement comme séparateur. Courir avec
php -r '<code>' <space separated numbers>

Perl 6 ,  48 33  30 octets

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

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

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

Essayez-le

Étendu:

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

Le *-1est également une expression lambda de type WwhatCode, où le *est le seul paramètre positionnel.

Julia 0.4 , 32 octets

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

Essayez-le en ligne!

BASH, 71 octets

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

C ++ 14, 103 octets

Comme lambda sans nom, ce qui nécessite son entrée d'avoir rbegin, rend, backet push_backcomme les conteneurs vector, dequeou list.

Utilisation de l'approche de la réponse Julia de Glen O

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

Non golfé et utilisation:

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

Utilise la même logique que JHM:

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

Assez lisible également.

Convexe , 10 octets

_î\(@¥+¡p;

Essayez-le en ligne!

Clojure, 101 octets

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

Suit à peu près la description:

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

Java 7, 96 octets

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;}

Explication:

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

Code de test:

Essayez-le ici.

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 })));
  }
}

Sortie:

[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 octets ^SBCS

Fonction de préfixe tacite anonyme.

+\⊃,∘⌽2-⍨/⊢

Essayez-le en ligne!

+\ somme cumulée de

⊃ le premier élément de l'argument

, suivi
∘ par
⌽ l'inversion de

2-⍨/ la différence par paire de

⊢ l'argument