Laboratório de Código

#include <stdio.h>

void main(){
    
    int quantidade=10;
    double pi=3.14159265;
    float valor=1.25;
    char letra = 'A';
    
    printf("Foram compradas %d maçãs a R$ %5.2f cada", quantidade,valor);
    printf("%c constante pi = %5.4lf",letra,pi);
    
}

#include <stdio.h>

void main(){
    
    char nome[30], endereco[50];
    int idade;
    
    printf("Informe o seu nome: ");
    scanf("%s",nome);
    printf("Informe a sua idade: ");
    scanf("%d",&idade);
    printf("Informe o seu endereço: ");
    scanf("%s",endereco);
    
    printf("%s tem %d anos e mora em %s",nome,idade,endereço);
}

/***Faça um algoritmo que leia a quantidade de pêras compradas em
uma mercearia e o valor da unidade. O algoritmo deve informar o total
a ser pago pelo cliente.***/
#include <stdio.h>

void main(){
    int qtde;
    float valor, total;

    printf("Digite a quantidade de pêras compradas: ");
    scanf("%d",&qtde);
    printf("Digite o valor da unidade da pêra (R$): ");
    scanf("%f",&valor);
   
    printf("\e[H\e[2J"); //esse comando limpa a tela
   
    total = valor*qtde;
    printf("Você deve pagar R$ %2.2f pelas %d unidades de pêra.",total,qtde);
}

/***Um motorista de táxi deseja calcular o rendimento de seu carro na
praça. Sabendo-se que o preço do combustível é de R$ 1,90, escreva
um programa para ler: a marcação do odômetro (Km) no início do dia,
a marcação (Km) no final do dia, o número de litros de combustível gasto
e o valor total (R$) recebido dos passageiros. Faça um algoritmo que
calcule e mostre a média do consumo em Km/L e o lucro líquido do dia.***/
#include <stdio.h>

#define preco 1.9

void main(){
    float inicio,fim,litrosGasto,total;

    printf("Digite a marcação do odômetro (Km) no início do dia: ");
    scanf("%f",&inicio);
    printf("Digite a marcação do odômetro (Km) no fim do dia: ");
    scanf("%f",&fim);
    printf("Digite a qtde de combustível gasta (lts): ");
    scanf("%f",&litrosGasto);
    printf("Digite o valor total recebido pelo taxista (R$): ");
    scanf("%f",&total);
   
    printf("O consumo do carro foi = %2.2f Km/l \n",((fim-inicio)/litrosGasto));
    printf("O lucro do dia foi = R$ %2.2f\n",(total-litrosGasto*preco));
}

/*********************
Escreva um algoritmo para ler o número total de eleitores de um município,
o número de votos brancos, nulos e válidos. Calcular e escrever o percentual
que cada um representa em relação ao total de eleitores.
**********************/
#include <stdio.h>

void main(){
    int total;
    printf("Informe a quantidade total de eleitores: ");
    scanf("%d",&total);
   
    int brancos;
    printf("Informe a quantidade de votos brancos: ");
    scanf("%d",&brancos);
   
    int validos;
    printf("Informe a quantidade de votos válidos: ");
    scanf("%d",&validos);
   
    int nulos = total - brancos - validos;
   
    float p_brancos = brancos*100/total;
    float p_nulos = nulos*100/total;
    float p_validos = validos*100/total;
   
    printf("Percentual de votos Válidos = %.1f%%, Percentual de votos Brancos = %.1f%%, Percentual de votos Nulos = %.1f%%", p_validos,p_brancos,p_nulos);
}

/******************************************************************************
Faça um algoritmo que leia as dimensões de uma sala retangular, largura e comprimento.
Leia as dimensões do azulejo quadrado que será utilizado na reforma desta sala.
Por fim, informe quantos azulejos serão necessários para cobrir todo o chão da sala.
*******************************************************************************/
#include <stdio.h>

int main()
{
    float largura, comprimento;
    printf("Digite a largura e o comprimento da sala (em metros): ");
    scanf("%f %f",&largura, &comprimento);
   
    float ladoAzulejo;
    printf("Digite a medida do lado do azulejo (em metros): ");
    scanf("%f",&ladoAzulejo);
   
    float qtde = (largura*comprimento)/(ladoAzulejo*ladoAzulejo);
   
    printf("Qtde de azulejos = %.0f", qtde+1);
    return 0;
}

//Faça um algoritmo que leia 3 valores inteiros e informe a soma dos dois maiores

#include <stdio.h>

void main() {
    int a,b,c,soma;
    
    printf("Informe 3 números inteiros quaisquer:");
    scanf("%d %d %d",&a,&b,&c);
    
    soma = ((a>c)&&(b>c))?(a+b):(((a>b)&&(c>b))?(a+c):(b+c));
    
    printf("Soma = %d",soma);
}

/******************************************************************************
Faça um algoritmo que leia um número inteiro e informe se ele é par ou ímpar
*******************************************************************************/
#include <stdio.h>

void main(){
int x;
    
    printf("Informe um número inteiro qualquer: \n");
    scanf("%d",&x);
    
    if ((x % 2)==0) printf("Número par");
    else printf("Número ímpar");
}

/******************************************************************************
Faça um algoritmo que leia um número e informe se ele é positivo, negativo ou nulo
*******************************************************************************/
#include <stdio.h>
#include <math.h>

void main(){
float x;
   
    printf("Informe um número qualquer: \n");
    scanf("%f",&x);
   
    if (x > 0){
        printf("Positivo");
    }else if (x < 0){
        printf("Negativo");
    }else{
        printf("Nulo");
    }
}

/******************************************************************************
Faça um algoritmo que leia as coordenadas de um ponto cartesiano
(x, y) e informe em qual quadrante o ponto está, ou se ele está na
origem (0, 0), ou em um dos eixos (eixo x ou eixo y).
*******************************************************************************/

#include <stdio.h>

void main(){
    float x,y;
    printf("Digite as coordenadas do ponto (x,y): \n");
    scanf("%f %f",&x,&y);
   
    if((x>0) && (y>0)) printf("1º Quadrante");
    else if((x<0) && (y>0)) printf("2º Quadrante");
    else if((x<0) && (y<0)) printf("3º Quadrante");
    else if((x>0) && (y<0)) printf("4º Quadrante");
    else if((x==0) && (y!=0)) printf("Eixo Y");
    else if((x!=0) && (y==0)) printf("Eixo X");
    else printf("Origem");
   
}

// 3. Faça um algoritmo que calcule o peso ideal de uma pessoa a partir de seus dados de altura e sexo (f - feminino e m - masculino)
// peso ideal dos homens = (72,7*altura) - 58
// peso ideal das mulheres = (62,1*altura) - 44,7
#include <stdio.h>

void main(){
    float altura,pesoIdeal;
    char sexo;
   
    printf("Informe o sexo: 'f'=feminino e 'm'=masculino:\n");
    scanf("%c",&sexo);
    printf("Informe a altura:\n");
    scanf("%f",&altura);
   
    if (sexo = 'f') pesoIdeal = (62.1*altura)-44.7;
    else pesoIdeal = (72.7*altura)-58;
   
    printf("Peso ideal = %.1f",pesoIdeal);
}

/******************************************************************************
Faça um algoritmo que leia três números, calcule a média e informe:
• "APROVADO", caso a média seja maior ou igual a 7,0
• "REPROVADO", caso a média seja menor ou igual a 2,5
• "PROVA FINAL", caso a média esteja entre 2,5 e 7,0
*******************************************************************************/

#include <stdio.h>

int main(){
    float n1,n2,n3,media;
    printf("Digite as três notas do aluno:\n");
    scanf("%f %f %f",&n1,&n2,&n3);
   
    media = (n1+n2+n3)/3;
   
    if (media>=7) printf("APROVADO");
    else if (media <= 2.5) printf("REPROVADO");
    else printf("PROVA FINAL");
   
    return 0;
}

/******************************************************************************
Faça um algoritmo que leia duas notas regulares e uma nota optativa
(caso o aluno não tenha nota optativa, digitar -1) e informe a média
das duas maiores notas, de acordo com as notas fornecidas.
*******************************************************************************/

#include <stdio.h>

void main(){
    float n1,n2,op,media;
    printf("Digite as duas notas do aluno: \n");
    scanf("%f %f",&n1,&n2);
    printf("Digite a notas optativa (-1 caso não tenha): \n");
    scanf("%f",&op);
   
    if(op!=-1){
        if((n1>n2) && (op>n2)) media = (n1+op)/2;
        else if ((n2>n1) && (op>n1)) media = (n2+op)/2;
        else if ((n2>op) && (n1>op)) media = (n2+n1)/2;
    }else media = (n2+n1)/2;
   
    printf("A média das duas maiores notas = %.2f",media);
}

/******************************************************************************
Questão 1 - Faça um algoritmo que leia a quantidade de lados de 
um polígono regular, e a medida desses lados e informe 
(usar switch):
a) caso seja um triângulo, quadrado, pentágono, hexágono, 
heptágono ou octógono, informar o tipo do polígono e seu perímetro.
b) Caso contrário, informar polígono inválido. (valor: 1,0pt)
*******************************************************************************/

#include <stdio.h>

int main(){
    int lados;
    float medida;
    
    printf("Informe a quantidade de lados do polígono: ");
    scanf("%d",&lados);
    printf("Informe a medida do lado: ");
    scanf("%f",&medida);
    
    
    switch (lados){
        case 3: 
            printf("Polígono é um triângulo com perímetro = %.1f",medida*3.0);
            break;
        case 4: 
            printf("Polígono é um quadrado com perímetro = %.1f",medida*4.0);
            break;
        case 5: 
            printf("Polígono é um pentágono com perímetro = %.1f",medida*5.0);
            break;
        case 6: 
            printf("Polígono é um hexágono com perímetro = %.1f",medida*6.0);
            break; 
        case 7: 
            printf("Polígono é um heptágono com perímetro = %.1f",medida*7.0);
            break;     
        default:
            printf("Polígono Inválido");
            break; 
    }
}

/******************************************************************************
Questão 1 - Faça um algoritmo que leia a quantidade de lados de 
um polígono regular, e a medida desses lados e informe 
(usar switch):
a) caso seja um triângulo, quadrado, pentágono, hexágono, 
heptágono ou octógono, informar o tipo do polígono e seu perímetro.
b) Caso contrário, informar polígono inválido. (valor: 1,0pt)
*******************************************************************************/

#include <stdio.h>

int main(){
    int lados;
    float medida;
    
    printf("Informe a quantidade de lados do polígono: ");
    scanf("%d",&lados);
    printf("Informe a medida do lado: ");
    scanf("%f",&medida);
    
    
    switch (lados){
        case 3: 
            printf("Polígono é um triângulo com perímetro = %.1f",medida*3.0);
            break;
        case 4: 
            printf("Polígono é um quadrado com perímetro = %.1f",medida*4.0);
            break;
        case 5: 
            printf("Polígono é um pentágono com perímetro = %.1f",medida*5.0);
            break;
        case 6: 
            printf("Polígono é um hexágono com perímetro = %.1f",medida*6.0);
            break; 
        case 7: 
            printf("Polígono é um heptágono com perímetro = %.1f",medida*7.0);
            break;     
        default:
            printf("Polígono Inválido");
            break; 
    }
}

// 4. Faça um algoritmo que leia o usuário e a senha e compare com usuário = "IFBA" e senha = "fsa1234", informe:
//  - "Acesso Permitido", caso usuários e senha sejam válidos
//  - "Acesso Negado", caso contrário
#include <stdio.h>
#include <string.h>

void main(){
    char senha[10],usuario[10];
   
    printf("Informe o usuário:\n");
    scanf("%s",usuario);
    printf("Informe a senha:\n");
    scanf("%s",senha);
   
    if ((!strcmp(usuario,"IFBA"))&&(!strcmp(senha,"fsa1234")))
          printf("Acesso Permitido!");
    else
        printf("Acesso Negado!");    
}

// 4. Faça um algoritmo que leia o usuário e a senha e compare com usuário = "IFBA" e senha = "fsa1234", informe:
//  - "Acesso Permitido", caso usuários e senha sejam válidos
//  - "Acesso Negado", caso contrário
#include <stdio.h>
#include <string.h>

void main(){
    char senha[10],usuario[10];
   
    printf("Informe o usuário:\n");
    scanf("%s",usuario);
    printf("Informe a senha:\n");
    scanf("%s",senha);
   
    printf(((!strcmp(usuario,"IFBA"))&&(!strcmp(senha,"fsa1234")))?"Acesso Permitido!":"Acesso Negado!");    
}

//Faça um algoritmo que leia um número inteiro qualquer e informe sua tabuada da multiplicação, soma, divisão e subtração

#include <stdio.h>

