Oggi comincerò a pubblicare alcuni esercizi di Python sui cicli. Si assomigliano tutti, ognuno presenta una difficoltà leggeremente diversa, e sono basati sulla geometria. Fondamentalmente l’esercizio è indipendente dal linguaggio usato, è più un esercizio di algoritmi, ma per concisione e immediatezza d’uso ho preferito il Python,
Lo scopo, banale se volete, è quello di disegnare linee e triangoli in modalità testo, ma è un’esercizio che, a fronte di un risultato ludico – il vedere comparire un disegno -, permette di impratichirsi con la corretta valorizzazione delle variabili di ciclo.
È una pratica che fa anche un po’ anni ’80 (per chi ci è passato, e per chi non ci è passato potrà avere un’idea di quanto poco ci bastava per divertirci :-)).
Sommario
Parte I – disegnare diagonali
I primi esercizi sono abbastanza semplici: tutti quanti hanno in comune la stessa struttura: due cicli for annidati e un test per stabiire se stampare un asterisco * o uno spazio. Per ognuno di questi ho riscritto più volte il codice in modo da approdare ad una forma il più simmetrica e concisa possibile (senza fare uso della funzione abs() che qui tornerebbe utile).
Esercizio 1 – disegnare una diagonale TLBR (Top Left Bottom Right)
Per prima cosa aggiungiamo ad ogni file l’intestazione
#!/usr/bin/python N = 10
che dichiara l’interprete da usare per poter invocare il programma come un script da linea di comando:
$ ./diagonals.py
e inizializza a 10 l’ampiezza del pattern da visualizzare.
"""
print TLBR diagonal
*
*
*
*
*
"""
print("TLBR")
# remember: range(N) goes form 0 to N-1
for i in range(N):
for j in range(i + 1):
if j == i:
print('*'),
else:
print(" "),
print(" ") # a capo
Questo è abbastanza semplice: occorre un ciclo esterno per disegnare le righe (uso la variabile i) e uno per scandire le colonne (uso la variabile j)
La condizione che discrimina se stampare uno spazio o un asterisco è che ascisssa i e ordinata j siano uguali.
Finito. Una piccola ottimizzazione: la scansione delle colonne non viene fatta per tutta la riga ma solo fino al raggiungimento della condizione di plot (chiamiamola così).
L’ouput è il seguente
TLBR
*
*
*
*
*
*
*
*
*
*
Esercizio 2: – disegnare una diagonale TRBL (Top Right Bottom Left)
Si tratta semplicemente di disegnare l’atra diagonale del rettangolo:
"""
print TRBL diagonal
*
*
*
*
*
"""
print("TRBL")
for i in range(N):
for j in range(N - i):
if j == N - 1 - i:
print("*"),
else:
print(" "),
print(" ") # a capo
Il risultato è questo
TRBL
*
*
*
*
*
*
*
*
*
* La condizione di plot è che l’indice di colonna sia uguale a N-1 (che è il massimo valore a cui arriva l’indice di riga) meno l’indice di colonna; è il numero di colonne che mancano da quella più a destra. È il duale del precedente in cui l’indice di riga era uguale all’indice di colonna (che è ovviamente il numero di colonne da quella più a sinistra). Quindi scritta così è evidente la simmetria che ci permette per sostituzione di passare da un programma all’altro. Ultima cosa, la scansione della riga non si estende a tutte le colonne ma solo fino alla condizione di plot, come nell’esercizio 1.
Dal punto di vista algebrico, nell’esecizio 1 si implementa il plot della funzione y=x (i = j nel nsotro programma), con il vincolo che l’asse delle y crescenti sia diretto verso il basso.
Nell’esercizio 2 si disegna la funzione y=N-x (i = N-j nel nostro codice), con la medesima convenzione.
Vi lascio anche i riferimenti per le puntate successive:
Fine! 🙂
Commenti recenti