Python mathematisches Verständnisproblem

[psi24]

Hallo,

als Hobby versuche ich mir im Moment Python anzueignen. Bei der Bearbeitung einer Aufgabe stellt sich mir jedoch ein Problem, das eher mathematischer Natur ist bzw. ein Verständnisproblem ist.

Ich will eine Funktion schreiben, die als Parameter einen integer hight entgegen nimmt und dann ein umgekehrtes gleichschenkliges Dreieck mit hight Zeilen im Terminal ausgibt:

Ausgabe für hight = 6:
***********
 *********
  *******
   *****
    ***
     *

Hier ist der Code der Funktion:

# int hight : als Parameter der Funktion die Anzahl der Zeilen (Höhe des Dreiecks)
# int baseLength : Länge der Basis des Dreiecks, keine Puffer-Leerzeichen
# string s : Puffer, der jede Zeile geleert wird und für jede Spalte erweitert wird. 
#Am Ende des for-loops für die Zeile wird er ausgegeben
# int row : Zeile
# int column : Spalte
def sTri(hight):
	baseLength = hight*2 -1
	for row in range(0, hight):
		s = ""
		for column in range(1, baseLength):
			if column <= baseLength - (baseLength - (row*2-1)/2) or column > (baseLength- (row*2-1)/2):
				s += " "
			else:
				s += "*"
		print(s)

Zur Erläuterung:
Ein for-loop geht Zeile für Zeile nach unten und ein for-loop geht innerhalb der Zeile jedes Zeichen bis zur Länge der Basis des Dreiecks durch.
Für jede Spalte wird dann geprüft, ob ein Leerzeichen als Puffer, oder ein * ausgegeben werden muss, damit das Dreieck wie oben ausgegeben wird.

Meine Idee war, dass jede Zeile die Anzahl und Stellen der Puffer-Leerzeichen durch die Differenz der Sternchen der Zeile zu denen in der Basis berechnet werden könnten:

row*2-1# Anzahl der Sternchen in der Zeile row
baseLength - (row*2-1)# Anzahl der Leerzeichen zum Puffern

Die Differenz dann durch 2 sollte die Anzahl und Position für die Puffer am Anfang der Zeile ergeben:

column <= baseLength - (baseLength - (row*2-1)/2)

und die Differenz durch 2 von baseLength abgezogen, die am Ende der Zeile

column > (baseLength- (row*2-1)/2)

Die Ausgabe für 6 ist aber:

**********
**********
 ******** 
  ******  
   ****   
    **    

00000000011
12345678901

Ich verstehe einfach nicht, wo mein Denkfehler liegt, ich habe vier DIN A4 Seiten diese beiden conditions entworfen (traurig genug), und war mir sicher, dass ich es hinbekommen hätte. Eigentlich sollten die ausgegebenen Zeilen eine ungerade Anzahl von Sternchen enthalten, also für sTri(6)
11
9
7
5
3
1

Ich würde die Funktion gerne selber reparieren, aber bin für jeden Hinweis auf mein Verständnisproblem dankbar.

EDIT:
- Klammerfehler verbessert (danke an NullPointer für den Hinweis)
- Berechnung von Hades85

Dieser Code funktioniert jetzt, aber die berechnung erschließt sich mir noch nicht ganz

def sTri(hight):
	baseLength = hight*2
	for row in range(0, hight):
		s = ""
		for column in range(1, baseLength):
			if column <= baseLength - (baseLength - (row*2)/2) or column >= (baseLength- (row*2)/2):
				s += "-"
			else:
				s += "x"
		print(s)

Mit freundlichen Grüßen

psi24

 

[NullPointer]

Ich denke, der Knackpunkt ist, wie Python den Ausdruck (row*2-1)/2 rundet. Prüf das mal nach.