void main(){
    int i,num;
    
    printf("Informe um número qualquer: ");
    scanf("%d",&num);
    
    printf("TABUADA DA MULTIPLICAÇÃO\n");
    for(i=0;i<10;i++) printf("%d X %d = %d\n", i,num, i*num);
    
    printf("TABUADA DA SOMA\n");
    for(i=0;i<10;i++) printf("%d + %d = %d\n", i,num, i+num);
    
    printf("TABUADA DA SUBTRAÇÃO\n");
    for(i=0;i<10;i++) printf("%d - %d = %d\n", i,num, i-num);
    
    printf("TABUADA DA DIVISÃO\n");
    for(i=1;i<10;i++) printf("%d / %d = %.3f\n", num, i, (float)num/i);   
        
}

//Faça um algoritmo que leia um número inteiro qualquer e informe sua tabuada da multiplicação, soma, divisão e subtração USANDO WHILE

#include <stdio.h>

void main(){
    int i,num;
    
    printf("Informe um número qualquer: ");
    scanf("%d",&num);
    
    printf("TABUADA DA MULTIPLICAÇÃO\n");
    i=0;
    while(i<10){ 
        printf("%d X %d = %d\n", i,num, i*num);
        i++;
    }
    
    printf("TABUADA DA SOMA\n");
    i=0;
    while(i<10){ 
        printf("%d + %d = %d\n", i,num, i+num);
        i++;
    }
    
    printf("TABUADA DA SUBTRAÇÃO\n");
    i=0;
    while(i<10){ 
        printf("%d - %d = %d\n", i,num, i-num);
        i++;
    }
    
    printf("TABUADA DA DIVISÃO\n");
    i=0;
    while(i<10){ 
        printf("%d / %d = %.3f\n", num, i, (float)num/i);   
        i++;
    }
}

/*João Pedro tem 1,60m e cresce 2cms por ano. Joaquim tem 1,00m e 
cresce 3cms por ano. Faça um algoritmo em C que informe quantos anos 
Joaquim levará para ultrapassar a altura de João Pedro*/
#include <stdio.h>

void main(){
    float JP=1.6, Joaquim = 1.0;
    int anos=0;
    
    while(JP>=Joaquim){
        JP+=0.02;
        Joaquim+=0.03;
        anos++;
    }
    
    printf("Após %d anos, Joaquim terá %.2fm de altura\n",anos,Joaquim);
    printf("e João Pedro terá %.2fm de altura\n",JP);
}

/*Faça um algoritmo em C que informe quantos anos X levará 
para ultrapassar a altura de Y. Leia as alturas iniciais e o
fator de crescimento*/
#include <stdio.h>

void main(){
    float X, Y, fatorX, fatorY,aux;
    int anos=0;
    
    printf("Informe a altura inicial de X: "); scanf("%f",&X);
    printf("Informe a altura inicial de Y: "); scanf("%f",&Y);
    
    printf("Informe o fator de crescimento de X: "); scanf("%f",&fatorX);
    printf("Informe o fator de crescimento de Y: "); scanf("%f",&fatorY);
    
    if(fatorX < fatorY){
        aux = fatorY;
        fatorY = fatorX;
        fatorX = aux;
        
        aux = Y;
        Y = X;
        X = aux;
    }
    
    while(Y>=X){
        Y+=fatorY;
        X+=fatorX;
        anos++;
    }
    
    printf("Após %d anos, X terá %.2fm de altura\n",anos,X);
    printf("e Y terá %.2fm de altura\n",Y);
}

// Faça um algoritmo que leia um número inteiro e informe se ele é primo. OBS.: Todo número primo é divisível apenas por 1 e ele mesmo.

#include <stdio.h>

void main(){
    int x, divisor, qtde;
    char resp;
   
    do{
        printf("Informe um número inteiro: ");
        scanf("%d%*c",&x);
       
        qtde=0;
        for(divisor = x; divisor > 0; divisor--){
            if(x%divisor == 0){
                printf("Divisor = %d\n",divisor);
                qtde++;
            }    
        }
        if(qtde==2) printf("Número primo!\n");
        else printf("Número não é primo!\n");
       
        printf("Deseja repetir operação? S-Sim e N-Não\n ");
        scanf("%c",&resp);
    }while(resp=='S');    
}

/**1.Escreva um algoritmo, em Linguagem C, que leia X e Y, que são os limites de um intervalo 
fechado [x,y], e mostre todos os números primos contidos neste intervalo. Após a execução, 
permita que o usuário repita o algoritmo quantas vezes ele quiser. (valor: 1,0pt)**/
#include <stdio.h>

void main() {
    int x,y,i,j,divisores,resp;
    
    do{
        printf("Informe os limites do intervalo [x,y]: ");
        scanf("%d %d", &x,&y);
        for(i=x;i<=y;i++){
            divisores = 0;
            for(j=1;j<=i;j++)
                if(i%j==0) divisores++;
            if(divisores == 2) printf("Primo = %d\n", i);    
        }
        printf("Deseja informar novo intervalo? Digite: 1-Sim e 2-Não");
        scanf("%d",&resp);
    }while(resp == 1);
}

// Faça um algoritmo que leia os limites de um intervalo de números inteiros [x,y] e informe todos os múltiplos de 3 contidos no intervalo

#include <stdio.h>

void main(){
    int x,y,aux;
    char resp;
   
    do{
        printf("Informe dois números inteiros: ");
        scanf("%d %d%*c",&x,&y);
       
        if(y<x){
            aux = x;
            x = y;
            y = aux;
        }
       
        for(aux=x; aux<=y; aux++)
            if(aux%3 == 0)
                printf("Múltiplo de 3 = %d\n",aux);
       
        printf("Deseja repetir operação? S-Sim e N-Não\n ");
        scanf("%c",&resp);
    }while(resp=='S');    
}

// Fazer um algoritmo em C para exibir os X primeiros múltiplos simultâneos de dois números dados.
#include <stdio.h>

void main(){
    int num1, num2, qtde=0, X, i;
    
    printf("Informe os dois números inteiros desejados: ");
    scanf("%d %d",&num1,&num2);
    
    printf("Informe quantos múltiplos você deseja mostrar: ");
    scanf("%d",&X);
    
    for(i=1;;i++){
        
        if((i%num1==0)&&(i%num2==0)){
            qtde++;
            printf("Múltiplo de %d e %d = %d\n",num1,num2,i);
        }    
        if(qtde == X) break;
    }
}

/**3.	Fazer um algoritmo, em Linguagem C, que mostre os N primeiros múltiplos simultâneos 
de dois números dados (X e Y). Os valores de N, X e Y serão fornecidos pelo usuário. 
Permita que o usuário repita o algoritmo quantas vezes ele quiser. (valor: 1,0pt).
**/
#include <stdio.h>

void main() {
    int n,x,y,i,resp,qtde;
    
    do{
        printf("Digite dois números inteiros: ");
        scanf("%d %d",&x,&y);
        
        printf("Informe quantos múltiplos você deseja mostrar: ");
        scanf("%d",&n);
        
        for(i=1,qtde=0;qtde<n;i++){
            if((i%x==0)&&(i%y==0)){
                printf("Múltiplo de %d e %d = %d\n",x,y,i); 
                qtde++;
            }
        }
        printf("Deseja repetir o programa? 1-Sim 2-Não: ");
        scanf("%d",&resp);
    }while(resp == 1);
}

// Faça uma algoritmo que implemente um sistema de LOGIN e SENHA. LOGIN = ”ifbaBSI” e SENHA = ”alunoIFBA”. O sistema deverá informar ”Acesso Negado”, caso o usuário erre login e/ou senha. E deverá informar ”Acesso Permitido”, caso contrário. O algoritmo deverá permitir que o usuário erre apenas 5 vezes. Após 5 erros, o usuário terá a senha bloqueada e não poderá tentar logar novamente. Informe, a cada erro, quantas tentativas o usuário ainda tem.

// 4. Faça um algoritmo que leia o usuário e a senha e compare com usuário = "IFBA" e senha = "fsa1234", informe:
//  - "Acesso Permitido", caso usuários e senha sejam válidos
//  - "Acesso Negado", caso contrário
#include <stdio.h>
#include <string.h>

void main(){
    char senha[10],usuario[10];
    int tentativas;
    
    for(tentativas = 5; tentativas > 0; --tentativas){
        printf("Informe o usuário:\n");
        scanf("%s",usuario);
        printf("Informe a senha:\n");
        scanf("%s",senha);
   
        if((!strcmp(usuario,"ifbaBSI"))&&(!strcmp(senha,"alunoIFBA"))){
            printf("Acesso Permitido!\n");
            break;
        }else{    
            printf("Acesso Negado!\n");
            if(tentativas > 2)
                printf("Você tem apenas %d tentativas\n", tentativas-1);
            else if (tentativas == 2)
                printf("Você tem apenas 1 tentativa\n");
            else 
                printf("Seu acesso foi bloqueado!\n");
        }        
    }
}

// Faça uma algoritmo que implemente um sistema de LOGIN e SENHA. LOGIN = ”ifbaBSI” e SENHA = ”alunoIFBA”. O sistema deverá informar ”Acesso Negado”, caso o usuário erre login e/ou senha. E deverá informar ”Acesso Permitido”, caso contrário. O algoritmo deverá permitir que o usuário erre apenas 5 vezes. Após 5 erros, o usuário terá a senha bloqueada e não poderá tentar logar novamente. Informe, a cada erro, quantas tentativas o usuário ainda tem.

// 4. Faça um algoritmo que leia o usuário e a senha e compare com usuário = "IFBA" e senha = "fsa1234", informe:
//  - "Acesso Permitido", caso usuários e senha sejam válidos
//  - "Acesso Negado", caso contrário
#include <stdio.h>
#include <string.h>

void main(){
    char senha[10],usuario[10];
    int tentativas;
    
    for(tentativas = 5; tentativas > 0; --tentativas){
        printf("Informe o usuário:\n");
        scanf("%s",usuario);
        printf("Informe a senha:\n");
        scanf("%s",senha);
   
        if((!strcmp(usuario,"ifbaBSI"))&&(!strcmp(senha,"alunoIFBA"))){
            printf("Acesso Permitido!\n");
            break;
        }else{    
            printf("Acesso Negado!\n");
            if(tentativas > 2)
                printf("Você tem apenas %d tentativas\n", tentativas-1);
            else if (tentativas == 2)
                printf("Você tem apenas 1 tentativa\n");
            else 
                printf("Seu acesso foi bloqueado!\n");
        }        
    }
}

/******************************************************************************
Faça um algoritmo que leia um número inteiro e informe se ele é
perfeito. Um número perfeito é um número inteiro que é igual à soma 
de todos os seus divisores excluindo o próprio número. 
Ex: 6 é perfeito, pois 6 = 1 + 2 + 3. obs.: fazer com decrementação
*******************************************************************************/

#include <stdio.h>

void main(){
    int num, soma;
    char resp;
    
    do{
        printf("Informe um número inteiro: ");
        scanf("%d%*c",&num);
        soma = 0;
        for(int i=(num-1); i>=1; i--)
            if(num%i == 0) soma+=i;
        
        if(soma == num) printf("%d é perfeito!\n",num);
        else printf("%d NÃO é perfeito!\n",num);
        
        printf("Deseja informar novo número? S-Sim, N-Não: ");
        scanf("%c",&resp);
    }while(resp!='N');    
}

/**Sabendo-se que um número perfeito é aquele cuja soma de seus divisores, 
excluindo ele mesmo, é igual ao próprio número (ex: 6 = 3+2+1), faça um algoritmo que 
leia um inteiro e informe se ele é perfeito. **/
#include <stdio.h>

void main(){
    int n, divisor, resp, x=0;
    
    do{
        printf("Informe um número inteiro: ");
        scanf("%d",&n);
        
        for(divisor=1;divisor<n;divisor++)
            if(n%divisor==0) x=x+divisor;
        
        if(x == n) printf("%d é perfeito!\n",n);
        else printf("%d não é perfeito!\n",n);
        
        printf("Deseja informar novo número? 1-Sim 2-Não\n");
        scanf("%d",&resp);
    }while(resp==1);
}

/** 4.	Sabendo-se que um número perfeito é aquele cuja multiplicação de seus divisores, 
exceto ele mesmo, é igual ao próprio número (ex: 6 = 3*2*1), faça um algoritmo que 
leia um número inteiro qualquer e informe se ele é perfeito. (valor: 2,0pts)
**/
#include <stdio.h>

void main(){
    int n, divisor, resp, x;
    
    do{
        printf("Informe um número inteiro: ");
        scanf("%d",&n);
        x=1;
        
        for(divisor=1;divisor<n;divisor++)
            if(n%divisor==0) x=x*divisor;
        
        if(x == n) printf("%d é perfeito!\n",n);
        else printf("%d não é perfeito!\n",n);
        
        printf("Deseja informar novo número? 1-Sim 2-Não\n");
        scanf("%d",&resp);
    }while(resp==1);
}

