Piramide di asterischi in Python

Piramide di asterischi in Python

Realizziamo in questa lezione una piramide di asterischi in Python, come quella mostrata nella figura sotto, avente come altezza 6 asterischi.

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

Per realizzare il nostro programma, prendiamo innanzitutto in input l’altezza della piramide.

La piramide dell’esempio ha altezza 6 e base 11, immaginiamo dunque che l’utente inserisca 6 alla domanda ‘qual è l’altezza della piramide che vuoi creare?’

Adesso, per risolvere il problema, facciamo le nostre considerazioni.

Innanzitutto notiamo che la prima riga ha un solo asterisco, mentre le altre si incrementano di due asterischi rispetto alla riga precedente.

Gli spazi non sono altro che caratteri vuoti e quelli che ci interessano sono solo quelli prima degli asterischi.

Dunque nella prima riga i primi 5 caratteri sono vuoti, mentre il successivo avrà l’asterisco.

Nella seconda riga invece saranno vuoti i primi 4 caratteri mentre i 3 caratteri successivi avranno l’asterisco. E così via.

In generale vale allora questa regola:

Per il carattere vuoto: (h-i-1) infatti nel primo caso saranno 6-0-1=5 caratteri vuoti, mentre nel secondo caso 6-1-1=4 caratteri vuoti e così via.

Per gli asterischi: (2*i+1) infatti nel primo caso si avrà 2*0+1=1 asterisco, mentre nel secondo caso 2*1+1=3 asterischi e così via.


Ecco allora il nostro algoritmo per costruire una piramide di asterischi in python con un solo ciclo for:

h=int(input(‘Inserisci l\’altezza della piramide: ‘))

for i in range(h):

print(‘ ‘ *(h-i-1) + ‘*’ *(2*i+1))


Oltre a questa soluzione, ne presento un’altra che fa uso di due cicli for annidati:

for i in range(h):

for j in range(h+i):

if (h-j-1>i):

print(‘ ‘, end=”)

else:

print(‘*’, end=”)

print()

In questa lezione abbiamo creato una piramide di asterischi in Python utilizzando uno o due cicli for, nelle prossime lezioni faremo ancora degli esempi sui cicli annidati.

Alcuni link utili

Indice argomenti linguaggio C++

1- Introduzione al linguaggio C++

2- Variabili in C++

3- Operatori di assegnazione in C++

4- Esempi in C++

5- Casting in C++

Successione di Fibonacci in C++

Rettangolo di asterischi

Rettangolo di asterischi

Realizziamo un programma che visualizzi in output un rettangolo di asterischi, prendendo in input la base e l’altezza.

Per realizzare questo algoritmo chiediamo innanzitutto all’utente di inserire la base e l’altezza.

Dopo impostiamo il range del ciclo for esterno con il valore dell’altezza (h) e il range del ciclo for interno con il valore della base.

Quindi all’interno del ciclo interno con la funzione print stampiamo gli asterischi ad ogni iterazione.

Poi all’uscita di ogni ciclo interno andiamo a capo usando semplicemente print().

Ecco dunque il codice completo del rettangolo di asterischi:

b=int(input(‘Base: ‘))

h=int(input(‘Altezza: ‘))

for i in range(h):

for j in range(b):

print(‘*’, end=‘ ‘)

print()

Oppure posso utilizzare anche un solo ciclo for, sempre dopo aver preso in input base e altezza:

for i in range(h):

print(‘* ‘*b)

Cioè moltiplico il carattere asterisco (*) per la base!


Rettangolo di asterischi – cornice

Proviamo adesso a rappresentare un rettangolo di asterischi solo con la cornice esterna.

Anche qui chiediamo di inserire la base e l’altezza all’utente.

Quindi consideriamo che solo la prima e l’ultima riga avranno tutti gli asterischi, cioè se i==0 oppure i==h-1.

Per quanto riguarda le altre righe avranno solo l’asterisco nella prima e nell’ultima colonna, cioè se j==0 oppure j==b-1.

Ecco dunque il codice completo del rettangolo di asterischi realizzato con la sola cornice esterna:

b=int(input(‘Base: ‘))

h=int(input(‘Altezza: ‘))

