Dois Algoritmos...

[VaNdo.WcG]

Estou com dois exercicios aqui, qual não consigo faze, o primeiro e esse, que nem comecar consegui:

1. O número 3025 possui a seguinte característica: 30 + 25 = 55 -> 55*55 = 3025. Fazer um programa para obter todos os números de 4 algarismos com a mesma característica do número 3025.

Como eu faca pra desmembrar um numero em 2 assim?!?!

O outro e o seguinte:

2. Fazer um algoritmo para determinar e escrever o valor do seguinte somatório:

S = X – X2/3! + X4/5! – X6/7! + X8/!9 - ...

usando os n primeiros termos do somatório. O valor de X e de n é fornecido pelo usuário.

Esse eu fiz, mas não deu certo, como eu faco um fatorial?! Tem alguma biblioteca e comando que faca isso?!

O codigo 2 que não deu certo, a resposta sai errada:

#include <conio.h>
#include <stdio.h>
#include <math.h>

/*
2.	Fazer um algoritmo para determinar e escrever o valor do seguinte somatório: 
S = X - X2/3! + X4/5! - X6/7! + X8/!9 - ...
usando os n primeiros termos do somatório. O valor de X e de n é fornecido pelo usuário.
*/

main()
      {
      int contt;
      float n,x,xfat,s,den,num,ele,cfat,cont;
      ele=2;
      printf("Digite o numero de termos desejado:\n");
      scanf("%f",&n);
      printf("\nDigite um valor para X:\n");
      scanf("%f",&x);
      cfat=3;
      s=x;
      contt=1;
      if (n==1)
         {
         s=x;
         }
         else {
              do {
                 den=pow(x,ele);
                 ele=ele+2;
                 cont=cfat;
                 xfat=1;
                 do {
                    xfat=xfat*cont;
                    cont--;
                    } while (cont>0);
                 cfat=cfat+2;
                 if (contt%2==0)
                    {
                    s=s+(den/xfat);
                    }
                    else {
                         s=s-(den/xfat);
                         };
                 contt++;
                 n--;
                 } while (n>=0);
              };
         printf("\nS=%.2f",s);
      getch();
      }

[/codebox]

Obrigado, agradeco...

Editado Abril 4, 2007 por VaNdo.WcG

[Jonas de Abreu]

No primeiro, para extrair os dois primeiros digitos, voce pode usar /100. Para extrair os dois ultimos, use %100.

fatorial voce pode fazer dessa forma:

int fat(int n){
     if (n == 0) return 1;
     return n*fat(n-1);
}

O problema é que fatorial estoura rapidamente int, long long ou qualquer outro tipo predefinido que voce use. Para resolver o seu problema, tente usar um algoritmo construtivo mais ou menos dessa forma:

double parcela = x;/*aqui é a sua variavel x*/
double res = 0;
int i = 1;
while (i < n){
    res += parcela;
    parcela = -((parcela * x * x) / ((2*i) * (2*i + 1));
        i++;
}

res tera o seu resultado. Mas antes de sair usando esse codigo (que eu não compilei), note que pra tranformar a parcela "i" na parcela "i+1" basta multiplicar por x^2 e dividir por 2*i*(2*i + 1), e assim o fatorial vai se formando.

edicao:Faltava um i++ no codigo e as duas primeiras variaveis do codigo acima eram int. não ia funcionar.

Editado Abril 5, 2007 por Jonas de Abreu

[VaNdo.WcG]

Ainda sou iniciante nisso, e bom, não entendi nenhum dos exemplos... kkk

Como usar /100 e %100?!

Obrigado.

[Graymalkin]

Ainda sou iniciante nisso, e bom, não entendi nenhum dos exemplos... kkk

Como usar /100 e %100?!

Mas... você nem ao menos tentou? Nem ao menos sabe que "/" serve para dividir e que "%" serve para retornar o resto de uma divisão? Se você tivesse procurado a respeito destes operadores a utilização seria bastante óbvia:

#include <stdlib.h>
#include <stdio.h>

int main()
{
    int valor = 3025;
    
    int doisprimeiros, doisultimos;
    
    doisprimeiros = valor / 100;
    
    doisultimos = valor % 100;
    
    printf("%i\n", doisprimeiros);
    printf("%i\n", doisultimos);
    
    system("pause");
}

Certo? ;)

Graymalkin

[VaNdo.WcG]

Como eu ia tentar aquilo, sem nem entendi o que ele estava falando... está, esse /100 e %100 vai apresentar os resultados esperados para 3025.. agora, vai funcinar para todos os numeros de 4 algarismos tambem?!?!

[Jonas de Abreu]

A utilizacao desses operadores seguem o seguinte principio:

Em C, uma divisao de inteiros devolve um inteiro n tal que n é o maior inteiro que satizfaca n*k <= x, sendo x o numero que voce quer dividir por k.

O operador % devolve o resto da divisao acima, ou seja, devolve r, tal que n*k + r = x. Isso é muito matematico e talvez voce não esteja entendendo lhufas. então vamos pra parte pratica:

Quando fazemos uma divisao por uma potencia da base que estamos usando (no caso base 10) é o mesmo que extrair os primeiros digitos do numero:

então:seja ABCD um numero de quatro digitos(que são A, B, C e D):

ABCD / 100 = AB, pois AB*100 <= ABCD e AB é o maior pois CD nunca podera chegar a 100 na base 10.

ABCD % 100 = CD, pois AB*100 + CD = ABCD.

Com base em tudo isso, da pra voce ver que sempre que voce tiver 4 digitos e quiser extrair os dois primeiros voce simplesmente divide o numero por 100 e quando quiser os dois ultimos voce pega o resto da divisao por 100, ou seja, toma o modulo 100 do numero.

Espero que isso tenha clareado um pouco pra voce.

[VaNdo.WcG]

Perfeito, entendi sim, aqui esta o codigo do que eu fiz com a explicação, vlw...

#include <stdio.h>
#include <conio.h>

/*
1.	O número 3025 possui a seguinte característica: 30 + 25 = 55   -> 55*55 = 3025.
Fazer um programa para obter todos os números de 4 algarismos com a mesma característica do número 3025.
*/

main()
      {
      int num,AB,CD,soma,quadrado;
      num=1000;
      do {
          AB=num/100; // Levando o numero 3025 como exemplo, fosse ABCD, aqui seria 30.
          CD=num%100; // e aqui, 25.
          soma=AB+CD; // 30 + 25.
          quadrado=soma*soma; // 55 * 55.
          if (quadrado == num) // Caso o numero apressente esse caracteristica, sera testado e impresso aqui.
              printf("%d + %d = %d * %d = %d\n",AB,CD,soma,soma,num);
          num++;
         } while (num<=9999);
      getch();
      }[/codebox]

Agora como eu faço esse exercicio?!

10. Fazer um algoritmo para determinar e escrever o valor do seguinte somatório:

S = X - X2/3! + X4/5! - X6/7! + X8/!9 - ...

usando os n primeiros termos do somatório. O valor de X e de n é fornecido pelo usuário.

Ate o fiz, com uma logica que achei aqui, mas da resultados errados, o codigo:

[codebox]#include <conio.h>
#include <stdio.h>
#include <math.h>

/*
10. Fazer um algoritmo para determinar e escrever o valor do seguinte somatório:
S = X - X2/3! + X4/5! - X6/7! + X8/!9 - ...
usando os n primeiros termos do somatório. O valor de X e de n é fornecido pelo usuário.
*/

main()
{
int contt;
float n,x,xfat,s,den,num,ele,cfat,cont;
ele=2;
printf("Digite o numero de termos desejado:\n");
scanf("%f",&n);
printf("\nDigite um valor para X:\n");
scanf("%f",&x);
cfat=3;
s=x;
contt=1;
if (n==1)
{
s=x;
}
else {
do {
den=pow(x,ele);
ele=ele+2;
cont=cfat;
xfat=1;
do {
xfat=xfat*cont;
cont--;
} while (cont>0);
cfat=cfat+2;
if (contt%2==0)
{
s=s+(den/xfat);
}
else {
s=s-(den/xfat);
};
contt++;
n--;
} while (n>=0);
};
printf("\nS=%.2f",s);
getch();
}

Como posso faze-lo?! Acho que o erro e nos fatoriais, onde mais me perdi.

Brigadao aí..

Editado Abril 5, 2007 por VaNdo.WcG

[Jonas de Abreu]

O segundo algoritmo do post dois calcula esta expansao de Taylor. Mas aqui vai um que é mais compreensivel, mas muito menos otimizado (dependendo da precisao ele pode levar muito mais tempo pra executar):

int n;
double x;

double res = x;
for (i = 2; i <= 2*n; i+= 2){
     if ((i / 2) % 2 == 1)/*controla o sinal da parcela*/
         res += pow(x, i)/fat(i+1);
     else
         res -= pow(x, i)/fat(i+1);
}

Para calcular o fatorial voce pode usar a funcao do post #2. Mas eu realmente aconselho voce a dar uma olhada na versao construtiva deste algoritmo (post #2). Aquela é uma estrategia geral pra calcular sequencias como essa de forma eficiente.

[VaNdo.WcG]