/******************************************************************************
Questão 2 - Faça um algoritmo que leia os limites de um intervalo fechado [x,y] 
de números inteiros e mostre todos os números perfeitos contidos no intervalo. 
Um número perfeito é um número inteiro que é igual à soma de todos os seus 
divisores excluindo o próprio número. Ex: 6 é perfeito, pois 6 = 1 + 2 + 3. 
(valor: 1,5pt)
*******************************************************************************/

#include <stdio.h>

int main(){
    int perfeito, x, y;
    
    printf("Informe as medidas do intervalo [x,y]: ");
    scanf("%d %d",&x, &y);
    
    for(int i = x; i<=y; i++){
       perfeito = 0; 
       for(int j = 1; j < i; j++)
            if(i%j == 0)
                perfeito += j;
       if (perfeito == i) printf("%d é perfeito!\n",i);            
    }
}

/*Faça um algoritmo em C que leia um intervalo [x,y] e informe 
todos os primos contidos no intervalo. Caso o número não seja primo, 
informar os seus divisores.*/

#include <stdio.h>

void main(){
    int x,y,aux,cont=0,divisor;
    char resp;
    do{
        printf("Informe os limites do intervalo [x,y]: ");
        scanf("%d %d%*c",&x,&y);
        
        if(x>y){
            aux=x;
            x=y;
            y=aux;
        }
        
        for(int i=x; i<=y; i++){
            cont = 0;
            
            printf("Divisores do número %d:\n",i);
            for(divisor = i; divisor>=1; divisor--)
                if(i%divisor == 0){
                    printf("%d\n",divisor);
                    cont++;
                }
                
            if(cont==2) printf("número primo!\n");    
        }
        printf("Deseja repetir o programa? S-Sim e N-Não\n");
        scanf("%c%*c",&resp);
    }while(resp!='N');   
}

/******************************************************************************
Questão 3 - Uma das maneiras de se conseguir a raiz quadrada de um número é 
subtrair do número os ímpares consecutivos a partir de 1, até que o resultado 
da subtração seja menor ou igual a zero. O número de vezes que se consegue 
fazer a subtração é a raiz quadrada exata (resultado 0) ou aproximada 
(resultado negativo). Faça um algoritmo que calcula a raiz quadrada de um 
número por esse método. (valor: 1,5pts)
*******************************************************************************/

#include <stdio.h>

int main(){
    int raiz, x, resultado;
    
    printf("Informe um número inteiro: ");
    scanf("%d",&x);
    resultado = x;
    raiz = 0;
    
    for(int i = 1; i <= x; i+=2){
        resultado -= i;
        raiz++;
        if (resultado <= 0) break;
    }
    
    if(resultado == 0)
        printf("A raiz quadrada exata de %d é %d",x,raiz);
    else
        printf("A raiz quadrada aproximada de %d é %d",x,raiz);    
}

/*Faça um algoritmo em C que colete os dados da realização do censo na cidade de 
Santo Estêvão, onde os dados coletados de cada residência corresponde a:
• Sexo biológico do chefe da família (F - Feminino e M - Masculino)
• Quantidade de filhos que moram na residência junto com o chefe de família
• Salário do chefe da família
• Quantidade de pessoas que moram na casa

Após a coleta dos dados, que não se sabe quantos serão, o algoritmo deverá informar:
(a) A média dos salários dos chefes de família homens
(b) A média dos salários dos chefes de família mulheres
(c) Percentual de chefes mulher
(d) Percentual de chefes homem
(e) Média da qtde de filhos
(f) Média da qtde de pessoas residentes na casa*/

#include <stdio.h>

void main(){
    char sexo, resp;
    int qtdeFilhos, qtdeResidentes, totalMulheres=0, totalHomens=0, totalResidencias=0, percMulheres=0, percHomens=0;
    float salario, mediaSalHomens=0.0, mediaSalMulheres=0.0, mediaFilhos=0.0, mediaResidentes=0.0;
    
    do{
        printf("Informe o sexo biológico do chefe da família:\nF = feminino\nM = masculino\n");
        scanf("%c%*c",&sexo);
        printf("Informe a qtde de filhos que moram com o chefe da família:\n");
        scanf("%d%*c",&qtdeFilhos);
        printf("Informe a qtde total de residentes da casa:\n");
        scanf("%d%*c",&qtdeResidentes);
        printf("Informe o salário do chefe da família:\n");
        scanf("%f%*c",&salario);
        
        switch(sexo){
            case 'M':
                totalHomens++;
                mediaSalHomens+=salario;
                totalResidencias++;
                mediaFilhos+=qtdeFilhos;
                mediaResidentes+=qtdeResidentes;
                break;
            case 'F':
                totalMulheres++;
                mediaSalMulheres+=salario;
                totalResidencias++;
                mediaFilhos+=qtdeFilhos;
                mediaResidentes+=qtdeResidentes;
                break;
            default: 
                printf("Sexo informado inválido!\n"); 
                break;
        }
        
        printf("Deseja fazer nova transação? S-Sim e N-Não\n");
        scanf("%c%*c",&resp);
    }while(resp!='N');
    
    mediaSalHomens/=totalHomens;
    mediaSalMulheres/=totalMulheres;
    mediaFilhos/=totalResidencias;
    mediaResidentes/=totalResidencias;
    
    printf("A média dos salários dos chefes de família homens = R$%.2f\n",mediaSalHomens);
    printf("A média dos salários dos chefes de família mulheres = R$%.2f\n",mediaSalMulheres);
    printf("Percentual de chefes homem = %.1f%%\n",((float)totalHomens/(float)totalResidencias)*100);
    printf("Percentual de chefes mulher = %.1f%%\n",((float)totalMulheres/(float)totalResidencias)*100);
    printf("Média da qtde de filhos = %.1f\n",mediaFilhos);
    printf("Média da qtde de pessoas residentes na casa = %.1f\n",mediaResidentes);
    
}

// Ler um vetor de inteiros e depois mostrá-lo
#include <stdio.h>

void main() {
    // Write C code here
    int v[10];
    
    for(int i=0; i<=9; i++){
        printf("Digite o elemento %d do vetor: ",i);
        scanf("%d", &v[i]);
    }
    
    for(int i=0; i<=9; i++){
        printf("%d, ",v[i]);
    }
}

/**Faça um algoritmo em C que crie um vetor A que armazene 10 números inteiros.
 * O programa deve executar os seguintes passos:
 *  (a) Atribua os seguintes valores a esse vetor: 1, 0, 5, -2, -5, 7, 8, 9, 3, 4.
 * (b) Armazene em uma variável inteira a soma dos valores das posições A[0],
 A[1], A[5] e A[8] do vetor e mostre na tela o resultado.**/
 #include <stdio.h>
 
 #define tam1 13
 #define tam2 10
 
 void main(){
     int vetor1[] = {1, 0, 5, -2, -5, 7, 8, 9, 3, 4, 11, 12, 25};
     int vetor2[tam2] = {1, 0, 5, -2, -5, 7, 8, 9, 3, 4}, soma=0;
     
     printf("Vetor 1 = ");
     for(int i=0; i<tam1;i++)
        printf("%d ", vetor1[i]);
       
   
     printf("\nVetor 2 = ");
     for(int i=0; i<tam1;i++)
        printf("%d ", vetor2[i]);
       
     soma = vetor1[0]+vetor1[1]+vetor1[5]+vetor1[8];
     
     printf("\nSoma = %d",soma);
 }

/*Faça um algoritmo em C que leia um vetor de 10 posições, Conte e
escreva quantos valores pares ele possui.*/
#include <stdio.h>

#define tam 10

void main(){
    int v[10], qtde=0;
    
    for(int i=0; i<tam; i++){
        printf("Informe o %dº elemento do vetor: ",i+1);
        scanf("%d",&v[i]);
        if(v[i]%2 == 0) qtde++;
    } 
    
    printf("O vetor possui %d elementos pares",qtde);
}

/** Faça um algoritmo em C que leia um vetor de 10 posições, Conte e escreva quantos valores pares ele possui.
**/

#include <stdio.h>

void main() {
    int vetor[10];
    int pares = 0;
   
    printf("Informe os valores do vetor:");
    for(int i=0;i<=9;i++){
        printf("\nVetor[%d] = ",i);
        scanf("%d",&vetor[i]);
    }
   
     for(int i=0;i<=9;i++)
        if(vetor[i]%2 == 0) pares++;
   
    printf("\nElementos do vetor = ");
    for(int i=0;i<=9;i++)
        printf("%d, ",vetor[i]);
   
    printf("\n Quantidade de elementos pares = %d",pares);
}

/** Faça um algoritmo em C que receba do usuário um vetor com 10 posições. Em seguida, o 
algoritmo deve imprimir o vetor na ordem inversa.
**/

#include <stdio.h>

void main() {
    int vetor[10];
    printf("Informe os valores do vetor:\n");
    for(int i=0;i<=9;i++){
        printf("Vetor[%d] = ",i);
        scanf("%d",&vetor[i]);
    }
   
    printf("\nElementos do vetor na ordem inversa= ");
    for(int i=9;i>=0;i--)
        printf("%d, ",vetor[i]);
}

/** Faça um algoritmo em C que receba do usuário um vetor com 10 posições. Em seguida, o algoritmo deve imprimir o maior e o menor elemento do vetor, informando a posição (índice) em que se encontram cada um deles.
**/

#include <stdio.h>

void main() {
    int vetor[10];
    printf("Informe os valores do vetor:\n");
    for(int i=0;i<=9;i++){
        printf("Vetor[%d] = ",i);
        scanf("%d",&vetor[i]);
    }
   
    printf("\nElementos do vetor na ordem inversa= ");
    for(int i=9;i>=0;i--)
        printf("%d, ",vetor[i]);
}

/** Faça um algoritmo em C que receba do usuário um vetor com 10 posições. Em seguida, o algoritmo deve imprimir o maior e o menor elemento do vetor, informando a posição (índice) em que se encontram cada um deles.
**/

#include <stdio.h>

void main() {
    int vetor[10];
    int maior, menor, indMaior, indMenor;
   
    printf("Informe os valores do vetor:\n");
    for(int i=0;i<=9;i++){
        printf("Vetor[%d] = ",i);
        scanf("%d",&vetor[i]);
        if(i==0){
            menor = vetor[0];
            maior = vetor[0];
            indMaior = 0;
            indMenor = 0;
        }
       
        if(maior < vetor[i]){
            maior = vetor[i];
            indMaior = i;
        }
       
        if(menor > vetor[i]){
            menor = vetor[i];
            indMenor = i;
        }
    }
   
    printf("\nElementos do vetor = ");
    for(int i=0;i<=9;i++)
        printf("%d, ",vetor[i]);
   
    printf("\nMaior = %d\nÍndice do maior = %d",maior, indMaior);
    printf("\nMenor = %d\nÍndice do menor = %d",menor, indMenor);
}

/******************************************************************************
Faça um algoritmo em C que receba do usuário um vetor de inteiro
com 10 posições. Em seguida, o algoritmo deve imprimir o maior e 
o menor elemento do vetor, informando a posição (índice) em que se 
encontram cada um deles.
*******************************************************************************/
#include <stdio.h>

void main(){
    int vetor[10], menor, maior;
    
    for(int i=0; i<=9; i++){
        printf("Informe um número inteiro: ");
        scanf("%d",&vetor[i]);
    }
    
    menor=maior=0;
    for(int i=1;i<=9;i++)
        if(vetor[i] < vetor[menor]) menor = i;
        else if(vetor[i] > vetor[maior]) maior = i;
    
    printf("O maior elemento é %d que está no índice %d\n",vetor[maior],maior); 
    printf("O menor elemento é %d que está no índice %d\n",vetor[menor],menor);    
}

// Faça um algoritmo que leia um vetor de até 100 posições e implemente as 
//funções: 
//int maior(int vetor[], int qtde);
//int menor(int vetor[], int qtde);
//float media(int vetor[], int qtde);

#include <stdio.h>

#define TAM 10

int preencheVetor(int vetor[], int qtde){
    int i;
    char resp;
    
    for(i = qtde; i<TAM; i++){
        printf("Informe o %dº elemento do vetor:",i+1);
        scanf("%d%*c",&vetor[i]);
        
        //printf("Deseja digitar novo elemento? S-Sim, N-Não: ");
        //scanf("%c%*c",&resp);
        //if(resp=='N') return i+1;
    }    
    return i;
}

int maior(int vetor[], int qtde){
    int maior=vetor[0];
    for(int i=0; i<qtde;i++)
        if(maior<vetor[i]) maior = vetor[i];
        
    return maior;
}

int menor(int vetor[], int qtde){
    int menor=vetor[0];
    for(int i=0; i<qtde;i++)
        if(menor>vetor[i]) menor = vetor[i];
        
    return menor;
}

float media(int vetor[], int qtde){
    float media=0;
    
    for(int i=0; i<qtde; i++)
        media = (float)(media+(float)vetor[i]);
    
    media = (float)(media/(float)qtde);
    return media;
}

