Funções em C : Como, Porquê e usos.

A Função em C,  - e em praticamente todas as outras linguagens de programação-, pode ser definida como um trecho de código, responsáveis por executar determinada função. A função pode ou não receber e devolver parâmetros de entrada e saída.

Por que utilizar? 

Reutilização de código - Vamos supor que hoje eu desenvolva um projeto em C de uma calculadora científica. E neste projeto separei em funções todos os cálculos necessários para o funcionamento da calculadora. Posteriormente, desenvolvo outro projeto para cálculo de impostos de determinada empresa. Em vista que já possuo métodos de cálculos que podem calcular alíquotas, taxas, percentuais e etc, é visível o ganho de tempo que posso ter aproveitando o código de um projeto em outro. Utilizando o conceito de funções, esse ganho é muito facilitado.

Manutenção mais fácil -  Colocando o código dentro de uma função, em caso de necessidade de alteração deste código, somente se altera uma vez. No caso de não utilização de função, em todos os lugares onde o código é repetido, teria que ser alterado ( o que é um prato cheio para se esquecer algo e ter um trabalhão para se achar depois.

Modularização do programa - Em programas de grande porte, as funções podem ser utilizadas somente para melhorar a leitura e compreensão do código. Da maneira que desenvolvemos até agora, ao desenvolver grandes programas, dar manutenção aos mesmos pode ser complicado, principalmente se o código inicial for de outra pessoa. Pode ser mais fácil, criar uma função para leitura de dados, outra para o processamento e outra para exibição do resultado final.

Depois de toda essa teoria, vamos a prática - e para exemplificar, faremos o seguinte exercício :

O usuário digitará quantos números quiser, e o programa retornará se o número digitado é primo ou não.

Segue o código comentado:



#include <stdio.h> 
#include <stdbool.h> /*Esta biblioteca nos permite usar os parâmetros TRUE e FALSE 

Criação da função - com o parâmetro de entrada V_NUMERO
O tipo da função BOOL determina que a função retorne um valor VERDADEIRO ou FALSO.
*/
bool verifica_numero_primo(int v_numero)
{
int v_cont;     /*Contador 1 até v_numero*/
int v_resto_div;
int v_cont_primo;

v_cont = 1;
v_cont_primo = 0;

 while( v_numero >= v_cont )
  {
 
   v_resto_div = v_numero % v_cont ; /* operador % pega o resto da divisão, de 1 até o numero digitado*/

   if(v_resto_div == 0)  /* conta a quantidade de divisões que tiverem 0 como resto*/
   {
    v_cont_primo = v_cont_primo + 1;
   }
 
   v_cont++ ; /*O comando ++ soma 1 a variável atual */
  }

  if(v_cont_primo <= 2) /*Se for menor ou igual a 2, o numero é primo( divisível por 1 e por ele mesmo
Retorno da função: verdadeiro ou falso
*/
  {
  return (true);
  }else{
  return (false);
  }
}

 /*Código principal */
int main() {

 int v_numero; /*Numero que sera verificado - digitado pelo usuário em tela */
 bool v_primo; /* tipo bool - armazena true ou false*/
 int tecla;

 do {

 /*Lê numero que sera verificado */
 printf("Digite um numero \n");
 scanf("%d", &v_numero);

 /*Chama a função e armazena o retorno dela na variável v_primo
    Para funções sem retorno, pode-se utilizar o tipo void
 */
 v_primo = verifica_numero_primo(v_numero);

 if (v_primo == true) {
  printf("\nO numero %d e primo", v_numero);
 }else{
  printf("\nO numero %d nao e primo", v_numero);
 }
 printf("\n Digite ENTER para sair ou qualquer outra tecla para processar outro numero\n");

  fflush(stdin); /*Limpa buffer do teclado*/

 tecla = getchar(); /* Lê o carácter digitado em tela, se for igual a 13 ( código do enter na tabela ASCII, sai do programa, caso contrário, executa novamente*/ 

} while(tecla != 13 & tecla != 10);

}

Obs.: Utilizei o código do Enter para encerrar a execução do programa. Por padrão, o código do enter na tabela ASCII é 13, mas no computador que estou por exemplo, este código é igual a 10.

Obrigado e até a próxima.

Números aleatórios em C

Demorou mais saiu ! Mais um exercício de C, nos voltando agora para a escolha randômica de números .

Para demonstrar a utilização dos números randômicos em C, faremos um pequeno programa que nos dara 6 números de 1 a 60 ( Dai jogar na mega-sena é com você).

Segue o código explicado:


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

/*Por que incluir a biblioteca TIME.H ? Basicamente por que nosso computador não gera 
números aleatórios, alias a função do computador é executar comandos de maneira exata.
Portanto, utilizaremos funções da biblioteca TIME.H que, utilizando o tempo (milesimos, etc)
nos gerará números pseudo-aleatórios */

#define MAX 60
#define QTDE 6

int main() {
  int i;
  int num[QTDE];

  srand(time(NULL));
  
  /*A função SRAND inicializa os valores de calculo da funcao RAND com o tempo atual
  isso evita que todas as vezes que exercutarmos o programa, exibirmos os mesmos valores*/
 
   for(i=0; i< QTDE; i++)
  {
  num[i] =  (rand() % MAX );
  /* O complemento do comando rand, %MAX, limita o número máximo que será gerado 
 pela função. O mesmo é definido pela constante MAX(60) */
  }
 
  /*Exibição dos valores*/
  printf("Numeros sorteados: \n");
  for(i=0; i< QTDE; i++)
  {
   printf(" %d ", num[i]) ;
  }
 
  return 0;
}

Execução:

Por que números aleatórios?

Em grandes sistemas comerciais, realmente a utilização deste recurso é muito pouca, ou quase nenhuma. Mas imagine um jogo de luta, onde o adversário sempre te ataca da mesma forma repetidamente. Meio chato né? Um comportamento "aleatório" é necessário neste caso. Principalmente no ramo de jogos, e quaisquer outros desenvolvimentos onde esta interação com o usuário é necessária, existe a necessidade de se utilizar deste recurso.

Sugestões de melhoria no algoritmo !

Vamos supor que eu queira utilizar o programa acima para jogar na loteria. Para isso, precisamos garantir que o programa não calcule aleatoriamente o mesmo número( isso é possível). Para facilitar para o usuário também seria bom exibir o resultado de forma crescente. Que tal implementar essas modificações?

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!.

Escolhendo uma linguagem e uma IDE

Bom dia!

Hoje vamos prosseguir com nossos exercícios de uma forma diferente. Escolhi a linguagem de programação C para continuarmos o aprendizado. A escolha desta linguagem deve-se as suas caracteristicas:  estruturada, simples e fácil de se usar.

Mas não se apegue a uma linguagem de programação. O importante é saber programar, independente da linguagem. Programar é como saber dirigir, você pode se acostumar a dirigir um carro de determinada marca, mas se é habilitado pode dirigir qualquer carro. Você pode precisar de um tempo de adaptação, mas vai acabar dirigindo normalmente. A mesma coisa acontece com a programação, uma vez que você domine uma linguagem, sua curva de aprendizagem é muito mais rápida. Eu mesmo não sou um especialista em linguagem C. Toda linguagem de programação tem uma estrutura de decisão, estruturas de repetição, conexões a banco de dados, etc.

Outro erro comum de quem está nessa fase de aprendizagem, é querer aprender logo a construir telas e fazer acesso a banco de dados. Não que isso não é importante, mas não é nem de longe o mais essencial. Portanto, o conselho que fica é: se esforcem na lógica. Mas vou deixar que suas futuras experiências falem por vocês.

Voltando a linguagem C, escolhi a ferramenta Dec C++. É simples, leve e ideal para iniciantes. Você também a encontra facilmente na internet.

Depois de instalada a ferramenta, vamos ao nosso primeiro projeto:

File > New > Project> Console Application ( C Project).

Salve o projeto em um diretório de sua preferencia.

Como uma boa IDE, já nos traz algum código:

#include <stdio.h>

#include <stdlib.h>

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

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

                return 0;

}