De fato eu ainda não entendi, tentei comeca do zero e bom, continua dando resultados errados.

O que seria double? um tipo de variavel?

E fat?! um comando como pow?!

obrigado pela paciencia.

[Jonas de Abreu]

Acho que já estou entendendo o problema aqui. Voce provavelmente nunca programaou em uma linguagem estruturada como C. Vou então explicar uns conceitos basicos de C (e de diversas outras linguagens estruturadas):

Em C, existem diversos tipos predefinidos (chamados tipos primitivos). são esses tipos que nos usamos para declarar variaveis ou criar estruturas mais complexas (usando struct). Alguns desses tipos: int (inteiro), float (ponto flutuante de precisao simples), double (ponto flutuante de precisao dupla), char (caractere), etc.

C é uma linguagem com suporte nativo a funcoes. Uma funcao é um bloco de codigo que possui as seguintes propriedades:

1 - Possui um tipo de retorno (mesmo que seja void);

2 - Possui um nome (identificador);

3 - Pode ou não possuir parametros;

4 - é executado quando seu identificador é usado (na verdade o identificador de funcao é um ponteiro, mas não vamos entrar em detalhes)

5 - Pode ser definida pelo programador.

Possui outras propriedades mas não vem ao caso.

fat e pow são funcoes. A primeira recebe um inteiro como parametro e a segunda recebe dois double como parametros. A primeira voce pode usar a funcao que eu defini no post #2. A segunda já esta na biblioteca que voce esta incluindo (math.h).

