Esquemas piramidales

13

Las pirámides mayas fueron (y son) una parte importante de la arquitectura antigua, que generalmente se usaban con fines religiosos.

Por lo general, eran pirámides escalonadas, pero los escalones de cada una eran demasiado empinados para subir. Los sacerdotes subirían a la cima de ellos a través de escaleras alternativas para realizar ceremonias. Las pirámides también se usaron como puntos de referencia debido a su altura, y a veces incluso se usaron como sitios de entierro para funcionarios de alto rango.

El reto

Escriba un programa que pueda imprimir un esquema piramidal basado en las especificaciones del usuario (ver más abajo).

Requisitos

  • Tome una entrada de dos variables separadas por espacios.

  • La entrada debe aceptarse a través de STDIN (o la alternativa más cercana).

  • La salida debe ser a través de STDOUT (o la alternativa más cercana).

Entrada

  • Altura como cualquier entero positivo. Esto se usa como el ancho del nivel base (en bloques). Cada nivel posterior de la pirámide tiene el ancho n - 1donde nestá el ancho del piso anterior (en bloques).

  • Tamaño de bloque que será 1 o cualquier entero impar impar ≤ (menor que) 10.

Bloques

El tamaño de bloque dado determina el ancho (y la altura) de cada pieza individual. Esencialmente, hay i^2espacios dentro del cuadro visible donde iestá el tamaño del bloque.

Un bloque 1x1 se vería así:

+++
| |
+++

Mientras que un bloque 5x5 se vería así:

+++++++
|     |
|     |
|     |
|     |
|     |
+++++++

Bloques adyacentes horizontalmente

Los bloques horizontalmente uno al lado del otro deben tener sus paredes intermedias fusionadas en una sola.

Usted debe tener presente:

+++++
| | |
+++++

En lugar de algo como esto:

++++++
| || |
++++++

Bloques adyacentes verticalmente (-5% de bonificación)

Los bloques verticales uno al lado del otro tienen una excepción especial: la pared intermedia se puede fusionar en una sola.

Entonces, en lugar de bloques 1x1 que se ve así:

 +++
 | |
 +++
+++++
| | |
+++++

Ellos podrían tener este aspecto:

 +++
 | |
+++++
| | |
+++++

Ejemplos

Input: 3 1

Output:

  +++
  | |
  +++
 +++++
 | | |
 +++++
+++++++
| | | |
+++++++

OR

  +++
  | |
 +++++
 | | |
+++++++
| | | |
+++++++

Input: 2 3

Output:

  +++++
  |   |
  |   |
  |   |
  +++++
+++++++++
|   |   |
|   |   |
|   |   |
+++++++++

OR

  +++++
  |   |
  |   |
  |   |
+++++++++
|   |   |
|   |   |
|   |   |
+++++++++

Marcador

Para ser clasificado en el marcador, ponga su respuesta en este formato:

# Language, Score

O si obtienes el bono -5%:

# Language, Score (Bytes - 5%)

Tu puntaje es solo un número entero. Si su puntaje es un decimal, redondee al número entero.

Mostrar fragmento de código

code-golf ascii-art geometry Puertas de Zach
fuente
¿Cuál es la entrada mínima? 1 1?
mınxomaτ
Sí, lo que sería un solo bloque. @minxomat Se explica en la sección "Entrada".
Zach Gates
¿Qué produciría la entrada 3 2?
Hand-E-Food
Según la segunda viñeta en la sección "Entrada", el segundo entero de entrada debe ser impar. @ Hand-E-Food Si quisiera preguntar qué sucedería para una entrada como 2 3, saldría cuando n - 1 = 0donde nestá el ancho del piso anterior en bloques.
Zach Gates
@ZachGates, gracias! No te preocupes por mi Claramente el café me ha fallado.
Hand-E-Food

Respuestas:

1

Pyth, 45 (47 bytes - 5%)

