ওপারসাইড ডাউন পিরামিড সংযোজন… প্রত্যাবর্তিত!

Question

আপসাইড-ডাউন পিরামিড সংযোজন হ'ল সংখ্যার একটি তালিকা নেওয়ার প্রক্রিয়া এবং ক্রমাগত এগুলি একসাথে যুক্ত করার প্রক্রিয়া যা আপনি একটি সংখ্যায় না পৌঁছায়।

সংখ্যাগুলি দেওয়া হলে 2, 1, 1নিম্নলিখিত প্রক্রিয়াটি ঘটে:

 2   1   1
   3   2 
     5

এটি সংখ্যায় শেষ হয় 5।

---

তোমার কাজ

একটি উল্টোদিকে ডাউন পিরামিড (আরোহী) এর ডান দিক দেওয়া, একটি প্রোগ্রাম বা ফাংশন লিখুন যা আসল তালিকাটি ফিরে আসবে।

নতুন অতিরিক্ত চ্যালেঞ্জ : এটি ও এর চেয়ে কম ক্ষেত্রে করার চেষ্টা করুন (n ^ 2)

EXAMPLE টি

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

দ্রষ্টব্য: উল্টোদিকে ডাউন পিরামিড কখনই খালি থাকে না এবং সর্বদা কেবল ধনাত্মক পূর্ণসংখ্যা থাকে।

Comments

পিপি ও সিজি তে স্বাগতম! এই চ্যালেঞ্জটি শালীন, যদিও এটি উন্নত হতে পারে। আমি আপনার চ্যালেঞ্জগুলি পোস্টটি মুখ্য হওয়ার আগে পোস্টটি উন্নত করতে প্রথমে স্যান্ডবক্সে পোস্ট করার পরামর্শ দিচ্ছি ।

— তাউ

নিখরচায় অন্তর্দৃষ্টি যে আমি এর চেয়ে কম ভাষা খুঁজে পাচ্ছি না: $$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}$$

— লিন

শুধু এফওয়াইআই, এটি কোডওয়ার্স কাটার সমান ।

— ggorlen

@ggorlen আমি জানি আমিই

— কেটা

Try doing this in less than O(n)অবশ্যই কোনও এন-আকারের অ্যারে বরাদ্দ করা বা ও (এন) জটিলতার চেয়ে দ্রুত এতে ও (এন) আইটেমগুলি পরিবর্তন করা অসম্ভব?

— আমার সর্বনাম

Answer 1

জাভাস্ক্রিপ্ট (ES6),  62 58 49  46 বাইট

অলিভারকে ধন্যবাদ 3 বাইট সংরক্ষণ করা হয়েছে

কমা-বিচ্ছিন্ন স্ট্রিং হিসাবে তালিকাটি ফেরত দেয়।

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

এটি অনলাইন চেষ্টা করুন!

মন্তব্য

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[]

Comments

@ অলিভার, হ্যাঁ

— শেগি

Answer 2

হাস্কেল , 22 বাইট

foldl(flip$scanr(-))[]

এটি অনলাইন চেষ্টা করুন!

Answer 3

হাস্কেল, 42 বাইট

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

এটি অনলাইন চেষ্টা করুন!

Answer 4

টিআই-বেসিক, 54 বাইট

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

Ansচ্যালেঞ্জটিতে বর্ণিত হিসাবে ইনপুটটি ত্রিভুজের ডান পাশের তালিকা ।
আউটপুট হল ত্রিভুজটির শীর্ষ সারি।

উদাহরণ:

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

ব্যাখ্যা:
এই দ্রবণটি এই সত্যটিকে অপব্যবহার করে যে ত্রিভুজটির ডান দিকটি ব্যবহার করে ত্রিভুজটি তৈরি শুরু হওয়ার সাথে সাথে প্রতিটি উপাদানগুলির পরিবর্তন হয়ে যায়।

অন্য কথায়,

2 1 1
 3 2
  5

হয়ে:

5 2 1
 3 1
  2

সুতরাং, ফলাফলের তালিকাটি এই নতুন ত্রিভুজটির ডান দিক, যা ফলাফলের তালিকায় তার পিতামাতার তালিকার দৈর্ঘ্যের সূচকে শেষ উপাদানটি নির্ধারণ করে গঠিত হতে পারে।

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"

---

দ্রষ্টব্য: টিআই-বেসিক একটি টোকেনাইজড ভাষা। অক্ষর গণনা বাইট গণনা সমান হয় না ।

Answer 5

