ย้อนกลับ Deltas ของอาเรย์

ความต่อเนื่องของDeltas ของ Array

งานของคุณคือการใช้อาร์เรย์ของจำนวนเต็ม 32 บิตที่เซ็นชื่อแล้วคอมไพล์ใหม่ด้วยการย้อนกลับของเดลต้า

ตัวอย่าง

รายการ,

18  19  17  20  16

มี deltas:

   1  -2   3  -4

ซึ่งเมื่อกลับรายการจะได้รับ:

  -4   3  -2   1

จากนั้นเมื่อคอมไพล์ใหม่โดยใช้อัตราผลตอบแทน:

18  14  17  15  16

ซึ่งควรเป็นค่าตอบแทนของคุณ

การคอมไพล์ใหม่ประกอบด้วยการรับCซึ่งเป็นค่าแรกของอาร์เรย์ ในกรณีนี้18และใช้ delta กับมันตามลำดับ ดังนั้น18 + -4ให้14, 14 + 3ให้17, และอื่น ๆ

Input / Output

คุณจะได้รับรายการ / อาร์เรย์ / ตาราง / tuple / stack / etc จำนวนเต็มที่ลงนามเป็น input ผ่านวิธีการป้อนข้อมูลมาตรฐานใด ๆ

คุณต้องส่งออกข้อมูลที่ถูกแก้ไขอีกครั้งในรูปแบบที่ยอมรับได้ใด ๆ ตามวิธีการย้อนกลับของเดลต้า

คุณจะได้รับอินพุต N 0 < N < 10ซึ่งแต่ละหมายเลขอยู่ในช่วงที่กำหนด-1000 < X < 1000

กรณีทดสอบ

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

หมายเหตุ

• ตามที่ระบุไว้ข้างต้นคุณจะได้รับอย่างน้อย 1 อินพุตและไม่เกิน 9
• หมายเลขแรกและครั้งสุดท้ายของการส่งออกของคุณจะเสมอตรงกับการป้อนข้อมูล
• ยอมรับเอาต์พุตอินพุตมาตรฐานเท่านั้น
• ช่องโหว่มาตรฐานใช้
• นี่คือโค้ดกอล์ฟดังนั้นจำนวนไบต์ที่น้อยที่สุดจึงเป็นผู้ชนะ!
• มีความสุข!

และผู้ชนะคือ...

เดนนิส! ใครเป็นคนแรกที่เข้ามาอันดับแรกจากนั้นก็เอาชนะตัวเองด้วยวิธีที่สั้นกว่าให้ตัวเองทั้งที่หนึ่งและที่สอง!

รางวัลชมเชยais523กับเจลลี่ของพวกเขาหากไม่ใช่เพื่อให้เดนนิสเข้ามาก่อนพวกเขาจะได้อันดับที่สอง

เยลลี่ 5 ไบต์

.ịS_Ṛ

นี้ใช้อัลกอริทึมจากเกลน O คำตอบของจูเลีย

ลองออนไลน์!

มันทำงานอย่างไร

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

เยลลี่ 6 ไบต์

I;ḢṚ+\

ลองออนไลน์!

มันทำงานอย่างไร

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.

จูเลีย 24 ไบต์

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

นี่เป็นวิธี "ฉลาด" ในการแก้ปัญหา การย้อนกลับด้านลบของอาเรย์นั้นมี "เดลตา" กลับด้านแล้วคุณเพียงแค่ต้องแก้ไขความจริงที่ว่ามันเริ่มต้น / สิ้นสุดในตำแหน่งที่ผิด

Snowman 1.0.2, 72 ไบต์

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

ลองออนไลน์!

นี่คือรูทีนย่อยที่รับอินพุตจากและส่งออกไปยัง permavar ปัจจุบัน

