Laboratorium programowania zad 10

Zadanie z laboratorium programowania na Informatyce UW.

Zadanie 10 (termin wysylania rozwiazan: 9 kwietnia 2008, godz. 23:59)

Seria bedziemy nazywali niepusty ciag liczb calkowitych wiekszych od zera.

Ciag serii bedziemy reprezentowali za pomoca ciagu liczb calkowitych, w
ktorym znajda sie kolejne elementy poszczegolnych serii ze znakiem
zaleznym od parzystosci numeru serii. Elementy pierwszej serii zapiszemy
jako liczby dodatnie, elementy drugiej serii jako ujemne, trzeciej
dodatnie itd. Po ostatnim elemencie ostatniej serii ma byc zero.

Np. ciag szesciu serii: 3 1 5, 4, 1 6, 1 6, 8 2, 4 bedzie reprezentowany
przez ciag liczb:

3
1
5
-4
1
6
-1
-6
8
2
-4
0

Napisz program, ktory wczyta z wejscia liczby calkowite reprezentujace
ciag serii i wypisze na wyjscie reprezentacje ciagu serii powstalego z
ciagu danego przez pominiecie tych serii, ktore sa identyczne z seriami
bezposrednio je poprzedzajacymi. Kazda liczbe reprezentacji ciagu serii
nalezy wypisac w oddzielnym wierszu.

Np. dla danych zapisanych powyzej program powinien wypisac na wyjscie:

3
1
5
-4
1
6
-8
-2
4
0

Uwaga: w rozwiazaniu wolno zalozyc, ze w pamieci zmieszcza sie na raz
dwie sasiadujace w ciagu serie. Nie wolno jednak nakladac zadnego
ograniczenia na dlugosc ciagu serii ani na dlugosc pojedynczej serii.

Wskazowka: serie mozna przechowywac w tworzonej dynamicznie (za pomoca
funkcji malloc) tablicy liczb calkowitych. Gdyby okazalo sie, ze utworzona
tablica jest zbyt mala, by zmiescic cala wczytywana serie, tworzymy
tablice dwa razy wieksza.

A oto rozwiązanie:

#include 
#include 
#include 

//Bedziemy przechowywac liczby w liscie dwuwymiarowej
typedef struct liczba_el{     
      int var;           
      struct liczba_el * nastepny; 
};


struct seria_el {
      struct liczba_el * liczba;    
      struct seria_el* nastepny; 
};

int porownaj (struct seria_el* pier,struct seria_el* dr)
{
//porownuje serie czy sa takie same

int rowne;
struct liczba_el* pierwszy;
struct liczba_el* drugi;
	rowne=0;
	
	if ((pier!=NULL)&&(dr!=NULL))
	{
		pierwszy=pier->liczba;
		drugi=dr->liczba;
		rowne=1;

		
		while((pierwszy!=NULL)&&(drugi!=NULL)&&(rowne==1))
		{
			if (pierwszy->var==drugi->var)
			{
				pierwszy=pierwszy->nastepny;
				drugi=drugi->nastepny;
			}
			else
			{
				rowne=0;
			}
			
		}

		if ((rowne==1)&&(pierwszy!=drugi))
		{
			//Sprawdzenie czy koncza sie oba w tym samym miejscu
			rowne=0;
		}
	}
	return rowne;
}

int bezwzgl(int liczba)
{
//Liczy wartosc bezwzgledna
	if (liczbaliczba=malloc(sizeof(teraz_liczba));
	start->nastepny=NULL;
	start->liczba->nastepny=NULL;
	teraz_seria=start;
	teraz_liczba=start->liczba;
	
	wynik=scanf("%d",&liczba);

	teraz_liczba->var=bezwzgl(liczba);			//
	poprzednia=liczba;
	wynik=scanf("%d",&liczba);
	
	

	while(wynik!=EOF)
	{
	
	
		if((liczba*poprzednia) liczba=NULL;
			}
			else
			{
				//nowa seria
				teraz_seria->nastepny=malloc(sizeof(start));
				poprzednia_seria=teraz_seria;
				teraz_seria=teraz_seria->nastepny;
			}
			teraz_seria->liczba=malloc(sizeof(tmp_liczba));
			teraz_liczba=teraz_seria->liczba;
			teraz_liczba->nastepny=NULL;
			teraz_seria->nastepny=NULL;
			teraz_liczba->var=bezwzgl(liczba);		//
		}
		else
		{
			//Nowa liczba w serii.
			teraz_liczba->nastepny=malloc(sizeof(teraz_liczba));
			teraz_liczba=teraz_liczba->nastepny;
			teraz_liczba->var=bezwzgl(liczba);		//
		}
		poprzednia=liczba;
		wynik=scanf("%d",&liczba);
		
		

	}

//I teraz trzeba wypisac!!
	
	mnoznik=1;

	teraz_seria=start;
	while(teraz_seria!=NULL)
	{
		teraz_liczba=teraz_seria->liczba;
		while(teraz_liczba!=NULL)
		{
			//Zwyczajnie wypisujemy
			printf("%dn",((teraz_liczba->var)*mnoznik));
			tmp_liczba=teraz_liczba;
			teraz_liczba=teraz_liczba->nastepny;
			free(tmp_liczba);
		}
		
		//czyscimy
		start=teraz_seria;
		teraz_seria=teraz_seria->nastepny;
		free(start);
		//Naprzemiennie ustawiamy mnoznik
		mnoznik=mnoznik*-1;
	}

return 1;
}