for i in range(h):

for j in range(b):

if i==0 or i==h-1:

print(‘* ‘, end=)

#asterisco e spazio vuoto all’interno degli apici

elif j==0 or j==b-1:

print(‘* ‘, end=)

#asterisco e spazio vuoto all’interno degli apici

else:

print(‘  ‘, end=) #due spazi vuoti all’interno degli apici

print()

Allo stesso modo:


b = int(input('Base: '))
h = int(input('Altezza: '))

for i in range(h):
    for j in range(b):
        if i == 0 or i == h-1 or j == 0 or j == b-1:
            print('* ', end=' ')
        else:
            print('  ', end=' ') #due spazi vuoti all’interno degli apici
    print()

Quadrato e diagonali

Realizziamo adesso un programma che generi un quadrato di asterischi con le sue diagonali.

Innanzitutto prendiamo in input il lato del quadrato.

Dopo, come nell’esercizio precedente pensiamo di realizzare la cornice inserendo due cicli for annidati.

Calcoliamo adesso le due diagonali.

Partiamo prima dalla diagonale principale.

Per capire come ricavarla facciamo un esempio.

Consideriamo ad esempio un quadrato di lato 6. Allora la diagonale principale sarà data dagli elementi (0,0), (1,1), (2, 2), (3,3), (4,4), (5,5).

Quindi la diagonale principale sarà caratterizzata dal fatto che i e j sono uguali.

Adesso calcoliamo la diagonale secondaria.

La diagonale secondaria è data dagli elementi: (0, 5), (1, 4), (2,3), (3, 2), (4, 1), (5,0).

Facciamo attenzione all’elemento j, noteremo che osserva questa regola:

j=n-i-1

Infatti, nel primo caso i=0 e j=6-0-1=5 quindi (0,5)

Secondo caso i=1 e j=6-1-1=4 quindi (1,4)

Terzo caso i=2 e j=6-1-2=3 quindi (2,3)

Quarto caso i=3 e j=6-1-3=2 quindi (3,2)

Quinto caso i=4 e j=6-1-4=1 quindi (4,1)

Infine nel sesto caso i=5 e j=6-1-5=0 quindi (5,0)

Approfondiremo questo discorso delle diagonali quando parleremo delle matrici.

A questo punto diventa semplice costruire il nostro algoritmo utilizzando due cicli for annidati.

Ecco dunque il codice completo:

lato=int(input(‘lato: ‘))

for i in range(lato):

for j in range(lato):

if i==0 or i==lato-1:

print(‘* ‘, end=)

elif j==0 or j==lato-1:

print(‘* ‘, end=)

elif j==i or j==lato-1-i: #elementi diagonali

print(‘* ‘, end=)

else:

print(‘ ‘, end=)

print()

Possiamo anche scrivere:


lato = int(input('lato: '))

for i in range(lato):
    for j in range(lato):
        if i == 0 or i == lato-1 or j == 0 or j == lato-1 or j == i or j == lato-1-i:
            print('*', end='')
        else:
            print(' ', end='')

    print()

In questa lezione abbiamo disegnato un rettangolo di asterischi e un quadrato con la sua diagonale, questi sono solo alcuni esempi d’uso dei cicli for in Python, presto ne farò degli altri.

Proviamo a scrivere il codice nell’editor sotto:

Alcuni link utili

Indice tutorial sul linguaggio Python

1 – Introduzione al linguaggio Python

2 – Le variabili

3 – Operatori aritmetici e di assegnazione

4 – Stringhe

5 – Casting

6 – Input e print

7 – Primi esercizi in Python

8 – Errori in Python

9 – Script Python

10 – Scambio di variabili

11 – Modulo math

Metodo append in Python

Metodo append in Python

In questa lezione realizziamo altri esercizi che utilizzano il metodo append in Python.

In particolare impareremo a popolare le liste con dei numeri primi.


Esercizio con il metodo append in Python

Il primo esercizio che propongo è dunque questo:

Creare una lista di n numeri primi. Dopo visualizzare in output gli elementi ed il suo indice.

Innanzitutto occorre chiedere la quantità di numeri primi da inserire nella lista, cioè n.

