अपसाइड-डाउन पिरामिड एडिशन ... पुनरीक्षित!

22

अपसाइड-डाउन पिरामिड एडिशन संख्या की एक सूची लेने और उन्हें एक साथ जोड़ने तक की प्रक्रिया है, जब तक कि आप एक नंबर तक नहीं पहुंच जाते।

जब संख्या दी जाती है 2, 1, 1तो निम्नलिखित प्रक्रिया होती है:

 2   1   1
   3   2 
     5

यह संख्या में समाप्त होता है 5।

आपका कार्य

एक अपसाइड-डाउन पिरामिड (आरोही) के दाहिने हिस्से को देखते हुए, एक प्रोग्राम या फ़ंक्शन लिखें जो मूल सूची लौटाएगा।

नई अतिरिक्त चुनौती : O (n ^ 2) से कम में ऐसा करने का प्रयास करें

उदाहरण

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

नोट: अपसाइड-डाउन पिरामिड कभी खाली नहीं होगा और हमेशा सकारात्मक पूर्णांक से मिलकर बनेगा।

code-golf  math  fastest-algorithm  algorithm 
— whimpers
स्रोत
6
PP & CG में आपका स्वागत है! यह चुनौती शालीन है, हालांकि इसमें सुधार किया जा सकता है। मैं सैंडबॉक्स में अपनी चुनौतियों को पोस्ट करने की सलाह दूंगा , ताकि मुख्य पर डालने से पहले पोस्ट को बेहतर बनाया जा सके।
— ताऊ
13
नि: शुल्क जानकारी मैं एक भाषा नहीं मिल सकता है कि इसमें कम है:
च([ए,ख,सी,घ,ई])=[1-46-4101-33-1001-210001-100001]⋅[एखसीघई]
— लिन 10
4
सिर्फ FYI करें, यह CodeWars काटा के समान है ।
— गगॉलेन
6
@ggorlen मुझे पता है। मैं वह हूँ जिसने काटा बनाया है :)
— व्हिम्पर्स
8
Try doing this in less than O(n)निश्चित रूप से यह एक n-size array आवंटित करना या O (n) आइटम को O (n) जटिलता से अधिक तेजी से बदलना असंभव है?
— मेरा सर्वनाम

जवाबों:

17

जावास्क्रिप्ट (ईएस 6),  62 58 49  46 बाइट्स

3 बाइट्स @Oliver की बदौलत बची

सूची को अल्पविराम द्वारा अलग किए गए स्ट्रिंग के रूप में देता है।

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[]
— Arnauld
स्रोत
@ ओलिवर, हाँ
— झबरा
6

टीआई-बेसिक, 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"

नोट: TI-BASIC एक टोकन भाषा है। कैरेक्टर काउंट बाइट काउंट नहीं के बराबर होता है ।

— ताउ
स्रोत
4

जेली , 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]
— जोनाथन एलन
स्रोत
एक समान समाधान था, लेकिन Uइसके बजाय एस के साथ Ṛ!
— निक केनेडी
IƬUZḢAदिए गए प्रश्न के साथ भी काम करेगा; मुझे आश्चर्य होता है कि कहीं बाइट बचा है ...
— जोनाथन एलन
ạƝƬZṪ€काम करता है, लेकिन फिर से एक छह है।
— निक कैनेडी
हां, मैंने उस संस्करण को देखा; मुझे अब कम उम्मीद है।
— जोनाथन एलन
मैंने अभी 5-बटर पोस्ट किया है, लेकिन यह पिरामिड निर्माण के बाद के हिस्से के बारे में आपके दृष्टिकोण से थोड़ा अलग है।
— आउटगोल्फर
4

मैथॉल्फ़ , 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
— maxb
स्रोत
3

पायथन 2 , 56 बाइट्स

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

एक पुनरावर्ती फ़ंक्शन जो सकारात्मक पूर्णांक की एक सूची को स्वीकार करता है जो गैर-नकारात्मक पूर्णांक की सूची देता है।

इसे ऑनलाइन आज़माएं!

— जोनाथन एलन
स्रोत
3

परी / जीपी , 36 बाइट्स

@Lynn की टिप्पणी के आधार पर :

नि: शुल्क अंतर्दृष्टि है कि मैं एक भाषा में यह छोटा है नहीं मिल सकता है:

च([ए,ख,सी,घ,ई])=[1-46-4101-33-1001-210001-100001]⋅[एखसीघई]