A duas primeiras linhas, os includes stdio.h e stlib.h são headers,  em que o comando include,  traz todas as funções destes dois arquivo e os deixa disponível para nossa utilização, de modo resumido.

Os comentários em C são iniciados por /* e finalizados por */.

O comando Int main, corresponde ao nosso INICIO. Tudo que estiver entre as chaves, estará entre nosso INICIO/ FIM.

E por fim, o que esse nosso mini-programa de exemplo faz? Aperte F10 para compilar esse código fonte:

E ele retorna 0!

Nós próximos post’s nos aprofundaremos mais na ferramenta e realizaremos alguns exercícios nele.

Obrigado.

Algoritmo dos Números Primos resolvido e comentado!

Um dos mais comuns exercícios passados nas faculdades e cursos que ensinam programação é o do número primo. Hoje vamos resolve-lo.

1) Escreva um algoritmo que receba a quantidade de números primos que o usuário deseja visualizar, e os escreva.
Um número primo é aquele que só é divisível por ele e por um, onde o resto da divisão é diferente de 0 para todos os demais números.

Portanto para resolver esse algoritmo, vamos nos utilizar dos contadores e divisões( ou o resto das mesmas).

Vale lembrar que o que for marcado em aspas são comentários para seu melhor entendimento do algoritmo.

