Bir Dizinin Ters Deltası

Göreviniz, bir dizi işaretli 32 bit tam sayı verildiğinde, ters deltalarıyla yeniden derlemektir. Örneğin, liste

1  3  4  2  8

deltaları tutar:

  2  1 -2  6

bunlar daha sonra reddedilir ve sonuç verir:

 -2 -1  2 -6

ve yeniden derlendi,

1 -1 -2  0 -6

nihai sonuç olarak.

Giriş çıkış

Size bir liste / dizi / tablo / tuple / yığın / vb verilecektir. herhangi bir standart giriş yöntemi ile girdi olarak işaretli tamsayıların.

Değiştirilmiş verileri, yukarıdaki delta inversiyon yöntemini izleyerek kabul edilebilir herhangi bir biçimde bir kez daha çıkarmalısınız.

0 < N < 10Her sayının aralık dahilinde olduğu yerde N girişi alırsınız-1000 < X < 1000

Test Durumları

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

notlar

• Delta tabanlı yöntemle sınırlı değilsiniz: ( daha zor olmamalı) daha kolay yöntemi çalıştırabiliyorsanız , bunu kullanmakta özgürsünüz.
• Yukarıda belirtildiği gibi, her zaman en az 1 giriş ve en fazla 9 giriş alırsınız.
• Çıktının ilk sayısı her zaman girişin ilk sayısı olmalıdır , eğer durum böyle değilse, yönteminiz yanlıştır.
• Yalnızca Standart Giriş Çıkışı kabul edilir
• Standart boşluklar geçerlidir
• Bu kod golf , bu yüzden en düşük bayt sayısı kazanır!
• İyi eğlenceler!

Bir kazananımız var.

Dennis 'in Jelly Cevap Tiny 3 Bytes nedeniyle bunun mağlup edemez izlenimi altında değilim olması nedeniyle, altın ev almıştır.

Ben orijinal spec dayalı bir cevap görmek alamadım, biraz hayal kırıklığına uğradım, ancak, daha sonra tam olarak bir lütuf koymak olabilir.

Jöle , 7 3 bayt

ḤḢ_

Çevrimiçi deneyin!

Arka fon

Deltaları (a, b, c, d) vardır b - a , c - b ve d - c . Çıkarma ile kümülatif olarak azaltılması (a, b - a, c - b, d - c) a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c ve 2a - c verir - (d - c) = 2a - d , dolayısıyla doğru sonuç (2a - a, 2a - b, 2a - c, 2a - d) .

Nasıl çalışır

ḤḢ_  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 bayt

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

Ideone üzerinde test edin .

Nasıl çalışır

Deltaları (a, b, c, d) vardır b - a , c - b ve d - c . Çıkarma ile kümülatif olarak azaltılması (a, b - a, c - b, d - c) a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c ve 2a - c verir - (d - c) = 2a - d , dolayısıyla doğru sonuç (2a - a, 2a - b, 2a - c, 2a - d) .

Mathematica, 8 bayt

2#-{##}&

Belirsiz sayıda argüman alan isimsiz işlev. Bu, "kolay" bir yol kullanır: tüm listeyi reddeder ve (orijinal) ilk öğenin iki katını ekler.

Örneğin 2#-{##}&[1,3,4,2,8]; gibi bir liste döndürür {1,-1,-2,0,-6}.

JavaScript (ES6), 21

Teşekkürler @Dennis

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

05AB1E , 4 bayt

¬·s-

Çevrimiçi deneyin!veya Test takımı olarak

açıklama

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

Python, 44 bayt

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

Bu "Daha kolay yöntem" kullanır.

Pyth, 5 bayt

-LyhQ

Çevrimiçi Tercüman!

R, 23 18 17 bayt

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

otomatik vektörleştirme ve kurtarmaya varsayılan baskı!

Ruby, 23 bayt

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

Özellikle orijinal değil.

Perl 6 ,  40  16 bayt

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

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

Expanded:

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

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

Çevrimiçi deneyin!

Açıklama:

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 bayt

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

Dennis ile aynı çözüm, fikriniz için teşekkür ederim 2a - x.

Christian Severs sayesinde bir bayt kurtardı.

Pyke, 5 4 bayt

h}m-

Burada deneyin!

PHP, 48 bayt

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

Dennis'in tekniğini kullanarak. Gibi kullanın:

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

Dennis 55 olmayan bayt sürümü:

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

APL, 8 bayt

+\⊃,2-/+

Açıklama:

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

Test senaryoları:

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

Labirent , 34 bayt

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

Çevrimiçi deneyin!

Kullanımları @Dennis 'ın (2a - a, 2a - b, 2a - c, 2a - d)yaklaşımı.

Sarı fayanslar kontrol akışı içindir. Bu 2D programlama dilinde, program başlangıç ​​için doğuya doğru hareket eden en soldaki en üstteki döşemeden başlar. Kavşaklarda, yön ana yığının üst kısmının işareti ile belirlenir. Boş fayans duvarlardır.

Yeşil

Bu bölüm yardımcı yığını 2a'ya kaydeder.

• ? İlk numarayı alın ve ana yığının üstüne itin
• : Yığının üstünü çoğalt
• _2 İkisini yığının üstüne it
• *Pop y, pop x, itx*y
• } Ana yığının üst kısmını yardımcı yığının üstüne getirin.
• _ Yığının üstüne sıfır it

