Pillole Python: esercizi su cicli annidati.

Spread the love

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 :-)).

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! 🙂

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.