Exercícios resolvidos sobre funções em C

Vamos agora resolver as questões propostas e comentar, em detalhes, os códigos das questões sobre funções que propomos no artigo passado em nosso curso online de C.

Questão 0, 1, 2 e 3:

Programa que calculas raízes de equação do segundo grau, até as complexas, em C

As questões 0, 1, 2 e 3 vão ensinar você a construir, passo a passo, um programa que recebe os coeficientes de uma equação do 2º grau, e devolver as raízes dele.

As funções que checam se um número é positivo, se é nulo e que retornam o valor delta são óbvias e você deve entender facilmente como fazer.

Vamos declarar os coeficientes como float, bem como as raízes, para que nossa aplicação seja mais flexível e aceite números decimais.

Como de praxe, vamos criar um laço DO WHILE para saber se o usuário desejar rodar o programa novamente, para calcular as raízes de uma nova equação. Como de costume, também usaremos uma variável inteira ‘continuar’ para o usuário escolher se vai querer continuar no programa ou não.

A primeira coisa que fazemos dentro do DO WHILE é pedir ao usuário os valores dos coeficientes.

Agora vamos a parte matemática da questão.

Para ser uma equação do segundo grau é necessário que o coeficiente de x² seja diferente de 0, no caso, é o nosso ‘a’.

Vamos criar um teste condicional do tipo IF ELSE e a função nulo() que criamos, para saber se esse coeficiente é 0 ou não.

Se for, a função nulo() retorna 1 e nossa aplicação é encerrada, pois não podemos calcular as raízes nesse caso.

Caso não seja nulo, a função nulo() retorna 0 e nosso teste cai no ELSE.

Ok, dentro do ELSE vamos checar se o delta é maior/igual a 0, pois se for, as raízes da equação serão reais.

Nesse caso, simplesmente aplicamos a fórmula de Bháskara.

Porém, vamos necessitar calcular uma raiz quadrada. Isso pode ser feito pela função sqrt() (de square root), que está na biblioteca math.h, por isso adicionamos ela no início.

Se o delta for menor que 0, as raízes serão imaginárias e serão da forma: x + i.y, onde i é conhecido como número imaginário, x é a parte real e y é a parte imaginária.

Lembre-se que você não pode calcular a raiz quadrada de um número negativo, por isso vamos multiplicar o delta por -1 para então tirar a raiz quadrada do delta.

Assim, imprimimos os números complexos dividindo a parte real da imaginária.

Esse programinha em C é bem útil, e com certeza você tem um irmão mais novo ou vizinho que irá adorar ter esse programa.

Código C:

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

int positivo(float n);
int nulo(float n);
float delta(float a, float b, float c);

int main()
{
    float a, b, c,
    raiz1, raiz2;
    int continuar;

    do
    {
        system("cls || clear");
        printf("Programa que acha as raizes de uma equacao do 2o grau: ax^2 + bx + c = 0\n\n");
        printf("Entre com os coeficientes a, b, e c: ");

        scanf("%f", &a);
        scanf("%f", &b);
        scanf("%f", &c);

        if( nulo(a))
            printf("'a' deve ser diferente de zero.");
        else
        {
            //Se delta for maior ou igual a zero, as raizes sao reais
            if( positivo( delta(a,b,c) ) || nulo( delta(a,b,c) ) )
            {
                raiz1 = ( (-1)*b + sqrt(delta(a,b,c)) )/(2*a);
                raiz2 = ( (-1)*b - sqrt(delta(a,b,c)) )/(2*a);
                printf("Raiz 1: %.2f\nRaiz 2: %.2f", raiz1, raiz2);
            }
            else
            {
                //Precisamos exibir a parte real e a parte imaginária separadamente
                //raiz 1
                printf("%.2f + i.%.2f\n", (-1)*b/(2*a),
                       sqrt((-1)*delta(a,b,c))/(2*a) );

                //raiz 2
                printf("%.2f - i.%.2f\n", (-1)*b/(2*a),
                       sqrt((-1)*delta(a,b,c))/(2*a) );
            }
        }

        printf("\n\nCalcular mais raizes?\n1. Continuar\n0. Sair\n");
        scanf("%d", &continuar);
    }
    while(continuar);
}


