[ANSI C] fixme: Dodawanie wielomianow

Odpowiedz Nowy wątek
Poczatkujacyy
2009-05-19 09:56
Poczatkujacyy
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;
}

Pozostało 580 znaków

2009-05-19 17:57

Rejestracja: 12 lat temu

Ostatnio: 1 minuta temu

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;
}

Jeśli chcesz pomocy, NIE pisz na priva, ale zadaj dobre pytanie na forum.

Pozostało 580 znaków

Odpowiedz

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