Grupo Lógica de Programação
ESTAMOS EM CONSTRUÇÃO - DESENVOLVIMENTO


Seja Bem Vindo ao Forum Grupo Lógica de Programação é uma satisfação recebê-los aqui.. espero que gostem desse espaço que foi feito para todos nós PROGRAMADORES.. Então venha fazer Parte deste Time tambem.. Saiba que este Forum foi feito com muita dedicação para o bem estar de todos vocês.. Então Registre-se e Decole no Mundo da Programação.....
Ao se Registrar você tem direito a participar do CHAT que só é visivel ao membros registrados. e pode bater papo com algum outro membro que estiver on line.. caso tenha alguma duvida pode olhar no Menu FAQ as perguntas mais recentes.
Bons Estudos é o que deseja todos nós que fazemos o GRUPO LÓGICA DE PROGRAMAÇÃO acontecer...

(EL MENSAJERO [FUNDADOR])

[Resolvido]Ajuda raiz quadrada usando iteração.

Ver o tópico anterior Ver o tópico seguinte Ir em baixo

[Resolvido]Ajuda raiz quadrada usando iteração.

Mensagem por Brunostelmack em Ter 29 Jan 2013, 10:50

Boa tarde galera, sou iniciante na programação, se alguém puder dar um ajudinha ai na lógica desde exercícios, pois já tentei de várias maneiras e não saio do lugar, grato desde já.


Este é o Exercício:

Um método iterativo para calcular a raiz quadrada é o seguinte: primeiro, buscamos um limite inferior, ou seja, um número cujo quadrado é menor do que x. Por exemplo, se x=20, o número poderia ser 3, porque 32=9 (menor que 20). Achamos então um limite superior, um número cujo quadrado é maior que x – no exemplo, o limite superior poderia ser 10, já que 102=100 (maior que 20). Sabemos então que a raiz de 20 está entre 3 e 10. Tomamos então um valor que esteja entre estes limites – por exemplo, 6.5. Verificamos se o quadrado deste valor é maior ou menor que x. Como 6.52=42.25, que é maior que x, sabemos que a raiz de x deve ser menor que 6.5. Atualizamos os limites e repetimos a operação, até encontrarmos um número cujo quadrado seja suficientemente próximo de x. A tabela abaixo mostra algumas iterações do algoritmo para x=20, escolhendo como limites iniciais 3 e 10, e escolhendo como palpite a média dos limites.

Iteração Limite inferior Limite superior Palpite Quadrado
0 3 10 6.5 42.25
1 3 6.5 4.75 22.56
2 3 4.75 3.88 10.05
3 3.88 4.75 4.32 18.66
4 4.32 4.75 4.54 20.61
5 4.32 4.54 4.43 19.63
6 4.43 4.54 4.49 20.16
7 4.43 4.49 4.46 19.89
8 4.46 4.49 4.48 20.07

Note que outros métodos poderiam ter sido escolhidos para determinar os limites iniciais e o palpite – no exemplo acima, o limite inferior poderia ser qualquer valor menor que √x, o limite superior poderia ser qualquer valor maior que √x, e o palpite poderia ser qualquer valor entre o limite inferior e o superior.

Note também que o quadrado do palpite tende a se aproximar cada vez mais da solução correta, enquanto os limites ficam cada vez mais próximos entre si. Chamamos isto de convergência. Existem métodos para se aproximar a raiz quadrada que convergem mais rápido que este, mas este método é intuitivo, e qualquer pessoa com conhecimentos elementares de matemática pode compreender seu mecanismo (e, se a precisão exigida for baixa, reproduzí-lo usando papel e caneta).
==================================================================================
O último que eu fiz, está aqui em baixo,grato desde já.

#include
#include

