Disegna una piramide discendente (aggiunta)

11

Sfida

Data una sequenza di numeri interi non negativi, creare una funzione che genera una piramide discendente in cui i figli sono la somma di entrambi i numeri padre.

Il risultato viene emesso come stringa usando tab \t.

Nota: le schede finali su ogni riga non sono necessarie

1\t\t2\t\t3\n\t3\t\t5\t\n\t\t8\t\t results in 
1       2       3
    3       5   
        8

Facoltativamente, il risultato può essere emesso come un array usando una posizione vuota come spazio. 

[[1,,2,,3],
[,3,,5,],
[,,8,,]]

Esempio:

Dato 4,5,7,3,4,2output:

4       5       7       3       4       2
    9       12      10      7       6
        21      22      17      13
            43      39      30
                82      69
                    151

Regole

  • Si applicano le regole standard del code-golf
  • L'input può essere una stringa utilizzando qualsiasi separatore o un array
  • Sono consentite nuove righe e tabulazioni iniziali / finali (ma non necessarie purché l'output sia una piramide invertita)

Casi test

Input: 1,3,5

1       3       5
    4       8
        12


Input: 9,8,7,6,5

9       8       7       6       5
    17      15      13      11
        32      28      24
            60      52
                112


Input: 5,5,2,5

[[5,,5,,2,,5],
[,10,,7,,7,],
[,,17,,14,,],
[,,,31,,,]]

Input: 3,3,3

[[3,,3,,3],
[,6,,6,],
[,,12,,]]

I criteri vincenti sono code-golf

Nota: questa sfida è molto vicina al triangolo Generate Pascal . La differenza è la sequenza iniziale personalizzata (pascal va da 1 e in modalità ascendente, questo da un input e in modalità discendente).

Posta sandbox

code-golf 
— Luis Felipe De Jesus Munoz
fonte
— AdmBorkBork,
non-negative integersdobbiamo gestire 0? Ci sono alcune possibilità di golf se gli spazi vuoti sono riempiti con 0s.
— JungHwan Min
Possiamo restituire un array con tab o stringhe / array vuoti nelle posizioni vuote?
— Adám,
2
"Sono consentite le righe e le linee guida iniziali / finali" - Possiamo includere anche risultati vuoti nella parte inferiore dell'output dell'array?
— Jonathan Allan,
1
@JonathanAllan sono consentite nuove righe e schede
— finali

Risposte:

4

APL (Dyalog Unicode) , 31 28 byte SBCS

Funzione prefisso tacita. Utilizza un singolo spazio come indicatore di slot vuoto. Restituisce un elenco di elenchi di numeri / spazi.

⍳∘≢{∊(⍺⍴''),,∘' '¨2+/⍣⍺⊢⍵}¨⊂

Provalo online!

⍳∘≢{... }¨⊂ applicare la funzione di seguito per ciascuna
⍳delle ɩ ndices  ∘della  ≢il riscontro con
⊂l'intero argomento:

 ⊢⍵ cedere l'argomento giusto (l'input originale)

 2+/⍣⍺ applica la somma a coppie tutte le volte indicate dall'argomento sinistro

 ,∘' '¨ aggiungere uno spazio a ciascun numero

 (... ), aggiungilo a quanto segue:

  ⍺⍴'' elementi di argomento sinistro della stringa vuota (riempita con spazi)

 ∊ ϵ nlist (appiattisci)

— Adamo
fonte
3

Gelatina ,  14  13 byte

14 -> 13 presuppone che nell'output del formato elenco sia consentita la voce solo spazi finali; in caso contrario, tornerò al 14 ( chiesto )

+ƝƬK€z⁶Zṙ"JC$

Un collegamento monadico. L'output è un elenco di elenchi che utilizzano spazi come caratteri (include una sola voce di spazi finali).

