Найти разницу двух многочленов

/*   Найти разницу двух многочленов Pn(x) и Qm(x) при x=3   */
 
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>
 
#define N  100
#define M  100
 
int main()
{
 
     int n, m;                            /* степень P(x) и Q(x) */
     float p[N+1], q[M+1];          /* коф P(x), коф Q(x)  */
 
     int s;                       /* степень R(x) */
     float r[N+M+1];        /* коф R(x) */
 
     int k,                 /* наименьший из степеней n и m */
         i;                 /* индекс */
     int error;           /* признак ошибки при вводе */
     /* =0, если нету ошибки, =1, если ошибка */
 
     
     do
      { error=0;                                       
        printf("Vvedite stepen' 1-go mnogochlena");
        printf("(n>=0 i n<%d):\n", N);
        scanf("%d", &n);
        if ( n<0 || n>N )
           { printf("Vi oshiblis! Povtorite vvod!\n");
             error=1;                                  
           } 
      }
      while (error);
 
      
      printf("Vvedite koophicent 1-go mnogochlena:\n");
      for(i=0; i<n+1; i++)
         {       
          printf("\nP[%d]=", i);
          scanf("%f", &p[i]);
         }
 
      
     do
      { error=0;                                       
        printf("Vvedite stepen' 2-go mnogochlena");
        printf("(m>=0 i m<%d):\n", M);
        scanf("%d", &m);
        if ( m<0 || m>M )
           { printf("Vi oshiblis! Povtorite vvod!\n");
             error=1;                                  
           }
      }
      while (error);
 
      
      printf("Vvedite koophicenti 2-go mnogochlena:\n");
      for(i=0; i<m+1; i++)
         { printf("\nQ[%d]=", i);
           scanf("%f", &q[i]);
         }
 
     s = (n>m) ? n : m;
     k = (n*m);
     for(i=k+1; i<=s; i++)
            r[i] = p[i];
     if (n<m)
     for(i=k+1; i<=s; i++)
         r[i] = q [i];
  
     /* ============ Вывод результатов ========= */
     printf ("Mnogochlen-rezultat stepeni=%d\n", s);
     for (i=0; i<s+1; i++)
        printf("r[%d]=%f\n", i, r[i]);
     getch();
 }

#include <stdio.h>          // библиотека стандартного ввода-вывода (для printf)
#include <conio.h>          // библиотека консольного ввода-вывода (для getch())
#include <math.h>           // библиотека математических функций (для abs())
 
 
// подпрограмма выделения памяти под коэффициенты многочлена
// входные переменные: нет
// выходные переменные: 
//                     n - степень многочлена (целое неотрицательное)
// возвращаемый результат: указатель на массив коэффициентов многочлена
float* create_poly(int* n) {
    
    // переменные
    bool input_errors;      // признак ошибок ввода
    float* K;               // указатель на массив коэффициентов многочлена
 
    // ввод степени многочлена Р
    do {
        input_errors = true;        // полагаем, что есть ошибка ввода
        
        printf("Input integer positive power of polynom: ");
        scanf("%d", n);
        
        if (n > 0) {
            input_errors = false;
        }
 
    } while (input_errors);
 
    // выделение памяти (n ячеек для вещественных чисел float) под коэффициенты многочлена Р
    K = new float[*n+1];
 
    // возвращаем в основную программу указатель на массив коэффициентов многочлена
    return K;
 
}
 
 
// подпрограмма ввода коэффициентов многочлена
// входные переменные: 
//                     n - степень многочлена (целое неотрицательное)
// выходные переменные: 
//                     K - указатель на массив коэффициентов полинома
// возвращаемый результат: нет
void input_poly(int n, float* K) {
    
    // переменные
    int ix;                 // индекс i-го коэффициента многочлена
 
    // ввод коэффициентов многочлена 
    printf("Input coeffs:\n");
    for (ix = 0; ix <= n; ix++) {
 
        printf("for x^%-1d: ",ix);
        scanf("%f", &K[ix]);
 
    }
 
 
}
 