জেলি , 6 বাইট

ṚIƬZḢṚ

একটি পূর্ণসংখ্যার লিঙ্ক পূর্ণসংখ্যার একটি তালিকা গ্রহণ করে যা পূর্ণসংখ্যার একটি তালিকা দেয়।

এটি অনলাইন চেষ্টা করুন!

কিভাবে?

পুরো ত্রিভুজ তৈরি করে তারপরে প্রয়োজনীয় উপাদানগুলি বের করে।

Ṛ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]

Comments

প্রায় অভিন্ন সমাধান ছিল তবে Uএর পরিবর্তে এর সাথে Ṛ!

— নিক কেনেডি

IƬUZḢAপ্রদত্ত প্রশ্নটি নিয়েও কাজ করবে; আমি ভাবছি যদি কোথাও কোনও বাইট থাকে তবে ...

— জোনাথন অ্যালান

ạƝƬZṪ€খুব কাজ করে কিন্তু আবার একটি ছয়।

— নিক কেনেডি

হ্যাঁ, আমি সেই রূপটি লক্ষ্য করেছি; আমি এখন কম আশাবাদী।

— জোনাথন অ্যালান

আমি কেবল একটি 5-বাইটার পোস্ট করেছি, তবে পিরামিড নির্মাণের পরে অংশটি সম্পর্কে আপনার দৃষ্টিভঙ্গির চেয়ে কিছুটা আলাদা।

— এরিক আউটগল্ফার 19

Answer 6

ম্যাথগল্ফ , 14 11 বাইট

xÆ‼├│?;∟;]x

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

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

Answer 7

পাইথন 2 , 56 বাইট

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

ইতিবাচক পূর্ণসংখ্যার একটি তালিকা গ্রহণ করে এমন একটি পুনরাবৃত্ত ফাংশন যা অ-নেতিবাচক পূর্ণসংখ্যার একটি তালিকা প্রদান করে।

এটি অনলাইন চেষ্টা করুন!

Answer 8

জেলি , 5 বাইট

_ƝƬa/

এটি অনলাইন চেষ্টা করুন!

আমরা ধরে নিতে পারি পুরো পিরামিডটি ইতিবাচক, তাই আমরা "ডান" অপারেশনের পরিবর্তে একটি && ক্রিয়াকলাপ ব্যবহার করতে পারি।

Answer 9

পরী / জিপি , 36 বাইট

@ লিনের মন্তব্যের ভিত্তিতে :

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

প্যাসিকাল ম্যাট্রিক্সের জন্য পারি / জিপি একটি অন্তর্নির্মিত রয়েছে এবং এর বিপরীতটি হ'ল আমাদের প্রয়োজনীয় ম্যাট্রিক্স:

$$\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)~)

এটি অনলাইন চেষ্টা করুন!

Answer 10

আর , 69 67 বাইট

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

এটি অনলাইন চেষ্টা করুন!

একটি কলাম ভেক্টর প্রদান করে।

-২ বাইট ধন্যবাদ কিরিল এলকে।

লিনের মন্তব্যের ভিত্তিতে :

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

এটি অন্য আর উত্তরের চেয়ে দীর্ঘ, তবে গল্ফ গ্রহণ এবং চেষ্টা করার জন্য এটি একটি আকর্ষণীয় পদ্ধতির ছিল।

Answer 11

জাভাস্ক্রিপ্ট (ES6), 127 বাইট

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}

আসল কোড

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

ওহ, আমি আগের মতো ... অনেক ... হারিয়ে গেলাম

Answer 12

ওল্ফ্রাম ভাষা (গণিত) , 57 বাইট

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

এটি অনলাইন চেষ্টা করুন!

Answer 13

05 এ বি 1 ই , 12 11 বাইট

R.¥.Γ¥}¨ζнR

@ জোনাথন অ্যালান এর জেলি উত্তর বন্দর , যদিও আমি জেলি এই ক্ষেত্রে আরও সুবিধাজনক বিল্টিন সম্পর্কে জেলি করছি । ;)
-1 থেকে বাইট ধন্যবাদ @Emigna ।

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা:

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)

Comments

R.¥.Γ¥}¨যার ব-দ্বীপটি ইনপুট সেই তালিকা থেকে শুরু করে আপনি একটি বাইট সংরক্ষণ করতে পারেন ।

— এমিগিনা

ইমেনা আহ, প্রিপেন্ডে একটি বাইট সংরক্ষণ করতে ডেল্টাসহ একটি লুপে আনডেল্টা দিন। :) ধন্যবাদ!