Provalo online! (include un piè di pagina per mostrare la struttura dell'elenco dall'esecuzione del collegamento monadico poiché un programma completo stamperà implicitamente l'output smash).

— Jonathan Allan
fonte
3

Buccia , 22 byte

zoΣ~+R"	"oJ"		"msNU¡Ẋ+

Provalo online!

Spiegazione

z(Σ~+R" "(J"  "ms))NU¡Ẋ+  -- example input: [1,2,3]
                     ¡    -- infinitely do and collect in list
                      Ẋ+  -- | sum adjacent
                          -- : [[1,2,3],[3,5],[8],[],[],...
                    U     -- keep up until first repetition: [[1,2,3],[3,5],[8],[]]
z(                )N      -- zip with natural numbers under (example on 1 [1,2,3])
   ~+    (       )        -- | join arguments modified by
     R" "                 -- | | replicate tab: " "
               ms         -- | | show each: ["1","2","3"]
          J"  "           -- | | join with 2 tabs: ["1","  ","2","  ","3"]
                          -- | : [" ","1","  ","2","  ","3"]
  Σ                       -- | concatenate: " 1  2  3"
                          -- : [" 1  2  3","  3  5","   8"]
— ბიმო
fonte
2

JavaScript (ES6), 73 byte

Strano codice sorgente ... Comunque, questo è code-golf !

Include spazi bianchi iniziali e finali.

f=(a,p=`
`)=>p+a.join`		`+(1/(y=a.shift())?f(a.map(x=>y+(y=x)),p+`	`):'')

Provalo online!

— Arnauld
fonte
2

Python 3 , 101 93 80 byte

Hai salvato 7 byte ( map(str,x)invece di for ine inizializza come '') e mi sono sbarazzato delle nuove righe finali ( x and[anziché print(), grazie a Jo King .

Salvato 13 byte ( [*map(sum,zip(x,x[1:]))]anziché [x[j]+x[j+1]for j in range(len(x)-1)]) grazie a ovs .

f=lambda x,y='':x and[y+'		'.join(map(str,x))]+f([*map(sum,zip(x,x[1:]))],y+'	')

Provalo online!

— Emigna
fonte
@ovs: Ah, bello. Avrei dovuto capire che potevo mappare la somma. Grazie!
— Emigna,
1

Retina , 35 byte

+¶<`\d+ *(?=(\d+)?)
    $#1*$.(*_$1*)

Provalo online! Spiegazione:

+

Ripeti finché il buffer non smette di cambiare,

¶<`

Stampa il contenuto del buffer prima della sostituzione, con una nuova riga finale e

\d+ *(?=(\d+)?)
    $#1*$.(*_$1*)

Sostituisci un singolo numero con una coppia di schede, ma un numero seguito da un altro numero con una scheda, la somma e un'altra scheda.

— Neil
fonte
1

Rosso , 151 byte

func[b][m: length? b repeat n m[loop n - 1[prin"^-"]print replace/all
form b" ""^-^-"c: copy[]repeat i -1 + length? b[append c b/(i) + b/(i + 1)]b: c]]

Provalo online!

Più leggibile:

f: func [ b ] [
    m: length? b
    repeat n m [
        loop n - 1 [ prin tab ]
        print replace/all form b " " rejoin [ tab tab ]
        c: copy []
        repeat i (length? b) - 1 [
            append c b/(i) + b/(i + 1)
        ]
        b: c
    ]
]
— Galen Ivanov
fonte
1

Perl 6 , 50 48 byte

{$_,{say "	"x$++~.join("		");$_[1..*]Z+@$_}...0}

Provalo online!

Blocco di codice anonimo che accetta un elenco di numeri interi e stampa la piramide invertita.

— Jo King
fonte
1

C # (compilatore Visual C #) , 163 byte

b=>{var s="";var c=b.Length;for(int i=0;i<c;i++){for(int z=0;z<i;z++)s+="\t";for(int x=0;x<c-i;x++){s+=b[x]+"\t\t";b[x]=x==c-i-1?0:b[x]+b[x+1];}s+="\n";}return s;}

Provalo online!

Leggibile:

b =>    {
            var s = "";
            var c = b.Length;
            for (int i = 0; i < c; i++)
            {
                for (int z = 0; z < i; z++)
                    s += "\t";
                for (int x = 0; x < c - i; x++)
                {
                    s += b[x] + "\t\t";
                    b[x] = x == c - i - 1 ? 0 : b[x] + b[x + 1];
                }
                s += "\n";
            }
            return s;
        }
— Hyarus
fonte
1

Japt -Rx , 20 18 byte

La seconda riga include una scheda finale.

Nc¡=ä+
Ëq' ² iEç'

Provalo

Spiegazione

                  :Implicit input of array U
N                 :The array of inputs (NOT the input array)
 c                :Concatenate
  ¡               :  Map U
    ä+            :    Consecutive sums of U
   =              :    Reassign to U for next iteration
\n                :Reassign the resulting 2D-array to U
Ë                 :Map each array at index E
 q                :  Join with
  '\t             :   Tab
     ²            :   Repeated twice
       i          :  Prepend
          '\t     :   Tab
         ç        :   Repeated
        E         :   E times
                  :Implicitly join with newlines, trim (not strictly necessary) and output.
— ispido
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.