Verilen bir tamsayıların listesi verilen bir sırada / derinlikte bir İleri Fark üretir .

Tam sayıların listesi için:

(10, 18, -12, 4, 8, -3, -5, 67, 9, 14)

Çeşitli emir / derinliklerdeki İleri Farklılıklar:

0   10,   18,  -12,    4,    8,   -3,   -5,  67,  9,  14
1      8,  -30,   16,    4,  -11,   -2,   72, -58,  5
2       -38,   46,  -12,  -15,    9,   74, -130, 63
3           84,  -58,   -3,   24,   65, -204, 193
4            -142,   55,   27,   41, -269, 397
5               197,  -28,   14, -310, 666
6                 -225,   42, -324, 976
7                    267, -366, 1300
8                      -633, 1666
9                         2299

Yani girişi ile

4, (10, 18, -12, 4, 8, -3, -5, 67, 9, 14)

Listeyi geri göndereceksin

(-142,   55,   27,   41, -269, 397)

Giriş

Giriş, STDIN veya fonksiyon parametreleri ile yapılabilir.

Döndürülecek derinliği belirten bir tam sayı. Bu eksi 1 listenin uzunluğu 0 olacaktır

İçin ileriye doğru farkı hesaplamak için bir tam sayı listesi

Çıktı

Çıkış, STDOUT yoluyla olabilir veya işlev tarafından döndürülebilir.

Bir tam sayı listesi olarak belirtilen derinlik için ileri farklar

kurallar

Bunu doğrudan yapan yerleşik ve 3. Parti işlevlerine izin verilmez.

Standart boşluk deliği kısıtlamaları uygulanır.

En kısa kod kazanır

J, 15 9 7 bayt

Çok kolay. Derinliği alır ve sol ve sağ argümanlar olarak listeler.

-~/\~&2

Tüm zarf hileci olmadan açık bir tanım olarak, bu azalır

4 : '(2 -~/\ ])^:x y'

• -~/\~&2 y- İleri fark y.
• x -~/\~&2 y- xİleri farkı y.

Bir yapmak olsaydı ciddi (.. İ e-olmayan golfed) Bu fonksiyonun tanımı, muhtemelen böyle bir şey yapacağını:

