Membalikkan Delta dari Array

Kelanjutan dari Invers Delta dari sebuah Array

Tugas Anda adalah untuk mengambil array integer 32 bit yang ditandatangani, kompilasi ulang dengan delta yang dibalik.

Contoh

Daftar,

18  19  17  20  16

memiliki delta:

   1  -2   3  -4

yang, ketika dibalik, menghasilkan:

  -4   3  -2   1

lalu saat dikompilasi ulang, menggunakan hasil:

18  14  17  15  16

yang seharusnya menjadi nilai pengembalian Anda.

Kompilasi ulang terdiri dari mengambil C, yang merupakan nilai pertama array. Dalam hal ini,,, 18dan menerapkan delta secara berurutan. Jadi 18 + -4memberi 14, 14 + 3memberi 17, dan sebagainya.

Input output

Anda akan diberikan daftar / array / tabel / tuple / stack / dll. bilangan bulat yang ditandatangani sebagai input melalui metode input standar apa pun.

Anda harus mengeluarkan data yang dimodifikasi sekali lagi dalam bentuk apa pun yang dapat diterima, mengikuti metode pembalikan delta di atas.

Anda akan menerima input N di 0 < N < 10mana setiap angka berada dalam kisaran-1000 < X < 1000

Uji Kasus

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

Catatan

• Seperti yang dinyatakan di atas, Anda akan selalu menerima setidaknya 1 input, dan tidak lebih dari 9.
• Angka pertama dan terakhir dari output Anda, akan selalu cocok dengan input.
• Hanya Output Input Standar yang diterima
• Celah standar berlaku
• Ini adalah kode-golf , jadi byte-count terendah menang!
• Selamat bersenang-senang!

Dan pemenangnya adalah...

Dennis! Yang pertama mengambil tempat pertama, lalu memukul dirinya sendiri dengan solusi yang lebih pendek, memberikan dirinya tempat pertama dan kedua!

Sebutan terhormat untuk ais523 dengan Jelly mereka, bahwa jika bukan karena Dennis masuk tepat sebelum mereka, akan menempati posisi kedua.

Jelly , 5 byte

.ịS_Ṛ

Ini menggunakan algoritma dari jawaban Glen O Julia .

Cobalah online!

Bagaimana itu bekerja

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

Jelly , 6 byte

I;ḢṚ+\

Cobalah online!

Bagaimana itu bekerja

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 byte

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

Ini adalah cara "pintar" untuk menyelesaikan masalah. Pembalikan negatif dari array memiliki "delta" terbalik, dan kemudian Anda hanya perlu memperbaiki fakta bahwa ia mulai / berakhir di tempat yang salah.

Snowman 1.0.2, 72 byte

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

Cobalah online!

Ini adalah subrutin yang mengambil input dari dan output ke permavar saat ini.

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

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

Port of @ JHM's Mathematica menjawab. (Saya yakin saya bisa membuatnya sendiri, tetapi tidak pada waktu malam ini.) Edit: Disimpan 8 byte berkat @ edc65.

Mathematica, 23 byte

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

Fungsi yang tidak disebutkan namanya. Hasilnya sederhana: membalikkan ((elemen pertama) + (elemen terakhir) - (setiap elemen)).

Python 2, 96 74 54 44 byte

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

Input diberikan sebagai array yang dikelilingi oleh tanda kurung siku. Output dalam format yang sama.

Terima kasih kepada @Kade untuk menghemat 22 42 byte dengan menggunakan metode yang jauh lebih sederhana daripada apa pun yang saya lakukan sebelumnya!

Terima kasih kepada @ Sherlock9 untuk menghemat 10 byte dengan menghilangkan penghitung indeks dari pemahaman daftar!

Hebat, sekarang jika saya bermain golf lagi saya akan mendapatkan masalah "dicoret 44 masih 44". ; _;

05AB1E , 8 byte

¬s¤sR(++

Cobalah online!

Terjemahan jawaban MATL saya, pendekatan kedua.

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

Sunting: Sekarang menggunakan pendekatan dalam jawaban Julia O Glen

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

Tua:

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

Membaca input, menghitung delta, menyatukan dengan elemen pertama dan menghitung jumlah kumulatif.

MATL , 8 byte

1)GdPhYs

Cobalah online!

Ini adalah aplikasi langsung dari definisi tersebut. Pertimbangkan input [18 19 17 20 16]sebagai contoh.

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]

Pendekatan berbeda, jumlah byte yang sama:

P_G5L)s+

Coba saja!

Array terbalik dan dinegasi ditambah entri pertama dan terakhir dari array asli.

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 byte

Ô®nUÌ+Ug

Jalankan secara online

Pyth - 10 byte

sM._+hQ_.+

Test Suite .

아희 (Aheui) , 3 * 21 karakter + 2 "\ n" = 65 byte

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

Mengasumsikan input dalam tumpukan 아. Keluaran akan disimpan dalam tumpukan 안.

Jika Anda ingin mencoba kode ini:

Di akhir baris pertama kode ini, tambahkan 벙panjang karakter (n) -kali (yaitu jika inputnya 7 bilangan bulat, masukkan 7 kali). Untuk setiap prompt, ketik satu bilangan bulat:

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

Coba di sini! (salin dan tempel kode)

Contoh

Untuk 1, 2, 3, 4, 5:

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

dan kemudian ketik 1, 2, 3, 4, dan5 (akan ada 5 petunjuknya).

Versi Alternatif (65 byte)

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

C # 42 byte

Mengambil int[]dan mengembalikan sebuah IEnumerable<int>.

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

(Ini sebenarnya hanya versi porting dari versi JHM ..)

TSQL, 200 byte

Variabel tabel digunakan sebagai input

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

Cobalah

PHP, 60 56 52 byte

-4 byte terima kasih ke @ user59178

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

beroperasi pada argumen baris perintah, menggunakan garis bawah sebagai pemisah. Jalankan dengan
php -r '<code>' <space separated numbers>

Perl 6 ,  48 33  30 byte

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

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

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

Cobalah

Diperluas:

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

Ini *-1juga merupakan ekspresi lambda dari jenis Apapun, yang *merupakan satu-satunya parameter posisi.

Julia 0,4 , 32 byte

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

Cobalah online!

BASH, 71 byte

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

C ++ 14, 103 byte

Sebagai lambda tidak disebutkan namanya, yang membutuhkan input untuk memiliki rbegin, rend, backdan push_backseperti kontainer vector, dequeatau list.

Menggunakan pendekatan dari jawaban Glen O Julia

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

Tidak digabungkan dan digunakan:

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

Menggunakan logika yang sama dengan JHM:

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

Cukup mudah dibaca juga.

Cembung , 10 byte

_î\(@¥+¡p;

Cobalah online!

Clojure, 101 byte

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

Cukup banyak mengikuti deskripsi:

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

Java 7, 96 byte

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

Penjelasan:

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

Kode uji:

Coba di sini.

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

Keluaran:

[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

Fungsi awalan diam-diam anonim.

+\⊃,∘⌽2-⍨/⊢

Cobalah online!

+\ jumlah kumulatif

⊃ elemen pertama dari argumen

, diikuti
∘ oleh
⌽  pembalikan

2-⍨/ perbedaan berpasangan dari

⊢ argumen