int main()
{
double x, cont,cont1,limite_inferior, limite_superior,palpite,teste,erro;

printf("digite x: \n");
scanf("%lf", &x);

printf("Digite erro: \n");
scanf("%lf", &erro);

cont=x;

while(cont*cont>x) \\ Para encontrar o limite inferior.
{
cont --;
}
limite_inferior= cont;

cont1=cont;

while(cont1*cont1 {
cont1 ++;
}
limite_superior=cont1;

palpite=(limite_superior+limite_inferior)/2;

while(teste {

if(palpite*palpite>x)
{
while(palpite*palpite>x)
{

limite_superior=palpite;
palpite=(limite_superior+limite_inferior)/2;
teste=(palpite*palpite)-x;
}
}


else
{
while(palpite*palpite {

limite_inferior=palpite;
palpite=(limite_superior+limite_inferior)/2;
teste=(palpite*palpite)-x;
}
}
}




printf("O valor do LS eh %lf\n", limite_superior);
printf("O valor da raiz eh %lf\n", palpite);
printf("O valor do LI eh %lf\n",limite_inferior);

return 0;
}

Brunostelmack
Novo no Fórum
Novo no Fórum

Mensagens : 1
Pontos : 6
Reputação : 0
Data de inscrição : 29/01/2013

Voltar ao Topo Ir em baixo

^^ o que entendi e uma das implementações possíveis

Mensagem por Adriane Medeiros em Dom 29 Dez 2013, 23:53

Olá,
Pelo que entendi você deseja encontrar a raiz quadrada de um número
inteiro não-quadrado perfeito...
Antes de colocar o código, escreverei como montei a lógica do programa =)
Então vamos a lógica ...

Passo 1 - Determinar os limites
Podemos observar que a raiz de um numero inteiro,não quadrado perfeito,
está entre a raiz exata imediatamente anterior e a raiz exata
imediatamente posterior:

√7 está entre  √4 e √9 ou seja,  √7 esta entre 2 e 3
√54 está entre  7 e 8  ou seja,  √54 esta entre √49 e  √64

Sabendo disso, para encontrar o limite inferior de  √7, por exemplo,
comecei subtraindo 1 do numero e verificando se a raiz é exata,
caso seja exata o limite inferior será o resultado desta raiz, caso
contrario continuo decrementando 1 do numero até que se encontre
uma raiz exata.
Para encontrar o limite superior usei a metodologia inversa, ou seja,
somando 1 ao numero, e verificando se sua raiz é exata, caso não seja,
continuo somando 1, até que se encontre um que tenha a raiz exata e
por conseguinte encontrar o limite superior.

Passo 2 -  Encontrar a Raiz
Tendo os limites extremos, eu partir da premissa de que a
raiz seria =  0.1+limiteInferior então testei sucessivamente o quadrado desta raiz até que ela fosse aproximadamente igual ao numero.

Segue o código...

#include
#include
#include

int lmtInferior(int x)
{
   int num = --x, exata=0;
   float inferior, teste;

   /*teste para econtrar a raiz exata anterior a x*/
   while(!exata)
   {
        inferior = sqrt(num);
        teste = inferior - (int)inferior; /*teste para verificar se essa raiz é exata*/
        if(teste > 0) /*caso a raiz não seja exata testa o numero
                      anterior e continua a procura*/
           num--;
        else  /*caso seja exata, termina o laço*/
           exata = 1;        
   }

  return inferior;    
}

int lmtSuperior(int x)
{
   int num = ++x, exata=0;
   float superior, teste;

   while(!exata)
   {
        superior = sqrt(num);
        teste = superior - (int)superior;
        if(teste > 0)
           num++;
        else
           exata = 1;        
   }
  return superior;    
}

float encontraRaiz(int inferior, int superior, int num)
{
     float raiz = inferior + 0.1;
     float teste = raiz * raiz;

     
     while(teste < num)
     {
          raiz += 0.1;
          teste = raiz * raiz;
                           
     }
   raiz -= 0.1;

   return raiz;
}

int
main(void)
{
  int num, inferior, superior;
  float raiz;
 
  printf("Qual raiz nao exata deseja encontrar?\n");
  scanf("%d", &num);
 
  printf("Limite Inferior = %d\n", inferior = lmtInferior(num));
  printf("Limite Superior = %d\n", superior = lmtSuperior(num));  

  printf("Raiz eh aproximadamente  %.1f\n", raiz = encontraRaiz(inferior, superior, num));

  printf("\n");
  system("pause");
  return 0;
}

Enfim, espero ter ajudado um pouco ^^  Very Happy Surprised

Adriane Medeiros
Moderador
Moderador

Mensagens : 2
Pontos : 6
Reputação : 0
Data de inscrição : 29/12/2013
Idade : 22
Localização : Manaus

Voltar ao Topo Ir em baixo

Ver o tópico anterior Ver o tópico seguinte Voltar ao Topo

- Tópicos similares

 
Permissão deste fórum:
Você não pode responder aos tópicos neste fórum