Pari / GP में पास्कल मैट्रिक्स के लिए एक अंतर्निहित है, और इसका उलटा वास्तव में आवश्यक मैट्रिक्स है:

[1000011000121001331014641]-1=[10000-110001-2100-13-3101-46-41]

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

इसे ऑनलाइन आज़माएं!

— alephalpha
स्रोत
3

आर , 69 67 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक कॉलम वेक्टर लौटाता है।

-2 बाइट्स धन्यवाद किरिल एल।

इसके अलावा लिन की टिप्पणी पर आधारित :

नि: शुल्क अंतर्दृष्टि है कि मैं एक भाषा में यह छोटा है नहीं मिल सकता है:

च([ए,ख,सी,घ,ई])=[1-46-4101-33-1001-210001-100001]⋅[एखसीघई]

यह अन्य आर उत्तर की तुलना में लंबा है, लेकिन इसे गोल्फ में ले जाना और प्रयास करना एक दिलचस्प तरीका था।

— ग्यूसेप
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 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;
}

ओह, मैं हार गया ... बहुत ... पिछले जवाब के लिए ...

— Naruyoko
स्रोत
2

05AB1E , 12 11 बाइट्स

R.¥.Γ¥}¨ζнR

पोर्ट ऑफ @JonathanAllan की जेली जवाब है, हालांकि मैं जेली इस मामले में जेली के और अधिक सुविधाजनक builtins के बारे में। ;)
-1 बाइट @ @ मिगना के लिए धन्यवाद ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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)
— केविन क्रूज़सेन
स्रोत
2
आप उस बाइट R.¥.Γ¥}¨को उस सूची से शुरू करके बचा सकते हैं जिसका डेल्टा इनपुट है।
— इमिग्ना
@Emigna आह, प्रिलेंड पर एक बाइट को बचाने के लिए डेल्टास के साथ एक लूप में अंडेल्टा। :) धन्यवाद!
— केविन क्रूज़सेन
2

पर्ल 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
— मजाक कर रहा है
स्रोत
1

चारकोल , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｆθ«

मूल सूची में प्रत्येक पद के लिए एक बार लूप।

ＰＩ§θ±¹↑

सूची में अंतिम शब्द प्रिंट करें, लेकिन कर्सर को पिछली पंक्ति की शुरुआत में ले जाएं, ताकि शब्द रिवर्स ऑर्डर में आउटपुट हो।

ＵＭθ⁻§θ⊖λκ

डेल्टास की गणना करें, शुरुआत में एक डमी मूल्य डालें ताकि हम एक ऑपरेशन का उपयोग कर सकें जो सूची की लंबाई को नहीं बदलता है।

— नील
स्रोत
1

एपीएल + विन, 34 या 28 बाइट्स

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

इसे ऑनलाइन आज़माएं! दरोगल क्लासिक के सौजन्य से

दाईं ओर वेक्टर के लिए संकेत।

या @ लिन का दृष्टिकोण लागू करना:

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

यह ऑनलाइन की कोशिश करो! Dyalog क्लासिक के सौजन्य से

दाईं ओर वेक्टर के लिए संकेत।

— ग्राहम
स्रोत
1

सी, 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

स्पष्टीकरण
दाईं ओर से ऊपर तक जा रहा है, चूंकि अंतिम तत्व इनपुट और आउटपुट दोनों में समान हैं और फ़ंक्शन के अंदर लूप बस त्रिभुज में अगले उच्च संख्या पाता है, धीरे-धीरे अंत में उत्तर बरकरार रखते हुए शीर्ष पर पहुंच जाता है।

अपंग (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];
}
— मुकुल कुमार
स्रोत
1

जाप , 11 9 बाइट्स

Nc¡=äa
yÌ

कोशिश करो

2 बाइट्स ने ओलिवर को धन्यवाद दिया।

12 11 बाइट्स

_äa}hUÊN yÌ

कोशिश करो

1 बाइट ने ओलिवर को धन्यवाद दिया।

— झबरा
स्रोत
2
— ओलिवर
@ ओलिवर, उपयोग करने के लिए नहीं सोच रहा है कि y(f)बहुत बुरा है, लेकिन पूरी तरह से भूल नई लाइन अक्षम्य है! शीघ्र ही अपडेट होगा। धन्यवाद :)
— झबरा
1

जूलिया 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

इसे ऑनलाइन आज़माएं!

@ लिन का एल्गोरिदम (इनपुट द्वारा पास्कल मैट्रिक्स का व्युत्क्रम गुणा)।

— किरिल एल।
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.