Bổ sung Kim tự tháp lộn ngược là quá trình lấy danh sách các số và liên tiếp cộng chúng lại với nhau cho đến khi bạn đạt được một số.

Khi được cho các số 2, 1, 1, quá trình sau đây xảy ra:

 2   1   1
   3   2 
     5

Điều này kết thúc bằng số 5.

NHIỆM VỤ CỦA BẠN

Đưa ra phía bên phải của Kim tự tháp lộn ngược (Tăng dần), viết chương trình hoặc hàm sẽ trả về danh sách ban đầu.

Thử thách mới : Thử làm điều này trong ít hơn O (n ^ 2)

THÍ DỤ

f([5, 2, 1]) => [2, 1, 1]
f([84,42,21,10,2]) => [4,7,3,8,2]

LƯU Ý: Kim tự tháp lộn ngược sẽ không bao giờ trống và sẽ luôn bao gồm các số nguyên dương CHỈ.

— Tiếng rên rỉ
nguồn

6

Chào mừng đến với PP & CG! Thách thức này là khá, mặc dù nó có thể được cải thiện. Trước tiên, tôi khuyên bạn nên đăng các thử thách của mình trong Sandbox để cải thiện bài đăng trước khi nó được đưa lên chính.

— Tàu

13

Thông tin chi tiết miễn phí mà tôi không thể tìm thấy ngôn ngữ ngắn hơn trong:

f ([một, b, c, d, e]) = = [\begin{matrix} 1 & - 4 & 6 & - 4 & 1 \\ 0 & 1 & - 3 & 3 & - 1 \\ 0 & 0 & 1 & - 2 & 1 \\ 0 & 0 & 0 & 1 & - 1 \\ 0 & 0 & 0 & 0 & 1 \end{matrix}] \cdot [\begin{matrix} một \\ b \\ c \\ d \\ e \end{matrix}]

$f([a,b,c,d,e]) = \begin{bmatrix} 1&-4&6&-4&1 \\ 0&1&-3&3&-1 \\ 0&0&1&-2&1 \\ 0&0&0&1&-1 \\ 0&0&0&0&1 \end{bmatrix} \cdot \begin{bmatrix}a\\b\\c\\d\\e\end{bmatrix}$

— Lynn

4

Chỉ cần FYI, điều này giống như CodeWars kata .

— ggorlen

6

@ggorlen tôi biết. Tôi là người đã tạo ra kata :)

— Whimpers

8

Try doing this in less than O(n)chắc chắn không thể phân bổ một mảng có kích thước n hoặc thay đổi các mục O (n) trong đó nhanh hơn độ phức tạp O (n)?

— đại từ của tôi là monicareinstate

17

JavaScript (ES6), 62 58 49 46 byte

Đã lưu 3 byte nhờ @Oliver

Trả về danh sách dưới dạng một chuỗi được phân tách bằng dấu phẩy.

f=a=>+a||f(a.map(n=>a-(a=n),a=a.shift()))+[,a]

Hãy thử trực tuyến!

Đã bình luận

f = a =>              // f = recursive function taking the input list a[]
  +a                  // if a[] consists of a single positive integer:
                      //   stop recursion and return this integer
  ||                  // else:
    f(                //   do a recursive call to f:
      a.map(n =>      //     for each value n in a[]:
        a - (a = n),  //       yield the difference between the previous value and n
                      //       and update a to n
        a = a.shift() //       start by removing the first element and saving it in a
                      //       (because of the recursion, it's important here to reuse
                      //       a variable which is defined in the scope of f)
      )               //     end of map()
    )                 //   end of recursive call
    + [, a]           //   append the last entry from a[]

— Arnauld
nguồn

@Oliver, vâng

— Shaggy

8

Haskell , 22 byte

foldl(flip$scanr(-))[]

Hãy thử trực tuyến!

— xnor
nguồn

7

Haskell, 42 byte

f[]=[]
f a=f(zipWith(-)a$tail a)++[last a]

Hãy thử trực tuyến!

— nimi
nguồn

6

TI-BASIC, 54 byte

