Esquemas de pirâmide

13

As pirâmides maias eram (e são) uma parte importante da arquitetura antiga, que geralmente era usada para fins religiosos.

Geralmente eram pirâmides de degraus, mas os degraus de cada uma eram íngremes demais para subir. Os padres subiam ao topo deles através de escadas alternativas para realizar cerimônias. As pirâmides também foram usadas como pontos de referência por causa de sua altura, e às vezes até usadas como locais de sepultamento para oficiais de alto escalão.

O desafio

Escreva um programa que possa imprimir um esquema de pirâmide com base nas especificações do usuário (veja abaixo).

Exigências

  • Faça uma entrada de duas variáveis ​​separadas por espaço.

  • A entrada deve ser aceita através do STDIN (ou alternativa mais próxima).

  • A saída deve ser através de STDOUT (ou alternativa mais próxima).

Entrada

  • Altura como qualquer número inteiro positivo. Isso é usado como a largura do nível base (em blocos). Cada nível subsequente da pirâmide tem a largura n - 1onde né a largura do piso anterior (em blocos).

  • Tamanho do bloco que será 1 ou qualquer número inteiro positivo, ímpar ≤ (menor que) 10.

Blocos

O tamanho do bloco determinado determina a largura (e a altura) de cada peça individual. Essencialmente, existem i^2espaços dentro da caixa visível, onde iestá o tamanho do bloco.

Um bloco 1x1 ficaria assim:

+++
| |
+++

Enquanto um bloco 5x5 ficaria assim:

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

Blocos horizontalmente adjacentes

Os blocos horizontalmente lado a lado devem ter suas paredes do meio fundidas em uma.

Você deve ter isso:

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

Em vez de algo como isto:

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

Blocos verticalmente adjacentes (bônus de -5%)

Blocos lado a lado verticalmente têm uma exceção especial: a parede do meio pode ser mesclada em uma.

Então, em vez de blocos 1x1 parecidos com este:

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

Eles poderiam ficar assim:

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

Exemplos

Input: 3 1

Output:

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

OR

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

Input: 2 3

Output:

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

OR

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

Placar

Para ser classificado no placar, coloque sua resposta neste formato:

# Language, Score

Ou se você receber o bônus -5%:

# Language, Score (Bytes - 5%)

Sua pontuação é apenas um número inteiro. Se sua pontuação for decimal, arredondar para o número inteiro.

Mostrar snippet de código

code-golf ascii-art geometry Zach Gates
fonte
Qual é a entrada mínima? 1 1?
mınxomaτ
Sim, o que seria um único bloco. @minxomat É explicado na seção "Entrada".
Zach Gates
O que a entrada 3 2produziria?
Hand-E-Food
De acordo com o segundo marcador na seção "Entrada", o segundo número inteiro de entrada deve ser ímpar. @ Mão-E-Food Se você queria perguntar o que aconteceria para uma entrada como 2 3, seria sair quando n - 1 = 0, onde né a largura do piso anterior em blocos.
Zach Gates
@ZachGates, obrigado! Não se importe comigo. Claramente o café falhou comigo.
Hand-E-Food

Respostas:

1

Pitão, 45 (47 bytes - 5%)

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

Experimente aqui .

                                                   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
fonte
1
+1. Antes tarde do que nunca. : P
Zach Gates
11

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

Usando seqüências de modelo, as duas novas linhas são significativas e contadas.

Teste a execução do trecho abaixo em um navegador EcmaScript 6. Firefox ok, não Chrome, porque falta suporte para a atribuição de desestruturação .

Código explicado após o snippet.

/*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 snippet

Menos Golfe

[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
fonte
9

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

Com comentários

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
fonte
Não se esqueça do seu bônus -5% (elevando sua pontuação para 124). Bom trabalho!
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

A idéia é construir em cima dos tijolos pcomo +++++++++e lateral vcomo | | |. A parte superior começa como +e é aumentada por n+1 +cada camada. O lado começa como |e é aumentado por nespaços e a |. Cada camada, aumentamos as partes superior e lateral, depois imprimimos uma parte superior en laterais.

Para centralizá-los, primeiro imprimimos um recuo l. Consiste em vários espaços que escalam com a altura atual h. Para atualizá-lo, diminuímos a variável height haté que ela atinja 0, após o que a camada atual é nivelada contra a borda esquerda da tela. Imprimimos a parte superior mais uma vez para formar a camada inferior e pronto.

xnor
fonte
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)

Eu usei a multiplicação de strings e removi espaços extras.

Zach Gates
fonte