Dopo inizializziamo la lista primi all’insieme vuoto ed N, cioè il numero da cui partire per verificare se è primo, a 2. Difatti sappiamo che 1 non è primo, dunque lo tralasciamo.

Abbiamo già discusso come trovare i numeri primi nel seguente articolo: numeri primi in Python.

In definitiva basta prendere ciascun numero (come detto prima si parte da 2) e verificare che non ci siano divisori.

Se non ci sono divisori allora si memorizza il numero nella lista.

Quindi continuiamo ad inserire i numeri nella lista finché la lunghezza della lista non raggiunge il numero immesso in input, cioè n.

In poche parole compio i seguenti passi:

parto da 2 e controllo se è primo, lo è quindi lo aggiungo alla lista;

dopo incremento 2 di 1 e quindi considero 3, è primo e dunque lo aggiungo alla lista;

poi considero 4, non è primo e quindi non lo aggiungo alla lista.

E così via.

Mi fermo quando raggiungo esattamente la quantità di numeri primi da aggiungere alla lista.

Ecco dunque l’esercizio sui numeri primi sviluppato con il metodo append in Python:


n = int(input('Inserisci la quantità n: '))
primi = []
N = 2 #parto da due perché 1 non è un numero primo
while len(primi) < n:  #finché la lunghezza della lista primi è minore di n
    div,count = 2,0    #div divide il numero, mentre count conta i divisori
    while div <= N/2 and count == 0:
        if N%div == 0:
            count += 1
        div += 1
    if count == 0:
        primi.append(N)    #se il numero non ha divisori allora lo aggiungiamo
    N += 1 #procediamo con un altro numero
#visualizziamo gli elementi ed il loro indice
for i in range(n):
    print('elemento di indice', i, ' vale ', primi[i])

Secondo esempio

Inserire i primi n numeri primi in una lista con un ciclo for. Dopo con un ciclo for modificare gli elementi di posto pari moltiplicandoli per 3. Infine utilizzare un altro ciclo per visualizzare gli elementi della lista e il loro indice.

Per sviluppare questo algoritmo, occorre semplicemente aggiungere all'esercizio precedente un altro ciclo. Questo ciclo prende gli elementi di posto pari e li moltiplica per 3. Infine si visualizza la lista modificata.

Ecco dunque il codice completo:


n = int(input('Inserisci la quantità n: '))
primi = []
N = 2
while len(primi) < n:
    div,count = 2,0
    while div <= N/2 and count == 0:
        if N%div == 0:
            count += 1
        div += 1
    if count == 0:
        primi.append(N)
    N += 1
for i in range(n):
    if i%2 == 0:
        primi[i] *= 3
        
for i in range(n):
    print('elemento di indice', i, ' vale ', primi[i])

Prova nell'editor:

Alcuni link utili

Indice tutorial sul linguaggio Python

1 – Introduzione al linguaggio Python

2 – Le variabili in python

3 – Operatori aritmetici e di assegnazione in python

4 – Stringhe in python

5 – Casting in python

6 – Input e print in python

7 – Primi esercizi in python

8 – Errori in python

9 – Script python

10 – Scambio di variabili in python

Cicli for annidati in Python

Cicli for annidati in Python

In questa lezione impareremo ad utilizzare i cicli for annidati in Python, ovvero le iterazioni eseguite dentro altre iterazioni.

Facciamo dunque degli esempi per capire il loro funzionamento.

Esempio sui cicli for annidati in Python

Produrre un rettangolo di asterischi di base 4 asterischi e altezza 3.

L’output dovrà essere dunque questo:

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

Per realizzare ciò usiamo due cicli, uno esterno ed uno interno.

Due cicli for annidati richiedono contatori diversi, indichiamo con i il contatore del primo ciclo, mentre con j il contatore del secondo ciclo.

Quindi, in questo caso, il ciclo esterno verrà ripetuto tre volte, mentre quello interno quattro volte per ogni ciclo esterno.

Ecco di seguito il codice completo:

for i in range(3):

for j in range(4):

print(‘*’, end=‘ ‘)

print()

Utilizziamo la keyword end all’interno del print per inserire gli asterischi sulla stessa riga e dunque evitare di andare a capo.

