Schémas de pyramide

13

Les pyramides mayas étaient (et sont) une partie importante de l'architecture ancienne, qui étaient généralement utilisées à des fins religieuses.

C'étaient généralement des pyramides à degrés, mais les marches sur chacune étaient trop raides pour grimper. Les prêtres grimperaient jusqu'au sommet d'eux via des escaliers alternatifs pour effectuer des cérémonies. Les pyramides ont également été utilisées comme points de repère en raison de leur hauteur, et parfois même utilisées comme lieux de sépulture pour les hauts fonctionnaires.

Le défi

Écrivez un programme qui peut imprimer un schéma pyramidal basé sur les spécifications de l'utilisateur (voir ci-dessous).

Exigences

  • Prenez une entrée de deux variables séparées par des espaces.

  • L'entrée doit être acceptée via STDIN (ou l'alternative la plus proche).

  • La sortie doit être via STDOUT (ou l'alternative la plus proche).

Contribution

  • Hauteur comme tout entier positif. Ceci est utilisé comme largeur du niveau de base (en blocs). Chaque niveau suivant de la pyramide a la largeur n - 1où nest la largeur de l'étage précédent (en blocs).

  • Taille de bloc qui sera 1 ou tout entier positif impair ≤ (inférieur à) 10.

Blocs

La taille de bloc donnée détermine la largeur (et la hauteur) de chaque pièce individuelle. Essentiellement, il y a des i^2espaces à l'intérieur de la boîte visible où iest la taille du bloc.

Un bloc 1x1 ressemblerait à ceci:

+++
| |
+++

Alors qu'un bloc 5x5 ressemblerait à ceci:

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

Blocs adjacents horizontalement

Les blocs côte à côte horizontalement doivent avoir leurs parois centrales fusionnées en une seule.

Vous devez avoir ceci:

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

Au lieu de quelque chose comme ça:

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

Blocs adjacents verticalement (bonus de -5%)

Les blocs verticalement côte à côte ont une exception spéciale: le mur du milieu peut être fusionné en un seul.

Donc, au lieu de blocs 1x1 ressemblant à ceci:

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

Ils pourraient ressembler à ceci:

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

Exemples

Input: 3 1

Output:

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

OR

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

Input: 2 3

Output:

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

OR

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

Tableau d'affichage

Pour être classé sur le tableau de bord, mettez votre réponse dans ce format:

# Language, Score

Ou si vous obtenez le bonus -5%:

# Language, Score (Bytes - 5%)

Votre score n'est qu'un nombre entier. Si votre score est décimal, arrondissez au nombre entier.

Afficher l'extrait de code

code-golf ascii-art geometry Portes Zach
la source
Quelle est l'entrée minimale? 1 1?
mınxomaτ
Oui, ce serait un seul bloc. @minxomat Il est expliqué dans la section "Entrée".
Zach Gates
Que produirait l'apport 3 2?
Hand-E-Food du
Selon la deuxième puce sous la section "Entrée", le deuxième entier d'entrée doit être impair. @ Hand-E-Food Si vous aviez l'intention de demander ce qui se passerait pour une entrée comme 2 3, elle se terminerait quand n - 1 = 0où nest la largeur de l'étage précédent en blocs.
Zach Gates,
@ZachGates, merci! Ne me dérange pas. De toute évidence, le café m'a échoué.
Hand-E-Food

Réponses:

1

Pyth, 45 (47 octets - 5%)

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

Essayez-le ici .

                                                   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
la source
1
+1. Mieux vaut tard que jamais. : P
Zach Gates
11

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

En utilisant des chaînes de modèle, les 2 nouvelles lignes sont significatives et comptées.

Testez l'exécution de l'extrait ci-dessous dans un navigateur EcmaScript 6. Firefox ok, pas Chrome car il ne prend pas en charge l' affectation de la déstructuration .

Code expliqué après l'extrait.

/*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>
Développer l'extrait

Moins de 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
la source
9

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

Avec commentaires

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
la source
N'oubliez pas votre bonus -5% (ce qui porte votre score à 124). Bon travail!
Zach Gates,
2

Python 2, 117 (123 octets)

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'idée est de construire le haut des briques pcomme +++++++++et le côté vcomme | | |. Le sommet commence au fur +et à mesure que n+1 +chaque couche est augmentée . Le côté commence au fur |et à mesure par des nespaces et a |. Chaque couche, nous augmentons les sommets et les côtés, puis imprimons un haut etn côtés.

Pour les centrer, nous imprimons d'abord un tiret l. Il se compose d'un certain nombre d'espaces qui évoluent avec la hauteur actuelle h. Pour le mettre à jour, nous décrémentons la variable de hauteur hjusqu'à ce qu'elle atteigne 0, après quoi le calque actuel affleure le bord gauche de l'écran. Nous imprimons le haut une fois de plus pour faire la couche inférieure, et nous avons terminé.

xnor
la source
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)

J'ai utilisé la multiplication de chaînes et supprimé les espaces supplémentaires.

Portes Zach
la source