Programa que obtém a raiz quadrada de um número via aproximação recursiva, o código não possui NENHUMA variável e é 100 por cento funcional,
então é ótimo pra quem quer aprender programação funcional ou recursividade.  Fique a vontade para testar, modificar ou usar em seus programas.

Construí o código porque estou montando um software gráfico totalmente recursivo e não queria sujar o programa com algum loop ou ter que usar a  math.h.

• Download 7060.raiz.c
• Enviar nova versão

Esconder código-fonte

#include <stdio.h>
#define CONTADOR 16

// Essa função retorna um número aproximado do resultado
const int retorna_contador_de_potencia   (const double *vetor_de_potencia,  const double numero,  int contador_de_potencia){

if (vetor_de_potencia [contador_de_potencia] >= numero/10){
--contador_de_potencia;
contador_de_potencia = retorna_contador_de_potencia(vetor_de_potencia,numero,contador_de_potencia);}


return (contador_de_potencia);
}

// essa aproxima o resultado em sentido positivo
const double retorna_resultado_positivo  (const double *vetor_de_potencia,  const double numero,  double resultado_positivo,   int contador_de_potencia){

if (resultado_positivo  * resultado_positivo  >= numero ){return (resultado_positivo);}

resultado_positivo  = resultado_positivo + vetor_de_potencia[contador_de_potencia];

resultado_positivo = retorna_resultado_positivo(vetor_de_potencia, numero,  resultado_positivo,  contador_de_potencia);

}

// essa aproxima o resultado em sentido negativo
const double retorna_resultado_negativo  (const double *vetor_de_potencia,  const double numero,  double resultado_negativo,   int contador_de_potencia){

if (resultado_negativo  * resultado_negativo  <= numero ){return (resultado_negativo);}

resultado_negativo  = resultado_negativo - vetor_de_potencia[contador_de_potencia];

resultado_negativo = retorna_resultado_negativo(vetor_de_potencia, numero,  resultado_negativo,   contador_de_potencia);

}

/* essa é a função mais importante ela acha o resultado
através de um decremento no contador a cada ciclo que se passa */
const double recursao_que_obtem_resultado(const double *vetor_de_potencia,  const double numero,  double resultado,            int contador_de_potencia){

resultado  = retorna_resultado_positivo(vetor_de_potencia, numero,  resultado,  contador_de_potencia);

--contador_de_potencia;  //|Acontece o decremento do contador

resultado = retorna_resultado_negativo(vetor_de_potencia,     numero,   resultado, contador_de_potencia);


switch (contador_de_potencia) {

  case 0:
  return (resultado);
  break;

  default:
  resultado = recursao_que_obtem_resultado(vetor_de_potencia, numero,  resultado,  contador_de_potencia );
  break;
}


}

// função só pra capturar o número e não precisar sujar o código com variáveis
const double captura_numero(void){
double numero;
scanf("%lf",&numero);
return (numero);
}


int main (void){

//| Esse é o vetor para obter os cálculos de aproximação
const double vetor_de_potencia [] ={
0.00000001,             //|0
0.000001,               //|1
0.00001,                //|2
0.0001,                 //|3
0.001,                  //|4
0.01,                   //|5
0.1,                    //|6
1,                      //|7
10,                     //|8
100,                    //|9
1000,                   //|10
10000,                  //|11
100000,                 //|12
1000000,                //|13
10000000,               //|14
100000000,              //|15
1000000000,             //|16
};

//---------------------------Strings de pergunda (nada demais)------------------------------------------
const char *pergunta_inicial        ="Por favor digite um número";
const char *declaracao_de_resultado ="A raiz quadrada é = ";
const char *pergunta_de_loop        ="deseja fazer outro cálculo (s) para sim e (n) para não";

//---------------------------Captura do número inicial---------------------------------------------------
printf("%s\n",pergunta_inicial);
const double numero =captura_numero();
//---------------------------Chamando as funções recursivas---------------------------------------------
/* a primeira constante obtem um número aproximado pra facilitar a
aproximação por tentativa e erro */
const int contador_de_potencia = retorna_contador_de_potencia(vetor_de_potencia, numero,CONTADOR);

/* A segunda constante declara o resultado inicial usando o contador de potencia
como referencia para o  vetor de potencia */
const double resultado_inicial = vetor_de_potencia[contador_de_potencia];

/* A terceira constante ja é o resultado final , por que ela chama a
recursão que obtem resultado, e a recursão que obtem resultado chama as duas
funções de aproximação */

const double resultado_final =recursao_que_obtem_resultado(vetor_de_potencia, numero, resultado_inicial,  contador_de_potencia);

//-----------------------------Printa os resultados e pergunta se quer voltar (nada demais)----------
printf("%s%lf\n", declaracao_de_resultado,resultado_final);
printf("%s\n",pergunta_de_loop);

getchar(); //| limpeza no buffer
const char resposta = getchar();

 //| swtich que chama a main novamente se a resposta for (s)
switch (resposta) {
  case 's' : main(); break;
  case 'S' : main(); break;
                   }

return 0;
}

Rotina para controle de portas paralelas em C.

Sistema básico de cadastro usando Listas Encadeadas

Beer.h

Jantar dos Filósofos - Programação Paralela

Leitura de String

Nenhum comentário foi encontrado.