Pyramidenschemata

13

Mayapyramiden waren (und sind) ein wichtiger Bestandteil der antiken Architektur, die im Allgemeinen für religiöse Zwecke verwendet wurden.

Es waren normalerweise Stufenpyramiden, aber die Stufen waren zu steil, um zu klettern. Die Priester erklommen sie über alternative Treppen, um Zeremonien abzuhalten. Die Pyramiden wurden aufgrund ihrer Größe auch als Wahrzeichen und manchmal sogar als Grabstätten für hochrangige Beamte genutzt.

Die Herausforderung

Schreiben Sie ein Programm, mit dem ein Pyramidenschema auf der Grundlage der Benutzerspezifikationen ausgedruckt werden kann (siehe unten).

Bedarf

  • Nehmen Sie eine Eingabe von zwei durch Leerzeichen getrennten Variablen vor.

  • Die Eingabe muss über STDIN (oder die nächstgelegene Alternative) akzeptiert werden.

  • Die Ausgabe muss über STDOUT (oder die nächstgelegene Alternative) erfolgen.

Eingang

  • Höhe als positive ganze Zahl. Dies wird als Breite der Basisebene (in Blöcken) verwendet. Jede nachfolgende Stufe der Pyramide hat die Breite , n - 1wo nwird die vorherige Bodenbreite (in Blöcken).

  • Blockgröße, die 1 oder eine ungerade positive ganze Zahl ≤ (kleiner als) 10 ist.

Blöcke

Die angegebene Blockgröße bestimmt die Breite (und Höhe) jedes einzelnen Stücks. Im Wesentlichen gibt es i^2innerhalb des sichtbaren Kastens Leerzeichen, in denen idie Blockgröße angegeben ist.

Ein 1x1 Block würde so aussehen:

+++
| |
+++

Während ein 5x5-Block so aussehen würde:

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

Horizontal benachbarte Blöcke

Bei horizontal nebeneinander angeordneten Blöcken müssen die Mittelwände zu einer einzigen zusammengeführt werden.

Das musst du haben:

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

Anstelle von so etwas:

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

Vertikal benachbarte Blöcke (-5% Bonus)

Vertikal nebeneinander liegende Blöcke haben eine besondere Ausnahme: Die Mittelwand kann zu einer zusammengefügt werden.

Also, anstelle von 1x1 Blöcken sieht das so aus:

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

Sie könnten so aussehen:

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

Beispiele

Input: 3 1

Output:

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

OR

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

Input: 2 3

Output:

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

OR

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

Anzeigetafel

Geben Sie Ihre Antwort in das folgende Format ein, um in die Rangliste aufgenommen zu werden:

# Language, Score

Oder wenn Sie den Bonus -5% bekommen:

# Language, Score (Bytes - 5%)

Ihre Punktzahl ist nur eine ganze Zahl. Wenn Ihre Punktzahl eine Dezimalzahl ist, runden Sie auf die ganze Zahl auf.

Code-Snippet anzeigen

code-golf  ascii-art  geometry 
— Zach Gates
quelle
Was ist die minimale Eingabe? 1 1?
— Mittwoch,
Ja, das wäre ein einzelner Block. @minxomat Wird im Abschnitt "Eingabe" erklärt.
— Zach Gates
Was würde der Input 3 2bewirken?
— Hand-E-Food
Gemäß dem zweiten Aufzählungszeichen im Abschnitt "Input" muss die zweite Ganzzahl ungerade sein. @ Hand-E-Food Wenn Sie fragen wollten, was für eine Eingabe wie passieren würde, 2 3würde es verlassen, wenn n - 1 = 0wo ndie Breite der vorherigen Etage in Blöcken ist.
— Zach Gates
@ ZachGates, danke! Stört mich nicht Offensichtlich hat der Kaffee bei mir versagt.
— Hand-E-Food

Antworten:

1

Pyth, 45 (47 Bytes - 5%)

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

Probieren Sie es hier aus .

                                                   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
quelle
1
+1. Besser spät als nie. : P
— Zach Gates
11

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

Unter Verwendung von Vorlagenzeichenfolgen werden die 2 Zeilenumbrüche signifikant und gezählt.

Testen Sie das folgende Snippet in einem EcmaScript 6-Browser. Firefox ok, nicht Chrome, da es keine Unterstützung für die Destrukturierung gibt .

Code nach dem Snippet erklärt.

/*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>
Erweitern Sie das Snippet

Weniger 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
quelle
9

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

Mit Kommentaren

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
quelle
Vergessen Sie nicht Ihren Bonus von -5% (bringen Sie Ihre Punktzahl auf 124). Gute Arbeit!
— 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

Die Idee ist , der Ziegel oben aufzubauen pwie +++++++++und Seite vwie | | |. Die Oberseite beginnt wie +folgt und wird um n+1 +jede Ebene erweitert. Die Seite beginnt als| und wird durch nLeerzeichen und a ergänzt |. Jede Schicht, wir erweitern die Oberseiten und Seiten, dann drucken wir eine Oberseite und nSeiten.

Um sie zu zentrieren, drucken wir zuerst einen Einzug l. Es besteht aus einer Reihe von Räumen, die mit der aktuellen Höhe skaliert werden h. Um es zu aktualisieren, dekrementieren wir die Höhenvariable, hbis es trifft 0, wonach die aktuelle Ebene bündig mit dem linken Rand des Bildschirms abschließt. Wir drucken die Oberseite noch einmal, um die untere Ebene zu erstellen, und fertig.

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

Ich habe die String-Multiplikation verwendet und zusätzliche Leerzeichen entfernt.

— Zach Gates
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.