void main(){
    int qtde=0;
    int vetor[100];
    
    printf("Informe os elementos do vetor:\n");
    qtde = preencheVetor(vetor,qtde);
    
    printf("O maior elemento = %d\n",maior(vetor,qtde));
    printf("O menor elemento = %d\n",menor(vetor,qtde));
    printf("A média dos elementos = %.1f\n",media(vetor,qtde));
}

/**Faça um algoritmo que leia 20 números inteiros e informe o maior e o menor.
O algoritmo deve ser modularizado. **/
#include <stdio.h>

#define TAM 20

int preencherVetor(int v[], int qtde){
    char resp;
    do{
        printf("Informe o valor do elemento %d do vetor: ",qtde);
        scanf("%d%*c",&v[qtde]);
        qtde++;
        printf("Deseja continuar? S-sim, N-Não: ");
        scanf("%c%*c",&resp);
    }while(resp!='N');
    return qtde;
}

void imprimirVetor(int v[], int qtde){
    printf("Vetor = ");
    for(int i=0; i<qtde; i++)
        printf("%d, ",v[i]);
    printf("\n");    
}

int maiorVetor(int v[], int qtde){
    int maior = v[0];
    for(int i=0; i<qtde; i++)
        if(maior < v[i]) maior = v[i];
    return maior;    
}

int menorVetor(int v[], int qtde){
    int menor = v[0];
    for(int i=0; i<qtde; i++)
        if(menor > v[i]) menor = v[i];
    return menor;    
}

int main(){
    int vetor[TAM], qtde=0, maior, menor;
   
    qtde = preencherVetor(vetor,qtde);
    imprimirVetor(vetor,qtde);
   
    maior = maiorVetor(vetor,qtde);
    menor = menorVetor(vetor,qtde);
   
    printf("Maior = %d\nMenor = %d\n",maior,menor);
}

/**Faça um algoritmo que leia 20 números inteiros e informe o maior e o menor.
O algoritmo deve ser modularizado. **/
#include <stdio.h>

#define TAM 20

void preencherVetor(int v[], int *qtde){
    char resp;
    do{
        printf("Informe o valor do elemento %d do vetor: ",*qtde);
        scanf("%d%*c",&v[*qtde]);
        (*qtde)++;
        printf("Deseja continuar? S-sim, N-Não: ");
        scanf("%c%*c",&resp);
    }while(resp!='N');
}

void imprimirVetor(int v[], int qtde){
    printf("Vetor = ");
    for(int i=0; i<qtde; i++)
        printf("%d, ",v[i]);
    printf("\n");    
}

void maiorMenor(int v[], int qtde, int *maior, int *menor){
    *maior = v[0];
    *menor = v[0];
    for(int i=0; i<qtde; i++)
        if(*maior < v[i]) *maior = v[i];
        else if(*menor > v[i]) *menor = v[i];
}

int main(){
    int vetor[TAM], qtde=0, maior, menor;
   
    preencherVetor(vetor,&qtde);
    imprimirVetor(vetor,qtde);
    maiorMenor(vetor,qtde, &maior, &menor);
   
    printf("Maior = %d\nMenor = %d\n",maior,menor);
}

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

void procurar(int vetor[], int tamanho, int * maior, int * menor) {
    if (tamanho == 1) { /* caso base */
        * maior = * menor = vetor[0];
    } else { /* passo indutivo */
        procurar(vetor + 1, tamanho - 1, maior, menor);
        if (vetor[0] > * maior) * maior = vetor[0];
        if (vetor[0] < * menor) * menor = vetor[0];
    }
}

int main() {
    int tamanho, i, maior, menor;
    int * vetor;
    
    printf("Informe o tamanho do vetor: ");
    if (scanf("%d", &tamanho) < 1 || tamanho < 1) {
        fputs("Não consegui ler o tamanho do vetor\n", stderr);
        return EXIT_FAILURE;
    }
    vetor = malloc(tamanho * sizeof (int));
    if (vetor == NULL) {
        fputs("Não consegui alocar o vetor\n", stderr);
        return EXIT_FAILURE;
    }

    printf("Informe os valores do vetor: ");
    for (i = 0; i < tamanho; i ++) {
        if (scanf("%d", &vetor[i]) < 1) {
            printf("Não consegui ler o %dº valor do vetor\n", i + 1);
            return EXIT_FAILURE;
        }
    }

    procurar(vetor, tamanho, &maior, &menor);
    printf("O maior número é %d e o menor, %d\n", maior, menor);

    return EXIT_SUCCESS;
}

/**Crie um programa que leia até 100 idades (inteiras), armazene-as e 
depois mostre-as. Crie funções e procedimentos para realizar as 
tarefas. **/

#include <stdio.h>

#define tam 100

void inserir(int id, int qtde, int idades[]){
    idades[qtde] = id;
}

int buscarRemover(int id, int qtde, int idades[]){
    
    for(int i=0; i<qtde; i++){
        if(idades[i]==id){
            for(int j=i; j<(qtde-1);j++)
                idades[j]=idades[j+1];
            printf("Elemento removido!\n");    
            return 1;
        }
    }
    printf("Elemento não encontrado!\n");
    return 0;
}

void mostrar(int qtde, int idades[]){
    for(int i=0; i< qtde; i++)
        printf("%d, ",idades[i]);
    printf("\n");    
    
}

void main(void){
    int idades[tam], id, qtde=0;
    int removeu;
    
    do{
        printf("Informe uma idade a ser inserida ou -1 para sair: ");
        scanf("%d",&id);
        
        if(id>=0){
            inserir(id,qtde,idades);
            qtde++;
            
            mostrar(qtde,idades);   
        }
    }while(id>=0);
    
    
    do{
        printf("Informe uma idade a ser removida ou -1 para sair: ");
        scanf("%d",&id);
        
        if(id>=0)
            if(buscarRemover(id,qtde,idades)) 
                qtde--;
        
        mostrar(qtde,idades);        
        
    }while(id>=0);
    
}

/***
  1. Um vetor ARRUMADO é um vetor v[p .. r] onde existe ao menos um j ∈ [p, r] tal 
que v[p..j − 1] ≤  v[j] ≤ v[j + 1..r] (ou seja, existe ao menos um j pertencente ao 
vetor v, cujos elementos da esquerda são menores que j e os elementos da direita são 
maiores que j). Escreva uma função que receba um vetor v[p..r] e informe se o vetor 
está ARRUMADO. Em caso afirmativo, o seu algoritmo deve devolver o valor de j, que é
o índice da posição em que está o elemento do MEIO que caracteriza o vetor como ARRUMADO. 
OBS.: Os vetores arrumados NÃO se resumem aos vetores ORDENADOS, ou vetores com todos 
os números iguais!! (valor: 4,0 pts) 
***/


#include <stdio.h>
#include <stdbool.h>

int encontrarJ(int v[], int tamanho) {
    for (int j = 1; j < tamanho - 1; j++) {
        bool esquerdaMenor = true;
        bool direitaMaior = true;

        // Verifica se todos os números à esquerda de 'J' são menores do que ele
        for (int i = 0; i < j; i++) {
            if (v[i] >= v[j]) {
                esquerdaMenor = false;
                break;
            }
        }

        // Verifica se todos os números à direita de 'J' são maiores do que ele
        for (int i = j + 1; i < tamanho; i++) {
            if (v[i] <= v[j]) {
                direitaMaior = false;
                break;
            }
        }

        if (esquerdaMenor && direitaMaior) {
            return v[j];
        }
    }

    return -1; // Retorna -1 se não existir um número J com as propriedades desejadas
}

int main() {
    int tamanho;
    printf("Digite o tamanho do vetor: ");
    scanf("%d", &tamanho);

    int v[tamanho];
    printf("Digite os elementos do vetor:\n");
    for (int i = 0; i < tamanho; i++) {
        scanf("%d", &v[i]);
    }

    int j = encontrarJ(v, tamanho);

    if (j != -1) {
        printf("Existe um numero J no vetor onde todos os numeros a esquerda dele sao menores e todos os numeros a direita dele sao maiores.\n");
        printf("Valor de J: %d\n", j);
    } else {
        printf("Nao existe um numero J no vetor com essa propriedade.\n");
    }

    return 0;
}

//---------------------------------------------------------------------
//
// Algoritmo desenvolvido pela professora Ana Carolina Sokolonski Anton
// na disciplina de Estruturas de Dados no IFBA Campus Feira de Santana
//
//--------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#define tam 100

int busca(int x, int v[], int qtde){
    if(qtde == 0) return -1;
    if(v[qtde-1] == x) return (qtde-1);
    else return(busca(x,v,(qtde-1)));
}

int buscaRemocao(int x, int v[], int qtde){
    int i;
    for(i=0; (i<qtde) && (v[i]!=x); i++);
    
    if(i<qtde){
        for(int j=i; j<(qtde-1);j++)
            v[j]=v[j+1];
        return 1;    
    }else return 0;    
}

int insereFim(int x, int v[], int qtde){
    if (qtde == tam) return 0;
    v[qtde] = x;
    return 1;
}


int insereInicio(int x, int v[], int qtde){
    if (qtde == tam) return 0;
    for(int i=qtde; i>0; i--)
        v[i] = v[i-1];
    v[0]=x; 
    return 1;
}

int eliminaRepetidos(int qtde,int v[]){
    int found;
    
    for(int i=1; i<qtde; i++){
        found = busca(v[i],v,i-1);
            
        if(found!=-1){
            printf("%d repetido e eliminado\n",v[i]);
            for(int j=i; j<(qtde-1); j++)
                v[j] = v[j+1];
            qtde--; 
            i--;
        }
    }

    
    return qtde;
}

void main(){
    int v[tam], num, indice, qtde;
    
    printf("Vetor original:\n");
    for(int i=0; i<tam; i++){
        v[i] = (int)rand()%100;
        printf("v[%d] = %d\n",i,v[i]);
    }  
    
    qtde = eliminaRepetidos(tam, v);
    
    printf("Vetor resultante:\n");
    for(int i=0; i<qtde; i++)
        printf("v[%d] = %d\n",i,v[i]);
    
}

/*Faça um programa que leia uma matriz de 3 x 3, usando o comando
FOR, multiplica cada elemento por 5 e imprime o resultado.*/
#include <stdio.h>

#define tam 3

void main(){
    int m[tam][tam];

    for(int i=0; i<tam; i++)
      for(int j=0; j<tam;j++){    
            printf("Informe elemento da matriz[%d,%d]: ",j+1,i+1);
            scanf("%d",&m[j][i]);
        } 
        
    
    printf("Matriz original = \n");
    for(int i=0; i<tam; i++){
      for(int j=0; j<tam;j++){  
        printf("%d ",m[j][i]);
        m[j][i] *= 5;
      }     
      printf("\n");          
    } 
    
    printf("Matriz resultante = \n");
    for(int i=0; i<tam; i++){
      for(int j=0; j<tam;j++) 
        printf("%d ",m[j][i]);
      printf("\n");          
    }     
}

/** Faça um programa que lê um vetor de 3 elementos e uma matriz de 3 x 3 elementos. Em seguida, o programa deve fazer a multiplicação do vetor pelas colunas da matriz.**/

#include <stdio.h>

void main() {
    int vetor[3];
    int matriz[3][3];
   
    printf("Informe os valores do vetor:\n");
    for(int i=0;i<=2;i++){
        printf("Vetor[%d] = ",i);
        scanf("%d",&vetor[i]);
    }
   
    printf("Informe os valores da matriz:\n");
    for(int i=0;i<=2;i++)
        for(int j=0;j<=2;j++){
            printf("Matriz[%d][%d] = ",i,j);
            scanf("%d",&matriz[i][j]);
        }    
   
    for(int i=0;i<=2;i++)
        for(int j=0;j<=2;j++)
            matriz[i][j] = matriz[i][j]*vetor[j];
       
    printf("\nElementos da matriz resultante = \n");
    for(int i=0;i<=2;i++){
        for(int j=0;j<=2;j++){
            printf("%d ",matriz[i][j]);
        }
        printf("\n");
    }    
}

// Faça um algoritmo recursivo que soma todos os valores de um vetor
#include <stdio.h>
#include <stdlib.h>
#define TAM 100

int somar(int qtde, int v[]){
    if(qtde == 0) return 0;
    return v[qtde-1] + somar(qtde-1,v);
}

void main(){
    int vetor[TAM];
    int soma;
   
    printf("Elementos do vetor: \n");
    for(int i=0; i<TAM;i++){
        vetor[i] = rand()%100;
        printf("%d, ",vetor[i]);
    }
       
    printf("Soma dos elementos = %d\n",somar(TAM,vetor));
   
}

/**Faca um algoritmo recursivo que encontre qual o maior valor
de um vetor.**/
#include <stdio.h>

#define TAM 10

