Schemi a piramide

13

Le piramidi Maya erano (e sono) una parte importante dell'architettura antica, che erano generalmente utilizzate per scopi religiosi.

Di solito erano piramidi a gradoni, ma i gradini su ciascuno erano troppo ripidi per salire. I sacerdoti salivano in cima a loro tramite scale alternative per celebrare le cerimonie. Le piramidi venivano anche utilizzate come punti di riferimento a causa della loro altezza e talvolta venivano addirittura utilizzate come siti di sepoltura per funzionari di alto rango.

La sfida

Scrivi un programma in grado di stampare uno schema piramidale basato sulle specifiche dell'utente (vedi sotto).

Requisiti

  • Prendi un input di due variabili separate da spazio.

  • L'ingresso deve essere accettato tramite STDIN (o l'alternativa più vicina).

  • L'output deve essere tramite STDOUT (o l'alternativa più vicina).

Ingresso

  • Altezza come qualsiasi numero intero positivo. Viene utilizzato come larghezza del livello di base (in blocchi). Ogni livello successivo della piramide ha la larghezza in n - 1cui si ntrova la larghezza del piano precedente (in blocchi).

  • Dimensione del blocco che sarà 1 o qualsiasi numero intero dispari e positivo ≤ (minore di) 10.

blocchi

La dimensione del blocco determinata determina la larghezza (e l'altezza) di ogni singolo pezzo. In sostanza, ci sono i^2spazi all'interno del riquadro visibile in cui si itrova la dimensione del blocco.

Un blocco 1x1 sarebbe simile al seguente:

+++
| |
+++

Mentre un blocco 5x5 sarebbe simile al seguente:

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

Blocchi adiacenti orizzontalmente

I blocchi orizzontalmente fianco a fianco devono avere le pareti centrali unite in uno.

È necessario avere questo:

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

Invece di qualcosa del genere:

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

Blocchi adiacenti verticalmente (bonus del -5%)

I blocchi affiancati verticalmente hanno un'eccezione speciale: il muro centrale può essere unito in uno solo.

Quindi, anziché i blocchi 1x1 in questo modo:

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

Essi potrebbero assomigliare a questo:

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

Esempi

Input: 3 1

Output:

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

OR

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

Input: 2 3

Output:

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

OR

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

tabellone segnapunti

Per essere classificato sul tabellone segnapunti, inserisci la tua risposta in questo formato:

# Language, Score

O se ricevi il bonus -5%:

# Language, Score (Bytes - 5%)

Il tuo punteggio è solo un numero intero. Se il tuo punteggio è un decimale, arrotonda per eccesso all'intero numero.

Mostra snippet di codice

code-golf  ascii-art  geometry 
— Zach Gates
fonte
Qual è l'ingresso minimo? 1 1?
— mınxomaτ,
Sì, che sarebbe un singolo blocco. @minxomat È spiegato nella sezione "Input".
— Zach Gates,
Cosa produrrebbe l'input 3 2?
— Hand-E-Food,
Secondo il secondo punto nella sezione "Input", il secondo numero intero di input deve essere dispari. @ Hand-e-Food Se si intende chiedere cosa sarebbe successo per un ingresso come 2 3, sarebbe uscire quando n - 1 = 0, dove nè la larghezza del piano precedente in blocchi.
— Zach Gates,
@ZachGates, grazie! Non importa a me. Chiaramente il caffè mi ha deluso.
— Hand-E-Food

Risposte:

1

Pyth, 45 (47 byte - 5%)

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

Provalo qui .

                                                   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. Meglio tardi che mai. : P
— Zach Gates,
11

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

Utilizzando le stringhe modello, le 2 nuove righe sono significative e contate.

Prova a eseguire lo snippet di seguito in un browser EcmaScript 6. Firefox ok, non Chrome perché manca il supporto per i compiti di destrutturazione .

Codice spiegato dopo lo 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>
Espandi frammento

Meno golfato

[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

Rubino, 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 commenti

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
Non dimenticare il tuo bonus -5% (portando il tuo punteggio a 124). Buon lavoro!
— Zach Gates,
2

Python 2, 117 (123 byte)

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

L'idea è quella di costruire sulla parte superiore dei mattoni pcome +++++++++e laterale vcome | | |. La parte superiore inizia come +ed è aumentata di n+1 +ogni livello. Il lato inizia come |ed è aumentato da nspazi e a |. Ogni strato, aumentiamo le parti superiori e i lati, quindi stampiamo una parte superiore e i nlati.

Per centrarli, stampiamo prima un rientro l. Consiste in un numero di spazi che si ridimensionano con l'altezza corrente h. Per aggiornarlo, stiamo diminuendo la variabile di altezza hfino a quando non colpisce 0, dopodiché il livello corrente è a filo con il bordo sinistro dello schermo. Stampiamo la parte superiore ancora una volta per creare il livello inferiore e il gioco è fatto.

— 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)

Ho usato la moltiplicazione delle stringhe e gli spazi extra messi a nudo.

— Zach Gates
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.