Média ponderada com Vetor em C

Bom dia!,

Considerando o último post, onde utilizamos vetores para cálculo de uma média aritmética, adaptei o mesmo programa para cálculo de uma média ponderada.
Ex.: Nota 1 tem Peso 1, Nota 2 tem peso 2 e Nota 3 tem peso 3. Simulando as notas 5, 10 e 7 com estes pesos, temos :

(5 * 1) + (10 * 2 ) + ( 7 * 3) / 1+ 2 + 3 =
5+ 20 + 21 / 6 =
46 / 6 = 7,66

Testando o programa:

Segue abaixo o código do programa, comentado:

int main(int argc, char *argv[]) {

int num_media[QTDE]; /* Vetor de variavel numerica(int) com 10 posicoes*/

int peso_media[QTDE]; /* Vetor de variavel numerica(int) com 10 posicoes*/

int indice;

float media;

int qtde_pesos; 

for(indice = 0; indice < QTDE ; indice ++){

printf ("\n Digite o valor %i  \n", indice +1 );

scanf("%d", &num_media[indice]); /*Le os valores e armazena no indice. 

A variável que está entre [ ] define em qual posição o valor será armazenado*/

printf ("\n Digite o peso do valor %i  \n", indice +1 );

scanf("%d", &peso_media[indice]);

}

for(indice = 0; indice < QTDE ; indice ++){

/* Executa o mesmo laço acima, porem com os vetores preenchidos*/

/* Soma todos os valores, multiplicados por seus pesos*/

media = media + ( num_media[indice] * peso_media[indice] );

qtde_pesos = qtde_pesos + peso_media[indice] ; /* Soma os pesos para posterior divisão*/

}

media = media / qtde_pesos; /*Divide a soma pela quantidade de termos*/

/*Exibe o resultado*/

printf ("\n A media ponderada E %f", media);

return 0;

}

Vetor em C - Primeiro exercício

Bom dia!

Hoje começaremos a trabalhar com vetores. Em programação, podemos utilizar destes vetores para facilitar a resolução de determinados problemas e dar maior flexibilidade ao código, assim como facilitar a manutenção do mesmo.

Ex.: Faça um programa que receba 10 números e mostre a média aritmética simples dos mesmos.

Para resolução deste exercício, não parece muito inteligente criar 10 variáveis, soma-las e dividi-las por 10.  Se houver uma alteração e for necessário receber 15 números, teriam que ser criadas mais 5 variáreis, mais 5 impressões e 5 leituras na tela ?

Com a utilização de vetores, podemos deixar nosso código com uma customização e manutenção mais fácil, conforme código abaixo:

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

#define QTDE 10

int main(int argc, char *argv[]) {

int num_media[QTDE]; /* Vetor de variável numérica(int) com 10 posições*/
int indice;
float media;

for(indice = 0; indice < QTDE ; indice ++){
/*Esta é a primeira vez que utilizamos o comando FOR nos nossos exercícios
é uma estrutura de repetição que trabalha com contador, onde se define 3 passos :
indice = 0 ; Define o inicio do laço
indice < QTDE ; A condição para o fim da execução do laço, quando o indice for 
menor do que a quantidade especificada acima (10), o laço não será mais executado;
indice ++ ; corresponde ao comando indice = indice + 1; 
*/
printf ("\n Digite o valor %i do vetor \n", indice +1 ); /* O índice vai de 0 a 9. Somamo                        mais 1 para ir de 1 a 10*/
scanf("%d", &num_media[indice]); /*Le os valores e armazena no índice. 
A variável que está entre [ ] define em qual posição o valor será armazenado*/
}

for(indice = 0; indice < QTDE ; indice ++){
/* Executa o mesmo laço acima, porem com o índice preenchido*/
/* Soma todos os fatores*/
media = media + num_media[indice];
}

media = media / QTDE; /*Divide a soma pela quantidade de termos*/
/*Exibe o resultado*/
printf ("\n A media aritmetica E %f", media);

return 0;
}

   O legal é que alterando o valor de QTDE, o programa passa a funcionar de acordo com a quantidade definida. Bem mais prático, né?

Programa de cálculo do Fatorial em C

Bom dia,

Seguindo nossa sequência de exercícios, em linguagem C, hoje calcularemos o Fatorial de determinados números definidos pelo usuário. Como o cálculo em si é simples, adicionei a este programa algumas sugestões que dei em exercícios anteriores, como só aceitar números positivos e  
dar a opção ao usuário de executar o programa novamente.
Segue abaixo o código comentado:

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