Ans→L₁:dim(L₁→dim(L₂:While 1-Ans:L₁(Ans→L₂(Ans:-ΔList(L₁→L₁:dim(Ans:End:L₁(Ans→L₂(Ans:L₂

Đầu vào là danh sách phía bên phải của tam giác trong Ans, như được mô tả trong thử thách.
Đầu ra là hàng trên cùng của tam giác nói.

Ví dụ:

{5,2,1
         {5 2 1}
prgmCDGF19
         {2 1 1}
{84,42,21,10,2
 {84 42 21 10 2}
prgmCDGF19
     {4 7 3 8 2}

Giải thích: Giải
pháp này lạm dụng thực tế là tam giác được hình thành bằng cách sử dụng cạnh phải của tam giác khi bắt đầu kết thúc là sự thay đổi trong mỗi yếu tố.

Nói cách khác,

2 1 1
 3 2
  5

trở thành:

5 2 1
 3 1
  2

Do đó, danh sách kết quả là phía bên phải của tam giác mới này, có thể được hình thành bằng cách đặt phần tử cuối cùng thành chỉ mục về độ dài của danh sách mẹ trong danh sách kết quả.

Ans→L₁          ;store the input list in L₁
dim(L₁→dim(L₂   ;set the length of L₂ to the length of L₁
While 1-Ans     ;while the L₁'s length is not 1
L₁(Ans→L₂(Ans   ;set the last element of L₁ to the corresponding index in L₂
-ΔList(L₁→L₁    ;get the change in each element, then negate
                ; (elements are in descending order so the change in each
                ;  element will be negative)
                ; and store the resulting list in L₁
dim(Ans         ;leave the length of L₁ in "Ans"
End
L₁(Ans→L₂(Ans   ;set the element again
                ; (needed for final step)
L₂              ;leave L₂ in "Ans"
                ;implicit print of "Ans"

Lưu ý: TI-BASIC là ngôn ngữ được mã hóa. Số lượng ký tự không bằng số byte.

— Tàu
nguồn

4

Thạch , 6 byte

ṚIƬZḢṚ

Liên kết đơn nguyên chấp nhận danh sách các số nguyên mang lại danh sách các số nguyên.

Hãy thử trực tuyến!

Làm sao?

Xây dựng toàn bộ tam giác sau đó trích xuất các yếu tố cần thiết.

ṚIƬZḢṚ - Link: list of integers          e.g.  [84,42,21,10,2]
Ṛ      - reverse                               [2,10,21,42,84]
  Ƭ    - collect & apply until a fixed point:
 I     -   incremental differences            [[2,10,21,42,84],[8,11,21,42],[3,10,21],[7,11],[4],[]]
   Z   - transpose                            [[2,8,3,7,4],[10,11,10,11],[21,21,21],[42,42],[84]]
    Ḣ  - head                                  [2,8,3,7,4]
     Ṛ - reverse                               [4,7,3,8,2]

— Jonathan Allan
nguồn

Có một giải pháp gần như giống hệt nhau nhưng với Us thay vì Ṛ!

— Nick Kennedy

IƬUZḢAcũng sẽ làm việc với câu hỏi nhất định; Tôi tự hỏi nếu có một byte lưu ở đâu đó ...

— Jonathan Allan

ạƝƬZṪ€làm việc quá nhưng lại là một sáu.

— Nick Kennedy

Đúng, tôi nhận thấy biến thể đó; Bây giờ tôi ít hy vọng hơn.

— Jonathan Allan

Tôi vừa đăng một bài viết 5 trang, nhưng nó hơi khác so với cách tiếp cận của bạn về phần sau khi xây dựng kim tự tháp.

— Erik the Outgolfer

4

MathGolf , 14 11 byte

xÆ‼├│?;∟;]x

Hãy thử trực tuyến!

Giải trình

x             reverse int/array/string
 Æ     ∟      do while true without popping using 5 operators
  ‼           apply next 2 operators to TOS
   ├          pop from left of list
    │         get differences of list
     ?        rot3
      ;       discard TOS (removes rest from ├ command)
              loop ends here
        ;     discard TOS (removes empty array from stack)
         ]    wrap stack in array
          x   reverse array

— châm ngôn
nguồn

3

Python 2 , 56 byte

f=lambda a:a and f([l-r for l,r in zip(a,a[1:])])+a[-1:]

Hàm đệ quy chấp nhận danh sách các số nguyên dương trả về danh sách các số nguyên không âm.

Hãy thử trực tuyến!

— Jonathan Allan
nguồn

3

Thạch , 5 byte

_ƝƬa/

Hãy thử trực tuyến!

Chúng ta có thể giả sử toàn bộ kim tự tháp là dương, vì vậy chúng ta có thể sử dụng thao tác && thay vì thao tác "đúng".

— Erik the Outgolfer
nguồn

3

Pari/GP, 36 bytes

Based on @Lynn's comment:

Free insight that I can't find a language it's shorter in:
$f ([một, b, c, d, e]) = = [\begin{matrix} 1 & - 4 & 6 & - 4 & 1 \\ 0 & 1 & - 3 & 3 & - 1 \\ 0 & 0 & 1 & - 2 & 1 \\ 0 & 0 & 0 & 1 & - 1 \\ 0 & 0 & 0 & 0 & 1 \end{matrix}] \cdot [\begin{matrix} một \\ b \\ c \\ d \\ e \end{matrix}]$ $f([a,b,c,d,e]) = \begin{bmatrix} 1&-4&6&-4&1 \\ 0&1&-3&3&-1 \\ 0&0&1&-2&1 \\ 0&0&0&1&-1 \\ 0&0&0&0&1 \end{bmatrix} \cdot \begin{bmatrix}a\\b\\c\\d\\e\end{bmatrix}$

Pari / GP được tích hợp sẵn cho ma trận Pascal và nghịch đảo của nó chính xác là ma trận chúng ta cần:

{[\begin{matrix} 1 & 0 & 0 & 0 & 0 \\ 1 & 1 & 0 & 0 & 0 \\ 1 & 2 & 1 & 0 & 0 \\ 1 & 3 & 3 & 1 & 0 \\ 1 & 4 & 6 & 4 & 1 \end{matrix}]}^{- 1} = = [\begin{matrix} 1 & 0 & 0 & 0 & 0 \\ - 1 & 1 & 0 & 0 & 0 \\ 1 & - 2 & 1 & 0 & 0 \\ - 1 & 3 & - 3 & 1 & 0 \\ 1 & - 4 & 6 & - 4 & 1 \end{matrix}]

$\begin{bmatrix} 1&0&0&0&0 \\ 1&1&0&0&0 \\ 1&2&1&0&0 \\ 1&3&3&1&0 \\ 1&4&6&4&1 \end{bmatrix}^{-1} = \begin{bmatrix} 1&0&0&0&0 \\ -1&1&0&0&0 \\ 1&-2&1&0&0 \\ -1&3&-3&1&0 \\ 1&-4&6&-4&1 \end{bmatrix}$

a->r=Vecrev;r(r(a)/matpascal(#a-1)~)

Hãy thử trực tuyến!

— alephalpha
nguồn

3

R , 69 67 byte

function(n,x=sum(n|1):1-1,`[`=outer)(x[x,choose]*(-1)^x[x,"+"])%*%n

Hãy thử trực tuyến!

Trả về một vectơ cột.

-2 byte nhờ Kirill L.

Cũng dựa trên nhận xét của Lynn :

Thông tin chi tiết miễn phí mà tôi không thể tìm thấy một ngôn ngữ ngắn hơn:
$f ([a, b, c, d, e]) = [\begin{matrix} 1 & - 4 & 6 & - 4 & 1 \\ 0 & 1 & - 3 & 3 & - 1 \\ 0 & 0 & 1 & - 2 & 1 \\ 0 & 0 & 0 & 1 & - 1 \\ 0 & 0 & 0 & 0 & 1 \end{matrix}] \cdot [\begin{matrix} a \\ b \\ c \\ d \\ e \end{matrix}]$ $f([a,b,c,d,e]) = \begin{bmatrix} 1&-4&6&-4&1 \\ 0&1&-3&3&-1 \\ 0&0&1&-2&1 \\ 0&0&0&1&-1 \\ 0&0&0&0&1 \end{bmatrix} \cdot \begin{bmatrix}a\\b\\c\\d\\e\end{bmatrix}$

It's longer than the other R answer, but it was an interesting approach to take and try to golf.

— Giuseppe
nguồn

2

Javascript (ES6), 127 bytes

f=a=>{for(e=[a],a=[a[l=a.length-1]],i=0;i<l;i++){for(e.push(g=[]),j=-1;j<l;)g.push(e[i][j]-e[i][++j]);r.unshift(g[j])}return r}

Original code

function f(a){
  var e=[a];
  var r=[a[a.length-1]];
  for (var i=1;i<a.length;i++){
    var g=[];
    for (var j=0;j<a.length;j++){
      g.push(e[i-1][j-1]-e[i-1][j]);
    }
    e.push(g);
    r.unshift(g[j-1]);
  }
  return r;
}

Oh, I lost like... a lot... to the previous answer...

— Naruyoko
nguồn

2

Wolfram Language (Mathematica), 57 bytes

(r=Reverse)[#&@@@Most@NestList[Differences,r@#,Tr[1^#]]]&

Try it online!

— J42161217
nguồn

2

05AB1E, 12 11 bytes

R.¥.Γ¥}¨ζнR

Port of @JonathanAllan's Jelly answer, although I'm jelly about Jelly's more convenient builtins in this case. ;)
-1 byte thanks to @Emigna.

Try it online or verify all test cases.

Explanation:

R            # Reverse the (implicit) input-list
             #  i.e. [16,7,4,3] → [3,4,7,16]
 .¥          # Undelta it (with leading 0)
             #  → [0,3,7,14,30]
   .Γ }      # Continue until the result no longer changes, and collect all steps:
     ¥       #  Get the deltas / forward differences of the current list
             #  → [[3,4,7,16],[1,3,9],[2,6],[4],[]]
       ¨     # Remove the trailing empty list
             #  → [[3,4,7,16],[1,3,9],[2,6],[4]]
        ζ    # Zip/transpose; swapping rows/column (with space as default filler)
             #  → [[3,1,2,4],[4,3,6," "],[7,9," "," "],[16," "," "," "]]
         н   # Only leave the first inner list
             #  → [3,1,2,4]
          R  # Revert it back
             #  → [4,2,1,3]
             # (after which it's output implicitly as result)

— Kevin Cruijssen
nguồn

2

You can save a byte with R.¥.Γ¥}¨ by starting from the list whose delta is the input.

— Emigna

@Emigna Ah, undelta into a loop with deltas to save a byte on the prepend. :) Thanks!

— Kevin Cruijssen

2

R, 55 63 55 53 bytes

x=scan();for(i in sum(1|x):1){F[i]=x[i];x=-diff(x)};F

Try it online!

-2 bytes thanks to Giuseppe.

— Kirill L.
nguồn

2

Perl 6, 37 bytes

{[R,]($_,{@(.[]Z-.skip)}...1)[*;*-1]}

Try it online!

Repeatedly reduces by elementwise subtraction, and then returns the last number of each list in reverse.

Explanation:

{                                  }  # Anonymous code block
      $_,               ...   # Create a sequence starting from the input
         {             }      # Where each element is
            .[]Z-.skip          # Each element minus the next element
          @(          )         # Arrayified
                           1  # Until the list has one element left
 [R,]                                # Reverse the sequence
     (                     )[*;   ]  # For every list
                               *-1   # Take the last element

— Jo King
nguồn

1

Python 2, 78 bytes

lambda n,*a:R(lambda r,v:R(lambda x,w:x+[w-x[-1]],r,[v]),a,[n])[::-1]
R=reduce

Try it online!

— TFeld
nguồn

1

C# (Visual C# Interactive Compiler), 164 bytes

a=>{int x=a.Length;var l=new int[x][];for(int i=0;i<x;i++){l[i]=new int[x];l[i][0]=a[i];for(int j=0;j<i;j++)l[i][j+1]=l[i-1][j]-l[i][j];}return l.Last().Reverse();}

Try it online!

— Innat3
nguồn

1

Charcoal, 19 bytes

Ｆθ«ＰＩ§θ±¹↑ＵＭθ⁻§θ⊖λκ

Try it online! Link is to verbose version of code. Explanation:

Ｆθ«

Loop once for each term in the original list.

ＰＩ§θ±¹↑

Print the last term in the list, but move the cursor to the beginning of the previous line, so that the terms are output in reverse order.

ＵＭθ⁻§θ⊖λκ

Compute the deltas, inserting a dummy value at the beginning so that we can use an operation that doesn't change the length of the list.

— Neil
nguồn

1

APL+WIN, 34 or 28 bytes

v←⊂⌽⎕⋄1↓⌽↑¨⍎∊'v',(∊⍴¨v)⍴⊂',-2-/¨v'

Try it online! Courtesy of Dyalog Classic

Prompts for right side vector.

or implementing @Lynn's approach:

0⍕⌽(⌹⍉n∘.!n←0,⍳¯1+⍴n)+.×⌽n←⎕

Try it online!Courtesy of Dyalog Classic

Prompts for right side vector.

— Graham
nguồn

1

Attache, 29 bytes

{y.=Delta@-_If[_,$@y'_@-1,y]}

Try it online!

Simply iterates the Delta function until its empty. Much shorter than the very verbose PeriodicSteps solution...

— Conor O'Brien
nguồn

1

C, 76 bytes

i=0;int*f(int*a,int n){for(;i<n;a[i++]=a[i]-a[i+1]);if(!n)return a;f(a,n-1);}

input : (*a = pointer to array, n = last element's index of that array)
output : return int* = output

Explanation
going from right side to up, as the last elements are same in both input and output the loop inside function simply finds next higher numbers in the triangle gradually reaching to the top leaving the answer intact in the end.

ungolfed(from C++)

#include <iostream>
#define SIZE_F 5

int*recFind(int*a, int n) {
    int i = 0;
    while (i < n)
        a[i++] = a[i] - a[i+1];
    if (!n) return a;
        recFind(a, n - 1);
}
int main()
{
    int first[SIZE_F],*n;
    for (int i = 0; i < SIZE_F; i++)
        std::cin >> first[i];

    n = recFind(first, SIZE_F - 1);//size - 1
    for (int i = 0; i < SIZE_F; i++)
        std::cout << n[i];
}

— Mukul Kumar
nguồn

1

Japt, 11 9 bytes

Nc¡=äa
yÌ

Try it

2 bytes saved thanks to Oliver.

12 11 bytes

_äa}hUÊN yÌ

Try it

1 byte saved thanks to Oliver.

— Shaggy
nguồn

2

9 bytes and 10 bytes

— Oliver

@Oliver, not thinking to use y(f) is bad enough, but completely forgetting the newline is unforgivable! Will update shortly. Thanks :)

— Shaggy

1

Julia 0.6, 44 bytes

x->reverse([(j=x[end];x=-diff(x);j)for i=x])

Try it online!

Same iterative principle as my R answer.

Julia 0.6, 55 bytes

x->inv([binomial(i,j)for i=(l=length(x)-1:-1:0),j=l])*x

Try it online!

@Lynn's algorithm (inverse of Pascal matrix multiplied by input).

— Kirill L.
nguồn

Bổ sung Kim tự tháp Upside Down Down REVERSED!

NHIỆM VỤ CỦA BẠN

THÍ DỤ

JavaScript (ES6), 62 58 49 46 byte

Đã bình luận

Haskell , 22 byte

Haskell, 42 byte

TI-BASIC, 54 byte

Thạch , 6 byte

Làm sao?

MathGolf , 14 11 byte

Giải trình

Python 2 , 56 byte

Thạch , 5 byte

Pari/GP, 36 bytes

R , 69 67 byte

Javascript (ES6), 127 bytes

Wolfram Language (Mathematica), 57 bytes

05AB1E, 12 11 bytes

R, 55 63 55 53 bytes

Perl 6, 37 bytes

Explanation:

Python 2, 78 bytes

C# (Visual C# Interactive Compiler), 164 bytes

Charcoal, 19 bytes

APL+WIN, 34 or 28 bytes

Attache, 29 bytes

C, 76 bytes

Japt, 11 9 bytes

12 11 bytes

Julia 0.6, 44 bytes

Julia 0.6, 55 bytes