ผกผัน Deltas ของอาเรย์

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

1  3  4  2  8

ถือสันดอน:

  2  1 -2  6

ซึ่งเมื่อตะกี้แล้วยอม:

 -2 -1  2 -6

และ recompiled ยอม:

1 -1 -2  0 -6

เป็นผลสุดท้าย

Input / Output

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

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

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

กรณีทดสอบ

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

หมายเหตุ

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

เรามีผู้ชนะ

คำตอบของเยลลี่เดนนิสที่ Tiny 3 Bytes ทำให้ทองคำกลับบ้านเนื่องจากความจริงที่ว่าฉันอยู่ภายใต้ความรู้สึกว่ามันไม่สามารถเอาชนะได้

ฉันผิดหวังเล็กน้อยฉันไม่ได้เห็นคำตอบจากสเป็คดั้งเดิมอย่างไรก็ตามในภายหลังฉันอาจวางรางวัลนั้นอย่างแม่นยำ

เยลลี่ , 7 3 ไบต์

ḤḢ_

ลองออนไลน์!

พื้นหลัง

สันดอนของ(A, B, C, D)มีข - , ค - ขและd - ค การลด(a, b - a, c - b, d - c)โดยการลบทำให้a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c , และ2a - c - (ง - ค) = 2a - dดังนั้นผลที่ถูกต้องคือ(2a - ที่ 2a - B, 2a - C, 2a - ง)

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

ḤḢ_  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 ไบต์

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

ทดสอบบนIdeone

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

สันดอนของ(A, B, C, D)มีข - , ค - ขและd - ค การลด(a, b - a, c - b, d - c)โดยการลบทำให้a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c , และ2a - c - (ง - ค) = 2a - dดังนั้นผลที่ถูกต้องคือ(2a - ที่ 2a - B, 2a - C, 2a - ง)

Mathematica ขนาด 8 ไบต์

2#-{##}&

ฟังก์ชั่นที่ไม่มีชื่อการรับจำนวนอาร์กิวเมนต์ที่ไม่แน่นอน ใช้วิธี "ง่าย": คัดค้านรายการทั้งหมดและเพิ่มองค์ประกอบแรก (ต้นฉบับ) สองรายการ

เรียกตัวอย่างเช่น2#-{##}&[1,3,4,2,8]; {1,-1,-2,0,-6}ส่งกลับรายการเช่น

JavaScript (ES6), 21

ขอบคุณ @ เดนนิส

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

05AB1E , 4 ไบต์

¬·s-

ลองออนไลน์! หรือเป็นชุดทดสอบ

คำอธิบาย

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

Python ขนาด 44 ไบต์

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

วิธีนี้ใช้ "วิธีที่ง่ายกว่า"

Pyth, 5 ไบต์

-LyhQ

ล่ามออนไลน์!

R, 23 18 17 ไบต์

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

auto-vectorisation และการพิมพ์เริ่มต้นเพื่อช่วยเหลือ!

Ruby, 23 ไบต์

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

ไม่ใช่ของแท้โดยเฉพาะ

Perl 6 ,  40  16 ไบต์

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

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

ขยาย:

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

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

ลองออนไลน์!

คำอธิบาย:

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

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

เช่นเดียวกับเดนนิสขอขอบคุณสำหรับความคิดของ2a - xคุณ

บันทึกหนึ่งไบต์ต้องขอขอบคุณ Christian Severs

Pyke, 5 4 ไบต์

h}m-

ลองที่นี่!

PHP, 48 ไบต์

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

การใช้เทคนิคจากเดนนิส ใช้เช่น:

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

รุ่นที่ไม่ใช่เดนนิส 55 ไบต์:

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

APL, 8 ไบต์

+\⊃,2-/+

คำอธิบาย:

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

กรณีทดสอบ:

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

เขาวงกต 34 ไบต์

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

ลองออนไลน์!

ใช้วิธีการของ@Dennis(2a - a, 2a - b, 2a - c, 2a - d)

