Poco più che novizio, mi presento

di
Massinati
il
4 risposte
M
Massinati
Pochi posts
Iscritto da
nov, 2012
Messaggi:
3

Poco più che novizio, mi presento

Buonasera a tutti,
Ero uno studente di informatica, scuola e qualche esame di scienze dell' informazione, nell'era pre-oggetti (primi '90). Ho deciso di ricominciare la mia formazione con il c++ (studiavo pascal) ripartendo da zero, fortunamente con molti ricordi ancora vivi, con il libro di H. e P.J. Deitel e devo dire che l'entusiasmo mi sta letteralmente divorando.
Ancora non sono arrivato alle funzioni e gli esercizi che faccio (e che spesso mi autoimpongo inventandomeli di sana pianta) vi faranno sicuramente ridere: una sequenza dritta dritta di istruzioni senza nessuna chiamata, ma in una settimana di studio ancora non prentendo di più da me stesso.
A questo proposito ho un listato con il quale ho provato a concretizzare questo esercizio:
data una matrice bidimensionale di dimensioni date, riempirla di 0 ed 1 casuali (o pseudocasuali, ma ora per me non è un problema di vitale importanza, dato che ho preso la funzione e la libreria così come l'ho trovata spulciando in rete) e sviluppare un algoritmo che trovi, se esistente, il primo percorso di "uno" da sinistra a destra senza interruzioni in cui le adiacenze ammesse sono sinistra-basso /destra, sinistra-destra, sinistra-alto / destra (matrice [j]-matrice[j-1][i+1], ecc.).
Allego il listato, con tutti i commenti che ho creduto essenziali, senza troppe speranze di una vostra attenzione vista la sua lughezza ed ovviamente accetto critiche e consigli, se non nel programma che ovviamente ancora non funziona (però devo dire che è la prima sconfitta, anche se non demordo), sicuramente nel metodo e su come eventualmente modificare il mio nuovo percorso da autodidatta.
Sperando di aver postato secondo le regole vi auguro buona serata
Massimiliano.

P.S. vedendo l'anteprima noto che si perdono i colori e parte della formattzione, provo ad allegare il sorgente e vi chiedo scusa in anticipo.

						// programma per la generazione di una matrice [righe][colonne] di zeri od "uni" casuali
						// con ricerca del primo percorso di "uni" contigui (alto-destra, destra, basso destra)
						// fino ad arrivare ad matrice [x][colonne] e visualizzazione del risultato
#include <iostream>
#include <math.h>
#include <stdlib.h>

using namespace std;

int main()
{
	const int righe = 2 , colonne = 2 ;
	bool flag = 0;
	int i = 0 , j = 0;
	double matrix [righe][colonne] , soluzione [righe][colonne] ;
	char vis_soluzione , altra_matrice = 's';

	while (altra_matrice == 's')
	{
		cout << "\n\n";
		for(j = 0; j < (righe); j++)														// INIZIALIZZAZIONE MATRICI
		{
			for(i = 0; i < (colonne); i++) 
			{
				soluzione [j][i] = 0;														// inizializzazione a 0 di tutta la matrice soluzione
				matrix [j][i] = rand()%2;													// inizializzazione con zeri ed "uni" casuali della matrice originale
				cout << matrix [j][i] <<"\t";												// visualizzazione matrice originale
			}
			cout <<"\n\n";
		}

		i = 0; 
		j = 0;

		cout <<"visualizzare soluzione ? ";								
		cin >> vis_soluzione;

		if ( vis_soluzione == 's')															// richiesta di visualizzare soluzione ed INIZIO CORE PROGRAMMA
		{
			while (j < righe && flag == 0)													// j < 10 condizione per passaggio a riga succ. su prima colonna se matrix[j][0] == 0, 
			{																				// flag == 0 condizione percui non si è arrivati alla 10ma colonna con soluzione
				do
				{
					if (j == 0)																// ITERAZIONI ED ASSEGNAZIONI PER RICERCA DI "uni" CONTIGUI SU PRIMA RIGA
					{
						if (matrix [j][i+1] == 1 && soluzione [j][i+1] != -1)				// ricerca di uno su colonna succ. e stessa riga e ev. successivo ritroso colonna se tag -1 su matirce soluzione
						{
							if (i == (colonne-2))											// asseganzioni specifiche penultima ed ultima colonna
							{
								soluzione [j][i] = 1;
								soluzione [j][i+1] = 1;
								i = i + 1;
							}
							else															// assegnazioni per tutte le colonne tranne prima penultima ed ultima
							{
								soluzione [j][i] = 1;
								i = i + 1;
							}
						}
						else
						{
							if (matrix [j+1][i+1] == 1 && soluzione [j+1][i+1] != -1)		// ricerca di uno su colonna succ. e riga successiva ed ev. successivo ritroso colonna se tag -1 su matirce soluzione
							{
								if (i == (colonne-2))										// asseganzioni specifiche penultima ed ultima colonna
								{
									soluzione [j][i] = 1;
									soluzione [j+1][i+1] = 1;
									j = j + 1;
									i = i + 1;
								}
								else														// assegnazioni per tutte le colonne tranne prima penultima ed ultima
								{
									soluzione [j][i] = 1;
									j = j + 1;
									i = i + 1;
								}
							}
							else
							{
								soluzione [j][i] = -1;										// flag -1 su matrice soluzione per indicare ramo morto sulle iterazione successiva che qui la porrà retrocessa di una colonna (ciclo comune per ogni valore di j)
								j = 0;
								i = i - 1;
								while (soluzione [j][i] != 1)								// ciclo ricerca di un "uno" su colonna retrocessa (ci deve essere perchè già esaminato nei cicli precedenti che hanno portato a rami morti)
									j = j + 1;
							}
						}
					}
					else												
					{
						if (j == (righe-1))													// ITERAZIONI ED ASSEGNAZIONI PER RICERCA DI "uni" CONTIGUI SU ULTIMA RIGA
						{
							if (matrix [j-1][i+1] == 1 && soluzione [j-1][i+1] != -1)		// ricerca di uno su colonna succ. e riga precedente ed ev. successivo ritroso colonna se tag -1 su matirce soluzione
							{
								if (i == (colonne-2))										// asseganzioni specifiche penultima ed ultima colonna
								{
									soluzione [j][i] = 1;
									soluzione [j-1][i+1] = 1;
									i = i + 1;
									j = j - 1;
								}
								else														// assegnazioni per tutte le colonne tranne prima penultima ed ultima
								{
									soluzione [j][i] = 1;
									i = i + 1;
									j = j - 1;
								}
							
							}
							else
							{
								if (matrix [j][i+1] == 1 && soluzione [j][i+1] != -1)		// ricerca di uno su colonna succ. e stessa riga  ed ev. successivo ritroso colonna se tag -1 su matirce soluzione
								{
									if (i == (colonne-2))									// asseganzioni specifiche penultima ed ultima colonna
									{
										soluzione [j][i] = 1;
										soluzione [j][i+1] = 1;
										i = i + 1;
									}
									else													// assegnazioni per tutte le colonne tranne prima penultima ed ultima
									{
										soluzione [j][i] = 1;
										i = i + 1;
									}
								}
								else
								{
									soluzione [j][i] = -1;									// flag -1 su matrice soluzione per indicare ramo morto sulle iterazione successiva che qui la porrà retrocessa di una colonna (ciclo comune per ogni valore di j)
									j = 0;
									i = i - 1;
									while (soluzione [j][i] != 1)							// ciclo ricerca di un "uno" su colonna retrocessa (ci deve essere perchè già esaminato nei cicli precedenti che hanno portato a rami morti)
										j = j + 1;
								}
							}

						}
						else																// ITERAZIONI ED ASSEGNAZIONI PER RICERCA DI "uni" CONTIGUI SU TUTTE LE RIGHE TRANNE PRIMA ED ULTIMA
						{
							if (matrix [j-1][i+1] == 1 && soluzione [j-1][i+1] != -1)		// ricerca di uno su colonna succ. e riga precedente ed ev. successivo ritroso colonna se tag -1 su matirce soluzione
							{
								if (i == (colonne-2))										// asseganzioni specifiche penultima ed ultima colonna
								{
									soluzione [j][i] = 1;
									soluzione [j-1][i+1] = 1;
									i = i + 1;
									j = j - 1;
								}
								else														// assegnazioni per tutte le colonne tranne prima penultima ed ultima
								{
									soluzione [j][i] = 1;
									i = i + 1;
									j = j - 1;
								}
							
							}
							else
							{
								if (matrix [j][i+1] == 1 && soluzione [j][i+1] != -1)		// ricerca di uno su colonna succ. e stessa riga  ed ev. successivo ritroso colonna se tag -1 su matirce soluzione
								{
									if (i == (colonne-2))									// asseganzioni specifiche penultima ed ultima colonna
									{
										soluzione [j][i] = 1;
										soluzione [j][i+1] = 1;
										i = i + 1;
									}
									else													// assegnazioni per tutte le colonne tranne prima penultima ed ultima
									{
										soluzione [j][i] = 1;
										i = i + 1;
									}
								}
								else
								{
									if (matrix [j+1][i+1] == 1 && soluzione [j+1][i+1] != -1)// ricerca di uno su colonna succ. e riga successiva ed ev. successivo ritroso colonna se tag -1 su matirce soluzione
									{
										if (i == (colonne-2))								// asseganzioni specifiche penultima ed ultima colonna
										{
											soluzione [j][i] = 1;
											soluzione [j+1][i+1] = 1;
											j = j + 1;
											i = i + 1;
										}
										else												// assegnazioni per tutte le colonne tranne prima penultima ed ultima
										{
											soluzione [j][i] = 1;
											j = j + 1;
											i = i + 1;
										}
									}
									else
									{
										soluzione [j][i] = -1;								// flag -1 su matrice soluzione per indicare ramo morto sulle iterazione successiva che qui la porrà retrocessa di una colonna (ciclo comune per ogni valore di j)
										j = 0;
										i = i - 1;
										while (soluzione [j][i] != 1)						// ciclo ricerca di un "uno" su colonna retrocessa (ci deve essere perchè già esaminato nei cicli precedenti che hanno portato a rami morti)
											j = j + 1;
									}
								}
							}
						}
					}

				}while (i < (colonne-1) || i> 0);											// i = 9 si esce con soluzione, i=0 si esce con necessità di passare a riga succ su prima colonna

				if (i == (colonne-1))														// flag = 1 di trovata soluzione se i = 9
				{
					flag = 1;
				}
				j = j + 1;																	// passaggio a riga successiva della prima colonna e nuovo inizio di ricerca ramo vivo

			}
			if (j == (colonne)	)															// se arrivati oltre ultima riga della prima colonna senza rami vivi, nessuna soluzione
			{
				cout <<"\n\n nessuna soluzione\n\n\n";
			}
			if (flag == 1)																	// condizione per iniziare la raffiguarazione della soluzione evidenziando il percorso vivo sulla matrice soluzione
			{
				for (j = 0; j<(colonne) ;i++)
				{
					for(i = 0; i < (righe);i++)
					{
						if (soluzione [j][i] = 1)
						{
							cout << soluzione [j][i] << "\t";
						}
						else
						{
							cout <<"\t";
						}
					}
					cout << "\n\n";

				}
			}
		}
	}
	cout << "\n\n\n altra matrice ? ";
	cin >> altra_matrice;

	return (0);		
}

4 Risposte

  • B
    barba59
    Molto attivo
    Iscritto da
    feb, 2012
    Messaggi:
    1353

    Re: Poco più che novizio, mi presento

    Ciao Massimiliano,
    bei tempi quelli del Pascal poi ne è passata di acqua sotto i ponti.

    Ti do qualche parere facendo il verso a Briatore:

    Se non usi le funzioni, sei fuori!
    Se scrivi una funzione di 200 righe, sei fuori!
    Se scrivi un commento ogni riga, sei fuori!
    Se non programmi a oggetti, sei fuori!

    L' ordine e l' indentazione invece mi piacciono.
  • M
    Massinati
    Pochi posts
    Iscritto da
    nov, 2012
    Messaggi:
    3

    Re: Poco più che novizio, mi presento

    Ahahahah !!

    Quindi sono fuori ! Ma questo gia lo sapevo .

    riguardo le funzioni, ricordo di averle studiate e tra poco ci tornerò.

    200 righe, si, lo so che sono troppe, ma mi sto esercitando e per ora lo prendo come un passo necessario per acquisire familiarita con la grammatica del linguaggio e per fare molti errori di sintassi e correggerli fino alla nausea, stile karate kid e, sempre in riferimento alla riga sopra, per ora non ho alternative.

    Metto molti commenti perchè per ora ho bisogno di "sapere dove sono", ancora non riesco a visualizzare il punto di un algoritmo a colpo d'occhio, sopratutto se sono 200 righe...

    Gli oggetti per ora sono per me un elemento astratto, ho iniziato a capirne la teoria, arriverò a capire e mettere in pratica il concetto tra qualche tempo, qualche esercizio e...qualche pagina ! A proposito, riguardo al libro che ho citato, credi possa essere una buona guida ? A me piace molto ma il mio metro di giudizio è vecchio di più di vent'anni...

    Diciamo che, almeno con l'ordine e l'indentazione, sono partito bene .

    Grazie della risposta, continuo a scornarmi con il debug di questo esercizio (ancora per poco) e poi passo al secondo capitolo .

    Ciao,
    Massimiliano.
  • B
    barba59
    Molto attivo
    Iscritto da
    feb, 2012
    Messaggi:
    1353

    Re: Poco più che novizio, mi presento

    Massinati ha scritto:

    Ahahahah !!
    Quindi sono fuori ! Ma questo gia lo sapevo .
    Bene! Il senso dell' umorismo ce l' hai, questo è importante!

    Massinati ha scritto:

    200 righe, si, lo so che sono troppe, ma mi sto esercitando e per ora lo prendo come un passo necessario per acquisire familiarita con la grammatica del linguaggio e per fare molti errori di sintassi e correggerli fino alla nausea, stile karate kid.
    Se sei un tipo ingegnoso, un buon enigmista, puoi anche gestire funzioni di 200 righe e oltre, però ad un certo punto arriverai al tuo limite. Se vuoi affrontare programmi complessi devi avere un metodo, seguire degli schemi. In pratica devi conoscere la programmazione ad oggetti. Lo studio della programmazione ad oggetti deve cominciare subito, non puoi rimandarlo o giovane jedi (n.b. lo jedi è un gradino sopra karate kid)

    Massinati ha scritto:

    Metto molti commenti perchè per ora ho bisogno di "sapere dove sono", ancora non riesco a visualizzare il punto di un algoritmo a colpo d'occhio, sopratutto se sono 200 righe...
    Una funzione di 200 righe è incomprensibile, quindi ti tocca mettere un mucchio di commenti, è un errore che genera un altro errore. Se dividi il codice in classi, metodi e oggetti saranno i loro nomi a guidarti. Se fai le cose per bene puoi tranquillamente scrivere un programma di grandi dimensioni senza un commento.

    Massinati ha scritto:

    Gli oggetti per ora sono per me un elemento astratto, ho iniziato a capirne la teoria, arriverò a capire e mettere in pratica il concetto tra qualche tempo, qualche esercizio e...qualche pagina !
    Inizia il prima possibile, non perdere tempo con tutti quei giochetti sui puntatori, quelli vengono dopo (a mio parere). Scrivere un programma significa individuare le classi che risolvono il problema e stabilirne le relazioni, poi al loro interno ci infili del codice. Prima pensi alle classi, pensi in grande, poi scrivi i dettagli.

    Ovviamente, come dicevi tu, prima ti servono i rudimenti, quello su cui insisto e di non fermartici troppo.

    Massinati ha scritto:

    A proposito, riguardo al libro che ho citato, credi possa essere una buona guida ? A me piace molto ma il mio metro di giudizio è vecchio di più di vent'anni...
    Non lo conosco, io avevo cominciato con il classico Stroustrup, comunuque ho buttato un occhio in rete e mi senbra buono.

    Massinati ha scritto:

    Diciamo che, almeno con l'ordine e l'indentazione, sono partito bene .
    Si, il tuo modo di indentare mi piace (è uguale al mio ) e anche il fatto di abbondare con gli spazi.
  • M
    Massinati
    Pochi posts
    Iscritto da
    nov, 2012
    Messaggi:
    3

    Re: Poco più che novizio, mi presento

    Beh, uno Jedi che si deve presto orientare agli oggetti è un gran passaggio rispetto ad un karate kid che deve fare errori di grammatica per imparare !!

    Grazie dei preziosi consigli, a presto !

    Massimiliano.

    P.S. Il libro di cui sopra ha come scopo iniziare subito e parallelamente la trattazione degli oggetti dal primo capitolo (da cui la mia conoscenza astratta) , quindi in linea con il tuo pensiero.
Devi accedere o registrarti per scrivere nel forum
4 risposte