Mentre l’ultimo print() serve semplicemente per andare a capo, dopo aver stampato ciascuna riga.

Spieghiamo dunque passo passo cosa succede:

Prima iterazione del ciclo esterno: i=0

Prima iterazione del ciclo interno: j=0  stampa l’asterisco seguito dallo spazio vuoto.

Seconda iterazione del ciclo interno: j=1  stampa un altro asterisco seguito dallo spazio vuoto.

Terza iterazione del ciclo interno: j=2  stampa un asterisco seguito dallo spazio vuoto.

Quarta iterazione del ciclo interno: j=3  stampa un asterisco seguito dallo spazio vuoto.

Seconda iterazione del ciclo esterno: i=1

Si procede analogamente a quanto detto prima.

Per provare quanto spiegato provate a sostituire gli asterischi ai valori di i e j, inserendo al posto di print(‘*’, end=’ ‘) il codice indicato sotto:

print(‘i:’,i,‘j:’,j, end=‘ ‘)

Ma attenzione! Lo stesso rettangolo si poteva realizzare con un solo ciclo for, semplicemente moltiplicando il carattere asterisco (*) 4 volte per ogni riga.

for i in range(3):

print(‘* ‘*4)


Disponibile il libro su Python “50 Algoritmi per imparare Python”

Secondo esempio sui cicli for

Variamo l’esercizio precedente producendo adesso un rettangolo con i numeri da 1 a 4.

Cioè l’output deve essere questo:

1 2 3 4
1 2 3 4
1 2 3 4

Dobbiamo cambiare solo il ciclo interno, impostando nel range i valori (1,5).

Dopo, ad ogni iterazione del ciclo interno stampiamo l’indice j.

Ecco dunque il codice:

for i in range(3):

for j in range(1,5):

print(j, end=‘ ‘)

print()


Terzo esempio

Adesso stampiamo i numeri in ordine decrescente, dunque variamo l’esempio precedente in modo da avere il seguente output:

4 3 2 1
4 3 2 1
4 3 2 1

Per stampare i numeri in ordine decrescente possiamo cambiare il range in modo tale che j varia da 4 a 1 con step di -1.

Ecco dunque il codice completo:

for i in range(3):

for j in range(4,0,-1):

print(j, end=‘ ‘)

print()

Disponibile il libro su Python “50 Algoritmi per imparare Python”

Quarto esempio cicli for

Vogliamo adesso realizzare un altro esempio utilizzando due cicli for annidati, come l’esempio sotto:

1234567
123456
12345
1234
123
12
1

Basta stampare j e di volta in volta diminuire di 1 il numero di righe:

n=7
for i in range(n):
    for j in range(1,n+1-i):
        print(j, end='')
    print()

Quinto esempio

Realizziamo un altro esempio:

7654321
654321
54321
4321
321
21
1
n=7
for i in range(n):
    for j in range(n-i,0, -1):
        print(j, end='')
    print()

Sesto esempio

Realizziamo adesso un esempio come questo:

1
21
321
4321
54321
654321
7654321
n=7
for i in range(1,n+1):
    for j in range(i,0, -1):
        print(j, end='')
    print()

Settimo esempio

Realizziamo una figura come questa:

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

Prima soluzione:

n=5
for i in range(1,n*2):
    if i<=n:
        for j in range(i,0, -1):
            print('*', end='')
    else:
         for j in range(1,n*2+1-i):
            print('*', end='')
        
    print()

Il ciclo esterno stamperà le nove righe. Infatti i varia da 1 a 9.

All’interno del ciclo se i <=5 realizziamo un altro ciclo for che stamperà la prima volta 1 asterisco, poi 2, ecc…fino ad arrivare a 5.

Infatti alla prima iterazione i vale 1, alla successiva 2 e così via fino a i=5.

for j in range(i,0, -1):

print(‘*’, end=”)

Quando i sarà uguale a 5 si farà quanto scritto nell’else e quindi l’altro ciclo for che stamperà n*2-i asterischi. La prima volta n*2-i=10-6 cioè 4 asterischi, la seconda n*2-i=10-7 cioè 3 e così via.