กระเบื้องสีเหลืองใช้สำหรับการควบคุมการไหล ในภาษาการเขียนโปรแกรม 2D นี้โปรแกรมเริ่มต้นที่ไทล์ซ้ายบนสุดที่เคลื่อนไปทางตะวันออกเพื่อเริ่ม ที่ทางแยกทิศทางจะถูกกำหนดโดยเครื่องหมายของด้านบนของสแต็กหลัก กระเบื้องว่างเปล่าเป็นผนัง

สีเขียว

ส่วนนี้จะช่วยประหยัด 2a ให้กับสแต็คเสริม

• ? รับหมายเลขแรกและกดไปที่ด้านบนสุดของสแต็กหลัก
• : ทำซ้ำส่วนบนสุดของสแต็ก
• _2 กดสองที่ด้านบนสุดของสแต็ก
• *ป๊อปป๊yอปxดันx*y
• } ย้ายด้านบนของสแต็กหลักไปที่ด้านบนของสแต็คเสริม
• _ ดันศูนย์ให้อยู่ด้านบนสุดของสแต็ก

ส้ม

ส่วนนี้จะลบ 2a ออกจากหมายเลขปัจจุบันปฏิเสธผลลัพธ์ส่งออกผลลัพธ์รับอักขระถัดไป (delimeter) ออกถ้า EOF แสดงบรรทัดใหม่รับตัวเลขถัดไป