void preencherVetor(int v[], int *qtde){
    char resp;
    do{
        printf("Informe o valor do elemento %d do vetor: ",*qtde);
        scanf("%d%*c",&v[*qtde]);
        (*qtde)++;
        printf("Deseja continuar? S-sim, N-Não: ");
        scanf("%c%*c",&resp);
    }while(resp!='N');
}

void imprimirVetor(int v[], int qtde){
    printf("Vetor = ");
    for(int i=0; i<qtde; i++)
        printf("%d, ",v[i]);
    printf("\n");    
}

int maiorVetor(int v[], int qtde){
    
    if(qtde == 1) return v[qtde-1]; //valor base
    
    if (v[qtde-1] > maiorVetor(v,qtde-1))
        return v[qtde-1];
    else return maiorVetor(v,qtde-1);
}

int main(){
    int vetor[TAM], qtde=0, maior;
    
    preencherVetor(vetor,&qtde);
    imprimirVetor(vetor,qtde);
    maior = maiorVetor(vetor,qtde);
    
    printf("Maior elemento do vetor = %d\n",maior);
}

/******************************************************************************
Faça um algoritmo recursivo que encontre qual o maior valor de um vetor
*******************************************************************************/

#include <stdio.h>
#define tam 100

void insercaoVetor(int x, int qtde, int vetor[]) {
    vetor[qtde - 1] = x;
}

int buscaVetor(int x, int qtde, int vetor[]) {
    if(qtde==0) return -1;
    if(vetor[qtde-1]==x) return (qtde-1);
    return buscaVetor(x,qtde-1,vetor);
   
    /**for(int i = qtde-1; i>=0; i--)
        if(vetor[i] == x)
            return i;
    return -1;**/
}

void imprimirVetor(int qtde, int vetor[]) {
    printf("Vetor: ");
    for(int i=0; i<qtde; i++)
        printf("%d, ",vetor[i]);
    printf("\n");
}


int excluirElemento(int x, int qtde, int vetor[]){
    int i=0;
   
    while(i<qtde){
        if(vetor[i]==x){
            for(int j=i; j<(qtde-1); j++)
                vetor[j]=vetor[j+1];
            printf("Exclusão realizada com sucesso!\n");    
            return qtde-1;    
        }
        i++;
    }
    printf("Elemento não encontrado!\n");
    return qtde;
}


int encontrarMaior(int qtde, int maior, int vetor[]){
    if(qtde==0) return maior;
    if(vetor[qtde-1]>vetor[maior]) return encontrarMaior(qtde-1, qtde-1,vetor);
    else return encontrarMaior(qtde-1, maior,vetor);
}

int main() {
    int vetor[tam];
    int cont = 0, resp, x, achou;

    do {
        printf("Digite a opção desejada:\n");
        printf("1 - Inserir elemento no vetor\n");
        printf("2 - Buscar elemento no vetor\n");
        printf("3 - Excluir elemento no vetor\n");
        printf("4 - Mostrar o vetor\n");
        printf("5 - Encontrar Maior\n");
        printf("6 - Sair\n");
        scanf("%d",&resp);

        switch(resp) {
        case 1:
            printf("Informe o elemento a ser inserido: ");
            scanf("%d",&x);
            cont++;
            insercaoVetor(x,cont,vetor);
            imprimirVetor(cont,vetor);
            break;
        case 2:
            printf("Informe o elemento a ser buscado: ");
            scanf("%d",&x);
            achou = buscaVetor(x,cont,vetor);
            if(achou >= 0) printf("A posição do elemento %d é %d.\n",x,achou);
            else printf("Elemento não encontrado!\n");
            break;
        case 3:
            printf("Informe o elemento a ser excluído: ");
            scanf("%d",&x);
            cont = excluirElemento(x,cont,vetor);
            imprimirVetor(cont,vetor);
            break;
        case 4:
            imprimirVetor(cont,vetor);
            break;
        case 5:
            achou = encontrarMaior(cont, cont-1, vetor);
            printf("A posição do maior elemento %d é %d.\n",vetor[achou],achou);
            break;
        case 6:
            printf("Saindo do programa...");
            break;
        default:
            printf("Opção inválida!");
            break;
        }
    } while(resp != 6);
}

/******************************************************************************
Faça um algoritmo que leia um vetor com n elementos desordenado
e implemente o BubbleSort para ordenar os seus elementos
*******************************************************************************/
#include <stdio.h>
#define tam 10

void InsertionSort(int qtde, int vetor[]){
    int aux;
    for(int i=1; i<qtde;i++)
        for(int j=i; j>0;j--)
            if(vetor[j]<vetor[j-1]){
                aux = vetor[j];
                vetor[j] = vetor[j-1];
                vetor[j-1] = aux;
            }else break;
}

void SelectionSort(int qtde, int vetor[]){
    int aux, menor;
    for(int i=0; i<qtde; i++){
        menor=i;
        for(int j=i;j<qtde;j++)
            if(vetor[j]<vetor[menor]) menor = j;
        aux = vetor[menor];
        vetor[menor] = vetor[i];
        vetor[i] = aux;
    }
}

void BubbleSort(int qtde, int vetor[]){
    int aux;
    for(int i=0;i<qtde;i++)
        for(int j=0;j<(qtde-1);j++)
            if(vetor[j]>vetor[j+1]){
                aux = vetor[j];
                vetor[j] = vetor[j+1];
                vetor[j+1] = aux;
            }
}

void BubbleSortOtimo(int qtde, int vetor[]){
    int aux, flag = 0;
    while(!flag){
        flag = 1;
        for(int j=0;j<(qtde-1);j++)
            if(vetor[j]>vetor[j+1]){
                flag = 0;
                aux = vetor[j];
                vetor[j] = vetor[j+1];
                vetor[j+1] = aux;
            }
    }        
}

void insereVetor(int qtde, int vetor[]){
    int x;
    printf("Informe o elemento a ser inserido: ");
    scanf("%d",&x);
    vetor[qtde] = x;
}


void imprimeVetor(int qtde, int vetor[]){
    printf("Elementos do vetor:\n");
    for(int i=0;i<qtde;i++)
        if(i==(qtde-1)) printf("%d",vetor[i]);
        else printf("%d, ",vetor[i]);
    printf("\n");    
}

void main(){
    int qtde = 0, resp, vetor[tam];
    
    do{
        printf("---------------------------------\n");
        printf("Informe a ação desejada:\n");
        printf("1 - Inserir elemento no vetor\n");
        printf("2 - Imprimir vetor\n");
        printf("3 - Ordenar vetor pelo BubbleSort Simples\n");
        printf("4 - Ordenar vetor pelo BubbleSort Otimizado\n");
        printf("5 - Ordenar vetor pelo SelectionSort\n");
        printf("6 - Ordenar vetor pelo InsertionSort\n");
        printf("7 - Sair\n");
        printf("---------------------------------\n");
        scanf("%d",&resp);
        
        switch(resp){
            case 1:
                insereVetor(qtde,vetor);
                qtde++;
                break;
            case 2:
                imprimeVetor(qtde,vetor);
                break;
            case 3:
                BubbleSort(qtde,vetor);
                break;
            case 4:
                BubbleSortOtimo(qtde,vetor);
                break;
            case 5:
                SelectionSort(qtde,vetor);
                break;
            case 6:
                InsertionSort(qtde,vetor);
                break;
            case 7:
                printf("Saindo...");
                break;
            default:
                printf("Opção Inválida!");
                break;   
        }
    }while(resp!=7);    
}

//Faça um algoritmo em C que leia os dados de nome, endereço, altura, peso e idade de 10 alunos de uma academia, calcule o IMC = peso/(altura*altura) e salve tudo num vetor de structs, por fim, mostre todo o cadastramento em tela.
#include <stdio.h>

typedef struct alunoAcademia{
    char nome[30];
    char ende[60];
    float altura;
    float peso;
    float imc;
    int idade;
}aluno;

void main() {
    aluno turma[10];
    
    for(int i=0; i<=9; i++){
        printf("Digite o nome do %dº aluno: ",i+1);
        scanf("%s",&turma[i].nome); getchar();
        printf("Digite o endereço do %dº aluno: ",i+1);
        scanf("%s",&turma[i].ende); getchar();
        printf("Digite a altura do %dº aluno: ",i+1);
        scanf("%f",&turma[i].altura); 
        printf("Digite o peso do %dº aluno: ",i+1);
        scanf("%f",&turma[i].peso);
        turma[i].imc = turma[i].peso/(turma[i].altura * turma[i].altura);
        printf("Digite a idade do %dº aluno: ",i+1);
        scanf("%d",&turma[i].idade);
    }
    
    printf("DADOS CADASTRADOS\n");
    for(int i=0;i<=9;i++){
        printf("Aluno %d:\n",i+1);
        printf("Nome = %s\n",turma[i].nome);
        printf("Endereço = %s\n",turma[i].ende);
        printf("Idade = %d\n",turma[i].idade);
        printf("Peso = %.1f\n",turma[i].peso);
        printf("Altura = %.1f\n",turma[i].altura);
        printf("IMC = %.1f\n",turma[i].imc);
        printf("\n");
    }
}

#include <stdio.h>
#define tamanho 100

typedef struct alunoAcademia{
    int idade; 
    float altura;
    float peso;
    char nome[30];
    char endereco[50];
    char telefone[11];
} aluno;

void main(){
aluno classe[tamanho];
for (int i = 0; i <= (tamanho-1); i++){
printf ("Informe o nome da %dª pessoa: ",i+1);
scanf ("%s", classe[0].nome); getchar();
printf ("Informe a idade da %dª pessoa: ",i+1);
scanf ("%d", &classe[0].idade);
printf ("Informe a altura da %dª pessoa: ",i+1);
scanf ("%f", &classe[0].altura);
printf ("Informe o peso da %dª pessoa: ",i+1);
scanf ("%f", &classe[0].peso);
printf ("Informe o endereço da %dª pessoa: ",i+1);
scanf ("%s", classe[0].endereco); getchar();
printf ("Informe o telefone da %dª pessoa: ",i+1);
scanf ("%s", classe[0].telefone);getchar();
}}

#include <stdio.h>
typedef struct pessoa{
    float Peso; 
    int Idade; 
    float Altura; 
} Pessoa;

void ImprimePessoa(Pessoa P){
  printf("Idade: %d  Peso: %5.2f Altura: %5.2f\n", P.Idade, P.Peso, P.Altura);
}

void SetPessoa(Pessoa *P, int idade, float peso, float altura){ 
    (*P).Idade = idade;  // o campo pode ser acessado desta forma
    P->Peso = peso;      // ou desta
    P->Altura = altura;
}
   
int main(){
    Pessoa Joao;
    SetPessoa(&Joao, 15, 70.5, 1.75);
    ImprimePessoa(Joao);
    return 0;
}

/***    2. Sistema de Notas e Estatísticas da Turma (Valor: 6,0pts):  Faça um algoritmo 
que gerencie os dados de alunos de uma disciplina. Para isso, você deve: 
        a) Definir uma struct chamada Aluno, com os seguintes campos: (nome (até 50 
        caracteres), matricula (inteiro), notas (vetor com 3 notas reais), media (real)).
        b) Faça funcões que:
            1. Leia os dados de até 100 alunos (permitir que o usuário informe quantos 
            alunos ele deseja cadastrar, entre 1 e 100).
            2. Calcule a média de cada aluno (com base nas 3 notas) e armazene no campo 
            media.
            3. Encontre e exiba: O aluno com maior média, O aluno com menor média, A média 
            geral da turma, Quantos alunos foram aprovados, considerando média maior ou 
            igual a 7.0 como critério de aprovação.
            ***/
            
#include <stdio.h>

#define TAM 100

typedef struct Aluno{
    char nome[50];
    int matricula;
    float nota[3];
    float media;
}aluno;

void lerDados(aluno lista[], int qtde){
    for(int i=0; i<qtde; i++){
        printf("Informe o nome do %dº aluno: ",i+1);
        scanf("%s",lista[i].nome);
        printf("Informe a matrícula do %dº aluno: ",i+1);
        scanf("%d",&lista[i].matricula);
        printf("Informe a primeira nota do %dº aluno: ",i+1);
        scanf("%f",&lista[i].nota[1]);
        printf("Informe a segunda nota do %dº aluno: ",i+1);
        scanf("%f",&lista[i].nota[2]);
        printf("Informe a terceira nota do %dº aluno: ",i+1);
        scanf("%f",&lista[i].nota[3]);
    }
}

void calculaMedia(aluno lista[], int qtde){
    for(int i=0; i<qtde; i++)
        lista[i].media = (lista[i].nota[1]+lista[i].nota[2]+lista[i].nota[3])/3;
}