Seconda soluzione semplificata con due cicli for:

n=5
for i in range(1,n*2):
        for j in range(1,n+1):
            if i<=n and j<=i:
                print('*', end='')
            elif i>n and j<n*2+1-i:
                print('*', end='')
                
        print()

Terza soluzione con gli operatori logici

n=5
for i in range(1,n*2):
        for j in range(1,n+1):
            if i<=n and j<=i or i>n and j<n*2+1-i:
                print('*', end='')
                
        print()

Disponibile il libro su Python “50 Algoritmi per imparare Python”

Alcuni link utili

Indice tutorial sul linguaggio Python

1 – Introduzione al linguaggio Python

2 – Le variabili

3 – Operatori aritmetici e di assegnazione

4 – Stringhe

5 – Casting

6 – Input e print

7 – Primi esercizi in Python

8 – Errori in Python

9 – Script Python

10 – Scambio di variabili

11 – Modulo math

for annidati

for annidati

Esercitiamoci con i for annidati, al fine di approfondire l’argomento.

Primo esercizio sui for annidati

Realizzare un programma in C++, che visualizzi 6 righe dove ciascuna riga contiene i numeri da 1 a 6, come da esempio sotto:
1 2 3 4 5 6
1 2 3 4 5 6
1 2 3 4 5 6
1 2 3 4 5 6
1 2 3 4 5 6
1 2 3 4 5 6

Realizzare questo algoritmo è piuttosto semplice.

Innanzitutto inizializziamo le due variabili contatore i e j e la costante n.

Poi realizziamo i due cicli for annidati e per ogni iterazione del ciclo esterno eseguiamo un ciclo interno da 1 a 6, che di volta in volta stampa il valore di j.

#include <iostream>
using namespace std;

main(){
	int i,j,n;
        n=6;
	
	for(i=1;i<=n;i++) {
		for(j=1;j<=n;j++)
			cout<<"\t"<<j;		
		cout<<endl;
	}
         return 0;
}

Modifichiamo adesso il programma proponendo un secondo esempio.

Secondo esempio

Realizziamo un programma in C++, che visualizzi 6 righe così come da esempio:
1 2 3 4 5 6
2 3 4 5 6
3 4 5 6
4 5 6
5 6
6

Innanzitutto dichiariamo le variabili i, j ed n. Dopo utilizziamo i due cicli for annidati. Il primo lo facciamo partire da 0 fino ad n-1, mentre il secondo da j ad n-i, così ogni volta sommiamo i + j.

Stampiamo così il risultato ad ogni iterazione del ciclo interno.

Ecco di seguito la possibile soluzione:

#include <iostream>
using namespace std;

main(){
	int i,j,n;
        n=6;
	
	for(i=0;i<n;i++) {
		for(j=1;j<=n-i;j++){
				cout<<"\t"<<j+i;
		}
		cout<<endl;
	}
        return 0;
}

Terzo esempio

Variamo l’esercizio precedente, producendo l’output come da esempio:
1 2 3 4 5 6
2 3 4 5 6 +
3 4 5 6 + +
4 5 6 + + +
5 6 + + + +
6 + + + + +

Cioè facciamo in modo da far apparire un simbolo al posto dei caratteri mancanti. Basta modificare il ciclo interno impostando j<=n e all’interno del ciclo controllare se j<=n-i allora stampare j+i, altrimenti stampare il carattere +.

Ecco dunque il codice di esempio:

#include <iostream>
using namespace std;

main(){
	int i,j,n,c;
        n=6;
	
	for(i=0;i<n;i++) {
		for(j=1;j<=n;j++){
			if(j<=n-i)
				cout<<"\t"<<j+i;
			else
				cout<<"\t"<<"+";
		}
		cout<<endl;
	}
        return 0;
}

Questi sono alcuni esempi sui cicli for annidati, nelle prossime lezioni proporrò tanti altri esempi.

Alcuni link utili

Indice argomenti linguaggio C++

1- Introduzione al linguaggio C++

2- Variabili in C++

3- Operatori di assegnazione in C++

4- Esempi in C++

5- Casting in C++

Successione di Fibonacci in C++