Baş Aşağı Piramit Ekleme… TERS!

22

Upside-Down Pyramid Addition, bir numara listesini alma ve bir numaraya ulaşana kadar bunları art arda toplama işlemidir.

Rakamlar 2, 1, 1verildiğinde aşağıdaki işlem gerçekleşir:

 2   1   1
   3   2 
     5

Bu sayıyla biter 5.

SENİN GÖREVİN

Başına Düşen Bir Piramidin (Yükselen) sağ tarafı göz önüne alındığında, orijinal listeye geri dönecek bir program veya işlev yazın.

Yeni Ekstra Zorluk : Bunu O (n ^ 2) 'dan daha düşük bir sürede yapmayı deneyin

ÖRNEK

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

NOT: Baş Aşağı Piramidi hiçbir zaman boş olmayacak ve her zaman SADECE pozitif tamsayılardan oluşacaktır.

code-golf  math  fastest-algorithm  algorithm 
— inlemeleriyle
kaynak
6
PP & CG'ye Hoşgeldiniz! Bu zorluk daha iyi olsa da, terbiyeli. Görevinizi daha önce yayınlanmadan önce geliştirmek için önce zorluklarınızı Sandbox'a göndermenizi öneririm .
— Tau
13
Daha kısa bir dil bulamadığım için içgörü:
f([a,b,c,d,e])=[1−46−4101−33−1001−210001−100001]⋅[abcde]
— Lynn
4
Sadece Bilginize, bu CodeWars kata ile aynıdır .
— ggorlen
6
@ggorlen biliyorum. Kata yapan benim :)
— Whimpers
8
Try doing this in less than O(n)Elbette n boyutlu bir dizi tahsis etmek veya içindeki O (n) maddelerini O (n) karmaşıklığından daha hızlı değiştirmek imkansız mı?
— zamirim

Yanıtlar:

17

JavaScript (ES6),  62 58 49  46 bayt

@Oliver sayesinde 3 bayt kaydedildi

Listeyi virgülle ayrılmış bir dize olarak döndürür.

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

Çevrimiçi deneyin!

Yorumlananlar

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
kaynak
@Oliver, evet
— Shaggy
6

TI-BASIC, 54 bayt

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

Girdi, Ansmeydan okumada tanımlandığı gibi içindeki üçgenin sağ tarafının listesidir .
Çıktı, söz konusu üçgenin üst sırasıdır.

Örnekler:

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

Açıklama:
Bu çözüm, başlangıçtaki üçgenin sağ tarafını kullanarak oluşturulan üçgenin her elemandaki değişiklik olduğu gerçeğini kötüye kullanıyor.

Diğer bir deyişle,

2 1 1
 3 2
  5

dönüşür:

5 2 1
 3 1
  2

Dolayısıyla, sonuç listesi, son öğeyi sonuç listesindeki üst listesinin uzunluğu dizinine ayarlayarak oluşturulabilecek olan bu yeni üçgenin sağ tarafıdır.

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"

Not: TI-BASIC belirtilmiş bir dildir. Karakter sayısı bayt sayısına eşit değil .

— Tau
kaynak
4

Jöle , 6 bayt

ṚIƬZḢṚ

Bir tamsayı listesini kabul eden bir monadik Bağlantı.

Çevrimiçi deneyin!

Nasıl?

Tüm üçgeni oluşturur ve ardından gerekli elemanları çıkarır.

Ṛ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
kaynak
Neredeyse aynı bir çözüm vardı ama Uyerine s Ṛ!
— Nick Kennedy,
IƬUZḢAverilen soru ile de çalışacaktı; Acaba bir yerde bir bayt var mı diye merak ediyorum ...
— Jonathan Allan
ạƝƬZṪ€de çalışır ama yine altı.
— Nick Kennedy,
Evet, bu varyantı fark ettim; Şimdi daha az umutluyum.
— Jonathan Allan,
Az önce 5 baytlık bir yazı gönderdim, ancak piramit yapımından sonraki bölümle ilgili yaklaşımınızdan biraz farklı.
— Outgolfer Erik,
4

MathGolf , 14 11 bayt

xÆ‼├│?;∟;]x

Çevrimiçi deneyin!

açıklama

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
kaynak
3

Pari / GP , 36 bayt

Dayanarak @Lynn Yorumu:

f([a,b,c,d,e])=[1−46−4101−33−1001−210001−100001]⋅[abcde]

Pari / GP, Pascal matrisi için bir yerleşik özelliğe sahiptir ve bunun tersi tam da ihtiyacımız olan matrisdir:

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

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

Çevrimiçi deneyin!

— alephalpha
kaynak
3

R , 69 67 bayt

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

Çevrimiçi deneyin!

Bir sütun vektörü döndürür.

Kirill L sayesinde -2 bayt

Ayrıca Lynn yorumuna göre:

f([a,b,c,d,e])=[1−46−4101−33−1001−210001−100001]⋅[abcde]

Diğer R cevabından daha uzun, ama golf oynamak ve denemek için ilginç bir yaklaşımdı.

— Giuseppe
kaynak
2

Javascript (ES6), 127 bayt

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}

Orijinal kod

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

Ah, ben de kaybettim ... önceki cevaba ... çok ...

— Naruyoko
kaynak
2

05AB1E , 12 11 bayt

R.¥.Γ¥}¨ζнR

Port @JonathanAllan 'ın Jelly cevap , ben her ne kadar jöle bu durumda Jelly daha uygun yerleşikleri hakkında. ;) @Emigna
sayesinde -1 bayt .

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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
kaynak
2
R.¥.Γ¥}¨Delta girişi olan listeden başlayarak bir bayt ile kaydedebilirsiniz .
— Emigna
@Emigna Ah, haznede bir bayttan tasarruf etmek için delta içeren bir döngüye geri dönün. :) Teşekkürler!
— Kevin Cruijssen
2

Perl 6 , 37 bayt

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

Çevrimiçi deneyin!

Elemanlar halinde çıkarma işlemiyle art arda azalır ve ardından her listenin son sayısını tersine döndürür.

Açıklama:

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

Kömür , 19 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

Ｆθ«

Orijinal listedeki her terim için bir kez döngü yapın.

ＰＩ§θ±¹↑

Listedeki son terimi yazdır, ancak terimleri ters sırada olacak şekilde imleci önceki satırın başına getir.

ＵＭθ⁻§θ⊖λκ

Deltaları hesaplayın, başında kukla bir değer ekleyerek listenin uzunluğunu değiştirmeyen bir işlemi kullanabiliriz.

— Neil
kaynak
1

C, 76 bayt

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

giriş : (*a = pointer to array, n = last element's index of that array)
çıkış :return int* = output

Açıklama
, son girdiler hem girdi hem de çıktıda aynı olduğu için sağdan yukarıya giden açıklama , içteki ilmek fonksiyonunun basitçe, en sonunda tepeye ulaşan üçgende bir sonraki daha yüksek sayıları bulmasını sağlar.

ungolfed (C ++ 'dan) 

#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
kaynak
1

Japt , 11 9 bayt

Nc¡=äa
yÌ

Dene

Oliver sayesinde 2 bayt kaydedildi.

12 11 bayt

_äa}hUÊN yÌ

Dene

Oliver sayesinde 1 bayt kaydedildi.

— kaba tüylü
kaynak
2
— Oliver
@Oliver, kullanmayı düşünmemek y(f)yeterince kötü, ancak yeni satırı tamamen unutmak affedilmez! Yakında güncellenecek. Thanks :)
— Shaggy
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.