[ANSI C] fixme: Dodawanie wielomianow

0
  1. uzytkownik wprowadza ile wielomianow chce dodac.
  2. wprowadza kazdy wielomian w postaci na przyklad: 12x23+3x13+44x21+42x1+343x^3

Co udalo mi sie zrobic:
a) wczytuje wielomian 1 do stringu, potem doklejam kolejne wielomiany - w ten sposob powstaje jeden dlugi string z wielomianem
b) pobieram wspolczynniki i potegi zapisuje je w tablicy[2][WIELKOSC]
c) sortuje tablice ze wzglegu na potegi (od najwiekszej do najmniejszej)
d) dodaje wspolczynniki przy tych samych potegach
e) wypisuje gotowy wielomian
(wypisuje tez wspolczynniki i potegi, ale to pomocniczo)

Czego nie potrafie zrobic...

  1. nie dodaje wyrazow wolnych (bez x) - po prostu samych liczb.
  2. nie dodaje wyrazow z potega rowna 1, jesli sa zapisane w postaci np. 32x zamiast 32x^1

Ogolnie powinien dodawac takie wielomiany jak np: 3x2+3x+7, a dodaje tylko jesli zapisze sie je w postaci 3x2+3x1+7x0

Nie mam pojecia, jak to zrobic :-/ .

Ponizej kod ktory udalo mi sie do tej pory wydziergac:

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#define WIELKOSC 59
#define WIELKOSC_1 11
int czy_liczba(char []);
int potegi(char [], int);


int czy_liczba(char ciag_znakow[10]) /*funkcja sprawdza czy wprowadzony ciag znakow jest liczba i zwraca jej wartosc*/
{
	int i; /*zmienna pomocnicza do petli*/
	for (i = 0; isdigit(ciag_znakow[i]) != 0; i++);
	if(i == strlen(ciag_znakow)) return atoi(ciag_znakow);
	else return -1;
}

void sortuj(int wielomian[2][WIELKOSC_1], int Lo, int Hi)
{
   int i,j;
   int x;
   x = wielomian[0][(Lo+Hi)/2];
   i = Lo;
   j = Hi;
   do
   {
      while (wielomian[0][i] > x) ++i;
      while (wielomian[0][j] < x) --j;
      if (i<=j)
      {
		 int tmp1;
         int tmp = wielomian[0][i];
         wielomian[0][i] = wielomian[0][j];
         wielomian[0][j] = tmp;
         tmp1 = wielomian[1][i];
         wielomian[1][i] = wielomian[1][j];
         wielomian[1][j] = tmp1;
         ++i; --j;
      }
   } while(i < j);
   if (Lo < j) sortuj(wielomian, Lo, j);
   if (Hi > i) sortuj(wielomian, i, Hi);
}


int potegi(char wielomian[WIELKOSC], int ktora)
{
	char pomoc[WIELKOSC]; /*tablica pomocnicza przechowujaca cyfry potegi wielomianu*/
	int potega[20], /*tablica poteg wielomianu*/
		n, /*ktora potega*/
		i, /*ktory znak w lancuchu wielomian*/
		k; /*ktory znak w lancuchu pomocniczym "pomoc"*/
		
	/*=======Czyszczenie tablicy wspolczynnikow=======*/
	for(k=0; k <= WIELKOSC_1-1; k++)
	{
	potega[k] = '\0';
	}	
	/*============================================*/
		
	/*=======Czyszczenie tabeli pomocniczej=======*/
	for(k=0; k <= WIELKOSC-1; k++)
	{
	pomoc[k] = '\0';
	}	
	/*============================================*/
		
	for(n = 0, i = 0, k = -1; i <= strlen(wielomian)-1; n++)
	{

		while(wielomian[i] == '-' || wielomian[i] == '+' || wielomian[i] == 'x' || isdigit(wielomian[i]) != 0) i++;
		if(wielomian[i-1] == 'x' && (wielomian[i] == '+' || wielomian[i] == '-' || wielomian[i] == '\0'))
		{
			potega[n] = 1;
			n++;
		}
		while(wielomian[i] == '^') i++;
		{
			for(k = 0; isdigit(wielomian[i]) != 0; i++, k++)
			{
				pomoc[k] = wielomian[i];
			}
		}
		potega[n] = atoi(pomoc);
		/*=======Czyszczenie tabeli pomocniczej=======*/
		for(k=0; k <= WIELKOSC-1; k++)
		{
		pomoc[k] = '\0';
		}		
		/*============================================*/
	}
	return potega[ktora];
}

int wspolczynniki(char wielomian[WIELKOSC], int ktory)
{
	char pomoc[WIELKOSC]; /*tablica pomocnicza przechowujaca cyfry wspolczynnika wielomianu*/
	int wspolczynnik[WIELKOSC_1], /*tablica wspolczynnikow wielomianu*/
		n, /*ktora wspolczynnik*/
		i, /*ktory znak w lancuchu wielomian*/
		k; /*ktory znak w lancuchu pomocniczym "pomoc"*/
	
	/*=======Czyszczenie tablicy wspolczynnikow=======*/
	for(k=0; k <= WIELKOSC_1-1; k++)
	{
	wspolczynnik[k] = '\0';
	}	
	/*============================================*/	
	
	
	/*=======Czyszczenie tabeli pomocniczej=======*/
	for(k=0; k <= WIELKOSC-1; k++)
	{
	pomoc[k] = '\0';
	}	
	/*============================================*/
	for(n = 0, i = 0, k = 0; i <= strlen(wielomian)-1; n++)
	{
		for(k = 0; isdigit(wielomian[i]) != 0 || wielomian[i] == '+' || wielomian[i] == '-'; i++, k++)
		{
			pomoc[k] = wielomian[i];
		}
			
		wspolczynnik[n] = atoi(pomoc);
		/*=======Czyszczenie tabeli pomocniczej=======*/
		for(k=0; k <= WIELKOSC-1; k++)
		{
		pomoc[k] = '\0';
		}		
		/*============================================*/	
		while(wielomian[i] == 'x' || wielomian[i] == '^' || isdigit(wielomian[i]) != 0) i++;
		
	}
	
	return wspolczynnik[ktory];
}
	