• "noop หากมาจากทางทิศเหนือด้านบนของสแต็กจะเป็นศูนย์และโปรแกรมจะดำเนินการต่อไปทางทิศใต้ หากมาจากตะวันตกด้านบนของสแต็กจะเป็นหนึ่งและโปรแกรมจะเลี้ยวขวา (ไปทางทิศใต้ต่อเนื่อง)
• ;ทิ้งส่วนบนสุดของสแต็ก เนื่องจากศูนย์หรือหนึ่งใช้สำหรับโฟลว์การควบคุมเท่านั้นเราต้องทิ้งสิ่งเหล่านี้
• { ย้ายด้านบนของสแต็ค auxilary (2a) ไปที่ด้านบนของสแต็กหลัก
• : ทำซ้ำด้านบนของสแต็กหลัก
• } ย้ายด้านบนของสแต็กหลักไปที่ด้านบนของสแต็คเสริม
• -ป๊อปป๊yอปxดันx-y
• \`` Negate the top of the stack. This and the previous three operations have the effect of- (x-2a) = 2a-x`
• ! วางที่ด้านบนของสแต็กและเอาท์พุทเป็นตัวเลข
• , กดอักขระถัดไป (ซึ่งจะเป็นตัวคั่น) หรือลบหาก EOF
• )เพิ่มส่วนบนสุดของสแต็ก หากอักขระตัวสุดท้ายคือ EOF ดังนั้นด้านบนสุดของสแต็กจะเป็นศูนย์และโปรแกรมจะดำเนินการตรงไปยัง@และออก หากอักขระตัวสุดท้ายเป็น delimeter ดังนั้นส่วนบนสุดของสแต็กจะเป็นค่าบวกทำให้โปรแกรมเลี้ยวขวาและไปทางตะวันออกต่อไป\
• \ ขึ้นบรรทัดใหม่
• ? รับหมายเลขถัดไป
• _1 กดหนึ่งที่ด้านบนสุดของสแต็กเพื่อเลี้ยวขวาที่ทางแยก

เขาวงกต 24 ไบต์

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

รูปแบบอินพุตและเอาต์พุตเป็นรายการที่แยก linefeed (แม้ว่ารูปแบบอินพุตจะมีความยืดหยุ่นมากกว่าเดิม) โปรแกรมสิ้นสุดลงพร้อมข้อผิดพลาด

ลองออนไลน์!

ฉันมีวิธีแก้ปัญหาอื่นอีกสองตัวที่จำนวนไบต์นี้ซึ่งทำงานเหมือนเดิม แต่ใช้โฟลว์การควบคุมที่แตกต่างกันบ้าง

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

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

คำอธิบาย

ตัวชี้คำแนะนำ (IP) เริ่มเคลื่อนไปทางตะวันออกตามบรรทัดแรก แต่คำสั่งทั้งหมดก่อนที่?จะไม่มีสถานะ op-on ทั่วโลกเนื่องจากเราไม่ได้ใช้คำสั่งสแต็คเชิงลึกที่ใดก็ได้ ดังนั้นรหัสจะเริ่มที่?ทางตะวันตกเนื่องจาก IP หันกลับมาเมื่อถึงจุดจบ

รหัสจึงเริ่มต้นด้วยรหัสบิตเชิงเส้นต่อไปนี้:

?:}:+}

นี้ก็ทำให้เราขึ้นมาพร้อมกับสำเนาของ2aการใช้[2a - a, 2a - b, 2a - c, ...]สูตร

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

ตอนนี้เราเข้าสู่ลูปหลักของโปรแกรมโดยใช้เคล็ดลับมาตรฐานที่เป็นธรรมเพื่อวนลูปผ่านโค้ดบรรทัดเดียว:

<...>

โปรดทราบว่าสแต็กจะว่างเปล่าเมื่อใดก็ตามที่เรากดปุ่ม<เพื่อให้เรารู้ว่าเราจะได้ศูนย์ที่นั่น <แล้วหมุนทั้งเส้นซ้าย, สละทรัพย์สินทางปัญญากับมันเพื่อให้เราได้รับนี้

...><

จากนั้น IP ต้องเลื่อนไปทางซ้ายโดยที่>บรรทัดเลื่อนกลับไปที่ตำแหน่งเดิม (เพื่อเตรียมสำหรับการทำซ้ำครั้งถัดไป) จากนั้นบรรทัดจะถูกดำเนินการจากขวาไปซ้ายดังนั้นการวนซ้ำลูปเดียวคือ:

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

สิ่งที่จับได้เมื่อทำงานกับลูปประเภทนี้คือคุณไม่สามารถทำงานกับการดำเนินการตามเงื่อนไขในรูปแบบใด ๆ ได้เนื่องจากเขาวงกตไม่มีวิธีที่จะข้ามโค้ด ดังนั้นเราจะยุติโปรแกรมด้วยการหารด้วยศูนย์เมื่อเรากด EOF นี่คือการแยกย่อยของการวนซ้ำแต่ละครั้ง

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

แลมบ์ดาที่ไม่มีชื่อที่ปรับเปลี่ยนอินพุต:

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

การใช้เทคนิคจากเดนนิส การทำงานสำหรับภาชนะใด ๆ เช่นหรือint[]vector<int>

การใช้งาน:

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

รูปแบบอินพุต: [1 2 3 4]. ใช้สูตรง่าย ๆ

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

คำอธิบาย:

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

ขออภัยที่ไม่มีลิงก์ทดสอบ ฉันเดาว่า SE ไม่ชอบลิงก์ที่มีวงเล็บอยู่ข้างใน

เร่งความเร็ว 9 ไบต์

{&}2*K~-_

$ pushy invdeltas.pshy 1,3,4,2,8ให้การขัดแย้งเป็นจุลภาคเป็นตัวคั่นในบรรทัดคำสั่ง: นี่คือรายละเอียดพร้อมสแต็กตัวอย่าง:

           % 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

หมายเหตุ: สามารถเป็น 8 ไบต์ได้หากอนุญาตเอาท์พุทย้อนหลัง: @&2*K~-_

Perl, 26 + 3 ( -plaตั้งค่าสถานะ) = 29 bytes

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

หรือ

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

โดยใช้:

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

Dyalog APL ขนาด 5 ไบต์

-+2×⊃

นี่คือรถไฟ 5 ขบวนแยกวิเคราะห์เหมือนสองชั้นซ้อนกัน 3 ขบวน ("ส้อม"): -+(2×⊃)

อ่านดังนี้: การปฏิเสธ ( -) ของทั้งอาร์เรย์บวก ( +) สองครั้ง ( 2×) องค์ประกอบแรก ( ⊃)

ised, 11 ไบต์

2*$1_0-$1

ภาวนา: ised --l 'file with input.txt' '2*$1_0-$1

(แก้ไข: แก้ไขโดยขโมยพีชคณิตจาก Dennis)

น่าแปลกใจ 17 ไบต์

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

ไม่แน่ใจว่าทำไมฉันไม่ได้โพสต์ก่อนหน้านี้ การใช้งาน:

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

อ่านเพิ่มเติมได้:

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