Dessiner une pyramide descendante (ajout)

11

Défi

Étant donné une séquence d'entiers non négatifs, créez une fonction qui génère une pyramide descendante où les enfants sont la somme des deux nombres parents.

Le résultat est affiché sous forme de chaîne à l'aide de tabulation \t.

Remarque: les onglets de fin sur chaque ligne ne sont pas requis

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

Le résultat peut éventuellement être sorti sous forme de tableau en utilisant une position vide comme espace. 

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

Exemple:

4,5,7,3,4,2Sortie donnée :

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

Règles

  • Les règles de code-golf standard s'appliquent
  • L'entrée peut être une chaîne utilisant n'importe quel séparateur ou tableau
  • Les sauts de ligne et les tabulations sont autorisés (mais non requis tant que la sortie est une pyramide inversée)

Cas de 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,,]]

Le critère de victoire est le golf de code

Remarque: ce défi est très proche du triangle de génération de Pascal . La différence est la séquence de démarrage personnalisée (pascal passe de 1 et en mode ascendant, ceci à partir d'une entrée et en mode descendant).

Poteau de bac à sable

code-golf 
— Luis felipe De jesus Munoz
source
— AdmBorkBork
non-negative integersdevons-nous gérer 0? Il existe des possibilités de golf si les espaces vides sont remplis de 0s.
— JungHwan Min
Pouvons-nous retourner un tableau avec des tabulations ou des chaînes / tableaux vides dans les positions vides?
— Adám
2
"Les sauts de ligne et les tabulations sont autorisés" - Pouvons-nous également inclure des résultats vides en bas dans la sortie du tableau?
— Jonathan Allan
1
@JonathanAllan Les sauts de ligne et les tabulations sont autorisés
— Adám

Réponses:

4

APL (Dyalog Unicode) , 31 28 octets SBCS

Fonction de préfixe tacite. Utilise un seul espace comme marqueur de slot vide. Renvoie la liste des listes de nombres / espaces.

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

Essayez-le en ligne!

⍳∘≢{... }¨⊂ appliquer la fonction ci - dessous pour chacun des
⍳les ɩ ndices  ∘de  ≢la concordance avec
⊂l'argument entier:

 ⊢⍵ produire le bon argument (l'entrée d'origine)

 2+/⍣⍺ appliquer la somme par paire autant de fois que l'indique l'argument de gauche

 ,∘' '¨ ajouter un espace à chaque numéro

 (… ), Joignez cela à ce qui suit:

  ⍺⍴'' éléments d'argument gauche de la chaîne vide (remplis d'espaces)

 ∊ ϵ nlist (aplatir)

— Adam
source
3

Gelée ,  14  13 octets

14 -> 13 suppose que l'entrée des espaces de fin uniquement est autorisée dans la sortie du format de liste; sinon je reviendrai au 14 ( demandé )

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

Un lien monadique. La sortie est une liste de listes utilisant des caractères d'espace comme espaces (comprend une seule entrée d'espaces de fin uniquement).

Essayez-le en ligne! (inclut un pied de page pour afficher la structure de la liste car l'exécution du lien monadique en tant que programme complet imprimera implicitement la sortie détruite.)

— Jonathan Allan
source
3

Husk , 22 octets

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

Essayez-le en ligne!

Explication

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"]
— ბიმო
source
2

JavaScript (ES6), 73 octets

Code source bizarre ... Quoi qu'il en soit, c'est le code-golf !

Inclut les espaces blancs de début et de fin.

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

Essayez-le en ligne!

— Arnauld
source
2

Python 3 , 101 93 80 octets

Enregistrement de 7 octets ( map(str,x)au lieu de for inet init y as '') et suppression des sauts de ligne ( x and[au lieu de print(), grâce à Jo King .

Enregistré 13 octets ( [*map(sum,zip(x,x[1:]))]au lieu de [x[j]+x[j+1]for j in range(len(x)-1)]) grâce à ovs .

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

Essayez-le en ligne!

— Emigna
source
@ovs: Ah, cool. J'aurais dû réaliser que je pouvais cartographier la somme. Merci!
— Emigna
1

Rétine , 35 octets

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

Essayez-le en ligne! Explication:

+

Répétez jusqu'à ce que le tampon cesse de changer,

¶<`

Imprimer le contenu du tampon avant la substitution, avec un retour à la ligne de fin, et

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

Remplacez un nombre unique par une paire d'onglets, mais un nombre suivi d'un autre nombre avec un onglet, la somme et un autre onglet.

— Neil
source
1

Rouge , 151 octets

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

Essayez-le en ligne!

Plus lisible:

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
source
1

C # (Visual C # Compiler) , 163 octets

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

Essayez-le en ligne!

Lisible:

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
source
1

Japt -Rx , 20 18 octets

La deuxième ligne comprend un onglet de fin.

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

Essayez-le

Explication

                  :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.
— Hirsute
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.