Dibuja una pirámide descendiente (además)

11

Desafío

Dada una secuencia de enteros no negativos, cree una función que genere una pirámide descendente donde los hijos son la suma de ambos números primarios.

El resultado se genera como una cadena usando tab \t.

Nota: no se requieren pestañas finales en cada línea

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

Opcionalmente, el resultado se puede generar como una matriz utilizando una posición vacía como espacio. 

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

Ejemplo:

4,5,7,3,4,2Salida dada :

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

Reglas

  • Aplican reglas estándar de código de golf
  • La entrada puede ser una cadena usando cualquier separador o una matriz
  • Se permiten nuevas líneas y pestañas iniciales / finales (pero no se requieren siempre que la salida sea una pirámide invertida)

Casos de prueba

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

El criterio ganador es code-golf

Nota: Este desafío está muy cerca del Generar el triángulo de Pascal . La diferencia es la secuencia de inicio personalizada (pascal va desde 1 y en modo ascendente, esto desde una entrada y en modo descendente).

Publicación de sandbox

code-golf Luis felipe De jesus Munoz
fuente
Algo relacionado .
AdmBorkBork
non-negative integerstenemos que manejar 0? Hay algunas posibilidades de golf si los espacios vacíos se llenan con 0s.
JungHwan Min
¿Podemos devolver una matriz con pestañas o cadenas / matrices vacías en las posiciones vacías?
Adám
2
"Se permiten nuevas líneas y pestañas iniciales / finales": ¿podemos incluir también resultados vacíos en la parte inferior de la salida de la matriz?
Jonathan Allan
1
@JonathanAllan se permiten
Adám

Respuestas:

4

APL (Dyalog Unicode) , 31 28 bytes SBCS

Función de prefijo tácito. Utiliza un solo espacio como marcador de ranura vacío. Devuelve la lista de listas de números / espacios.

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

Pruébalo en línea!

⍳∘≢{… }¨⊂ Aplique la siguiente función para cada uno de
⍳los of nices  ∘de  ≢la cuenta con
⊂el argumento completo:

 ⊢⍵ producir el argumento correcto (la entrada original)

 2+/⍣⍺ aplique la suma por pares tantas veces como lo indique el argumento izquierdo

 ,∘' '¨ agrega un espacio a cada número

 (... ), agregue eso a lo siguiente:

  ⍺⍴'' Elementos de argumento izquierdo de la cadena vacía (rellenados con espacios)

 ∊ ϵ nlist (aplanar)

Adán
fuente
3

05AB1E , 15 bytes

gFD„		ý'	N×ì,ü+

Pruébalo en línea!

Emigna
fuente
Eso es un montón de espacios ... pestañas?
JungHwan Min
... o cero espacios y algunas pestañas: p
Jonathan Allan
De hecho, esas son pestañas :)
Emigna
3

Jalea ,  14  13 bytes

14 -> 13 asume que solo se permite la entrada de espacios finales en la salida del formato de lista; si no, volveré a los 14 ( preguntado )

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

Un enlace monádico. La salida es una lista de listas que utilizan caracteres de espacio como espacios (incluye una sola entrada de espacios finales).

Pruébalo en línea! (incluye un pie de página para mostrar la estructura de la lista ya que ejecutar el enlace monádico como un programa completo imprimirá la salida aplastada implícitamente).

Jonathan Allan
fuente
3

Casco , 22 bytes

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

Pruébalo en línea!

Explicación

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

JavaScript (ES6), 73 bytes

Código fuente extraño ... De todos modos, ¡eso es código golf !

Incluye espacios en blanco iniciales y finales.

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

Pruébalo en línea!

Arnauld
fuente
2

Python 3 , 101 93 80 bytes

Ahorré 7 bytes (en map(str,x)lugar de for ine init y as '') y me libré de las nuevas líneas finales (en x and[lugar de print(), gracias a Jo King .

Guardado 13 bytes (en [*map(sum,zip(x,x[1:]))]lugar de [x[j]+x[j+1]for j in range(len(x)-1)]) gracias a los ovs .

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

Pruébalo en línea!

Emigna
fuente
@ovs: Ah, genial. Debería haberme dado cuenta de que podía mapear la suma. ¡Gracias!
Emigna
1

Retina , 35 bytes

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

Pruébalo en línea! Explicación:

+

Repita hasta que el búfer deje de cambiar,

¶<`

Imprima el contenido del búfer antes de la sustitución, con una nueva línea final, y

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

Sustituya un solo número con un par de pestañas, pero un número seguido de otro número con una pestaña, la suma y otra pestaña.

Neil
fuente
1

C (clang) , 112 bytes

j,k;f(*i,c){for(j=c+1;--j;puts("")){for(k=c-j;k--;)printf("\t");for(;++k<j;i[k]+=i[k+1])printf("%d\t\t",i[k]);}}

Pruébalo en línea!

ErikF
fuente
Sugerir en putchar(9)lugar deprintf("\t")
ceilingcat
1

Rojo , 151 bytes

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

Pruébalo en línea!

Más legible:

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

Perl 6 , 50 48 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma una lista de enteros e imprime la pirámide invertida.

Jo King
fuente
1

C # (compilador de Visual C #) , 163 bytes

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

Pruébalo en línea!

Legible:

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

Japt -Rx , 20 18 bytes

La segunda línea incluye una pestaña final.

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

Intentalo

Explicación

                  :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.
Lanudo
fuente