// подпрограмма вывода многочлена
// входные переменные: 
//                     n - степень многочлена (целое неотрицательное)
//                     K - указатель на массив коэффициентов полинома
// выходные переменные: нет
// возвращаемый результат: нет
void output_poly(int n, float* K) {
    
    // переменные
    int ix;                 // индекс i-го коэффициента многочлена
 
    // вывод многочлена 
    for (ix = n; ix >= 0; ix--) {
 
        // если выводим старший коэффициент
        if (ix == n) {
                
            // если полином 1-ой степени
            if (n == 1) {
                
                // выводим коэффициент без значка "^"
 
                // если старший коэффициент не отрицательный
                if (K[n] >= 0) 
                    // выводим его без знака
                    printf("%5.3f*x ", K[n]);
        
                // иначе, старший коэффициент отрицательный
                else
                    // и выводим его со знаком "-"
                    printf("- %5.3f*x ", abs(K[n]));
            }
 
            else {
 
                // если старший коэффициент не отрицательный
                if (K[n] >= 0) 
                    // выводим его без знака
                    printf("%5.3f*x^%-1d ", K[n], n);
        
                // иначе, старший коэффициент отрицательный
                else
                    // и выводим его со знаком "-"
                    printf("- %5.3f*x^%-1d ", abs(K[n]), n);
            }
            
        }
 
        else {
 
            switch (ix) {
            
                case 0: 
                    if (K[0] > 0) 
                        printf("+ %5.3f", K[0]);
                    else
                        printf("- %5.3f", abs(K[0]));
                    break;
 
                case 1: 
                    if (K[1] > 0) 
                        printf("+ %5.3f*x ", K[1]);
                    else
                        printf("- %5.3f*x ", abs(K[1]));
                    break;
        
            default:
                if (K[ix] > 0) 
                    printf("+ %5.3f*x^%-1d ", K[ix], ix);
                else
                    printf("- %5.3f*x^%-1d ", abs(K[ix]), ix);
                
            }
    
        }
 
    }
 
}
 
 
// подпрограмма определения коэффициентов многочлена-разности двух многочленов
// входные переменные: 
//                     n - степень многочлена-уменьшаемого (целое неотрицательное)
//                     P - указатель на коэффициенты многочлена-уменьшаемого 
//                     m - степень многочлена-вычитаемого (целое неотрицательное)
//                     Q - указатель на коэффициенты многочлена-вычитаемого 
// выходные переменные: 
//                     r - степень многочлена-разности (целое неотрицательное)
// возвращаемый результат: указатель на массив коэффициентов многочлена-разности
float* substract_poly(int n, float* P, int m, float* Q, int* r) {
    
    // переменные
    float* K;               // указатель на массив коэффициентов многочлена-разности
    int ix;                 // индекс коэффициента многочлена-разности
 
    // если степень многочлена-уменьшаемого, больше либо равна степени многочлена-вычитаемого
    if (n >= m) {
        
        // выделение памяти (n ячеек для вещественных чисел float) под коэффициенты многочлена 
        K = new float[n+1];
 
        // рассчитываем значения коэффициентов как разность 
        for (ix = 0; ix <= m; ix++) {
            K[ix] = P[ix] - Q[ix]; 
        }
 
        // переписываем старшие коэффициенты без изменений
        for (ix = m+1; ix <= n; ix++) {
            K[ix] = P[ix]; 
        }
 
        // задаем степень полинома-разности по степени полинома-уменьшаемого
        *r = n;
 
    }
 
    else {
 
        // выделение памяти (n ячеек для вещественных чисел float) под коэффициенты многочлена 
        K = new float[m+1];
 
        // рассчитываем значения коэффициентов как разность 
        for (ix = 0; ix <= n; ix++) {
            K[ix] = P[ix] - Q[ix]; 
        }
 
        // переписываем старшие коэффициенты с противоположным знаком
        for (ix = n+1; ix <= m; ix++) {
            K[ix] = -Q[ix]; 
        }
 
        // задаем степень полинома-разности по степени полинома-вычитаемого
        *r = m;
 
    }
 
 
    // возвращаем в основную программу указатель на массив коэффициентов многочлена-разности
    return K;
 
}
 
 
// подпрограмма расчета значения многочлена при заданом аргументе
// входные переменные: 
//                     n - степень многочлена(целое неотрицательное)
//                     P - указатель на коэффициенты многочлена
//                     x - значение аргумента
// выходные переменные: нет
// возвращаемый результат: значение многочлена
float calc_poly(int n, float* P, float x) {
    
    // переменные
    int ix;                 // индекс коэффициента многочлена
    float res;              // результат вычисления
 
    // выполняем вычисления
    res = 0;
    for (ix = 0; ix <= n; ix++) {
        res = res + P[ix] * pow(x, ix); 
    }
    
    // возвращаем в основную программу результат расчетов
    return res;
 
}
 
 
 