INICIO.

VARIAVEIS v_qde, v_contador, v_contador_2, v_cont_primo, v_resto_div;

v_contador = 0;
v_cont_primo = 1;

ESCREVA "Digite a quantidade de números primos que deseja receber";
LEIA v_qtde; " Entrada de dados

ESCREVA "Seguem os números primos :"

ENQUANTO v_qtde <> 0; "A ideia é dimunir a quantidade até 0"
   
      v_contador = v_contador + 1;
      v_contador2 = 0;
      v_cont_primo = 0;

                ENQUANTO v_contador <> v_contador2. "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 = RESTO ( v_contador / v_contador2). " A ideia é pegar o resto da divisão. Corresponde ao comando MOD / % em muitas linguagens de programação.

                 SE v_resto_div = 0;
                           v_cont_primo = v_cont_primo + 1;
                FIMSE;

    v_contador2 = v_contador2 + 1;

FIM ENQUANTO.
     
               SE v_cont_primo = 2. "Quer dizer que ele só foi dividido com resto 0 por 1 e por ele mesmo. Portanto, é número primo
           
               ESCREVA v_contador.
               v_qtde = v_qtde -1. "Diminui a quantidade até que a mesma zere.

                FIMSE.


FIMENQUANTO.

FIM.


       A lógica é um pouco complicada de se entender no inicio, mas a melhor forma de fazer isso é utilizar o teste de mesa. Simule o funcionamento do algoritmo acima, assim fazendo seu passo-a-passo fica mais fácil, entender, seguir e estimular sua lógica.

Obrigado!

Exercicio de lógica e Teste de mesa.

      1) Uma loja de tênis possui 2 funcionários. Cada funcionário ganha 5% de comissão sobre cada par de sapato vendido. O salário base de cada funcionário é de 800,00 reais, mais a comissão. Escreva um algoritmo que receba a quantidade de sapatos vendida por cada vendedor e o preço de cada sapato. Calcular a comissão e o total do salário de cada funcionário, e exibi-los em tela.

Pode parecer um pouco complicado a primeira vista, mas vou resolver e comentar a resposta, é só acompanhar o raciocínio. Tudo que for marcado com aspas,  são comentários no algoritmo.

Primeiro declararemos nossas variáveis :

Inicio.

Variável SalarioFixo = 800,00

Variável ValorComissao,ValorComissao1, ValorComissao2;

Variável Qtde,QtdeComissao1, QtdeComissao2;

Variável Salario1, Salario2;

Variável Contador;

“Entrada de dados do usuário

Escreva “Digite a quantidade de sapatos vendidos pelo vendedor 1”;

Leia QtdeComissao1;

Contador = QtdeComissao1;

ENQUANTO contador <> 0;

               Escreva “Digite o valor da venda do Vendedor 1”;

               Leia ValorComissao;

               ValorComissao1 = ValorComissao + ValorComissao1;       

               Subtraia 1 de contador;

FIM ENQUANTO  ;

Contador = 0;

Escreva “Digite a quantidade de sapatos vendidos pelo vendedor 2”;

Leia QtdeComissao2;

Contador = QtdeComissao2;

ENQUANTO contador <> 0;

               Escreva “Digite o valor da venda do vendedor 2” ;

               Leia ValorComissao;

               ValorComissao2 = ValorComissao + ValorComissao2;

               Subtraia 1 de contador;

FIM ENQUANTO;

“Vamos ao processamento de dados

“Calculando a porcentagem do vendedor 1, temos na variável ValorComissao1  o valor total dos produtos que devem ser calculado o valor da comissão, com isso, vamos ao seguinte cálculo.

ValorComissao1 = ValorComissao1 * 0,05.

ValorComissao2 = ValorComissao2 * 0,05.

“Calculo dos salários

Salario1 = SalarioFixo + ValorComissao1;

Salario2 = SalarioFixo + ValorComissao2;

“Saida dos dados

Escreva  “ O salario do funcionário 1 é de” +  Salario 1 “ e a comissão é de “ ValorComissao1”;

Escreva  “ O salario do funcionário 2 é de” +  Salario 2 “ e a comissão é de “ ValorComissao2”;