void encontrar(aluno lista[], int qtde){
    float maior=lista[0].media;
    float menor=lista[0].media;
    float media=0;
    int aprovados=0;
    
    for(int i=0; i<qtde; i++){
        media += lista[i].media;
        if(lista[i].media>=7) aprovados++;
        if(lista[i].media>maior) maior = lista[i].media;
        if(lista[i].media<menor) menor = lista[i].media;
    }
    media = media/(float)qtde;
    printf("Menor = %.1f\nMaior = %.1f\nMédia da turma = %.1f\nQtde de aprovados = %d\n",menor,maior,media,aprovados);
}

void main(){
    aluno lista[TAM];
    int qtde, sair;
    
    do{
        printf("Cadastro de alunos\n");
        printf("Informe quantos alunos deseja cadastrar:\n");
        scanf("%d%*c",&qtde);
        lerDados(lista,qtde);
        calculaMedia(lista,qtde);
        encontrar(lista,qtde);
        
        printf("Deseja repetir? 1-Sim 2-Não");
        scanf("%d",&sair);
    }while(sair==1);    
}
            

/******************************************************************************
Criar um vetor de Structs para armazenar até 100 produtos de um estoque. Os produtos
devem possuir as seguintes informações: nome(string), quantidade(int) e valor unitário
(float). Por fim, implemente o seguinte menu de forma modularizada:

+----------Controle de Estoque------------+
1. Inserir novo produto
2. Excluir produto pelo nome
3. Modificar dados do produto
4. Listar produtos cadastrados
5. Buscar produto pelo nome
6. Sair
+-----------------------------------------+
*******************************************************************************/
#include <stdio.h>
#include <string.h>

#define TAM 100

typedef struct Produto{
    char nome[30];
    int qtde;
    float valor;
}produto;


int inserirProduto(int tam, produto lista[]){
    printf("Informe o nome do produto: ");
    scanf("%[a-z A-Z]%*c", lista[tam].nome);
    printf("Informe a quantidade do produto: ");
    scanf("%d%*c", &lista[tam].qtde);
    printf("Informe o valor unitário do produto: R$");
    scanf("%f%*c", &lista[tam].valor);
 
    return (tam+1);
}

int excluirProduto(int tam, produto lista[], char nome[]){
    
    if (tam==0) return 0;
    for(int i=0; i<tam; i++)
        if(strcmp(lista[i].nome,nome)==0){
            for(int j=i; j<(tam-1); j++)
                lista[j] = lista[j+1];
            printf("Elemento excluído da posição %d\n",i);
            return tam-1;
        }
    return tam;    
}

void modificarProduto(int tam, produto lista[], char nome[]){
    
    if (tam!=0){
        for(int i=0; i<tam; i++)
            if(strcmp(lista[i].nome,nome)==0){
                printf("Informe a nova quantidade do produto: ");
                scanf("%d%*c",&lista[i].qtde);
                printf("Informe o novo valor do produto: ");
                scanf("%f%*c",&lista[i].valor);
                printf("Produto modificado com sucesso!\n");
            }
    }else printf("Lista vazia!\n");        
}

void listarProdutos(int tam, produto lista[]){
    if (tam!=0){
        for(int i=0; i<tam; i++){
            printf("Produto %d: \n",i+1); 
            printf("Nome = %s\n",lista[i].nome);
            printf("Quantidade = %d\n",lista[i].qtde);
            printf("Valor = R$%.2f\n",lista[i].valor);
            printf("\n");
        }
    }else printf("Lista vazia!\n");        
}

void buscarProduto(int tam, produto lista[], char nome[]){
    if (tam!=0){
        for(int i=0; i<tam; i++)
            if(strcmp(lista[i].nome,nome)==0){
                printf("Produto encontado na posição: %d\n",i); 
                printf("Nome = %s\n",lista[i].nome);
                printf("Quantidade = %d\n",lista[i].qtde);
                printf("Valor = R$%.2f\n",lista[i].valor);
                printf("\n");
            }
    }else printf("Lista vazia!\n");       
}

void main(){
    produto lista[TAM];
    int resp, qtde=0;
    char nomeProduto[30];
    
    do{
        printf("+----------Controle de Estoque------------+\n");
        printf("1. Inserir novo produto\n");
        printf("2. Excluir produto pelo nome\n");
        printf("3. Modificar dados do produto\n");
        printf("4. Listar produtos cadastrados\n");
        printf("5. Buscar produto pelo nome\n");
        printf("6. Sair\n");
        printf("+-----------------------------------------+\n");
        printf("\n");
        scanf("%d%*c",&resp);
        
        switch (resp){
            case 1:
                qtde = inserirProduto(qtde, lista);
                break;
            case 2: 
                printf("Digite o nome do produto a ser excluído: ");
                scanf("%[a-z A-Z]%*c", nomeProduto);
                qtde = excluirProduto(qtde, lista, nomeProduto);
                break;
            case 3: 
                printf("Digite o nome do produto a ser modificado: ");
                scanf("%[a-z A-Z]%*c", nomeProduto);
                modificarProduto(qtde, lista, nomeProduto);
                break;
            case 4: 
                listarProdutos(qtde, lista);
                break;
            case 5: 
                printf("Digite o nome do produto a ser buscado: ");
                scanf("%[a-z A-Z]%*c", nomeProduto);
                buscarProduto(qtde, lista, nomeProduto);
                break;
            case 6: 
                printf("Saindo ...\n");
                break;
            default: printf("Opção Inválida! Digite novamente!\n");break;
        }
    }while(resp!=6);
}

/** Faça um programa para armazenar um livro de receitas e:
    
    (a) Crie um vetor de 5 receitas, que deve ter nome (máximo 25 letras), quantidade de ingredientes e os ingredientes, que podem ser no máximo 10.
    (b) Para cada receita, leia seu nome e a quantidade de ingredientes. Então crie e leia o vetor de ingredientes, sendo que cada ingrediente contém nome e quantidade (em gramas).
    (c) Permita que o usuário procure a receita por nome, mostrando seus ingredientes e quantidade, caso a encontre. Se não encontrar, informe ao usuário que não encontrou **/

#include <stdio.h>
#include <string.h>

typedef struct tipoIngrediente{
    char nome[25];
    float qtde;
} ingrediente;

typedef struct livroReceitas{
    char nome[25];
    int qtdeIngredientes;
    ingrediente lista[10];
} receita;

void main(){
    receita Vreceitas[5];
    int resp, i, j;
    char nome[25];
    
    do{
        printf("------------------------------------\n");
        printf("---------LIVRO DE RECEITAS----------\n");
        printf("------------------------------------\n");
        printf("Escolha uma das opções abaixo:\n");
        printf("1 - Preencher o livro de receitas\n");
        printf("2 - Buscar uma receita pelo nome\n");
        printf("3 - Mostrar conteúdo do livro\n");
        printf("4 - Sair\n");
        scanf("%d",&resp);
        getchar();
    
        switch (resp){
            case 1:
                for(i=0; i<5; i++){
                    printf("Informe o nome da %dª receita: ",i+1);
                    scanf("%s",Vreceitas[i].nome);
                    getchar();
                    printf("Informe a quantidade de ingredientes da %dª receita: ",i+1);
                    scanf("%d",&Vreceitas[i].qtdeIngredientes);
                    while(Vreceitas[i].qtdeIngredientes > 10){
                        printf("Informe uma quantidade menor que 10!:\n");
                        scanf("%d",&Vreceitas[i].qtdeIngredientes);
                    }
                    getchar();
                    for(j = 0; j<Vreceitas[i].qtdeIngredientes;j++){
                        printf("Informe o nome do %dº ingrediente da %dª receita: ",j+1,i+1);
                        scanf("%s",Vreceitas[i].lista[j].nome);
                        getchar();
                        printf("Informe a quantidade do %dº ingrediente da %dª receita: ",j+1,i+1);
                        scanf("%f",&Vreceitas[i].lista[j].qtde);
                    }
                }
                break;
            case 2:
                printf("Informe o nome da receita: que você deseja buscar: ");
                scanf("%s",nome);
                getchar();
                for(i=0; i<5; i++)
                    if(strcmp(Vreceitas[i].nome,nome)==0){
                        printf("Quantidade de ingredientes = %d\n Lista:\n",Vreceitas[i].qtdeIngredientes);
                        for(j=0;j<Vreceitas[i].qtdeIngredientes; j++){
                            printf("%s, %.1fg\n",Vreceitas[i].lista[j].nome,Vreceitas[i].lista[j].qtde);
                        }
                    }
                break;
            case 3:
                for(i=0; i<5; i++){
                    printf("Nome da receita = %s\n",Vreceitas[i].nome);
                    printf("Quantidade de ingredientes = %d\n Lista:\n",Vreceitas[i].qtdeIngredientes);
                        for(j=0;j<Vreceitas[i].qtdeIngredientes; j++){
                            printf("%s, %.1fg\n",Vreceitas[i].lista[j].nome,Vreceitas[i].lista[j].qtde);
                        }
                    }
                break;
            case 4:
                printf("Saindo do programa...");
                break;
            default:
                printf("Opção inválida! Tente de novo!");
                break;
        }
    }while(resp!=4);    
}

/******************************************************************************
1.	Faça um algoritmo modularizado para armazenar um livro de receitas:

 a)	O algoritmo deverá armazenar até 100 receitas, cada receita deverá ter: 
 nome, quantidade de ingredientes, lista de ingredientes e procedimento 
 (string de até 300 caracteres).
 b)	Para cada receita, leia seu nome, a quantidade de ingredientes e o 
 procedimento. Então crie e leia o vetor de ingredientes, sendo que cada 
 ingrediente contém nome e quantidade (em gramas).
 c)	Faça um Menu que permita que o usuário: 
•	procure a receita por nome, mostrando seus ingredientes, quantidade 
e procedimento, caso a encontre. Se não encontrar, informe ao usuário que 
não encontrou.
•	Insira uma nova receita (inserir todos os dados da receita, inclusive 
os ingredientes)
•	Exclua uma receita pelo nome
•	Liste todas as receitas cadastradas
•	Sair do programa
*******************************************************************************/

#include <stdio.h>
#include <string.h>

#define TAM 100
#define iTAM 10

typedef struct ingrediente{
    char nome[30];
    float qtde;
}ing;

typedef struct receita{
    char nome[30];
    int qtdeIng;
    ing listaIng[iTAM];
    char procedimento[300];
}rec;

int inserirReceita(int qtde, rec lista[]){
    if(qtde<TAM){
        printf("Informe o nome da receita: ");
        scanf("%[a-z A-Z]%*c",lista[qtde].nome);
        printf("Informe a qtde de ingredientes da receita: ");
        scanf("%d%*c",&lista[qtde].qtdeIng);
        printf("Informe o procedimento da receita: ");
        scanf("%[a-z A-Z]%*c",lista[qtde].procedimento);
        for(int i=0; i<lista[qtde].qtdeIng; i++){
            printf("Informe o nome do ingrediente %d: ",i+1);
            scanf("%[a-z A-Z]%*c",lista[qtde].listaIng[i].nome);
            printf("Informe a qtde do ingrediente %d: ",i+1);
            scanf("%f%*c",&lista[qtde].listaIng[i].qtde);
        }
        return qtde+1;
    }else{
        printf("Lista cheia! Não pode inserir mais receitas!\n");
        return qtde;
    }    
}

int excluirReceita(int qtde, rec lista[]){
    char nome[30];
    printf("Informe o nome da receita a ser excluída: ");
    scanf("%[a-z A-Z]%*c",nome);
    
    for(int i=0; i<qtde; i++)
        if(strcmp(nome,lista[i].nome)==0){
            for(int j=i; j<(qtde-1); j++)
                lista[j] = lista[j+1];   
            printf("Receita %s que estava na posição %d foi excluída!\n",nome,i);    
            return qtde-1;
        }
    printf("Receita %s não encontrada",nome);    
    return qtde;    
}

void listarReceitas(int qtde, rec lista[]){
    printf("Listagem de Receitas:\n");
    for(int i=0; i<qtde; i++){
        printf("Receita %d\n",i+1);
        printf("Nome: %s\n",lista[i].nome);
        printf("Qtde de ingredientes: %d\n",lista[i].qtdeIng);
        printf("Procedimento: %s\n",lista[i].procedimento);
        for(int j=0; j<lista[i].qtdeIng; j++){
            printf("Nome do ingrediente %d: %s\n",j+1,lista[i].listaIng[j].nome);
            printf("Qtde do ingrediente %d: %f\n",j+1,lista[i].listaIng[j].qtde);
        }
    }
}