void sumuj(int wielomian[2][WIELKOSC_1])
{
	int i;
	for(i = WIELKOSC_1; i > 0; i--)
	{
		if(wielomian[0][i] == wielomian[0][i-1])
		{
			wielomian[1][i-1] = wielomian[1][i] + wielomian[1][i-1];
			wielomian[1][i] = 0;
		}

	}
}

int main()
{
	
	char ile[10], wielomian_2[WIELKOSC], pomoc[WIELKOSC];
	char wielomian_1[WIELKOSC];
	int n=0, i, k=0, wielomian[2][WIELKOSC_1];
	
	for(k = 0; k <= WIELKOSC_1-1; k++)
	{
		wielomian[0][k] = '0';
		wielomian[1][k] = '0';
	}
	
	
	printf("ile wielomianow chcesz zsumowac: ");
	gets(ile);
	i = czy_liczba(ile);
	if(i != -1)
	{
		printf("Podaj wielomian 1: ");
		gets(wielomian_1);
		for(i = i-1; n < i; n++)
		{
			printf("Podaj wielomian %i: ", n+2);
			gets(wielomian_2);
			
			if(wielomian_2[0] != '-')
			{
				for(k = 0; k <= WIELKOSC; k++) pomoc[k] = wielomian_2[k];
				for(k = 0; k <= WIELKOSC; k++) wielomian_2[k+1] = pomoc[k];
				wielomian_2[0] = '+';
			}
			strcat(wielomian_1, wielomian_2);
			puts(wielomian_1);
		}
		
				
		for(k=0; k <= 10; k++)
		{
			wielomian[1][k] = wspolczynniki(wielomian_1, k);
			wielomian[0][k] = potegi(wielomian_1, k);
		}
		sortuj(wielomian, 0, WIELKOSC_1-1);
		sumuj(wielomian);
		printf("Wynik to: ");
		
		if(wielomian[1][0] > 0 && wielomian[0][k] != 0)
		{
			printf("%ix^%i", wielomian[1][0], wielomian[0][0]);
			for(k=1; k < WIELKOSC_1-2; k++)
			{

				if(wielomian[1][k] > 0 && wielomian[0][k] != 0)
				printf("+%ix^%i", wielomian[1][k], wielomian[0][k]);
				else if(wielomian[1][k] < 0 && wielomian[0][k] != 0)
				printf("%ix^%i", wielomian[1][k], wielomian[0][k]);
			}
		}
		else if(wielomian[1][0] < 0 && wielomian[0][k] != 0)
		{
			for(k=0; k <= WIELKOSC_1-1; k++)
			{
				if(wielomian[1][k] < 0 && wielomian[0][k] != 0)
				printf("%ix^%i", wielomian[1][k], wielomian[0][k]);
				else if(wielomian[1][k] > 0 && wielomian[0][k] != 0)
				printf("+%ix^%i", wielomian[1][k], wielomian[0][k]);
			}	
		}
		else
		{
			for(k=0; k <= WIELKOSC_1-1; k++)
			{
				if(wielomian[1][k] < 0 && wielomian[0][k] == 0)
				printf("%i", wielomian[1][k]);
				else if(wielomian[1][k] > 0 && wielomian[0][k] == 0)
				printf("+%i", wielomian[1][k]);
			}	
		}

		for(k=0; k <= 10; k++)
		{
			printf("\nwspolczynnik: %i \t potega: %i", wielomian[1][k], wielomian[0][k]);
		}
	}
	else printf("Podaj liczbe!");
return 0;
}
0

Wczytywanie wielomianu powinno wyglądać tak:

#include <string.h>

int wczytajWielomian(char* text, double *factors, int maxSize)
{
    int highestPower = -1;
    for(int i=0;i<maxSize;++i)
        factors[0] = 0.0;

    char *next = text;
    
    while(*next);
    {
        char *p = next;
        double value;
        int power;

        value = strtod(next,&p);
        if(p==next)
            {
            return text-next; // - pozycja gdzie jest błąd
            }
        next = p;

        if(tolower(*next) == 'x')
            {
            next++;
            if(*next =='^') 
                {
                p = ++next;
                power = strtol(next,&p,10);
                if(p==next)
                    {
                    return text-next; // - pozycja gdzie jest błąd
                    }
                }
            else
                power = 1;
            }
        else
            power = 0;

    if(power>=maxSize)
         return -1000; // to big power

    factors[power]+=value;
    if(highestPower <power)
         highestPower  = power;

    while(isspace(*next))
         ++next;
    }
    return highestPower+1;
}

1 użytkowników online, w tym zalogowanych: 0, gości: 1