int positivo(float n)
{
    if(n > 0)
        return 1;
    else
        return 0;
}

int nulo(float n)
{
    if(n == 0)
        return 1;
    else
        return 0;
}

float delta(float a, float b, float c)
{
    return ((b*b) - (4*a*c));
}

4. Crie uma função em linguagem C que receba 2 números e retorne o maior valor.

Código C:

float maior2(float num1, float num2)
{
    if(num1 >= num2)
        return num1;
    else
        return num2;
}

5. Crie uma função em linguagem C que receba 2 números e retorne o menor valor.

Código C:

float menor2()2(float num1, float num2)
{
    if(num1 <= num2)
        return num1;
    else
        return num2;
}

6. Crie uma função em linguagem C que receba 3 números e retorne o maior valor, use a função da questão 4.

Código C:

float maior3(float num1, float num2, float num3)
{
    if( maior2(num1, num2) >= num3)
        return (maior2(num1, num2));
    else
        return num3;
}

7. Crie uma função em linguagem C que receba 3 números e retorne o menor valor, use a função da questão 5.

Código C:

float menor3(float num1, float num2, float num3)
{
    if( menor2(num1, num2) <= num3)
        return (menor2(num1, num2));
    else
        return num3;
}

8. Crie uma função em linguagem C chamado Dado() que retorna, através de sorteio, um número de 1 até 6.

Código C:

int dado()
{
    return (1 + rand()%6);
}

9. Use a função da questão passado e lance o dado 1 milhão de vezes. Conte quantas vezes cada número saiu.
A probabilidade deu certo? Ou seja, a porcentagem dos números foi parecida?

Vamos criar 6 variáveis do tipo inteiro para armazenar quantos vezes cada um dos números do dado foi sorteado (não esqueça de inicializar elas com 0).

A seguir, faça um looping de 1 milhão de iterações.
A cada iteração, use um teste condicional para saber que número foi gerado pela função dado(), e incremente a variável correspondente.

Ao final do laço você saberá quantas vezes cada número foi sorteado. Divida por 1 milhão para saber a parcela que cada número apareceu, ou multiplique por 100 depois para obter a porcentagem.

O resultado deve ser algo bem 'justo', com cerca de 16,7% de aparição para cada face do dado.

Código C:

#include <stdio.h>
#include <time.h>

int dado();

int main()
{
    int num1=0, num2=0, num3=0, num4=0, num5=0, num6=0,
        count;

    for(count=0 ; count < 1000000 ; count++)
        switch( dado() )
        {
            case 1:
                num1++;
                break;
            case 2:
                num2++;
                break;
            case 3:
                num3++;
                break;
            case 4:
                num4++;
                break;
            case 5:
                num5++;
                break;
            case 6:
                num6++;
        }

    printf("Numero 1: %d -> %.2f\%%\n", num1, (num1/1000000.0)*100);
    printf("Numero 2: %d -> %.2f\%%\n", num2, (num2/1000000.0)*100);
    printf("Numero 3: %d -> %.2f\%%\n", num3, (num3/1000000.0)*100);
    printf("Numero 4: %d -> %.2f\%%\n", num4, (num4/1000000.0)*100);
    printf("Numero 5: %d -> %.2f\%%\n", num5, (num5/1000000.0)*100);
    printf("Numero 6: %d -> %.2f\%%\n", num6, (num6/1000000.0)*100);

    printf("\nTotal: %d -> %.2f\%%\n", num1+num2+num3+num4+num5+num6,
                                       (num1/1000000.0)*100+(num2/1000000.0)*100+
                                       (num3/1000000.0)*100+(num4/1000000.0)*100+
                                       (num5/1000000.0)*100+(num6/1000000.0)*100);

}

int dado()
{
    return (1 + rand()%6);
}