void buscarPorNome(int qtde, rec lista[]){
    char nome[30];
    printf("Informe o nome da receita a ser excluída: ");
    scanf("%[a-z A-Z]%*c",nome);
    
    for(int i=0; i<qtde; i++)
        if(strcmp(nome,lista[i].nome)==0){
            printf("Receita %d\n",i+1);
            printf("Nome: %s\n",lista[i].nome);
            printf("Qtde de ingredientes: %d\n",lista[i].qtdeIng);
            printf("Procedimento: %s\n",lista[i].procedimento);
            for(int j=0; j<lista[i].qtdeIng; j++){
                printf("Nome do ingrediente %d: %s\n",j+1,lista[i].listaIng[j].nome);
                printf("Qtde do ingrediente %d: %f\n",j+1,lista[i].listaIng[j].qtde);
            }
            return;
        }
}
void main(){
    rec lista[TAM];
    int resp, qtde = 0;
    
    do{
        printf("+--------------Menu--------------+\n");
        printf("1. Inserir Receita\n");
        printf("2. Excluir Receita\n");
        printf("3. Listar Receitas\n");
        printf("4. Buscar Receita pelo nome\n");
        printf("5. Sair\n");
        printf("+--------------------------------+\n");
        scanf("%d%*c",&resp);
        
        switch (resp){
            case 1: qtde = inserirReceita(qtde,lista); 
                    break;
            case 2: qtde = excluirReceita(qtde,lista); 
                    break;
            case 3: listarReceitas(qtde,lista);
                    break;
            case 4: buscarPorNome(qtde,lista);
                    break;
            case 5: printf("Saindo... \n"); 
                    break;
            default: printf("Opção Inválida!\n"); 
                    break;
        }
    }while(resp!=5);    

}

/*Fazer um programa para simular uma agenda de telefones. Para cada
pessoa devem-se ter os seguintes dados: Nome, E-mail, Endereço, Telefone 
(Com DDD e Número), Data de Nascimento DDMMAAAA

Observações (String com 100 caracteres)

Defina a Struct, declare a variável AGENDA com capacidade para 100
elementos, e desenvolva um MENU com as seguintes ações:

(a) Buscar pelo primeiro nome: Imprime os dados da pessoa com esse
nome (se tiver mais de uma pessoa, imprime para todas).
(b) Buscar pela data de nascimento: Imprime os dados de todas as
pessoas que nasceram naquele dia, mês e ano.
(c) Inserir dados de uma pessoa: Insere dados da pessoa em ordem
alfabética
(d) Deletar dados de uma pessoa: Apaga dados da pessoa mantendo
a ordem alfabética*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TAM 100

typedef struct pessoa{
    char nome[30];
    char email[30];
    char endereco[50];
    char telefone[11];
    int data_nascimento;  // formato DDMMAAAA como inteiro
}AGENDA;

void buscaPeloNome(AGENDA lista[], int qtde){
    char nome[30];
    
    printf("Digite o nome a buscar: ");
    scanf("%[a-z A-Z]%*c",nome);

    int encontrado = 0;
    for (int i = 0; i < qtde; i++) {
            if (nome && strcmp(nome, lista[i].nome) == 0) {
                printf("\n--- Contato %d ---\n", i + 1);
                printf("Nome: %s\n", lista[i].nome);
                printf("Email: %s\n", lista[i].email);
                printf("Endereco: %s\n", lista[i].endereco);
                printf("Telefone: %s\n", lista[i].telefone);
                printf("Data de nascimento: %d\n", lista[i].data_nascimento);
                encontrado = 1;
            }
        }

    if (!encontrado) 
        printf("Nenhum contato encontrado com esse nome.\n");
}

void buscaPelaData(AGENDA lista[], int qtde){
    int data;
    printf("Digite a data de nascimento (DDMMAAAA): ");
    scanf("%d%*c", &data);

    int encontrado = 0;
    for (int i = 0; i < qtde; i++) {
        if (lista[i].data_nascimento == data) {
            printf("\n--- Contato %d ---\n", i + 1);
            printf("Nome: %s\n", lista[i].nome);
            printf("Email: %s\n", lista[i].email);
            printf("Endereco: %s\n", lista[i].endereco);
            printf("Telefone: %s\n", lista[i].telefone);
            printf("Data de nascimento: %d\n", lista[i].data_nascimento);
            encontrado = 1;
        }
    }

    if (!encontrado) 
        printf("Nenhum contato encontrado com essa data de nascimento.\n");
    
    
}

int inserirDados(AGENDA lista[], int qtde){
    if (qtde >= TAM) {
        printf("Agenda cheia!\n");
    }

    AGENDA nova;
    printf("Nome: ");
    scanf("%[a-z A-Z]%*c",nova.nome);

    printf("Email: ");
    scanf("%[a-z A-Z]%*c",nova.email);

    printf("Endereco: ");
    scanf("%[a-z A-Z]%*c",nova.endereco);

    printf("Telefone: ");
    scanf("%[a-z A-Z]%*c",nova.telefone);

    printf("Data de nascimento (DDMMAAAA): ");
    scanf("%d%*c", &nova.data_nascimento);

    // Inserir em ordem alfabética
    if(qtde==0) lista[0] = nova;
    else{
        int i = qtde - 1;
        while ((i >= 0) && (strcmp(nova.nome, lista[i].nome) < 0)) {
            lista[i + 1] = lista[i];
            i--;
        }
        lista[i + 1] = nova;
	}
	qtde++;
    printf("Contato adicionado com sucesso!\n");
    return qtde;         
}

int deletarDados(AGENDA lista[], int qtde){
    char nome[30];
    int i;
    printf("Digite o nome completo da pessoa a ser deletada: ");
    scanf("%[a-z A-Z]%*c",nome);

    for (i = 0; i < qtde; i++)
        if (strcmp(lista[i].nome, nome) == 0) break;
    
    if (i == qtde) {
        printf("Pessoa não encontrada.\n");
        return qtde;
    }

    for (int j = i; j < qtde - 1; j++)
        lista[j] = lista[j + 1];
    
    qtde--;
    printf("Contato removido com sucesso!\n");
    return qtde;            
}

void imprimir(AGENDA lista[], int qtde){
    for (int i = 0; i < qtde; i++) {
        printf("\n--- Contato %d ---\n", i + 1);
        printf("Nome: %s\n", lista[i].nome);
        printf("Email: %s\n", lista[i].email);
        printf("Endereco: %s\n", lista[i].endereco);
        printf("Telefone: %s\n", lista[i].telefone);
        printf("Data de nascimento: %d\n", lista[i].data_nascimento);
    }
}

void main(){
    AGENDA agenda[TAM];
    int total_contatos = 0;
    int opcao, data, encontrado = 0, i;
    char nome[30];

    do {
        printf("\n--- MENU AGENDA ---\n");
        printf("1. Buscar pelo primeiro nome\n");
        printf("2. Buscar pela data de nascimento\n");
        printf("3. Inserir dados de uma pessoa\n");
        printf("4. Deletar dados de uma pessoa\n");
        printf("5. Listar todos os dados cadastrados\n");
        printf("6. Sair\n");
        printf("Escolha uma opcao: ");
        scanf("%d%*c", &opcao);

        switch (opcao) {
            case 1:
                buscaPeloNome(agenda, total_contatos);
                break;
            case 2:
                buscaPelaData(agenda, total_contatos);
                break;
            case 3:
                total_contatos = inserirDados(agenda, total_contatos);
                break;
            case 4:
                total_contatos = deletarDados(agenda,total_contatos);
                break;
            case 5:
                imprimir(agenda,total_contatos);
                break;
            case 6:
                printf("Saindo...\n");
                break;
            default:
                printf("Opção invalida!\n");
        }
    }while(opcao != 6);
}

/******************************************************************************
Escreva um procedimento que gere um cabeçalho para um relatório. Esse
procedimento deve receber um nome como parâmetro. O cabeçalho tem a seguinte forma:
============================================
 IFBA - Instituto Federal de Educação, Ciência e Tecnologia da Bahia
 COINF - Coordenação de Informática
 Disciplina de Linguagem de Programação I
 Nome: ****substituir pelo nome digitado***
============================================ 
*******************************************************************************/

#include <stdio.h>

void cabecalho(char nome[]){
    printf("============================================\n");
    printf("IFBA - Instituto Federal de Educação, Ciência e Tecnologia da Bahia\n");
    printf("COINF - Coordenação de Informática\n");
    printf("Disciplina de Linguagem de Programação I\n");
    printf("Aluno: %s\n", nome);
    printf("============================================\n"); 
}

void main(){
    char resp;
    char nome[30];
    
    do{
        printf("Informe o nome para gerar o cabeçalho: ");
        scanf("%[a-z A-Z]%*c",nome);
        cabecalho(nome);
        
        printf("Deseja continuar? S-sim e N-não: ");
        scanf("%c%*c",&resp);
    }while(resp!='N');
}

/******************************************************************************
Escreva uma função que receba um número inteiro e imprima o mês
correspondente ao número. Por exemplo, 2 corresponde à “fevereiro”. A função
deve mostrar uma mensagem de erro caso o número recebido não faça sentido. Gere
também um algoritmo que leia um valor e chame a função criada. 
*******************************************************************************/

#include <stdio.h>

void qualMes(int x){
    switch (x){
        case 1: printf("Janeiro\n"); break;
        case 2: printf("Fevereiro\n"); break;
        case 3: printf("Março\n"); break;
        case 4: printf("Abril\n"); break;
        case 5: printf("Maio\n"); break;
        case 6: printf("Junho\n"); break;
        case 7: printf("Julho\n"); break;
        case 8: printf("Agosto\n"); break;
        case 9: printf("Setembro\n"); break;
        case 10: printf("Outubro\n"); break;
        case 11: printf("Novembro\n"); break;
        case 12: printf("Dezembro\n"); break;
        default: printf("Número não corresponde a um mês válido!\n"); break;
    }
}

void main(){
    char resp;
    int mes;
    
    do{
        printf("Informe um número inteiro: ");
        scanf("%d%*c",&mes);
        qualMes(mes);
        
        printf("Deseja continuar? S-sim e N-não: ");
        scanf("%c%*c",&resp);
    }while(resp!='N');
}

/******************************************************************************
Faça uma função que leia 3 números inteiros e mostre-os em ordem crescente
*******************************************************************************/

#include <stdio.h>

void ordemCrescente(int x, int y, int z){
    if((x<=y) && (y<=z)) printf("%d <= %d <= %d\n",x,y,z);
    else if((x<=z) && (z<=y)) printf("%d <= %d <= %d\n",x,z,y);
    else if((y<=x) && (x<=z)) printf("%d <= %d <= %d\n",y,x,z);
    else if((y<=z) && (z<=x)) printf("%d <= %d <= %d\n",y,z,x);
    else if((z<=x) && (x<=y)) printf("%d <= %d <= %d\n",z,x,y);
    else printf("%d <= %d <= %d\n",z,y,x);
}

void main(){
    char resp;
    int a,b,c;
    
    do{
        printf("Informe três números inteiros: ");
        scanf("%d %d %d%*c",&a,&b,&c);
        ordemCrescente(a,b,c);
        
        printf("Deseja continuar? S-sim e N-não: ");
        scanf("%c%*c",&resp);
    }while(resp!='N');
}

/******************************************************************************
Sabendo-se que um número perfeito é aquele cuja multiplicação de seus divisores, 
excluindo ele mesmo, é igual ao próprio número (ex: 6 = 3 + 2 + 1), faça uma função que
receba como parâmetro um inteiro e informe se ele é perfeito.
*******************************************************************************/

#include <stdio.h>

void perfeito(int x){
    int resultado = 0;
    
    for(int i = (x-1); i>=1; i--)
        if(x%i == 0) resultado+=i;
    
    if(resultado == x) printf("Número Perfeito!\n");
    else  printf("Número NÃO Perfeito!\n");
}

void main(){
    char resp;
    int x;
    
    do{
        printf("Informe um número inteiro: ");
        scanf("%d%*c",&x);
        perfeito(x);
        
        printf("Deseja continuar? S-sim e N-não: ");
        scanf("%c%*c",&resp);
    }while(resp!='N');
}

/******************************************************************************
Escreva uma função que leia 2 números inteiros, x e y, que são os limites de
um intervalo e informe todos os números primos contidos no intervalo.
*******************************************************************************/

#include <stdio.h>

void troca(int *x, int *y){
    int aux;
    if(*x > *y){
        aux = *x;
        *x = *y;
        *y = aux;
    }
}

void primo(int x, int y){
    int aux, cont;
    
    troca(&x,&y);
    
    for(int i = x; i <= y; i++){
        cont = 0;
        for(int j = 1; j <= i; j++)
            if(i%j == 0) cont++;
        if(cont==2) printf("Primo = %d\n",i);    
    }
}

void main(){
    char resp;
    int x, y;
    
    do{
        printf("Informe o intervalo [x,y]: ");
        scanf("%d%*c %d%*c",&x,&y);
        primo(x,y);
        
        printf("Deseja continuar? S-sim e N-não: ");
        scanf("%c%*c",&resp);
    }while(resp!='N');
}

/**Faça um algoritmo que implemente um calculadora modularizada **/

#include <stdio.h>

void soma(float a, float b){
    printf("%.1f + %.1f = %.1f\n", a, b, a+b);
}

void subtracao(float a, float b){
    printf("%.1f - %.1f = %.1f\n", a, b, a-b);
}