((
  }       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 ไบต์

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

คำตอบ Mathematica ของ Port of @ JHM (ฉันแน่ใจว่าฉันจะได้มาด้วยตัวเอง แต่ไม่ใช่ในเวลากลางคืน) แก้ไข: บันทึก 8 ไบต์ขอบคุณ @ edc65

Mathematica ขนาด 23 ไบต์

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

ฟังก์ชันที่ไม่มีชื่อ ผลลัพธ์คือ: ย้อนกลับ ((องค์ประกอบแรก) + (องค์ประกอบสุดท้าย) - (แต่ละองค์ประกอบ)

Python 2, 96 74 54 44 ไบต์

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

อินพุตถูกกำหนดเป็นอาร์เรย์ล้อมรอบด้วยวงเล็บเหลี่ยม เอาต์พุตอยู่ในรูปแบบเดียวกัน

ขอบคุณ @Kade สำหรับการประหยัด22 42 ไบต์โดยใช้วิธีการง่ายกว่าที่ฉันเคยทำมาก่อน!

ขอบคุณ @ Sherlock9 สำหรับการบันทึก 10 ไบต์โดยกำจัดตัวนับดัชนีออกจากรายการความเข้าใจ!

เยี่ยมมากตอนนี้ถ้าฉันเล่นกอล์ฟอีกต่อไปฉันจะได้รับปัญหา "กากบาท 44 ยังคง 44" ; _;

05AB1E , 8 ไบต์

¬s¤sR(++

ลองออนไลน์!

การแปลคำตอบ MATL ของฉันวิธีที่สอง

¬    % 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 ไบต์

แก้ไข: ตอนนี้ใช้วิธีการในคำตอบ Julia ของ Glen O

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

เก่า:

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

อ่านอินพุตคำนวณเดลตาเชื่อมกับองค์ประกอบแรกและคำนวณผลรวมสะสม

MATL , 8 ไบต์

1)GdPhYs

ลองออนไลน์!

นี่เป็นแอปพลิเคชันโดยตรงของคำนิยาม พิจารณาการป้อนข้อมูล[18 19 17 20 16]เป็นตัวอย่าง

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]

วิธีที่ต่างกันนับไบต์เดียวกัน:

P_G5L)s+

ลองเลย!

อาเรย์ที่ถูกย้อนกลับและที่ผ่านมารวมถึงรายการแรกและสุดท้ายของอาเรย์เดิม

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

Japtet, 8 ไบต์

Ô®nUÌ+Ug

เปิดใช้งานออนไลน์

Pyth - 10 ไบต์

sM._+hQ_.+

Test Suite

아희 (Aheui) , 3 * 21 ตัวอักษร + 2 "\ n" = 65 ไบต์

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

ถือว่าอินพุตในสแต็ก아 เอาต์พุตจะถูกเก็บไว้ใน stack 안

หากคุณต้องการลองใช้รหัสนี้:

ในตอนท้ายของบรรทัดแรกของรหัสนี้ให้เพิ่ม벙ความยาวอักขระ(n) -times (เช่นถ้าอินพุตคือ 7 จำนวนเต็มใส่ 7 ครั้ง) สำหรับแต่ละพรอมต์ให้พิมพ์หนึ่งจำนวนเต็ม:

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

ลองที่นี่! (คัดลอกและวางรหัส)

ตัวอย่าง

สำหรับ1, 2, 3, 4, 5:

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

แล้วพิมพ์1, 2, 3, 4และ5(จะมีการแจ้งให้ 5)

รุ่นทางเลือก (65 ไบต์)

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

C # 42 ไบต์

ใช้เวลาและการส่งกลับint[]IEnumerable<int>

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

(อันที่จริงนี่เป็นเพียงเวอร์ชั่นที่ได้รับการแปลเวอร์ชั่นของ JHM .. )

TSQL, 200 ไบต์

ตัวแปรตารางที่ใช้เป็นอินพุต

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

ลองดู

PHP, 60 56 52 ไบต์

-4 ไบต์ต้องขอบคุณ @ user59178

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

ทำงานบนอาร์กิวเมนต์บรรทัดคำสั่งใช้ขีดล่างเป็นตัวคั่น ทำงานด้วย
php -r '<code>' <space separated numbers>

Perl 6 ,  48 33  30 ไบต์

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

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

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

ลองมัน

ขยาย:

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

*-1ยังเป็นแสดงออกแลมบ์ดาประเภท WhateverCode ที่*เป็นพารามิเตอร์เฉพาะตำแหน่ง

Julia 0.4 , 32 ไบต์

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

ลองออนไลน์!

BASH, 71 ไบต์

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

C ++ 14, 103 ไบต์

ในฐานะที่เป็นชื่อแลมบ์ดาต้องป้อนข้อมูลให้มีrbegin, rend, backและpush_backเช่นภาชนะบรรจุvector, หรือdequelist

การใช้วิธีการจากจูเลียตอบของเกลน

[](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 และการใช้งาน:

#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 ไบต์

ใช้ตรรกะเดียวกันกับ JHM:

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

ค่อนข้างอ่านได้เช่นกัน

นูน 10 ไบต์

_î\(@¥+¡p;

ลองออนไลน์!

Clojure 101 ไบต์

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

สวยมากดังต่อไปนี้คำอธิบาย:

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

Java 7, 96 ไบต์

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

คำอธิบาย:

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

รหัสทดสอบ:

ลองที่นี่

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

เอาท์พุท:

[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 ไบต์^SBCS

ฟังก์ชันนำหน้าเงียบโดยไม่ระบุชื่อ

+\⊃,∘⌽2-⍨/⊢

ลองออนไลน์!

+\ ผลรวมสะสมของ

⊃ องค์ประกอบแรกของการโต้แย้ง

, ตาม
∘ ด้วย
⌽  การกลับรายการของ

2-⍨/ ความแตกต่างของ

⊢ อาร์กิวเมนต์