Essas funcoes funcionam do seguinte modo: Quando voce as chama (escreve o nome delas e coloca os parametros como eu fiz no post #8), elas vao executar o bloco de codigo delas (que fica depois da declaracao da funcao e entre { e } como voce pode ver no post #2) e colocar o resultado delas no mesmo lugar em que foram chamadas. Assim, ao invés de eu calcular o fatorial do numero colocando em uma variavel e depois usar a variavel para dividir, já divido pela funcao, sabendo que ela vai devolver o resultado e ele sera usado como uma variavel. O mesmo vale para o pow.

O proprio main que voce declarou é uma funcao (que é chamada pelo inicializador do seu programa, algo que raramente precisamos mexer).

Se tiver mais duvidas sobre funcoes ou structs que eu citei mais acima, abra um (ou quantos forem necessarios) novo tópico no forum e a gente discute la.

[VaNdo.WcG]

E... realmente, estou no comeco, agora que estou aprendendo a programar... E bom, isso que me disse eu entendendo. O problema que não estou sacando a logica do seu codigo, nem as explicacoes e mesmo tentando compila-lo, não vai..

[Jonas de Abreu]

Este codigo que eu tinha colocado na compila. A ideia é ele servir de base pra voce escrever o seu codigo. Vou colocar detalhadamente o caminho que eu fiz pra chegar a esse codigo:

Como é uma somatoria de N termos, achei mais facil calcular um termo por vez e soma-lo (ou subtrai-lo) de uma variavel que armazena o resultado.

Chamei de i o indice do termo e dai olhei pra sequencia procurando um padrão de construcao:

S = X - X2/3! + X4/5! - X6/7! + X8/!9

Tirando o primeiro termo (i = 0), os outros são formados dessa forma como uma funcao de i (Vou chamar de S o iesimo termo da sequencia):

S[1] = (X^2)/3! = (X^(2*i))/(2*i + 1)!

S[2] = (X^4)/5! = (X^(2*i))/(2*i + 1)!

A partir desse ponto, assumi que todos os termos subsequentes vao ser da mesma forma, como funcao de i. (Eu já conhecia esta somatoria, mas voce prova por inducao que isso é verdade).

em C, cada termo ficaria mais ou menos assim:

S = pow(x, 2*i)/fatorial(2*i + 1);

Faltava definir fatorial, mas já tinhamos feito isso no post #2, então onde escrevi a chamada para a funcao fatorial, podemos simplesmente a funcao fat. então:

S = pow(x, 2*i)/fat(2*i + 1);

Agora falta fazer um loop para calcular N termos

Para o loop, eu notei que a gente pode simplificar a funcao se definirmos j como 2*i

S[j/2] = pow(x, j)/fat(j+1);

Note que a funcao é exatamente a mesma, apenas fiz uma troca de variaveis para facilitar o codigo.

Como j = 2*i, quando queremos calcular o termo i, calculamos o termo j/2.

então em um loop que ira calcular todas os termos, a nossa variavel que controla o termo sendo calculado sera incrementada de 2 ao invez de um (novamente porque j = 2*i)

Para saber quando eu cheguei ao termo N, que é o ultimo a ser calculado, novamente me vali que j = 2*i. Se i deveria parar em N, j tem que parar em 2*N.

Faltava apenas um pequeno detalhe: Existe uma alternancia de sinal entre os termos. De alguma forma eu preciso saber se eu devo somar ou subitrair do resultado este termo. Em

S = X - X2/3! + X4/5! - X6/7! + X8/!9 -

da pra notar que os termos impares devem ser subtraidos (estou contando o primeiro termo como sendo o termo zero)

como a minha variavel é j (que é igual a 2*i), primeiro eu precisava tranformar j em i e depois ver se ele é impar.

Como o resto da divisao de um numero impar por dois sempre resulta em 1, cheguei a seguinte condicao:

((j/2)%2 == 1)

então montando o codigo, ficou assim:

res = X;
for (j = 2; j <= 2*n; j+=2){
     if ((j/2)%2 == 1)/*o termo é impar*/
         res = res - pow(x, j)/fat(j+1);
     else /*o termo é par*/
         res = res + pow(x, j)/fat(j+1);
}

Como voce nota, a cada interacao do for o termo é calculado e ate o termo j/2 (termo i) a somatoria já esta na variavel res.

Quando o laco termina, todos os termos já foram colocados na variavel res.

Apenas mais um comentario. Como a nossa formula funciona apenas para os termos a partir do segundo (termo 1)

, eu inicializo o resultado com o primeiro termo (termo 0) que é X. dai o laco calcula os outros (por isso ele comeca a partir de j = 2).

Para mostrar o que acontece com o valor da variavel res, aqui vai um diagramazinho de cada interacao:

Antes de comecar:

res = X

Valor de j | Valor de res

2 | X - X2/3!

4 | X - X2/3! + X4/5!

6 | X - X2/3! + X4/5! - X6/7!

8 | X - X2/3! + X4/5! - X6/7! + X8/!9

e assim por diante.

Espero que eu tenha conseguido clarear o algoritmo para voce. Caso não entenda alguma coisa, não se preocupe e continue perguntando ate que tenha entendido. Faz parte do aprendizado.

[VaNdo.WcG]

Nss... perfeito, entendi tudo, vlw, mas ainda não consegui como definir a funçao agora, assim como no post 2...

Obrigado...

[Jonas de Abreu]

Para definir a funcao, basta voce colocar o seguinte codigo antes do lugar onde ela for usada (e fora de outras funcoes).

No caso da funcao fatorial:

double fat(int n){
     if (n == 0)
           return 1.0;
     return n*fat(n-1);
}

[VaNdo.WcG]

Rsrs, vlw aí pela ajuda, mas ainda não saquei de como definir essas funcoes e tal. Ainda esse ano eu aprende, rsrs...

Tentei pela enesima vez e por incrivel que pareca, dessa vez eu consegui, rsrs... resposta certa, pra quem queira ver:

#include <stdio.h>
#include <conio.h>
#include <math.h>

/*
10.	Fazer um algoritmo para determinar e escrever o valor do seguinte somatório: 
S = X - X2/3! + X4/5! - X6/7! + X8/!9 - ...
usando os n primeiros termos do somatório. O valor de X e de n é fornecido pelo usuário.
*/

main()
    {
    float fatorial,Nfatorial,ContFatorial,VALORX,SOMA;
    int NUMEROdeTERMOS,CONTADOR,EXPOENTE;
    printf("Digite o numero de termos desejados:\n");
    scanf("%d",&NUMEROdeTERMOS);
    printf("Digite o valor para X:\n");
    scanf("%f",&VALORX);
    CONTADOR=2;
    EXPOENTE=2;
    SOMA=0;
    ContFatorial=3;
    while (CONTADOR<=NUMEROdeTERMOS)
        {
             Nfatorial=ContFatorial;
             fatorial=Nfatorial;
             while (Nfatorial>2)
                 {
                 fatorial=fatorial * (Nfatorial-1);
                 Nfatorial--;;
                 }
             if (NUMEROdeTERMOS==1)
                  SOMA=VALORX;
                       else
                       {
                            if (CONTADOR%2==0)
                                 {
                                      SOMA=SOMA-(pow(VALORX,EXPOENTE)/fatorial);
                                      EXPOENTE=EXPOENTE+2;
                                 }
                                      else
                                      {
                                           SOMA=SOMA+(pow(VALORX,EXPOENTE)/fatorial);
                                           EXPOENTE=EXPOENTE+2;
                                      }
                       };
             CONTADOR++;
             ContFatorial=ContFatorial+2;
        }
        SOMA=SOMA+VALORX;
        printf("O valor de S, sera:%.5f.",SOMA);
    getch();
    }
[/codebox]

Muuuuito obrigado.