// главная функция - точка входа в программу 
void main() {
 
    // переменные
    int n;                  // степень многочлена Р
    int m;                  // степень многочлена Q
    int d;                  // разность степеней многочленов P и Q (для корректного вывода)
    int r;                  // степень многочлена-разности
 
    int ix;                 // индекс 
 
    float *P;               // указатель на массив коэффициентов многочлена Р 
    float *Q;               // указатель на массив коэффициентов многочлена Q
    float *R;               // указатель на массив коэффициентов многочлена R = P - Q
 
    float P3;               // значение полинома Р при х=3
    float Q3;               // значение полинома Q при х=3
    float R3;               // значение полинома R при х=3
 
    // --- ввод исходных данных ---------------------------------------------
 
    // ввод многочлена P 
    P = create_poly(&n);
    input_poly(n, P);
    
    // ввод многочлена Q 
    Q = create_poly(&m);
    input_poly(m, Q);
        
 
    // --- вычисление разности многочленов ----------------------------------------
    
    // вывод многочленов для вычитания "столбиком"
    if (n >= m) {
        
        // вывод многочлена Р
        printf("\nPolynom P(x):     ");
        output_poly(n, P);
 
        // определяем на сколько степень многочлена Р больше степени многочлена Q
        d = n - m;
 
        // вывод многочлена Q со сдвигом вправо
        printf("\nPolynom Q(x):     ");
        for (ix = 0; ix < d; ix++) {
            // выводим пробелы
            printf("            ");
        }
        output_poly(m, Q);
        
    }
 
    else {
        
        // определяем на сколько степень многочлена Р больше степени многочлена Q
        d = m - n;
 
        // вывод многочлена Р со сдвигом вправо
        printf("\nPolynom P(x):     ");
        for (ix = 0; ix < d; ix++) {
            // выводим пробелы
            printf("            ");
        }
        output_poly(n, P);
 
        // вывод многочлена Q 
        printf("\nPolynom Q(x):     ");
        output_poly(m, Q);
        
    }
 
    // вычисление разности полиномов P и Q и запись результата в R
    R = substract_poly(n, P, m, Q, &r);
 
    // вывод полинома-разности
    printf("\n\nR(x) = P(x)-Q(x): ");
    output_poly(r, R);
    
 
    // --- расчет и вывод значений полиномов при х=3 --------------------------------
 
    // рассчитываем значения полиномов при х=3
    P3 = calc_poly(n, P, 3);
    Q3 = calc_poly(m, Q, 3);
    R3 = calc_poly(r, R, 3);
 
    // выводим значения полиномов при х=3
    printf("\n\nP(x=3) = %5.3f", P3);
    printf("\nQ(x=3) = %5.3f", Q3);
    printf("\nR(x=3) = %5.3f", R3);
 
    // проверяем корректность вычислений
    if (R3 = P3-Q3) {
        printf("\n\nSubstraction correct! (R(x=3) = P(x=3) - Q(x=3) = %5.3f - %5.3f = %5.3f)", P3, Q3, R3);
    }
    else {
        printf("\n\nSubstraction incorrect! (R(x=3) <> P(x=3) - Q(x=3) = %5.3f - %5.3f <> %5.3f)", P3, Q3, R3);
    }
    
 
    // освобождаем память, выделенную под коэффициенты многочлена-разности R
    delete[] R;
    
 
    // освобождаем память, выделенную под коэффициенты многочлена Q
    delete[] Q;
 
    // освобождаем память, выделенную под коэффициенты многочлена Р
    delete[] P;
 
    // задержка до нажатия любой клавиши (чтобы не закрывалось консольное окно)
    getch();
 
}