(}. - }:) : ($:@[&0)

Monadik durumda ileriye doğru fark hesaplanırken, dyadik durumda- xöne doğru fark hesaplanır .

Daha da basit, ancak tam olarak eşit değil:

+/\inv

+/\Argümanın öneklerinin toplamlarının bir vektörünü verir. inv(olarak tanımlanır ^:_1) bir fiili ters çeviren bir bağlantıdır. Bu, J'nin bir fiili nasıl tersine çevireceğini bildiği yerde çalışır ve +/\J için nasıl yapıldığını bilir.

Python, 61 59 bayt

f=lambda n,L:n and f(n-1,[x-y for x,y in zip(L[1:],L)])or L

Burada, listenin sonuncusunu, listenin sonunu hariç tümünü listenin sonuncusundan başka bir yere çevirerek çıkarmayı gerçekleştiririz. İki listenin asgari uzunluğunu alması nedeniyle zip(L[1:],L), buna eşittir :zip(L[1:],L[:-1])zip

>>> zip([1,2,3],[4,5])
[(1, 4), (2, 5)]

Bu kadar uzun bir alternatif (sadece Python 2):

f=lambda n,L:n and f(n-1,map(int.__sub__,L[1:],L[:-1]))or L

Ne yazık ki Python 2 listenin sonunu kesmiyor, bu yüzden yapamam map(int.__sub__,L,L[1:]). Can sıkıcı bir şekilde, Python 3 bunu yapar , ancak mapartık bir liste döndürmez, böylece bu bir bayt daha fazla olur (60 bayt):

f=lambda n,L:n and f(n-1,list(map(int.__sub__,L[1:],L)))or L

Bununla birlikte, girişin aşağıdaki gibi bir derinlik olmasına izin verirsek f(3, 2, 5, 6, 7, 5, 10, 25)(örneğin derinlik 3 ve liste [2, 5, 6, 7, 5, 10, 25]), bu 56 bayttır :

f=lambda n,*T:n and f(n-1,*map(int.__sub__,T[1:],T))or T

İşte bunu üretim kodunda görenleri gerçekten rahatsız edecek başka bir alternatif (bu, orijinal listeyi imha ediyor):

f=lambda n,L:n and f(n-1,[L[1]-L.pop(0)for _ in L[1:]])or L

Mathematica 23 57 23 bayt

Martin Büttner'ın önerisi, çıkarmanın uygunluğundan yararlanarak.

 Rest@#-Most@#&~Nest~##&

Örneğin

Rest@# - Most@# &~Nest~## & @@ {{10, 18, -12, 4, 8, -3, -5, 67, 9, 14}, 4}

{-142, 55, 27, 41, -269, 397)

Rest@#-Most@# fark yaratan çıkarma işlemini gerçekleştirir.

Nest, belirtilen işlemi her zaman en son listede çalışan, belirtilen sayıda gerçekleştirir.

Haskell, 40 34 bayt

n#l=iterate(zipWith(-)=<<tail)l!!n

Kullanım örneği: 4 # [10,18,-12,4,8,-3,-5,67,9,14]hangi çıktılar [-142,55,27,41,-269,397].

Nasıl çalışır: komşu elemanlar arasındaki farkı tekrar tekrar hesaplayın ve ara sonuçları bir listede saklayın. nBu listeden th öğesini alın .

Düzenleme: @Zgarb kaydetmek için 6 bayt bulundu. Müthiş!

JavaScript (ES6), 52 49 bayt

Basit özyinelemeli işlev, mapdiziyi taramak ve sliceher özyinelemeli çağrıdaki ilk elemanı bırakmak için kullanılır.

3 bayt düzenle kaydedildi, teşekkürler @ DocMax, gerçekten akıllı öneri

F=(n,l)=>n?F(n-1,l.slice(1).map((a,k)=>a-l[k])):l

Firefox / FireBug konsolunda test edin

for(i=0;i<10;i++)console.log(F(i,[10, 18, -12, 4, 8, -3, -5, 67, 9, 14]))

[10, 18, -12, 4, 8, -3, -5, 67, 9, 14]
[8, -30, 16, 4, -11, -2, 72, -58, 5]
[-38 , 46, -12, -15, 9, 74, -130, 63]
[84, -58, -3, 24, 65, -204, 193]
[-142, 55, 27, 41, -269, 397 ]
[197, -28, 14, -310, 666]
[-225, 42, -324, 976]
[267,
-366, 1300] [-633, 1666]
[2299]

CJam, 15 bayt

l~{{_@-\}*;]}*p

Bir CJam tarzı dizi ve ardından derinlik olarak girdi alır:

[10 18 -12 4 8 -3 -5 67 9 14] 4

ve sonucu CJam tarzı bir dizi olarak yazdırır.

Burada test et.

açıklama

l~              "Read and eval input.";
  {         }*  "Repeat this block N times, which computes the forward differences.";
   {    }*      "Fold this block onto the list - this is quite an abuse of folding semantics.";
    _           "Duplicate the current element (for the use in the next difference).";
     @          "Pull up the other copy of the last element.";
      -         "Subtract.";
       \        "Swap the difference and the other copy of the current element.";
          ;     "Discard the last element.";
           ]    "Wrap everything in an array again.";

Java, 122 119 bayt

int[]a(int[]a,int b){if(b<1)return a;int e=a.length-1,c[]=new int[e],i=e;for(;i-->0;)c[i]=a[i+1]-a[i];return a(c,b-1);}

Örnek Kullanım: http://ideone.com/ALgYez

Geobits sayesinde 3 bayt: v)>

> <> 53 50 bayt

l:[2-&\~~]r1-:?!vr
&}-@:$/!?&:-1
:;!? &&  lo*84n~<       