Portakal

Bu bölüm 2a'yı geçerli sayıdan çıkarır, sonucu reddeder, sonucu çıkarır, bir sonraki karakteri (sınırlayıcı) alır, EOF bir yeni satır çıkarırsa, bir sonraki sayıyı alırsa çıkar.

• "Noop. Kuzeyden geliyorsa, yığının üstü sıfır olacak ve program güneye devam edecektir. Batıdan geliyorsa, yığının üstü bir olacak ve program sağa dönecek (güneye devam edecek)
• ;Yığının üstünü atın. Sıfır veya bir yalnızca kontrol akışı için kullanıldığından, bunları atmamız gerekir
• { Yardımcı yığının (2a) üstünü ana yığının üstüne getirin
• : Ana yığının üstünü çoğaltın
• } Ana yığının üst kısmını yardımcı yığının üstüne taşıyın
• -Pop y, pop x, itx-y
• \`` Negate the top of the stack. This and the previous three operations have the effect of- (x-2a) = 2a-x`
• ! Yığının üstünü aç ve sayı olarak çıkar
• , Sonraki karakteri (ayırıcı olacak) veya EOF ise negatif karaktere basın
• )Yığının üst kısmını artırın. Son karakter EOF ise, yığının üstü şimdi sıfır olur ve program doğrudan @ve çıkışına devam eder . Son karakter bir sınırlayıcıysa, yığının üst kısmı pozitif olacaktır ve programın sağa dönmesine ve doğuya doğru devam etmesine neden olacaktır.\
• \ Yeni satır çıktısı al
• ? Sonraki numarayı al
• _1 Kavşaktan sağa dönebilmek için destenin üstüne bir tane itin

Labirent , 24 bayt

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

Giriş ve çıkış formatları satır beslemesinden ayrı listelerdir (giriş formatı aslında çok daha esnek olmasına rağmen). Program bir hatayla sona erer.

Çevrimiçi deneyin!

Bu bayt sayımında temel olarak aynı şekilde çalışan ancak biraz farklı kontrol akışı kullanan iki çözüm daha var.

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

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

açıklama

Talimat işaretçisi (IP) ilk satır boyunca doğuya doğru ilerlemeye başlar, ancak önceki durumda tüm komutlar genel olarak hareketsizdir ?, çünkü hiçbir yerde yığın derinliği komutları kullanmıyoruz. Kod gerçekten? batıya doğru , çünkü IP çıkmaza girdiğinde geri döner.

Bu nedenle kod, aşağıdaki doğrusal kod bitiyle başlar:

?:}:+}

Bu bizi sadece 2a[2a - a, 2a - b, 2a - c, ...] formülü kullanmak için .

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

Şimdi, programın ana döngüsüne, tek bir kod satırında döngü için oldukça standart bir numara kullanarak giriyoruz:

<...>

Vuruş yaptığımızda yığının boş kalacağını unutmayın, <böylece oraya sıfır alacağımızı biliyoruz. <Sonra tüm çizgi biz bu olsun, böylece onunla IP alarak sol döner:

...><

IP daha sonra sola, > hattı orijinal yerine geri kaydırır (bir sonraki yinelemeye hazırlamak için). Daha sonra çizgi sağdan sola doğru yürütülür, bu nedenle tek bir döngü yinelemesi budur:

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

Bu tür bir döngü ile çalışırken yakalanan şey, Labirent'in kodu atlamanın bir yolu olmadığı için koşullu yürütme ile çalışamazsınız. Bu nedenle, EOF tuşuna bastığımızda programı sıfıra bölünerek sonlandıracağız. İşte her döngü yinelemesinin dökümü.

{:   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 bayt

Adsız lambda girdisini değiştirirken:

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

Dennis'in tekniğini kullanarak. int[]Veya gibi herhangi bir kap için çalışır vector<int>.

Kullanımı:

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

Girdi biçimi: [1 2 3 4]. Kolay formülü kullanır.

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

Açıklama:

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

Test bağlantısı için özür dileriz. Sanırım SE içeride köşeli parantezler olan bağlantıları sevmiyor.

Pushy , 9 bayt

{&}2*K~-_

Cmd satırda virgülle ayrılmış değerler olarak argümanlar verin: $ pushy invdeltas.pshy 1,3,4,2,8. Örnek yığınla ilgili döküm:

           % 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

Not: geriye doğru çıkışa izin verilirse bu 8 bayt olabilir: @&2*K~-_

Perl, 26 + 3 ( -plabayrak) = 29 bayt

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

veya

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

Kullanımı:

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

Dyalog APL , 5 bayt

-+2×⊃

Bu 5-tren, iki iç içe 3-tren ("çatal") gibi ayrışıyor: -+(2×⊃)

şöyle okur: -tüm dizinin negation ( ) artı ( +) iki kez ( 2×) ilk eleman ( ⊃)

11 bayt

2*$1_0-$1

çağırma: ised --l 'file with input.txt' '2*$1_0-$1

(değiştir: Dennis'den cebiri çalarak düzeltildi)

Harika , 17 bayt

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

Bunu neden daha önce göndermediğimden emin değilim. Kullanımı:

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

Daha okunabilir:

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