Edit: Angenommen, du benutzt Python 2.*, rundet Python bei der Division von Ganzzahlen ab. D.h. für row=0 ergibt der Ausdruck das Ergebnis -1, für row=1 ergibt er 0 usw. Du willst aber aufrunden. Dafür musst du die Zahlen als Dezimalzahlen dividieren, dann selbst runden und das Ergebnis wieder in eine Ganzzahl umwandeln, z.B. so: math.trunc(math.ceil((row*2.0-1)/2))

 

[DefconDev]

def sTri(hight):
	baseLength = hight*2
	for row in range(0, hight):
		s = ""
		for column in range(0, baseLength):
			if column <= baseLength - (baseLength - (row*2)/2) or column >= (baseLength- (row*2)/2):
				s += " "
			else:
				s += "*"
		print(s)

Ich habe dem Eindruck dass du nicht genau weißt wie viele Schritte deine Schleife macht.
baseLength = hight*2 -1
row*2-1)/2) or column > (baseLength- (row*2-1)/2):

in der äußeren Schleife startest du bei 0 und in der inneren bei 1.!? Macht einfach keinen Sinn.

in range(start, stop, step)
in range(0,10)
er startet bei 0 und zählt bi 9, also 10 Schritte. Das solltest du dir ganz klar vor Augen halten.

 

[0x8100]

ich würde es ohne die schleife über die spalten machen (python3):

def bla(height):
    for i in range (0, height):
        x = (height * 2 - 1) - (i * 2)  # anzahl der * pro zeile
                                        # pro zeile 2 (links+rechts) abziehen
        print(' ' * i, '*' * x)         # leerzeichen abhängig von der zeile
                                        # und * ausgeben

bla(6)

 

[psi24]

@NullPointer:
Ah, daher kommen also die geraden Zahlen in der Ausgabe
Das hätte natürlich

(baseLength - (row*2-1))/2

sein müssen, also die Differenz der beiden ungeraden Zahlen (gerade) / 2
Vielen Dank

@Hades85:
Dass die zweite Schleife mit 1 und nicht mit null beginnt hab eich durch die vorherigen Versuche herausbekommen.
Dein Snippet mit der 0 gibt folgendes aus:

-xxxxxxxxxxx
--xxxxxxxxx-
---xxxxxxx--
----xxxxx---
-----xxx----
------x-----

Also auch in der ersten Zeile ein Pufferzeichen.
Mit der Schleife beginnend bei 1:

xxxxxxxxxxx
-xxxxxxxxx-
--xxxxxxx--
---xxxxx---
----xxx----
-----x-----

Also mit deiner Anpassung der Berechnung funktioniert es. Ich muss nur noch herausfinden, warum meine Berechnung so vermurkst war.

Danke für den Code

Habe meinen jetzt dahingehend verbessert:

def sTri(hight):
	baseLength = hight*2
	for row in range(0, hight):
		s = ""
		for column in range(1, baseLength):
			if column <= baseLength - (baseLength - (row*2)/2) or column >= (baseLength- (row*2)/2):
				s += "-"
			else:
				s += "x"
		print(s)

@0x8100:
Die Herangehensweise muss ich mal genauer unter die Lupe nehmen
Aber vielen Dank für den Code, sieht auf jeden Fall sehr schlank aus
Edit:

Dein Code funktioniert, aber ich verstehe ihn nicht genau.
Ich habe mal die Puffer-Leerzeichen durch - ersetzt, da ich davon ausging, dass dein Code nur vor den Sternchen puffert. Die Ausgab überrascht mich ein wenig:

def bla(height):
	for i in range (0, height):
		x = (height * 2 - 1) - (i * 2)
		print('-' * i, 'x' * x)

 xxxxxxxxxxx
- xxxxxxxxx
-- xxxxxxx
--- xxxxx
---- xxx
----- x

Wo kommen die Leerzeichen her?

 

[0x8100]

das ist das standardverhalten von "print" mit mehreren parametern, kann man aber ändern:

>>> print('a', 'b')
a b
>>> print('a', 'b', sep='')
ab
>>>