Polinômio - C - problema para desenvolver

[zuug]

Estou com dificuldade no exercício abaixo, o código que eu já consegui fazer segue logo após o exercício

se puderem me ajudar eu agradeço.

Um polinômio com os termos "a₀, ... ,a_n E R" com "a_n <> 0", tem sua função polinomial escrita da seguinte forma:

f(x) = a_nxⁿ + a_n - 1x^n-1 + ... + a₁x + a₀

Faça um programa que realize as operações de soma, subtração e multiplicação de polinômios. O seu programa deve apresentar o seguinte menu para a escolha do usuário:

1) Adicao

2) Subtracao

3) Multiplicacao

4) Sair

Operacao:

O programa deve continuar em loop até que a opção 4 seja escolhida.

---------------------------------------------------------------------------------

Operações com Polinômios:

Considere os polinômios p e q:

p(x) = a₀ + a₁x + a₂x² + ... + a_nxⁿ

q(x) = b₀ + b₁x + b₂x² + ... + b_nxⁿ

Adição

p(x) + q(x) = (a₀ + b₀) + (a₁ + b₁)x + (a₂ + b₂)x³ + ... + (a_n + b_n)xⁿ

Subtração

p(x) - q(x) = (a₀ - b₀) + (a₁ - b₁)x + (a₂ - b₂)x³ + ... + (a_n - b_n)xⁿ

Multiplicação

p(x) * q(x) = c₀ + c₁x + c₂x² + ... + c_nxⁿ, onde c é dado por: c_k = a₀b_k + a₁b_k-1 + a₂b_k-2 + ... + a_k-1b₁ + a_kb₀

---------------------------------------------------------------------------------

Entrada:

O usuário irá digitar apenas os coeficientes dos termos. As duas equações abaixo são equivalentes.

1 + 2x² + 3x⁴

1 + 0x¹ + 2x² + 0x³ + 3x⁴

Para representar o polinômio acima, o usuário irá digitar os coeficientes no seguinte formato:

1 0 2 0 3

Obs:

O usuário deve digitar o grau do polinômio e os dois polinômios da operação.

O grau maximo é 100.

Deve-se considerar que ambos os polinômios tem o mesmo grau.

Se os dois polinômios não tiverem o mesmo grau, o menor será preenchido com coeficientes zeros ate ambos polinômios estarem com o mesmo tamanho.

Os coeficientes são números reais.

A ordem de entrada dos termos é do menor grau para o maior grau.

Quando houver um termo nulo, o coeficiente será zero.

---------------------------------------------------------------------------------

Saida:

O polinômio de entrada: 1 0 2 0 3, ficaria da seguinte forma:

3.0x^4 + 2.0x^2 + 1.0

Obs:

Para cada operação, o programa deve imprimir o polinômio.

Deve-se imprimir primeiro, os termos de maior grau (ordem contrária da leitura dos coeficientes na entrada dos dados).

Imprima os sinais de + e - de acordo com o sinal do coeficiente. Há um espaço em branco antes e depois dos sinais (+ ou -), exceto se for o primeiro termo do polinômio, que tem o sinal de - junto do coeficiente.

Um termo é impresso da seguinte forma: 5.0x^3, onde o 5.0 é o coeficiente e o ^3 é o grau do termo.

O coeficiente deve ter uma casa de precisão.

não escrever coeficientes iguais a 1.0 ou -1.0.

Escrever apenas x e não x^1.

não escrever x^0.

Caso o usuário digite um grau inválido (menor ou igual a zero), deve-se imprimir na tela a frase: "Grau invalido" e retornar para o menu.

Caso o usuário digite uma opção não existente no menu, deve-se imprimir na tela a frase: "Opcao invalida" e retornar para o menu.

--------------------------------------------------------------------------------

Exemplo:

1) Adicao

2) Subtracao

3) Multiplicacao

4) Sair

Operacao: 1

Grau: 3

P1: 6 9 4 5

P2: 0 5 6 0

5.0x^3 + 10.0x^2 + 14.0x + 6.0

Neste exemplo de execução, encontram-se em vermelho as entradas do usuário. Seu programa deve imprimir todo o restante do texto.

---------------------------------------------------------------------------------

Observações:

Não utilize comandos do tipo: printf("Digite o valor de...");

Exercitar conceito: Vetores

Nome do arquivo: polinomio.c

Códigos sem edentação e sem comentários não serão corrigidos!

O programa deve ser submetido na linguagem C.

O número máximo de submissões é 10.

meu código:

#include <stdio.h>
int main(){
    float polinomio1[101];
    float polinomio2[101];
    float presultante[201];
    int grau, posicao, operacao;
    
    printf("1 - Adicao\n");
    printf("2 - Subtracao\n");
    printf("3 - Multiplicacao\n");
    printf("4 - Sair\n"); 
    switch(operacao){
           case 1:
            for(posicao=grau;posicao
            presultante = polinomio1[posicao] + polinomio2[posicao];
            printf("%f.1", presultante);
            break;
           case 2:
            presultante = polinomio1 + polinomio2;
            printf("%f.1", presultante);
            break;           
           case 3:
            presultante = polinomio1 * polinomio2;
            printf("f.1", presultante);
            break;           
           case 4:
            break;
           default:
            printf("Opção invalida");
    }
            
    printf("Grau:");
    scanf("%d", &grau);
    printf("P1");
    for(posicao=0; posicao<=grau; posicao++){
           scanf("%f", &polinomio1[grau]);
    }
    printf("P2");
    for(posicao=0; posicao<=grau; posicao++){
           scanf("%f", &polinomio2[grau]);
    }
}

abraços

Gustavo

Editado Abril 16, 2010 por zuug

[p4t0X]

Boa tarde!

Em qual parte você está tendo dificuldade?

É na parte de programação? Ou é do algoritmo?

[zuug]

estou com dificuldade de fazer o algoritmo

[p4t0X]

Certo, qual algoritmo? Soma, subtração,...?

[RonaldoRG]

Só duas coisas:

1- o polinômio presultante tá com o tamanho 202, mas na verdade ele tem que ter 101*101 = 10201 posições pois na multiplicação de polinômios geralmente o grau do resultante é o produto dos graus dos operandos.

2- O for do case 1 do switch está incompleto. E as operações dos polinômios estão erradas.

Você tem que fazer as operações como você colocou no seu post.

Primeiro você tem que ler o grau do polinômio e depois ler os dois polinômios e por fim fazer as operações.

Pense que cada coeficiente do polinômio é uma posição do vetor:

Ex. 3x² + 4x - 5

polinomio[0]= -5;

polinomio[1]= 4;

polinomio[2]= 3;

Depois posta o código. Abraço.

[zuug]

#include <stdio.h>

int main(){
    float polinomio1[101];                   //um polinomio de grau 100 apresenta 101 termos
    float polinomio2[101];
    float polinomioR[201];                   //um polinomio de grau 200 apresenta 201 termos
    int grau, posicao, opcao, operador, posicao2;
    
    operador=100;                            //inicializacao da variavel e condicao para que o menu continue aparecendo, numero escolhido aleatoriamente
    while(operador==100){                    //cria-se um menu para o usuario escolher a operacao
       printf("1) Adicao\n");                //o menu deve continuar rodando ate que o usuario escolha a opcao 4, por isso usa-se while
       printf("2) Subtracao\n");             
       printf("3) Multiplicacao\n");
       printf("4) Sair\n"); 
    
       printf("Operacao: ");                 
       scanf("%d", &opcao);                  //primeiro deve-se ler a operacao desejada pelo usuario
         if(opcao==4){                       //se for a operacao 4, o programa encerra
            operador=99;                     //condicao diferente da estipulada anteriormente no while para que o programa encerre
         }
         else if(opcao==0||opcao>4){         //se a opcao não for valida, o usuario deve ser avisado
            printf("Opcao Invalida");        
         }
         else{                               //se a opcao for valida, o programa executa os proximos comandos
             printf("Grau: ");              
             scanf("%d", &grau);             //apos ler a operacao, deve-se ler o grau do polinomio
             if((grau<=0)||(grau>100)){      //o grau tem que ser entre 1 e 100
                printf("Grau invalido");     //caso o grau seja invalido o usuario deve ser avisado
             }
             else{ 
    
                  printf("P1: ");            //o polinomio 1 é lido completamente, na ordem em que foi digitado
                  for(posicao=0; posicao<=grau; posicao++){
                     scanf("%f", &polinomio1[posicao]);
                  }
           
                  printf("P2: ");            //o polinomio 2 tambem é lido completamente, na ordem em que foi digitado
                  for(posicao=0; posicao<=grau; posicao++){
                     scanf("%f", &polinomio2[posicao]);
                  }
    
       switch(opcao){                        //as operacoes deve estar dentro do switch porque dependem da opcao escolhida pelo usuario
        
         case 1:                             //os polinomios são lido novamente e ao mesmo tempo ocorre a operacao de adicao
         for(posicao=0;posicao<=grau;posicao++){
           polinomioR[posicao] = polinomio1[posicao] + polinomio2[posicao];
           printf("%.1f ", polinomioR[posicao]);
         }
         break;
         case 2:                             //os polinomios são lidos novamente e ao mesmo tempo ocorre a operacao de subtracao
         for(posicao=0;posicao<=grau;posicao++){
           polinomioR[posicao] = polinomio2[posicao] - polinomio1[posicao];
           printf("%.1f ", polinomioR[posicao]);
         }
         break;           
         case 3:                            //o polinomio resultado deve ser zerado e o grau é o dobro dos polinomios iniciais
         for(posicao=2*grau; posicao>=0; posicao--){
           polinomioR[posicao]=0;
         }
                                            //os polinomios são lidos novamente e a multiplicacao é realizada
         for(posicao=0; posicao<=grau; posicao++){
           for(posicao2=0; posicao2<=grau; posicao2++){
                                            //os expoentes devem ser somados, logo as posicoes devem ser somadas.
              polinomioR[posicao+posicao2] = polinomioR[posicao+posicao2] + polinomio1[posicao] * polinomio2[posicao2];
            }                               //o polinomio resultado é somado aos outros polinomios para que o valor de cada multiplicacao não seja perdido
         }                                  //é necessario fazer um comando for para que o polinomio resultado seja impresso
         for(posicao=0; posicao<=grau*2;posicao++){
           printf("%.1f ", polinomioR[posicao]);
         }
         break;          
            
            
       }
       }
             } 
       printf("\n");
    }
       return 0;
}

[RonaldoRG]

Vou fazer uma correção do meu post anterior:

1- o polinômio presultante tá com o tamanho 202, mas na verdade ele tem que ter 101*101 = 10201 posições pois na multiplicação de polinômios geralmente o grau do resultante é o produto dos graus dos operandos.

Na verdade o grau vai ser a soma dos graus dos operandos. Desculpem a falha.