In questa lezione realizzeremo la tavola pitagorica in linguaggio C++, in modo da applicare i cicli for annidati che abbiamo studiato nelle precedenti lezioni.
La tavola pitagorica è utilizzata in ambito scolastico per imparare le tabelline e ha, di solito, 10 righe e 10 colonne. Ciascuna riga o colonna viene detta tabellina.
Mi ricordo che nei miei vecchi quaderni di scuola si trovava nell’ultima pagina ed era formata da 12 righe e 12 colonne. Quindi l’ultima tabellina era quella del 12.
Ho già presentato un esempio della tavola pitagorica in C, utilizzando le matrici, visibile al link tavola pitagorica in C. Infatti una tavola pitagorica è una matrice di numeri naturali.
Ma in questa lezione vi propongo una soluzione molto semplice che fa un uso indiretto delle matrici, che affronteremo andando avanti nel tutorial.
Realizziamo una tavola pitagorica di 10 righe e 10 colonne che visualizzi le tabelline dall’1 al 10.
Innanzitutto dichiariamo le variabili i e j e la costante n, pari a 10, perché 10 sono sia le righe che le colonne.
Dopo, per risolvere questo algoritmo, utilizzeremo due cicli for annidati, un ciclo esterno e uno interno che vanno da 1 a 10.
Poi, ad ogni ciclo esterno moltiplicheremo il contatore del ciclo esterno per quello del ciclo interno che varia da 1 a 10.
Cioè essendo i l’indice del ciclo esterno e j l’indice del ciclo interno, moltiplicheremo i x j:
Prima iterazione ciclo esterno i=1:
prima iterazione ciclo interno j=1: 1 x 1 = 1
seconda iterazione ciclo interno j=2: 1 x 2 = 2
terza iterazione ciclo interno j=3: 1 x 3 = 3
quarta iterazione ciclo interno j=4: 1 x 4 = 4
quinta iterazione ciclo interno j=5: 1 x 5 = 5
sesta iterazione ciclo interno j=6: 1 x 6 = 6
settima iterazione ciclo interno j=7: 1 x 7 = 7
ottava iterazione ciclo interno j=8: 1 x 8 = 8
nona iterazione ciclo interno j=9: 1 x 9 = 9
decima iterazione ciclo interno j=10: 1 x 10 = 10
Utilizziamo dunque endlper andare a capo e procediamo con la seconda iterazione del ciclo esterno dove i questa volta è uguale a 2 e j assumerà nuovamente i valori da 1 a 10.
Ecco dunque il codice che realizza la tavola pitagorica:
#include <iostream>
using namespace std;
main(){
int i,j;
const int n=10;
for(i=1;i<=n;i++) {
for(j=1;j<=n;j++)
cout<<"\t"<<i*j;
cout<<endl;
}
return 0;
}
In questo breve articolo parleremo dei JavaScript canvas, cioè uno strumento utile per tracciare linee, disegni, immagini e figure geometriche all’interno di una pagina web.
Quindi facciamo una precisazione: canvas è un tag introdotto con HTML5 e può essere utilizzato per disegnare, quanto detto sopra, utilizzando un linguaggio di script.
Esempio 1 di utilizzo di JavaScript Canvas
Facciamo quindi un esempio di utilizzo dei canvas con JavaScript.
Disegneremo un arco di circonferenza al clic del pulsante crea arco.
Per creare questo esempio innanzitutto creo il mio pulsante, che richiama la funzione creaF() al verificarsi dell’evento onclick().
Dopo creo l’area dove comparirà il disegno, aggiungendo un messaggio di avviso per i browser che non supportano i canvas.
<canvas id="disegno" width="400" height="100">
Spiacente non supporto i canvas di HTML5 </canvas>
Poi realizzo il codice per creare il semicerchio.
Dapprima rendiamo disponibile l’oggetto disegno in JavaScript e lo facciamo in questo modo:
var disegno=document.getElementById('disegno');
var context=disegno.getContext('2d');
In definitiva sto specificando il contesto 2d ovvero a due dimensioni, escludendo cioè la coordinata Z della terza dimensione.
Imposto anche lo spessore della linea utilizzando il metodo lineWidth che di default setta lo spessore a 1.
context.lineWidth=5;
Poi devo disegnare un arco di circonferenza che va da 0° a 180°, cioè appunto una semicirconferenza e per farlo utilizzo il metodo arc() e specifico alcuni valori:
Innanzitutto le coordinate dove creare la semicirconferenza (100,100);
Quindi il raggio (50);
A seguire l’angolo di partenza uguale a 0° e l’angolo di arrivo uguale a 180° e per rappresentarlo utilizzo la funzione predefinita Math.PI.
Infine il senso antiorario utilizzando true.
context.arc(100,100,50,0,Math.PI,true);
Poi con il metodo stroke() disegno la linea e utilizzando anche strokeStyle() dò un colore alla linea, che di default è nera.
#include <iostream>
using namespace std;
int main() {
int i, j;
const int h = 4;
for (i = 0; i < h; i++) {
for (j = 0; j < 1 + i; j++) {
cout << " * ";
}
cout << endl;
}
return 0;
}
Nella prima iterazione del ciclo esterno:
i=0 Nel ciclo interno j verrà incrementato di 1, una volta (j=0), poiché nell’iterazione successiva j diventerebbe 1 e la condizione 1<1+i non è più verificata. Quindi stamperà *
La seconda iterazione del ciclo esterno porterà:
i=1 e nel ciclo interno j verrà incrementato due volte di 1 (j=0, j=1), quindi stamperà * *
Nella terza iterazione del ciclo esterno:
i=2 e j verrà incrementato tre volte di 1 (j=0, j=1,j=2), quindi stamperà * * *
Nella quarta iterazione del ciclo esterno:
i=3 e j verrà incrementato di 1, tre volte (j=0, j=1, j=2,j=3), quindi stamperà * * * *
Il ciclo termina perché i diventa 4 e la condizione i<4 non è più verificata.
Dunque il risultato sarà dunque, un triangolo rettangolo di asterischi:
* * * * * * * * * *
Terzo esempio
Produrre un programma che mostri un triangolo rettangolo di asterischi avente come altezza 4, come da figura sotto:
****
***
**
*
Quindi intuiamo che il ciclo più esterno deve essere sempre eseguito 4 volte mentre quello più interno questa volta dobbiamo iniziare da h-i, ovvero da destra e decrementare j di volta in volta.
#include <iostream>
using namespace std;
int main() {
int i, j;
const int h = 4;
// Stampare un triangolo rettangolo rovesciato con asterischi
for (i = 0; i < h; i++) {
for (j = h - i; j > 0; j--) {
cout << "*";
}
cout << endl;
}
return 0;
}
Produrre un programma che mostri una figura come quella sotto:
*******
*****
***
*
*
***
*****
*******
#include <iostream>
using namespace std;
int main() {
int i, j, n;
n = 8;
for (i = 0; i < n; i++) {
for (j = 1; j <= n; j++) {
if (j < n - i && j > i || j <= i && j >= n - i) {
cout << "*";
} else {
cout << " ";
}
}
cout << endl;
}
return 0;
}
Quinto esempio
Produrre un programma che mostri una figura come quella sotto:
* *
** **
*** ***
**** ****
*** ***
** **
* *
#include <iostream>
using namespace std;
int main() {
int i, j, n;
n = 8;
for (i = 0; i < n; i++) {
for (j = 0; j <= n; j++) {
if (j <= n - i && j >= i || j >= i && j <= n - i) {
cout << " ";
} else {
cout << "*";
}
}
cout << endl;
}
return 0;
}
Sesto esempio
Variamo ancora la figura da creare, creando un triangolo isoscele.
Produrre un programma che mostri un triangolo isoscele di asterischi avente come base 9, come da figura sotto:
*
***
*****
*******
*********
#include <iostream>
using namespace std;
int main() {
int i, j, x;
const int n = 9;
x = n / 2 + 1; // Troviamo l'altezza
// Stampare una piramide di asterischi
for (i = 0; i < x; i++) {
for (j = 0; j < x + i; j++) {
if (x - j - 1 > i) {
cout << " ";
} else {
cout << "*";
}
}
cout << endl;
}
return 0;
}
Poniamo x uguale alla metà della base più 1, ottenendo in questo caso 5 che rappresenta la nostra altezza.
Poi inseriamo i due cicli for. Il ciclo esterno va da 0 ad x-1, il ciclo interno da 0 a x+i-1. Il ciclo interno verrà eseguito una volta in più ad ogni iterazione del ciclo esterno. Quindi esaminiamo nel dettaglio le iterazioni.
Prima iterazione ciclo esterno:
i=0 Nel ciclo interno j è incrementato di 1, cinque volte (j=0, j=1,j=2, j=3, j=4). Ogni volta si controlla se questa condizione è vera x-j-1>i e dunque si stampa il carattere vuoto, altrimenti si stampa l’asterisco.
5-0-1>0 cioè 4>0 vera spazio bianco
5-1-1>0 cioè 3>0 vera spazio bianco
5-2-1>0 cioè 2>0 vera spazio bianco
5-3-1>0 cioè 1>0 vera spazio bianco
5-4-1>0 cioè 0>0 falsa asterisco
Quindi stamperà 4 spazi bianchi e un *
Seconda iterazione ciclo esterno:
i=1 Sempre nel ciclo interno j riparte da 0 ed è incrementato di 1, sei volte. Analizziamo anche questa volta la condizione x-j-1>i
5-0-1>1 cioè 4>1 spazio bianco
5-1-1>1 cioè 3>1 spazio bianco
5-2-1>1 cioè 2>1 spazio bianco
5-3-1>1 cioè 1>1 asterisco
5-4-1>1 cioè 0>1 asterisco
5-5-1>1 cioè -1>1 asterisco
Quindi stamperà tre spazi bianchi e tre * * *
E così via! In output visualizzeremo un triangolo isoscele.
Analogamente potevamo anche ragionare in questo modo:
#include <iostream>
using namespace std;
int main() {
int i, j, x;
const int n = 9;
x = n / 2;
// Stampare una piramide rovesciata di asterischi
for (i = 0; i <= x; i++) {
for (j = 0; j <= x + i; j++) {
if (j > x - i - 1) {
cout << "*";
} else {
cout << " ";
}
}
cout << endl;
}
return 0;
}
#include <iostream>
using namespace std;
int main() {
int i, j, x;
const int n = 9;
x = n / 2;
// Stampare un diamante di asterischi
for (i = 0; i <= n; i++) {
for (j = 0; j <= x + i; j++) {
if (j > x - i - 1 && i <= x) {
cout << "*";
} else if (i >= x && j >= i - n / 2 && j < n - (i - n / 2)) {
cout << "*";
} else {
cout << " ";
}
}
cout << endl;
}
return 0;
}
Nella prossima lezione svilupperemo altri esempi sui cicli for annidati in C++.
Commenti recenti