/* --------------------------------------------------------------------

E' dato un array N per M  tessere contraddistinte con  0 o 1. Ci sono
degli 1 sparsi (rumore) e c'e' un solo cammino fatto di tessere contenti
1 che va da sinitra a destra. Nessuna tessera contenente  1 e non
appartenente al cammino e' adiacente ad una delle tessere del cammino
stesso.  Ad esempio:

	0 0 0 0 1
	0 1 1 0 0
	1 0 0 1 0
	0 0 0 0 1
	1 0 0 0 0
 
Calcolare la lunghezza del cammino.
 
-------------------------------------------------------------------- */

#include <stdio.h>

#define N	6
#define M	6


int main()
{

	int matrice_tessere[N][M] = {	{0, 0, 0, 0, 1, 0},
					{0, 0, 1, 0, 0, 0},
					{0, 1, 0, 1, 0, 1},
					{1, 0, 0, 0, 1, 0},
					{0, 0, 0, 0, 0, 0},
					{1, 0, 0, 0, 1, 0}};

	int lunghezza_cammino = 1, riga=0, colonna=0, riga_ricerca;

	do {

    	riga = 0;

		do {

			if(matrice_tessere[riga][colonna] == 1) {

				riga_ricerca = riga > 0 ? riga-1: 0;

				while	(riga_ricerca < riga+1 &&
						 riga_ricerca < N-1 &&
 
matrice_tessere[riga_ricerca][colonna+1] == 0)

				++riga_ricerca;


 
	if(matrice_tessere[riga_ricerca][colonna+1] == 1){

						++lunghezza_cammino;
						riga = riga_ricerca;
						++colonna;
				}
				else ++riga;

          }
			else ++riga;

		} while (riga < N && colonna < M-1);

       ++colonna;
 
	} while (colonna < M-1 && lunghezza_cammino <= 1);


	if(lunghezza_cammino > 1)
		printf("C'e' un cammino di lunghezza %d", lunghezza_cammino);
	else 	printf("Non ci sono cammini");

	return(0);
}

/* Dato un vettore di interi non negativi, stampare il relativo istogramma
fatto di asterischi. Ad esempio:


	3 4 5 0 2

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

*/


#include <stdio.h>

#define N	5



int main()
{

	int vettore[N] = {5, 6, 0, 8, 2}; /*eventualmente sostituire 
con un input di dati */
	int massimo = 0, i, riga, colonna;



/* calcolo il massimo tra tutti gli elementi perche' mi influenza il modo
    di stampare dall'altro verso il basso */
	for(i=0; i < N; ++i)
		if(massimo < vettore[i])
			massimo = vettore[i];

printf("\nIl massimo vale= %d\n\n", massimo);

	for(riga = massimo; riga > 0; --riga) {

//		putchar('\t');

		for(colonna = 0; colonna < N; ++colonna)

			if (vettore[colonna] >= riga)
				printf("%2c", '*');
			else printf("%2c", ' ');

		putchar('\n');

	}

return(0);
}


/* --------------------------------------------------------------------

E' data una stringa di lunghezza (strettamente) minore di 80, fatta di
parole intervallate da uno spazio. Giustificarla a 80 inserendo
uniformemente ulteriori spazi tra le parole.

-------------------------------------------------------------------- */


#include <stdio.h>

#define AMPIEZZA_RIGA	80


int main()
{

	char riga[AMPIEZZA_RIGA +1], ch_aux;

	int numero_intervalli = 0, delta, resto, spazi_da_copiare, 

         posiz_corrente_sin = 0, posiz_corrente_des;


	printf("Dammi una sequenza di parole di lunghezza massima 80");
	printf(" caratteri\nintervallate da uno spazio:\n\n");

	while((ch_aux= getchar()) != '\n') {

		riga[posiz_corrente_sin++] = ch_aux;

		if (ch_aux == ' ')
			++numero_intervalli;
	}

	riga[AMPIEZZA_RIGA] = '\0';

	delta = (AMPIEZZA_RIGA - posiz_corrente_sin) / numero_intervalli;
	resto = (AMPIEZZA_RIGA - posiz_corrente_sin) % numero_intervalli;

	posiz_corrente_des = AMPIEZZA_RIGA - 1;
	--posiz_corrente_sin;

	while(numero_intervalli > 0) {

		while((riga[posiz_corrente_des--] = 
riga[posiz_corrente_sin--]) != ' ');

		/* ++posiz_corrente_des; */

		spazi_da_copiare = (resto-- > 0) ? delta+1 : delta;

		while (spazi_da_copiare > 0) {
			riga[posiz_corrente_des] = ' ';
			--spazi_da_copiare;
			--posiz_corrente_des;
		}

	 	--numero_intervalli;
	}

	printf("\n%s\n", riga);

	return(0);
}