void divisao(float a, float b){
    if(b==0){
        printf("Não é permitido realizar divisão por zero!\n");
    }else printf("%.1f/%.1f = %.1f\n", a, b, a/b);
}

void multiplicacao(float a, float b){
    printf("%.1f x %.1f = %.1f\n", a, b, a*b);
}

void main(){
    int x,y,resp;
    char op;
    do{
        printf("-----------Calculadora------------\n");
        printf("Digite a operação desejada:\n");
        printf("Número operador Número\n");
        scanf("%d%*c", &x);
        scanf("%c", &op);
        scanf("%d%*c", &y);
        switch (op){
            case '+': soma(x,y); break;
            case '-': subtracao(x,y); break;
            case '/': divisao(x,y); break;
            case '*': multiplicacao(x,y); break;
            default: printf("Operação Inválida!\n"); break;
        }
        printf("Deseja repetir a operação? 1-Sim 2-Não\n");
        scanf("%d%*c", &resp);
        
    }while(resp==1);
}

/**Elabore uma função que receba três notas de um aluno como parâmetro e uma 
letra. Se a letra for ‘A’, a função deve calcular a média aritmética das notas 
do aluno; se a letra for ‘P’, deverá calcular a média ponderada, com pesos 
5, 3 e 2. Retorne a média calculada para o programa principal.**/
#include <stdio.h>

float calcularMedia(float n1, float n2, float n3, char tipo){
    if(tipo == 'A') return ((n1+n2+n3)/3);
    if(tipo == 'P') return ((n1*5+n2*3+n3*2)/10);
    return 0;
}

void main(){
   float n1,n2,n3;
   char tipo;
    
   printf("Informe as 3 notas do aluno:\n");
   scanf("%f%*c %f%*c %f%*c",&n1,&n2,&n3);
    
    do{
        printf("Digite 'A' para média aritmética e 'P' para média ponderada:\n");
        scanf("%c%*c", &tipo);
    
        if((tipo!='A') && (tipo!='P')) printf("Opção inválida! Digite novamente:\n");
    }while((tipo!='A') && (tipo!='P'));
    
    printf("Média = %.1f\n", calcularMedia(n1,n2,n3,tipo));
}

// Faça um algoritmo que leia dois números inteiros e informe o MDC desses 
//números. OBS.: O Máximo Divisor Comum (MDC) corresponde ao maior número 
//inteiro capaz de dividir dois ou mais números inteiros simultaneamente.

#include <stdio.h>

int MDC(int x, int y){
    for(int MDC=x; MDC>=1; MDC--)
        if((x%MDC==0) && (y%MDC==0))
            return MDC;
}

void main(){
    int x,y,mdc;
    
    printf("Informe dois números inteiros: ");
    scanf("%d %d", &x, &y);
    
    mdc = MDC(x,y);
    
    printf("MDC(%d,%d) = %d",x,y,mdc);
}

/**Crie um programa que leia até 100 idades (inteiras), armazene-as e 
depois mostre-as. Crie funções e procedimentos para realizar as 
tarefas. **/

#include <stdio.h>

#define tam 100

void inserir(int id, int qtde, int idades[]){
    idades[qtde] = id;
}

int buscarRemover(int id, int qtde, int idades[]){
    
    for(int i=0; i<qtde; i++){
        if(idades[i]==id){
            for(int j=i; j<(qtde-1);j++)
                idades[j]=idades[j+1];
            printf("Elemento removido!\n");    
            return 1;
        }
    }
    printf("Elemento não encontrado!\n");
    return 0;
}

void mostrar(int qtde, int idades[]){
    for(int i=0; i< qtde; i++)
        printf("%d, ",idades[i]);
    printf("\n");    
    
}

void main(void){
    int idades[tam], id, qtde=0;
    int removeu;
    
    do{
        printf("Informe uma idade a ser inserida ou -1 para sair: ");
        scanf("%d",&id);
        
        if(id>=0){
            inserir(id,qtde,idades);
            qtde++;
            
            mostrar(qtde,idades);   
        }
    }while(id>=0);
    
    
    do{
        printf("Informe uma idade a ser removida ou -1 para sair: ");
        scanf("%d",&id);
        
        if(id>=0)
            if(buscarRemover(id,qtde,idades)) 
                qtde--;
        
        mostrar(qtde,idades);        
        
    }while(id>=0);
    
}

/******************************************************************************
Crie uma função recursiva que receba um número inteiro positivo N e
calcule o somatório de todos os inteiros contidos no intervalo [1,N].
*******************************************************************************/

#include <stdio.h>


int soma(int N){
    if (N==1) return 1;
    else return N+soma(N-1);
}

void main(){
    int N;
    char resp;
    
    do{
    	printf("Informe um número inteiro: ");
    	scanf("%d",&N);
    
    	printf("Somatório dos números de 1 a %d: %d\n", N, soma(N));
    	
        printf("Deseja executar novamente? (s-sim e n-não): ");
        scanf("%c%*c",&resp);
        
    } while(resp!='n');
}

/******************************************************************************
A multiplicação de dois números inteiros pode ser feita através de somas
sucessivas. Proponha um algoritmo recursivo Mult(n1,n2) que calcule
a multiplicação de dois inteiros.
*******************************************************************************/

#include <stdio.h>

int Mult(int x, int y) {
	if (y==0) return 0;
    if (y==1) return x;
    else return x+Mult(x, (y-1));
}

int main() {
    int x,y;
    char resp;
    
    do{
        
        printf("Digite dois números para calculo da multiplicação:\n");
        scanf("%d %d%*c",&x,&y);
    
        printf("Mult(%d,%d) = %d\n",x,y,Mult(x,y));
        
        printf("Deseja executar novamente? (s-sim e n-não): ");
        scanf("%c%*c",&resp);
        
    } while(resp!='n');
}

/******************************************************************************
Crie um programa em C, que contenha uma função recursiva que receba
dois inteiros positivos k e n e calcule kˆn. Utilize apenas multiplicações.
O programa principal deve solicitar ao usuário os valores de k e n e
imprimir o resultado da chamada da função.
*******************************************************************************/

#include <stdio.h>


int elevado(int k, int n){
	if (n==0) return 1;
    if (n==1) return k;
    else return k*elevado(k, n-1);
}

void main(){
    int k,n;
    char resp;
    
    do{
        printf("Informe um número inteiro e seu expoente: ");
        scanf("%d %d%*c",&k,&n);
    
        printf("%d elevado a %d = %d\n", k, n, elevado(k,n));
    
        printf("Deseja executar novamente? (s-sim e n-não): ");
        scanf("%c%*c",&resp);
        
    } while(resp!='n');
}

// Online C compiler to run C program online
#include <stdio.h>

int MDC(int x, int y){
   if (x == y) return x;
   if (x < y) return MDC(y, x);
   return MDC(x-y, y);
}

int main() {
    int x,y;
    printf("Digite um dois números para o cálculo do MDC: ");
    scanf("%d %d",&x,&y);
    printf("MDC(%d,%d) = %d",x,y,MDC(x,y));
    return 0;
}

/******************************************************************************
O máximo divisor comum dos inteiros x e y é o maior inteiro que é
divisível por x e y. Escreva uma função recursiva mdc em C, que retorna
o máximo divisor comum de x e y. O mdc de x e y é definido como
segue: se y é igual a 0, então mdc(x,y) é x; caso contrário, mdc(x,y) é
mdc (y, x%y), onde % é o operador resto.
*******************************************************************************/

#include <stdio.h>

int MDC(int x, int y) {
    if (y==0) return x;
    else return MDC(y, x%y);
}

int main() {
    int x,y;
    char resp;
    
    do{
        
        printf("Digite dois números para calculo do MDC:\n");
        scanf("%d %d%*c",&x,&y);
    
        printf("MDC(%d,%d) = %d\n",x,y,MDC(x,y));
        
        printf("Deseja executar novamente? (s-sim e n-não): ");
        scanf("%c%*c",&resp);
        
    } while(resp!='n');
}

// Faça um algoritmo que calcula o reto da divisão de forma recursiva
#include <stdio.h>

int MOD(int x, int y){
   if (x == y) return 0;
   if (x < y) return x;
   return MOD(x-y, y);
}

int main() {
    int x,y;
    printf("Digite um dois números para o cálculo do resto da divisão: ");
    scanf("%d %d",x,y);
    printf("MOD(%d,%d) = %d",x,y,MOD(x,y));
    return 0;
}

/******************************************************************************
Faça um algoritmo que leia um intervalo [x,y] e informe todos os números contidos 
no intervalo que são pares e divisíveis por 3 ao mesmo tempo. Para estes números, 
e somente para estes números, mostre a lista dos seus divisores
*******************************************************************************/

#include <stdio.h>

void main(){
    int x,y;
    
    printf("Informe o intervalo [x,y]: ");
    scanf("%d %d",&x,&y);
    
    if(x>y){
    	int aux;
    	aux = x;
    	x = y;
    	y = aux;
    }
    
    for(int i=x; i<=y; i++)
        if((i%2==0)&&(i%3==0)){
            printf("Divisores de %d:\n",i);
            for(int divisor=i;divisor>=1;divisor--)
                if(i%divisor==0) printf("%d\n",divisor);
        }

}

/******************************************************************************
Dada a série de Fibonacci: Fib = 1, 1, 2, 3, 5, 8, 13, 21, 34 …, na qual podemos 
descobrir o valor do elemento seguinte, pois o elemento sempre é a soma dos dois 
elementos anteriores da série, logo:  Fib(n) = Fib(n-1) + Fib(n-2). Faça um 
algoritmo que mostre o N-ésimo termo da série de Fibonacci. N deverá ser informado 
pelo usuário.
*******************************************************************************/

#include <stdio.h>

void main(){
    int fib,fib1,fib2,n;
    
    printf("Informe o elemento de Fibonacci desejado: ");
    scanf("%d",&n);
    
    printf("%dº elemento da série de Fibonacci = ",n);
    
    fib1=fib2=1;
    
    if((n==1)||(n==2)) printf("1");
    else if(n>2){
        for(int i=3; i<=n; i++){
            fib = fib1+fib2;
            fib1 = fib2;
            fib2 = fib;
        }
        printf("%d\n",fib);
    }else printf("O elemento não pode ser negativo!\n");        

}

/******************************************************************************
Faça um algoritmo que lei uma quantidade indeterminada de informações sobre 
clientes de uma academia. Deve-se ler: idade, sexo biológico (F-feminino e M-masculino), 
peso e altura. No final, informar: 
        a) Quantidade total de clientes cadastrados
        b) Percentual de mulheres e de homens
        c) Maior peso entre as mulheres, menor peso entre os homens
        d) média das alturas das mulheres e média das alturas dos homens
        e) Idade do homem mais velho e idade da mulher mais nova
*******************************************************************************/

#include <stdio.h>

void main(){
    int idade, total=0, mulher=0, homem=0,nova,velho;
    float pesada, leve, altMulher=0.0, altHomem=0.0, altura, peso;
    char sexo, resp;
    
    do{
        printf("Cadastro de Academia\n");
        printf("Informe o sexo (F-feminino, M-masculino):\n");
        scanf("%c%*c",&sexo);
        printf("Informe a idade:\n");
        scanf("%d%*c",&idade);
        printf("Informe a altura:\n");
        scanf("%f%*c",&altura);
        printf("Informe o peso:\n");
        scanf("%f%*c",&peso);
        
        if((sexo == 'F')||(sexo=='f')){
            total++;
            mulher++;
            altMulher+=altura;
            
            if(mulher == 1){
                pesada = peso;
                nova = idade;
            }else{
                if(pesada < peso) pesada = peso;
                if(nova > idade) nova = idade;
            }
        }else if((sexo == 'M')||(sexo=='m')){
            total++;
            homem++;
            altHomem+=altura;
            
            if(homem == 1){
                leve = peso;
                velho = idade;
            }else{
                if(leve > peso) leve = peso;
                if(velho < idade) velho = idade;
            }
        }else printf("Sexo digitado é inválido! Informar F ou M\n");
        
        printf("Deseja repetir o cadastramento? (S-Sim, N-Não)\n");
        scanf("%c%*c",&resp);
    }while(resp!='N');     
    
    printf("Total de pessoas cadastradas = %d\n",total);
    printf("Percentual de Mulheres = %.1f%%\n",(float)(mulher*100)/(float)total);
    printf("Percentual de Homens = %.1f%%\n",(float)(homem*100)/(float)total);
    printf("Maior peso entre as mulheres = %.1fKgs\n",pesada);
    printf("Menor peso entre os homens= %.1fKgs\n",leve);
    printf("Média das alturas das mulheres = %.2fm\n",((float)altMulher/(float)mulher));
    printf("Média das alturas das homens= %.2fm\n",((float)altHomem/(float)homem));
    printf("Idade do homem mais velho = %d\n", velho);
    printf("Idade da mulher mais nova = %d\n", nova);
}