AmvdczdVGjm.[Jh*GhHj*H?d\ \+*+2N?d\|\+\ hH;*J\+

Pruébalo aquí .

                                                   Implicit: z=input(), d=' '
    czd                                            Split input on spaces
 mvd                                               Evaluate each part of the above (convert to int)
A                                                  Store the pair in G,H
             Jh*GhH                                J = 1+(G*(H+1))
       VG                                          For N in [0 to G-1]:
          m                             hH;          Map d in [0 to H] to:
                                ?d\|\+                 Get '|' or '+' (vertical edges or corners)
                            *+2N                       Repeat the above (N+2) times
                      ?d\ \+                           Get ' ' or '+' (block centre or horizontal edge)
                    *H                                 Repeat the above H times
                   j                                   Join (|/+) by (   /+++)
           .[J                        \                Centrally pad the above to width J using spaces
         j                                           Join on newlines, implicit print
                                           *J\+    Get J '+'s, implicit print
Sok
fuente
1
+1. Mejor tarde que nunca. : P
Zach Gates
11

JavaScript (ES6), 161 (169-5%) 166 (174-5%)

Usando cadenas de plantilla, las 2 nuevas líneas son significativas y contadas.

Pruebe a ejecutar el fragmento a continuación en un navegador EcmaScript 6. Firefox está bien, no Chrome porque carece de soporte para tareas de desestructuración .

Código explicado después del fragmento.

/*Test: redefine console.log*/ console.log=x=>O.innerHTML+=x+'\n';

for([h,b]=prompt().split` `,g='+'[R='repeat'](-~b),f=' '[R](b),n=o='';h--;o+=e+(d=g[R](++n)+`+
`)+f.replace(/./g,e+('|'+f)[R](n)+`|
`))e=' '[R](h*-~b/2);console.log(o+d)
<pre id=O></pre>
Expandir fragmento

Menos golf

[h, b] = prompt().split` `; // get the space separated input values
c = -~b; // Add 1 to b. As b is of string type b+1 would be a string concatenation
g = '+'.repeat(c); // top border
f = ' '.repeat(b); // inner blank row
o = ''; // initialize output string
for(n = 0; h > 0; --h) // loop on height
{
   ++n;
   e = ' '.repeat(h*c/2); // blanks for offset from left margins
   d = g.repeat(n) + `+\n`; // top border repeated, then right end and newline
   // the block body is squared, there are as many rows as columns inside
   // so I can build the right number of rows replacing the chars in a single row
   o += e + d + f.replace(/./g, e + ('|'+f).repeat(n)+`|\n`)
}
o += d // add last top border as bottom
console.log(o)
edc65
fuente
9

Rubí, 124 (130 - 5%)

n=(g=gets).to_i
b=g[-2].to_i+1
a=(0..n*b-1).map{|i|[?+*(i/b*b+b+1),(?|+' '*(b-1))*(i/b+1)+?|][i%b<=>0].center(n*b+1)}
puts a,a[-b]

Con comentarios

n=(g=gets).to_i                                  #get input and interpret as a number for pyramid height (everything after the space is ignored)
b=g[-2].to_i+1                                   #the single-character block size is the second last character (just before the newline.) Add 1 to give the pitch between squares.
a=(0..n*b-1).map{|i|                             #run through all lines except the last one
[?+*(i/b*b+b+1),                                 #calculate number of + symbols
(?|+' '*(b-1))*(i/b+1)+?|]                       #or alternatively, pattern '|    |'
     [i%b<=>0]                                   #check if i%b is zero or positive to decide which to print
     .center(n*b+1)}                             #centre the text. It will be mapped to the array a.
puts a,a[-b]                                     #a contains the pyramid, minus its last line. Print it, and add the last line
Level River St
fuente
No te olvides de tu bono -5% (llevando tu puntaje a 124). ¡Buen trabajo!
Zach Gates
2

Python 2, 117 (123 bytes)

h,n=map(int,raw_input().split())
p,v='+|'
while h:p+='+'*-~n;v+=' '*n+'|';h-=1;l=~n/-2*h*' ';print l+p+('\n'+l+v)*n
print p

La idea es construir la parte superior de los ladrillos pcomo +++++++++y de lado vcomo | | |. La parte superior comienza como +y es aumentada por n+1 +cada capa. El lado comienza como |y es aumentado porn espacios y a |. Cada capa, aumentamos la parte superior y los lados, luego imprimimos una parte superior y los nlados.

Para centrarlos, primero imprimimos una sangría l. Consiste en una serie de espacios que se escalan con la altura actual h. Para actualizarlo, disminuimos la variable de altura hhasta que golpea 0, después de lo cual la capa actual está al ras contra el borde izquierdo de la pantalla. Imprimimos la parte superior una vez más para hacer la capa inferior, y listo.

xnor
fuente
0

Python 2, 200 (210 - 5%)

a,b=map(int,raw_input().split());c=0;a+=1;i=a*b+a-b;e=[i*'+']
while a-1:
 v=(('|'+' '*b)*a).rstrip();p=' '*((i-len(v))/2);a-=1;c+=1
 for u in range(b):e.insert(0,p+v)
 e.insert(0,p+'+'*len(v))
print'\n'.join(e)

Usé la multiplicación de cuerdas y espacios adicionales despojados.

Puertas de Zach
fuente