— কেভিন ক্রুইজসেন

Answer 14

আর , 55 63 55 53 বাইট

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

এটি অনলাইন চেষ্টা করুন!

-2 বাইট জিউসেপ্পিকে ধন্যবাদ

Answer 15

পার্ল 6 , 37 বাইট

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

এটি অনলাইন চেষ্টা করুন!

বারবার অ্যালিমিটওয়্যার বিয়োগফলকে হ্রাস করে এবং তারপরে বিপরীতে প্রতিটি তালিকার শেষ সংখ্যাটি প্রদান করে।

ব্যাখ্যা:

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

Answer 16

পাইথন 2 , 78 বাইট

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

এটি অনলাইন চেষ্টা করুন!

Answer 17

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 164 বাইট

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

এটি অনলাইন চেষ্টা করুন!

Answer 18

কাঠকয়লা , 19 বাইট

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

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। ব্যাখ্যা:

Ｆθ«

মূল তালিকায় প্রতিটি শর্তের জন্য একবার লুপ করুন।

ＰＩ§θ±¹↑

তালিকার শেষ শব্দটি মুদ্রণ করুন, তবে কার্সারটিকে আগের লাইনের শুরুতে সরিয়ে দিন, যাতে পদগুলি বিপরীত ক্রমে আউটপুট হয়।

ＵＭθ⁻§θ⊖λκ

শুরুতে একটি ডামি মান সন্নিবেশ করিয়ে ব-দ্বীপগুলি গণনা করুন যাতে আমরা এমন একটি অপারেশন ব্যবহার করতে পারি যা তালিকার দৈর্ঘ্য পরিবর্তন করে না।

Answer 19

এপিএল + উইন, 34 বা 28 বাইট

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

এটি অনলাইন চেষ্টা করুন! সৌজন্যে ডায়ালগ ক্লাসিক

ডান পাশের ভেক্টরের জন্য অনুরোধ জানানো হয়।

বা @ লিনের পদ্ধতির বাস্তবায়ন:

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

অনলাইনে চেষ্টা করে দেখুন! ডায়ালগ ক্লাসিকের সৌজন্যে

ডান পাশের ভেক্টরের জন্য অনুরোধ জানানো হয়।

Answer 20

সংযুক্তি , 29 বাইট

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

এটি অনলাইন চেষ্টা করুন!

Deltaখালি খালি অবধি ফাংশনটি পুনরাবৃত্তি করে । খুব ভার্জোজ PeriodicStepsসমাধানের চেয়ে অনেক কম ...

Answer 21

সি, 76 বাইট

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

ইনপুট : (*a = pointer to array, n = last element's index of that array)
আউটপুট :return int* = output

ডান দিক থেকে উপরের দিকে যাচ্ছে ব্যাখ্যা , কারণ শেষ উপাদানগুলি ইনপুট এবং আউটপুট উভয় ক্ষেত্রে সমান হয় কারণ ফাংশনের ভিতরে লুপটি কেবল ত্রিভুজের পরবর্তী উচ্চতর সংখ্যাগুলি ধীরে ধীরে উত্তরকে অক্ষত রেখে শীর্ষে পৌঁছায়।

অবারিত (সি ++ থেকে)

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

Answer 22

জাপট , 11 9 বাইট

Nc¡=äa
yÌ

চেষ্টা করে দেখুন

অলিভারকে ধন্যবাদ 2 বাইট

12 11 বাইট

_äa}hUÊN yÌ

চেষ্টা করে দেখুন

অলিভারকে ধন্যবাদ 1 বাইট

Comments

9 বাইট এবং 10 বাইট

— অলিভার

@ অলিভার, ব্যবহার করার চিন্তা না করা y(f)যথেষ্ট খারাপ, তবে সম্পূর্ণরূপে নতুন লাইনটি ভুলে যাওয়া ক্ষমাযোগ্য নয় ! শীঘ্রই আপডেট হবে। ধন্যবাদ :)

— শেগি

Answer 23

জুলিয়া 0.6 , 44 বাইট

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

এটি অনলাইন চেষ্টা করুন!

আমার আর উত্তর হিসাবে একই পুনরাবৃত্তি নীতি।

জুলিয়া 0.6 , 55 বাইট

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

এটি অনলাইন চেষ্টা করুন!

@ লিনের অ্যালগরিদম (পাস্কল ম্যাট্রিক্সের বিপরীতে ইনপুট দ্বারা গুণিত)।