FIM.

E está resolvido nosso exercício. Porém, como podemos ter a certeza de que está certo?

TESTE DE MESA

Sugestão: Pegar uma folha em separado e escrever o nome de todas as variáveis de um lado, e simular o funcionamento do programa do outro, substituindo os valores das variáveis conforme forem mudando no programa.

Se o usuário acessa-se esse programa, o que ele veria?

“Digite a quantidade de sapatos vendidos pelo vendedor 1” :

Vamos supor que o usuário digite “2”

2

(Acompanhe os valores das variáveis com uma folha sua)

Então seguindo os passos do programa, o usuário verá:

“Digite o valor da venda do vendedor1”: 100
“Digite o valor da venda do vendedor 1” : 200

Seguindo esses passos, a variável contador deve se igual a 0, saindo do laço ENQUANTO/ FIM ENQUANTO,   retornando o valor dele para 0, mas acompanhe mais detalhadamente por sua conta. Prosseguindo com o processamento, o programa deve pedir os mesmos valores para o vendedor 2, e supondo as mesmas entradas do usuário,  a saída do programa deverá ser:

O salario do funcionário 1 é de 815 e a comissão é de 15;

O salario do funcionário 2 é de 815 e a comissão é de 15;

Para seu próprio entendimento, resolva e detalhe seu teste de mesa!

Obs. DESAFIO: Tratar a entrada de dados para não aceitar valores negativos.

Variáveis, Escrever e Ler;

Bom dia!

Vamos nos aproximar mais dos primeiros programas que criaremos e incrementar um pouco mais nosso português estruturado, resolvendo problemas mais comuns em computadores. Basicamente todo programa se baseia em uma entrada, um processamento e uma saída de dados. Por exemplo, quando você abre seu navegador, digita um site (entrada) o navegador busca e processa todos os dados necessários (processamento) , e o formata para sua exibição(saída).

Para assimilar esse conceito nos nossos exercícios, vamos incorporar os comandos ESCREVA e LEIA nos nossos algoritmos. E juntamente com o comando leia, vamos utilizar o conceito de variável.

As Variáveis são um espaço que o programa reserva na memória do computador, que obviamente podem mudar seu valor. Por enquanto, vamos utilizar somente essa simples definição.

                Resolverei um exercício bem simples e irei comenta-lo, para deixar como modelo para os próximos.

1)      Receber dois números e apresentar a soma, divisão e multiplicação entre eles.

Inicio. “Começo da resolução

Variável Numero1;                                “Preferencialmente declarar todas as variáveis juntas
Variável Numero2;                                “Utilizar nomes sugestivos para cada variável
Variável ResultadoSoma;
Variável ResultadoSubtracao;
Variável ResultadoDivisao;
Variável ResultadoMultiplicacao;

Escreva “Digite número 1”;                      “Saída de dados para o usuário, solicitando informação
Leia Numero1;                                         “Aguarda usuário digitar o número 1;
Escreva “Digite número 2”;
Leia Numero2;                                         “Termino da entrada de dados

Calcular ResultadoSoma = Numero1 + Numero2;                    “Inicio do processamento
Calcular ResultadoSubtracao = Numero1 – Numero2;
Calcular ResultadoDivisao = Numero1 / Numero2;
Calcular ResultadoMultiplicacao = Numero1 * Numero2;    “Fim do processamento

Escreva “ O resultado da soma é”+ ResultadoSoma;                              “Saída de dados
Escreva “O resultado da subtração é” + ResultadoSubtracao;
Escreva “O resultado da divisão é” + ResultadoDivisão;
Escreva “O resultado da Multiplicação é” ResultadoMultiplicacao;

Fim.

O exercício acima poderia utilizar menos variáveis, mas o importante nesse momento é ser didático, e ainda não performático. 

        É importante também observar a ordem, entrada, processamento e saída. Poderiam ser feitas saídas assim que o processamento é feito e o resultado final seria o mesmo, mas isso pode tornar seu futuro código confuso. Imagine sempre que alguém irá dar manutenção nele, e nesse momento você não quer que ninguém lembre de sua mãe, rs.

No próximo post, irei pegar alguns exercícios um pouco mais complexos e resolve-los.

Comandos SE e ENQUANTO

Bom dia!

Hoje vamos conceituar os comandos SE e ENQUANTO nos nossos exercícios de português estruturado,para futuros algoritmos.

O comando SE representa uma decisão, sobre uma condição que pode ser verdadeiro ou falso. Exemplo:

SE está chovendo:

Pegar o guarda chuva; ( Condição verdadeira)

SENÃO;

Pegar o boné; ( Condição falsa)

FIMSE.

A estrutura em si é bem simples.

Comando ENQUANTO serve justamente para fazer o que o nome sugere: Enquanto determinada condição não for atingida( retorno falso) o programa/ algoritmo repetirá determinado bloco de instruções (até o comando FIM ENQUANTO). 

Quando a condição for verdadeira, o programa/algoritmo seguirá seu fluxo normalmente, não repetindo mais aquele bloco de instruções

 Exemplo: Lavar a louça;

Inicio. "Vamos delimitar o inicio e fim do programa

Ir a pia;

ENQUANTO existir louça suja.

Pegue um talher/copo/prato;
Lavar com a buchinha;
Enxaguar;
Secar;
Guardar;

FIMENQUANTO.  “Se ainda existir louça suja, volta para o comando enquanto. Se não, prossegue com os comandos abaixo.

Lavar a buchinha;

Secar a pia;

Fim.

Nas próximas postagens irei assimilar mais nossos exercícios com alguns algoritmos simples.

Exercícios

A melhor maneira de treinar sua lógica de programação é praticar, errar, comparar resultados, tentar de novo, entender o por que e como você errou para se aperfeiçoar para uma proxima tentativa.
Portanto, vou deixar aqui alguns exercicios com suas resoluções, ( que podem ser aprimoradas ) . Nestes exercicios vamos fazer basicamente o mesmo esquema de resolução em português estruturado, separando o máximo possível todos os passos para a resolução de um problema.

1.Tomar um banho;

Pegar uma toalha;
Se dirigir até um banheiro;
Retirar suas roupas e guarda-las;
Ajustar a temperatura do chuveiro;
Entrar de baixo da água;
Se molhar completamente;
Sair debaixo da água;
Utilizar o shampoo no cabelo;
Pegar um sabonete e se ensaboar;
Ligar o chuveiro novamente;
Limpar toda a espuma do corpo;
Desligar o chuveiro;
Se secar com a toalha;
Vestir novas roupas.

Impressionante como uma simples tarefa diária pode se traduzir em tantos passos - e poderiam haver mais. Para ter uma boa lógica de programação é necessário ter todos esses passos muito bem definidos, pois como já disse, o computador não faz nada que não lhe é ordenado.

2. Comprar pão;

Pegar dinheiro;
Se dirigir até uma padaria;
Pedir a quantidade requisitada de pães;
Pegar os pães;
Retornar para seu local de origem.

3.Ligar a TV;

Verificar se a TV está ligada na tomada;
Procurar pelo controle remoto;
Ligar a TV;
Na resolução acima, o primeiro passo pode parecer desnecessário. Porém, se retirarmos este passo e ao concluir todos os passos , a TV não liga? Precisariamos retornar ao passo um.  No proximo post , apresentarei os comandos SE e ENQUANTO, para complementar nosso algoritmo e dar uma melhor solução a este problema.

Começando do início

Bom dia!

Neste artigo pretendo apresentar uma introdução à lógica de programação, começando do zero.

Acredito que a lógica não pode ser ensinada, e sim deve ser treinada. Todos nós temos em nosso cérebro os passos pré-determinados para a resolução dos problemas deste artigo. Só precisamos treiná-lo para isto.

Problema
1) Tomar água

Resolução:

 Dirigir-se até a geladeira;

2.       Pegar uma garrafa de água;

3.       Encher um copo;

4.       Tomar a água;

Pode parecer bem simples e óbvio,  mas a separação destes passos é muito importante e necessária para futuros programadores. Bem, se você notou que estava faltando algo acima, meus parabéns. Vamos completar nossa resolução:

1.       Dirigir-se até a geladeira;

2.       Se a porta estiver fechada; a abra;

3.       Retire a garrafa de água;

4.       Abra a garrafa de água;

5.       Pegue um copo;

6.       Encha o copo com água;

7.       Tome a água.

Nosso amigo computador não faz nada que não lhe é solicitado, portanto, saber separar esses passos, mesmo que óbvios, é fundamental no inicio da aprendizagem de qualquer linguagem de programação.

O que estamos fazendo chama-se Algoritmo, que nada mais é do que uma sequência de passos lógicos para a resolução de determinado problema.

Deixo aqui sugestões de exercícios para este inicio de caminhada:

Chupar bala;

Lavar a louça;

Caminhar;

Assistir um filme;

Bom pessoal, de inicio é somente isso, treinem bastante!.