Kullanımı: Yığını (python yorumlayıcısında -v) önce derinliği, ardından tamsayıları hazırlayın.

Örneğin:

forward.fish -v 3 2 5 6 7 5 10 25

İade

2 -3 10 3

Yardım için Sp3000'e teşekkürler.

Prelude , 95 92 79 78 bayt

?    (1-vv- # ) v  !
  ?     #   ^   #
?(1-)   1  (#)  1)(#)
  1   #(# ) 1  (#

Giriş formatı

N
M
n_1
n_2
...
n_M

nerede Nfarklılıkların derinliğidir ve Mgirişteki tamsayılar sayısıdır. Ekleme Mgerekliydi, çünkü Prelude'un bir 0girişi girdiden ayırması mümkün değil . Çıktı aynı zamanda bir yeni satırlı tamsayı listesidir. Standart Prelude, negatif sayıları girmeyi imkansız kılan tam sayıları byte değerleri olarak okuduğundan, bu zorluk için tasarladığımız biraz ayarlanmış Prelude özelliğini varsaymak zorunda kaldım . Temel olarak, bu ek bir bayrak içeren Python yorumlayıcısıdırNUMERIC_INPUT .

Referans için sadece 48 38 37 boşluk olmayan karakterler vardır - geri kalanının sadece kodu doğru şekilde hizalaması gerekiyordu.

açıklama

Prelude'da, her satır kendi yığınında çalışan ayrı bir "ses" tir. Program ayrı seslerin "paralel" olarak çalışması için alındığı sütunlar halinde yürütülür. Tüm komutlar tek karakterlerdir ve parantezler Brainfuck benzeri döngülerdir (kümenin üstü sıfır olmadığında girilir ve tekrarlanır). Kapatma parantezinin dikey konumunun önemsiz olduğuna dikkat edin - farklı bir sese koymak hala en son açılış paranteziyle eşleşiyor sayılır ve döngü koşulu için kontrol edilen yığın her zaman (görünen sesdir. Şimdi bu programa ...

Program temel olarak iki bölüme ayrılabilir. Alttaki iki çizgi sadece programdaki döngülerin çoğu için (ana döngü bitmeden N) 1ileri geri geçerek kullanılır . En üstteki iki satır ana döngü ve gerçek farklılığı içerir. Aşağıdaki açıklamada aktarılan kod vardır, bu yüzden tek tek sütunları ekleyebilirim:

? ?   # Read two integers. Read instructions are processed top to bottom, so the first voice 
      # reads N and the third voice reads M.
  (   # Start a loop on the third voice. This loop will execute M times, reading the input list
      # and pushing M 1s onto the fourth voice - i.e. a unary representation of M.
 ?11  # Read an integer onto the second voice, push 1s onto the third and fourth voice.
  -   # Subtract the 1 from the third voice, decrementing M down to 0.
  )   # End of loop, if the third voice is not 0 yet, to back two columns.
(     # Start a loop on the first voice. This is the main loop and will execute N times. Each
      # iteration will compute the forward differences once and thereby shorten the list by one
      # element and also reduce the stack of 1s on the bottom voice by one.
1  #  # Push a 1 onto the first voice and pop a 1 from the last. Together with the next column,
      # this decrements both N and (the unary) M.
-  (  # Subtract the 1 from the first voice (decrementing N), and start a loop on the fourth 
      # voice over whatever is left of M (the length of the resulting difference list). Note 
      # that this column is *not* part of the loop, so the - on the first voice will only be 
      # executed once. This loop builds the differences in reverse order on the first voice.
v#1#  # Pop a 1 from the fourth voice and push a 1 onto the third. This loops over M while
      # shifting its unary representation to the other stack. In addition, shift the top stack
      # element from the second to the first voice.
v     # Copy the next element from the second voice to the first, without popping.
-  )  # Subtract the two elements on the first voice and end the loop if the fourth voice is 
      # empty. Note that his column *is* part of the loop.
  (   # Start a loop on the third voice. This is another loop over M, shifting the stack of 1s 
      # back to the fourth voice, and reversing the differences by shifting them onto the 
      # second.
#^#1  # As stated above, shift an element from the first to the second voice, a 1 from the
      # third to the fourth.
  )   # End the loop. After this point, we're back to the original situation, except that the
      # second voice has been replaced by its differences. The bottom stack element the
      # previous list is also still on that stack, but the decreasing loop lengths on the third
      # and fourth voices ensures that this element is never touched again.
)     # End the main loop when N has been reduced to 0.
   (  # Start another loop over the remaining list length, shifting and reversing the result.
v#1#  # Shift a 1 back to the third voice and an element from the second to the first voice.
  )   # End the loop. Note that this parenthesis is not on the same voice as the corresponding
      # opening parenthesis, but its exact position is irrelevant. Moving it to this voice
      # saves a byte.
  (   # Start one last loop over the length of the result.
! #   # Pop a 1 from the third voice while printing (and popping) one element of the result.
  )   # End the loop.

Python, 70 68 67 59 bayt

f=lambda x,n:n and f([x[1]-x.pop(0)for i in x[1:]],n-1)or x

Özyinelemeye başlamadan önce golf oynamayan sürüm:

def f(x,n):
    for j in range(n):
        for i in range(len(x)-1):
            x[i]=x[i+1]-x[i]
    return x[:-n]

R, 48 39 46 44 bayt

Özyineleme!

function(x,y)if(x)Recall(x-1,diff(y)) else y

• xgerçekleştirilecek yineleme sayısı ve ytam sayıların bir vektörüdür.
• if(x)sürece geçerlidir x>0.
• Recall Geçerli işlevi çağırır, ancak yeni argümanlarla.
• Diff ardışık liste / vektör elemanları arasındaki farkları çıkarır.

Önceki sürümler:

#does not work for x=0:
function(x,y){for(i in 1:x)y=diff(y);y}

#does not use diff function:
function(x,y){for(i in 1:x)y=y[-1]-head(y,-1);y}

y[-1]       is a list minus its first element
head(y,-1)  is a list minus its last element

Python, 92 87 86 bayt

def a(b,c):
 if c<1:return b
 d=[];e=b[0]
 for f in b[1:]:d+=f-e,;e=f
 return a(d,c-1)

Bu benim ilk Python golfüm. Herhangi bir öneriniz takdir edilecektir :)

Sp3000: D sayesinde 5 6 bayt

c, 68 55 bayt

f(int *l){for(--l[-1]?f(l):0;*l;l++)*l=l[1]-*l;*--l=0;}

Bu girdi spesifikasyonuyla ilgili biraz özgürlük kazanıyor olabilir. Bir int dizisi, eleman 0'ın derinlik ve elemanlar 1 ila (n + 1) girdi listesi elemanları 0 ila n olacak şekilde oluşturulur. Ardından eleman 1'in adresi işleve iletilir.

Dizi sıfırlanmalı. Dizi yerinde düzenlenir.

Örneğin:

#include <stdio.h>

f(int *l){for(--l[-1]?f(l):0;*l;l++)*l=l[1]-*l;*--l=0;}

int main (int argc, char **argv)
{
  int list[] = {4, 10, 18, -12, 4, 8, -3, -5, 67, 9, 14, 0};
  int *elem;

  f(list + 1);

  for (elem = list + 1; *elem; elem++) {
    printf("%d, ", *elem);
  }
}

http://ideone.com/m5PDgF

Powershell 115 111 bayt

$p={param($a, $b)0..($a-1)|%{$b=@($l=$b.length;for($i=0;$i-lt$l;$i++){$b[$i+1]-$b[$i]})[0..($l-2)]};$b-join','}

Gibi yürütün:

.$p 4 @(10,18,-12,4,8,-3,-5,67,9,14)

Çıktı:

-142,55,27,41,-269,397

Kıvrımlı ayracı farklı bir noktaya taşımak, bunun cevabın her adımını göstermesini sağlar.

8,-30,16,4,-11,-2,72,-58,5
-38,46,-12,-15,9,74,-130,63
84,-58,-3,24,65,-204,193
-142,55,27,41,-269,397

STATA, 126 bayt

di _r(a)_r(b)
token $b
gl $c=wordcount($b)
forv x=1/$a{
gl $c--
forv y=1/$c{
loc `y'=``y'+1'-``y''
}
}
forv z=1/$c{
di ``z''
}

Girdiyi, derinliği temsil eden bir tamsayı olarak bekliyor, ardından her ikisi de standart komut istemi ile verilen boşlukla ayrılmış bir tamsayı listesi. Çıktı, newline ayrılmış bir tamsayı listesidir.

Öncelikle (1 uzun dize olarak görülen tamsayılar) listesini isimleri 1,2,3 olan bir yerel değişkenler listesine dönüştürür. y + 1. yerel değişkenin değeri eksi yth yerel değişkenin değerini (yani 18-10 = 8), sadece kullanımdan sonra mevcut değerlerin üzerine yazar. Bu $ a (global değişken a değeri) kez yapar. Ardından, her seferinde 1 olan her yerel değişkenin değerini görüntüler.

T-SQL, Çok Fazla :)

Bu sorunu ilk gördüğümde, bunu sorguda yapmanın bir yolu olup olmadığını merak ettim. Çoğu dil için önemsiz olsa da, SQL sorgusu için o kadar da değil.

Giriş, tamsayı listesi için @ (derinlik için) ve @ L değişkenlerine gider. @ L, kullanıcı tarafından tanımlanan bir masa türüdür

CREATE TYPE L AS TABLE(n INT IDENTITY(0,1),v INT)

Giriş kurulum

DECLARE @L L,@ INT=4
INSERT @L(v)values(10),(18),(-12),(4),(8),(-3),(-5),(67),(9),(14)

Bazı yorumlar ile sorgu

WITH R AS( 
    -- Recursive query to calculate the level of a pascal triangle with alternating negatives
    -- For 4 this is 1 -4  6 -4  1  
    SELECT 1c,0g UNION ALL SELECT-c*(@-g)/(g+1),g+1FROM r WHERE g<@
    ),
    O AS( 
    --Multiple N values of list by reversed pascal triangle values
    --shifting the start for each iteration (list length) - N
    SELECT c*v v,F 
    FROM @L L 
        CROSS APPLY(
            SELECT TOP((SELECT COUNT(*)FROM @L)-@)ROW_NUMBER()OVER(ORDER BY(SELECT\))-1F FROM sys.all_views a,sys.all_views b)c 
        JOIN R ON N=F+@-G
    )
-- Sum the multiplied values
SELECT SUM(V)FROM o GROUP BY F ORDER BY F

Sonuç

-142
55
27
41
-269
397

Japt -h , 17 5 bayt

@Shaggy sayesinde 12 bayt kurtarıldı

VÆ=än

Çevrimiçi deneyin!

SmileBASIC, 76 bayt

Sonunda kullanmak için bir neden ARYOP!

DEF F L,D
IF!D THEN@R
DIM B[0]COPY B,L
T=SHIFT(L)ARYOP 1,L,L,B
F L,D-1@R
END

Clojure, 47 bayt

#(if(= 0 %)%2(recur(dec %)(map -(rest %2)%2))))

Anonim işlevde basit bir özyineleme. Argümanların sırası, şimdi %2olduğundan daha sık gerçekleştiği şekilde değiştirilirse, 1 bayt kazanırsınız %.

Jöle , 2 bayt

I¡

Çevrimiçi deneyin!

açıklama

I¡  Main Link
 ¡  Repeat `n` times; this repeats the previous link by <right argument> times
I   Get forward differences

Çok açık cevap: P

Japt , 7 bayt

Luis'e çözümü için sunduğum birkaç alternatif .

_än}gNÅ

Dene

10 bayt

ÏÄ<V}f@=än

Dene