int main(int argc, char *argv[]) {

int num1;
unsigned long int total; /* Como o calculo do fatorial pode retornar numeros altos, declaramos 
a variavel int (numero inteiro) como unsigned long, onde não considera os numeros negativos. 
o long int  tem 16 bits(pode variar de acordo com seu processador) o que o faz suportar numeros         de  -2147483647, até + 2147483647. Com o undigned, esse valor vai de 0 até +4294967294*/
char continua;

do { /* A estrutura DO faz basicamente a mesma coisa que o WHILE, porém com a diferenca                         que a verificação da condição é feita no final, o que obriga a executar no minimo uma                         vez código entre o DO / WHILE*/

/* Entrada de dados*/
do{
printf("\n Digite um numero positivo para calculo de seu fatorial \n");
scanf("%d", &num1);
}while(num1 < 0); /* Não permite números negativos*/


/*o fatorial é o produto de determinado numero de 1 até N
No nosso programa multiplicamos n * n -1 até 1
Porem todas as variaveis quando criadas, estão zeradas
Para a primeira multiplicação, consideramos o valor de 1 * N*/

total = 1;

/* Processamento */
while(num1 != 0)
{
total = total * num1;
if (num1 > 1 ){
printf("%d * ", num1);
}else {
printf("%d ", num1);
}
num1 = num1 - 1;
}

  printf(" = %d", total);

fflush(stdin); /* Necessário para limpar o buffer do teclado, caso contrario não irá ler a operação*/

do{

printf("\n Deseja calcular outro numero ? (Y / N ))\n");
scanf("%c", &continua);

fflush(stdin); /* Necessário para limpar o buffer do teclado, caso contrario não irá ler a operação*/

/*&& = Operador "E". Ex.: Se continua diferente de Y e continua diferente de y, etc  */
if (continua != 'Y' && continua != 'y' && continua != 'N' && continua != 'n' )
{
printf("\n Opcao invalida !!! \n ");
}
/*Só sai do loop com uma operacao valida*/
}while(continua != 'Y'  && continua != 'y' && continua != 'N'  && continua != 'n' );

/*Se o usuario digitar Y, calcula outro fatorial, caso contrario termina o programa */
}while (continua == 'Y' || continua == 'y' );

return 0;

}


Fiquem a vontade para testar e melhorar o código!

Programa de cálculo da Sequência Fibonacci em C

Bom dia!

A sequência Fibonacci é uma sequência de números inteiros, que começa com 0 e 1 e segue com a soma dos dois últimos número dessa sequência. Ex.:

   0, 1  (Para calcular o próximo número = 0 + 1 = 1),

O que gera o próximo número dessa sequência :

0, 1, 1 (1+1 = 2)
0, 1, 1, 2 (1+2 = 3)
0, 1, 1, 2, 3.

Um algoritmo bem legal de ser implementado em C. Vamos ao código:

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

int main() {

int v_qtde; /*Quantidade de numeros exibidos */

int num1, num2;
int prox_num;

printf("\n Sequencia Fibonacci \n");

v_qtde = 0;

while(v_qtde < 2) { /*Somente aceita numeros maiores que 2 */

printf("\n Digite a quantidade de numeros que deseja exibir : \n");
scanf("%d", &v_qtde);

if(v_qtde <= 2)
{
printf("\n A quantidade deve ser um número maior do que 2");
}
}

num1 = 0 ; /*Inicio da sequencia*/
num2 = 1;

printf("\n %d", num1);
printf("\n %d", num2);

while(v_qtde > 2) /*Calcula e exibe numeros*/
{
prox_num = num1 + num2; /*Soma os dois ultimos numeros para obter o proximo*/
num1 = num2; /*Atribui o segundo numero ao primeiro*/
num2 = prox_num; /*Atribui a soma dos dois numeros anteriores ao segundo numero*/

printf("\n %d", prox_num); /*Exibicao*/

v_qtde = v_qtde - 1; /*Diminui a quantidade, pois um item foi exibido*/
}
}

No programa acima, somente serão aceitos mais de dois termos para exibição, onde você pode usar essa lógica para aprimorar o  Programa para exibição de números Primos e não permitir termos negativos.

Você também pode adaptar esse programa para aceitar 1 ou 2 números.

Até +.

Programa de cálculo de números Primos em C

Bom dia!,

Lembram do algoritmo de exibição dos números primos ? (clique aqui) . Resolveremos o mesmo utilizando a linguagem C hoje.

Segue o código comentado abaixo:

int main() {

int v_qtde; /*Quantidade de numeros primos exibidos */
int v_cont1, v_cont2;
int v_cont_primo;
int v_resto_div;

v_cont_primo = 1;

/*Lê qtde numeros primos exibidos */

printf("Digite a quantidade de numeros primos que deseja exibir : \n");
scanf("%d", &v_qtde);

printf("Numeros primos : \n");

v_cont1 = 0;

while( v_qtde != 0 ) /* Enquanto a quantidade for diferente de 0 */
{
v_cont1 = v_cont1 + 1;
v_cont_primo = 0;
v_cont2 = 1;

while(v_cont1 >= v_cont2 ) /*Enquanto os contadores forem diferentes,
o contador 2 percorrerá de 1 até contador1 para verificar a quantidade de 
números divisíveis onde o resto for igual a 0. */
{

v_resto_div = v_cont1 % v_cont2 ; /* operador % pega o resto da divisao*/


if(v_resto_div == 0)  /* conta a quantidade de divisoes que tiverem 0 como resto*/
{
v_cont_primo = v_cont_primo + 1;
}

v_cont2 = v_cont2 + 1;

}

if(v_cont_primo <= 2) /*Se for menor ou igual a 2, o numero é primo( divisível por 1 e por ele mesmo*/
{
printf("\n  %d", v_cont1);
v_qtde = v_qtde - 1 ; /*Subtrai a quantidade, até 0*/
}

}

printf("\n");

return 0;
}

Testando:

Acho legal comparar esse programa com o inicial feito em português estruturado.

Obs.: Tente digitar um número negativo. Boa sorte na resolução deste problema !

Primeiro programa em C - Mini Calculadora

Bom dia!,

Hoje vamos ao nosso primeiro programa em C. A ideia é criar uma mini calculadora, onde o usuário digita dois números e escolhe a operação desejada entre eles, e também se familiarizar com os comandos de . O código não é o mais otimizado possível no intuito de ser mais didático. Segue abaixo:

#include <stdio.h> /*Header para utilizar as funções de exibição e leitura de dados */


int main() { /* Inicio do nosso programa*/

/*Declaração de variáveis*/

int num1, num2, resultado; /* INT = números inteiros */
char op;  /* CHAR = caracteres */

/*Entrada de dados - Funções PRINTF e SCANF*/

printf("\n Digite o primeiro numero  :");
scanf("%d", &num1);

printf("\n Digite o segundo numero :");
scanf("%d", &num2);

fflush(stdin); /* Necessário para limpar o buffer do teclado, caso contrario não irá ler a operação*/

printf("\n Digite a operacao (+,-,/,*)  :");
scanf("%c", &op);

if (op == '+')  /*Corresponde ao nosso comando SE*/
{
resultado = num1 + num2; /*Processamento*/
printf("\n Resultado da soma : %d", resultado);  /*Saída de dados */
}

     if (op == '-') /* Mesmo padrão acima*/
{
resultado = num1 - num2;
printf("\n Resultado da subtracao : %d", resultado);  /*Comando \N pula uma linha*/
}

if (op == '/')
{
resultado = num1 / num2;
printf("\n Resultado da divisao : %d", resultado);
}

 if (op == '*')
{
resultado = num1 * num2;
printf("\n Resultado da multiplicacao : %d", resultado);
}
}


Testando: (F12 / F11 )

E assim sucessivamente com a subtração, multiplicação e divisão( por enquanto, somente com números inteiros ).

A linguagem C é case sensitive , portanto letras maiúsculas diferem de letras minúsculas.  Se você tentar digitar um Printf, a nossa IDE de devolverá uma mensagem de erro nesta linha.

Existem outras peculiaridades do C que podem travar seu desenvolvimento, como a utilização do comando  fflush(stdin);, necessário quando lemos um char depois de ler um número.

Outro ponto importante de observação é a sintaxe dos comandos printf e scanf. As variáveis são representadas pelos códigos abaixo, e adicionadas após o as aspas, como parâmetros. Segue uma pequena tabela dos mais utilizados:

%c                 Char
%d ou %i  inteiros
%f              ponto flutuante ( com casas decimais depois da virgula)
%g                 usa %f ou %e(notação científica), depende do que for mais curto graficamente
%s                 cadeia de caracteres (string)
%u                 inteiros sem sinal

Na função scanf, é necessário a utilização do &, que é basicamente um operador de endereço, que é utilizado para localizar na memória onde a variável foi alocada( muito resumidamente).

Existem várias melhorias que podem ser implementadas nesse programa, como utilização de else if, case, e até reduzir o número de variáveis. Boa sorte!.