Professional Documents
Culture Documents
Sumário
Aula 1 ............................................................................................................................... 6
Apresentação da Disciplina .......................................................................................... 6
1. Considerações iniciais ...................................................................................... 6
1.1. Lógica e Lógica de Programação ................................................................. 6
1.2. Problema ....................................................................................................... 6
1.3. Algoritmo ..................................................................................................... 6
1.4. Programa....................................................................................................... 6
1.5. Formas de se representar um Algoritmo ...................................................... 6
1.6. Regras para a Criação de Algoritmos ........................................................... 7
1.7. Como proceder na construção de algoritmos? .............................................. 7
1.7.1. Leia com atenção o enunciado do problema ............................................ 7
1.7.2. Obtenha os dados de entrada .................................................................... 7
1.7.3. Obtenha os dados de saída ........................................................................ 8
1.7.4. Determinar o que deve ser feito para transformar as entradas
determinadas nas saídas especificadas ..................................................................... 8
1.7.5. Testar o algoritmo..................................................................................... 8
1.8. Exercícios propostos ..................................................................................... 8
2. Variáveis e Constantes de memória (RAM) ..................................................... 9
2.1. Memória ....................................................................................................... 9
2.2. Como um programa é tratado na memória? ................................................. 9
2.3. Variáveis ....................................................................................................... 9
2.4. Constantes..................................................................................................... 9
2.5. Regras para formação de Identificadores ..................................................... 9
2.6. Tipos de Dados ........................................................................................... 10
2.7. Principais tipos de dados utilizados na disciplina ...................................... 10
2.8. Exercícios Propostos .................................................................................. 10
Aula 2 ............................................................................................................................. 11
Começando a programar na Linguagem C ................................................................. 11
3. Linguagens de programação ........................................................................... 11
3.1. Linguagens de Baixo Nível ........................................................................ 11
3.2. Linguagens de Alto Nível ........................................................................... 11
3.3. Compilador ................................................................................................. 11
3.4. Estrutura padrão de um algoritmo (C) ........................................................ 11
3.5. Indentação..................................................... Erro! Indicador não definido.
3.6. Operadores aritméticos ............................................................................... 13
3.7. Regras de precedência de operadores ......................................................... 13
3.8. Exercícios Propostos .................................................................................. 13
Aula 3 ............................................................................................................................. 14
3.9. Utilizando instruções de I/O ....................................................................... 14
3.10. Exercícios Propostos .............................................................................. 15
Aula 4 ............................................................................................................................. 17
Introdução ao DEV-C++ ............................................................................................ 17
4. Sobre o software ............................................................................................. 17
4.1. O que é DEV-C++? .................................................................................... 17
4.2. Versão do DEV-C++ .................................................................................. 17
4.3. Interface do Software.................................................................................. 17
4.4. Compilando um Projeto .............................................................................. 19
4.5. Tipos de Erros............................................................................................. 21
Aula 1
Apresentação da Disciplina
1. Considerações iniciais
1.2. Problema
A definição mais simples para problema é uma situação que precisa ser resolvida
1.3. Algoritmo
Algoritmo é uma seqüência ordenada e finita de passos lógicos, bem definas e
eficazes para a solução de um problema em um tempo finito.
Reparem que algoritmo não está diretamente relacionado à informática. Uma receita de
bolo, por exemplo, seria um algoritmo que iria solucionar um problema específico do
cotidiano humano.
Reparem também que para um problema podemos ter diversos algoritmos, e que
muitas vezes, estes só funcionariam dependendo de fatores externos. Como fazer um
bolo de chocolate visto que faltou luz? A solução provavelmente será diferente da
solução convencional.
1.4. Programa
Um programa não mais é do que um algoritmo computacionalmente aplicável. Isto
é, serve para resolvermos problemas exclusivos do ambiente computacional.
Todo programa é um algoritmo, porém nem todo algoritmo é um programa.
Onde:
Entrada: São os dados que devem ser informados (pelo usuário, ou não) para que o
programa possa ser executado.
Processamento: São os procedimentos que devem ser empregados para solucionar o
problema. Neste podemos incluir operações matemáticas, comparações, repetições, etc.
Saída: É o resultado final do algoritmo que deve ser entregue a algum lugar ou alguém.
Exemplo
Imagine o seguinte problema: calcular a média final dos alunos da 3ª Série. Os
alunos realizarão quatro provas: P1, P2, P3 e P4.
Onde:
P1 + P2 + P3 + P4
Média Final =
4
A entrada de dados serão as quatro notas.
O processamento será o cálculo da média propriamente dita.
A saída de dados será a exibição dessa média.
1. Especifique as ações necessárias para mover três disco de uma Torre de Hanói, que
consiste de três hastes (a - b - c), uma das quais serve de suporte para três discos de
tamanhos diferentes (1 - 2 - 3 ), os menores sobre os maiores. Pode-se mover um
disco de cada vez para qualquer haste, contanto que nunca seja colocado um disco
maior sobre um menor. O objetivo é transferir os três disco para outra haste.
a b c
2. Construa um algoritmo que informe os passos necessários para a trocar o pneu de
um carro. Tendo como situação inicial que o carro estava em movimento numa
estrada, que há acostamento e espaço suficiente para a troca.
2.1. Memória
Memória é um dispositivo utilizado para guardar de forma temporária ou não algum
tipo de informação.
Quando um programa é executado (tornando-se o que chamamos de processo), todo o
seu conteúdo é posto na memória RAM (Random Access Memory) do computador.
Sendo que é somente nela que o mesmo é executado.
Área de Dados
Área de Código
Pilha
Onde:
Área de Dados: É o local destinado para o armazenamento dos dados vindos do
usuário, cálculos, saídas. Enfim, é o espaço que o algoritmo tem para trabalhar.
Área de Código: É o local onde está o algoritmo propriamente dito.
Pilha: É quem garante a continuidade do programa. Se o programam efetua “saltos”
dentro do código, é a pilha que mantém a informação de onde o código estava antes do
salto consequentemente garantindo um retorno correto ao final do salto. Pilhas utilizam
uma estrutura de dados manipulada pelo que chamamos de FIFO (First Input First
Output).
2.3. Variáveis
Variáveis são espaços reservados (alocados) na memória RAM do computador, que
devem possuir um nome e um tipo de dado, sendo que seu conteúdo pode sofrer
alteração durante a execução do programa.
Em outras palavras, variáveis são as informações que podemos utilizar na área de dados
de um programa. Por exemplo, o Nome de um cliente, as Notas de um aluno, a
Temperatura atual. Mas note que todos estes dados podem mudar a qualquer momento.
2.4. Constantes
Variáveis são espaços reservados (alocados) na memória RAM do computador, que
devem possuir um nome e um tipo de dado, sendo que seu conteúdo NÃO pode sofrer
alteração durante a execução do programa.
Repare que a diferença entre uma variável e uma constante na sua definição é sutil,
porém na prática essa diferença é muito relevante. O valor que for definido na criação
(declaração) de uma constante a acompanha durante todo o ciclo de vida do processo.
2. Defina o melhor tipo de dado para cada expressão abaixo. Considerando apenas int,
float e char.
a) 23.56
b) “minha casa é azul”
c) 45
d) “123B56”
e) -345
f) 40456
g) -34.6
Aula 2
Começando a programar na Linguagem C
3. Linguagens de programação
Linguagem de programação é uma classe de software (do mesmo jeito que editores de
texto, planilhas eletrônicas, etc.) onde todos os seus representantes têm por
característica principal a capacidade de desenvolver novos softwares. Sendo que essa
classe de software é dividida em dois grandes grupos. Linguagens de alto e baixo nível.
3.3. Compilador
Compilador é o nome do software responsável pela tradução de um código alto nível
para baixo nível (para que o processador possa executar suas instruções) gerando ao
final o que chamamos de arquivo executável. Sendo que a velocidade de processamento
de um programa está diretamente relacionado a qualidade deste compilador.
#include <stdio.h>
void main()
{
int valor1, valor2;
float soma;
valor1 = 23000;
valor2 = 15500;
soma = valor1 + valor2;
}
int valor1, valor2 Cria na área de dados (declara) duas variáveis de tipo
inteiro com nomes valor1 e valor2.
float soma; Cria na área de dados (declara) uma variável de tipo
ponto flutuante com nome soma
valor1 = 23000; Atribui o valor 23000 para a variável valor1
soma = valor1 + valor2; Soma o conteúdo das duas variáveis e joga a resposta do
cálculo na variável soma.
} Encerra o bloco de intruções
3.5. Endentação
Repare que o código acima possui alguns espaços entre os caracteres { e } que servem
para facilitar a visualização do código na busca de possíveis erros. Esta técnica chama-
se endentação de código. Sendo vital no desenvolvimento de um programa.
Na grande maioria das linguagens a endentação tem uma importância meramente
estética, porém existem linguagens que definem inicio e fim de bloco por ela. Python
seria um bom exemplo disso.
Aula 3
3.9. Utilizando instruções de I/O
Até o momento, nossos algoritmos apesar de funcionarem, não estão respeitando
corretamente o principio da informática (aula 1) que é o da Entrada, Processamento e
Saída de dados. Já que:
Nossa entrada de dados é sempre fixa
Não estamos exibindo o resultado de nossos cálculos para o usuário do
programa.
Para solucionar este problema, a linguagem C possui três instruções para a
leitura/escrita de dados, scanf, gets e printf. Onde:
scanf: Utilizado para a leitura de valores numéricos, sendo que sempre devemos
utilizar o operador “&” antes da variável de leitura.
gets: Utilizado para leitura de valores alfanuméricos
printf: Utilizado para a escrita de valores tanto numéricos quanto
alfanuméricos.
Exemplo de utilização
#include <stdio.h>
void main()
{
int v1, v2;
float media;
char nome[30];
gets(nome);
scanf("%d", &v1);
scanf("%d", &v2);
Repare a maneira como foi feita a leitura das variáveis nome, v1 e v2:
Nome como é um char, foi lida utilizando a função gets.
v1 e v2 por serem numéricas, precisaram ser lidas utilizando o scanf, sendo que
“%d” é um atributo da função que avisa o compilador que será lido (no caso da
printf, escrito) um valor de tipo de dado inteiro.
A leitura da linha onde encontra-se o printf seria da seguinte forma: Escreva na
tela a frase “A sua média é: juntamente com um valor de ponto flutuante”, sendo
que esse valor foi passado para a função logo em seguida separado por uma
vírgula.
Alguns atributos importantes que podem ser utilizado nas funções scanf e printf:
Atributo Utilização Exemplo
%d Leitura/escrita de dados numéricos inteiros scanf(“%d”, &idade);
%f Leitura/escrita de dados numéricos reais printf(“%f”,salario);
%s Escrita de dados do tipo char (strings) printf(“%s”, nome);
printf (“%s, Os valores %d e %d formam a média: %f”, nome, v1, v2, media);
Podemos também utilizar a função printf para exibir mensagens para o usuário. Por
exemplo, no caso anterior, seria interessante exibir uma mensagem ao usuário pedindo
para que ele informe o seu nome e dois valores inteiros.
O código ficaria da seguinte maneira:
#include <stdio.h>
void main()
{
int v1, v2;
float media;
char nome[30];
printf ("%s, Os valores %d e %d formam a media: %f", nome, v1, v2, media);
}
2. Faça um algoritmo que leia três valores reais (ponto flutuante) e calcule a sua média
ponderada, com os respectivos pesos 2, 3 e 4 para os valores.
3. Faça um algoritmo que leia um valor inteiro e um valor real. Multiplique estes
valores e exiba o resultado.
4. Faça um algoritmo que leia 4 valores reais (x1, y1, x2, y2) equivalentes a dois pares
ordenados. Calcule e exiba a distância entre estes dois pontos de acordo com a
fórmula abaixo:
d ( x2 x1 ) 2 ( y2 y1 ) 2
5. Faça um algoritmo que leia três valores reais e calcule x’ e x” de acordo com a
fórmula abaixo
b b2 4 * a * c
x' , x"
2*a
7. Faça um algoritmo que leia dois valores inteiros. Logo após troque os valores entre
estas variáveis. Ou seja, o conteúdo da variável 1 passará para a variável 2 e vice e
versa.
Aula 4
Introdução ao DEV-C++
4. Sobre o software
Onde:
No canto esquerdo temos o navegador de classes/projetos que será utilizado para
podermos alternar entre arquivos.
Na área superior encontram-se os principais atalhos do compilador
Na parte inferior temos uma caixa de mensagens que o compilador irá exibir
conforme a necessidade.
Ao clicar em OK, o compilador irá solicitar que você salve seu projeto. Procure salvar
um projeto por pasta para evitar um acumulo de arquivos, de modo que seja fácil a
seleção do documento certo.
Onde:
system(“pause”): Fará com que o programa após sua conclusão seja fechado somente
após o pressionamento de alguma tecla. A não existência desta linha de instrução
fecharia o programa sem que o usuário tenha tempo de visualizar as respostas. Podemos
utilizar qualquer instrução DOS na função system.
Repare que neste caso o compilador não encontrou nenhum erro durante a tradução do
código fonte.
Vejamos abaixo uma situação onde existam erros de sintaxe.
Aula 5
Algoritmos Condicionais
5. Introdução
Até o momento, todos os algoritmos que estamos fazendo podem ser considerados
Algoritmos Seqüenciais, isto é, executam todas as suas linhas de instrução sem que
hajam desvios nem repetições no código fonte. Em um ambiente prático, este tipo de
situação não ocorre, já que durante um programa diversas situações devem ser testadas
para que seu resultado final seja satisfatório.
Por exemplo, se formos fazer um programa para cálculo de peso ideal para um
indivíduo, a fórmula para homens e mulheres é diferente. Sendo assim, em algum
momento do programa deve-se descobrir o sexo da pessoa e caso seja alguém do sexo
masculino, faça a fórmula X, caso contrário, a fórmula Y será executada.
Para podermos trabalhar com algoritmos condicionais podemos utilizar dois tipos de
instruções IF (SE) e SWITCH (CASO, não é tradução literal):
Dentro da instrução if, ainda podemos utilizar uma segunda instrução (else - senão) que
também avalia a condição lógica testada, porém somente sendo executado se esta
condição for falsa.
Sintaxe:
if (condição lógica)
{
<Bloco de algoritmo que será executado caso a condição lógica seja verdadeira>;
}
else
{
<Bloco de algoritmo que será executado caso a condição lógica seja falsa>;
}
Para melhor compreensão, faremos agora um exemplo prático da utilização deste tipo
de instrução. Façamos um algoritmo que leia o nome e as duas notas de um aluno,
retornando a sua média e uma mensagem “Aprovado” ou “Reprovado” dependendo da
sua média. A média mínima para aprovação será 6.
system("pause");
}
Operador Significado
> Maior do que
< Menor do que
>= Maior ou igual a
<= Menor ou igual a
== Igual a
!= Diferente de
2. Faça um algoritmo que leia um valor inteiro e informe se este valor é maior do que
10 ou não.
3. Faça um algoritmo que leia dois valores reais e informe se estes valores são iguais
ou diferentes.
4. Faça um algoritmo que leia um valor inteiro e retorne se este valor é PAR ou
ÍMPAR.
5. Faça um algoritmo que leia dois valores reais e exiba ao final qual dos dois é o
maior.
6. Faça um programa que leia o Nome, Valor Hora e Total de Horas Trabalhadas de
um funcionário. Calcule e exiba:
a) O salário bruto
b) O valor de Vale Transporte (6% do Salário Bruto)
c) O desconto de Imposto de Renda (11% do Salário Bruto para salários superiores
a R$ 1440,00)
d) O salário líquido.
7. Faça um algoritmo que leia dois valores inteiros equivalentes a hora inicial e final de
um jogo. Retorne o tempo de duração deste jogo sabendo que o jogo pode começar
em um dia e terminar em outro, e que o tempo máximo de jogo é 24 horas.
Aula 6
Exercícios
Aula destinada a continuação e implementação dos exercícios sobre algoritmos
condicionais.
Aula 7
Seleção encadeada
É muito comum que dentro de um algoritmo tenhamos vários testes que tenham que ser
feitos a uma mesma variável ou situação. Para este tipo de situação podemos utilizar o
encadeamento (aninhamento) de instruções if. Por exemplo, vamos modificar o
exercício número um da lista anterior para que agora ele considere o valor 0 (zero)
como nulo.
#include <stdio.h>
void main()
{
float valor;
if (valor > 0)
{
printf("O valor é positivo! \n");
}
else
{
if (valor < 0)
{
printf("O valor é Negativo! \n");
}
else
{
printf("O valor é nulo! \n");
}
}
system("pause");
}
Repare que o segundo teste só será feito caso o primeiro falhe. Este tipo de abordagem é
interessante para evitar que uma grande quantidade de testes similares sejam feitas
quando apenas um deles pode ser executado.
#include <stdio.h>
void main()
{
int valor;
switch (valor)
{
case 1:
printf ("Foi digitado o valor 1 \n");
break;
case 2:
printf ("Foi digitado o valor 2 \n");
break;
case 3:
printf ("Foi digitado o valor 3 \n");
break;
default:
printf("Foi digitado um valor diferente de 1, 2 ou 3 \n");
}
system("pause");
}
2. Faça um algoritmo que recebe dois valores reais juntamente com uma variável
controladora de tipo inteiro.
a) Caso a variável controladora seja 1, some os valores digitados.
b) Caso a variável controladora seja 2, multiplique os valores digitados.
c) Caso a variável controladora seja 3, encontre o maior valor.
d) Caso a variável controladora seja qualquer outro valor, calcule a média entre os
valores.
Tabela verdade
&& V F
V V F
F F F
Exemplos
a) (25 > 10 && 23 % 2 == 1)? Resposta: VERDADEIRO
b) (25 != 50/2 || 12 > 20)? Resposta: FALSO
c) (!(2 + 2 = 4)) ? Resposta: FALSO
d) (40 > 30 && 25 < 12 || 12 % 2 ==0)? Resposta:
e) (!((25 > 10 && 23 % 2 == 1)))? Resposta:
#include <stdio.h>
void main()
{
float n1, n2, freq, media;
system("pause");
}
2. Faça um algoritmo que leia três valores reais e os exiba de forma crescente.
3. Faça um algoritmo que leia três valores reais e exiba ao final o maior valor
4. Faça um algoritmo que leia três valores reais e calcule x’ e x” de acordo com a
fórmula abaixo. Obs.: Seu programa deve prever os erros de raiz negativa e divisão
por zero.
b b2 4 * a * c
x' , x"
2*a
Aula 8
Aula destinada a continuação e implementação dos exercícios propostos na lista
anterior, bem como novos exercícios disponibilizados pelo professor.
Faça um algoritmo que leia o dia e o mês de nascimento de uma pessoa. Ao final do
algoritmo retorne o seu signo de acordo com a tabela abaixo:
Aula 9
Avaliação I
6. Introdução
Aula destinada a apresentação do primeiro trabalho a ser desenvolvido na disciplina de
lógica de programação.
Aula 10
Algoritmos de Repetição (Laços – Loops)
7. Introdução
Como visto anteriormente, dentro de um algoritmo existem vários tipos de estruturas
que podem ser utilizadas. Até o momento estudamos estruturas seqüenciais e
condicionais.
Dentro de nossos algoritmos vai ser comum encontrarmos trechos de código que
precisam ser executados várias vezes em seqüência (para validações, por exemplo). Para
este tipo de problema, ao invés de repetirmos seguidamente o código fonte, podemos
utilizar instruções de repetição que fazem justamente o papel de re-executar um
determinado bloco de algoritmo.
As instruções que permitem repetição de código são três:
Este algoritmo irá executar as instruções “soma = soma + valor;” e “valor = valor + 1;”
enquanto o conteúdo da variável valor for menor ou igual a 8. Sendo que quando esta
condição for falsa o programa irá exibir essa soma na tela e encerrar.
Exemplo:
#include <stdio.h>
void main()
{
int valor, soma;
valor = 5;
soma = 0;
do
{
soma = soma + valor;
valor = valor + 1;
} while (valor<=8);
printf("%d\n", soma);
system("PAUSE");
}
Repare que este código retorna o mesmo valor que o exemplo anterior, porém o teste é
feito apenas no final da execução da primeira volta do laço. Este tipo de abordagem é
Exemplo:
#include <stdio.h>
void main()
{
int valor, soma;
valor = 5;
soma = 0;
for (valor = 5; valor<=8; valor = valor +1)
{
soma = soma + valor;
}
printf("%d\n", soma);
system("PAUSE");
}
Utilizando este tipo de abordagem, reparem que não foi necessário incrementar a
variável valor dentro do bloco do for.
2. Faça um algoritmo que leia um valor inteiro e calcule a soma de todos os valores
inteiros entre 1 e o valor informado. Faça esse algoritmo três vezes, uma para cada
laço de repetição.
3. Faça um algoritmo que leia um valor inteiro e calcule o seu fatorial. O fatorial de
um número é o resultado da multiplicação deste próprio número pelos seus valores
menores parando no 1. Exemplo: 5! = 5x4x3x2x1 = 120. Faça esse algoritmo três
vezes, uma para cada laço de repetição.
Aula 11
Continuação dos exercícios
4. Faça um programa que leia um número qualquer e calcule a tabuada desse número.
A tabuada deve ser exibida ao usuário no seguinte formato (considerando a leitura
do número 2):
2X1=2
2X2=4
2X3=6
...
2 X 10 = 20
5. Faça um algoritmo que leia dois valores (X e Y) e calcule XY. Obs.: Não utilize a
função “pow”.
Aula 12
Continuação dos exercícios (leitura de dados dentro dos laços)
8. Faça um algoritmo que leia um número indeterminado de valores reais e quando for
digitado um valor negativo, exiba a soma destes valores.
9. Faça um algoritmo que leia 25 valores inteiros. Logo após a leitura dos valores,
exiba a média entre os valores.
10. Faça um algoritmo que leia um número indeterminado de valores. E quando for
digitado 0 (zero) exiba a quantidade de números pares e ímpares digitados.
11. Faça um algoritmo que leia 15 valores reais e ao final da leitura exiba o maior valor
informado.
12. Faça um algoritmo que leia 10 nomes e idades. Ao final da leitura exiba o nome da
pessoa mais velha.
13. Faça um algoritmo que leia 50 valores inteiros e logo após a leitura exiba o
percentual de valores múltiplos de 5 digitados.
Aula 13
Continuação dos exercícios
14. Faça um algoritmo que leia um valor inteiro e retorne se este valor é perfeito ou não.
Obs.: Números perfeitos são aqueles cujo a soma de seus divisores (excluindo o
próprio número) formam exatamente o valor original. Exemplo: 6 (1+2+3 = 6)
15. Faça um algoritmo que leia um usuário e senha digitados pelo usuário. O programa
deve exibir a mensagem “Bem Vindo” caso o usuário digitado seja “aluno” e a
senha digitada seja “segredo”. O programa deve avisar quando o login não for
efetuado e emitir um aviso de bloqueio caso o usuário erre seu login três vezes.
16. Faça um programa que leia o Nome, Valor Hora, Total de Horas Trabalhadas e a
idade de 50 funcionários. Após a leitura dos dados exiba:
a) A média salarial bruta da empresa
b) O nome e a idade do funcionário mais velho
c) O nome e o salário do funcionário que tiver a maior renda.
Aula 14
Continuação dos exercícios (desafios)
17. Faça um algoritmo que leia um número inteiro qualquer e retorne se este número é
primo ou não. Obs.: Números primos são aqueles divisíveis apenas por 1 (um) e por
eles mesmos.
18. Faça um algoritmo que leia 3 valores inteiros e exiba o MMC (Mínimo Múltiplo
Comum) entre estes valores.
19. Faça um algoritmo que leia o Nome, Idade e Sexo de 50 pessoas. Retorne ao final o
nome da mulher mais velha e do homem mais jovem.
Aula 15
Revisão Geral Para a Prova I
Aula destinada a revisão de todo o conteúdo desenvolvido até o momento, bem como
conclusão de exercícios.
Aula 16
Prova I
Boa prova a todos.
Lembrem-se sempre de ler com atenção todas as questões da prova.
Faça primeiro as questões que você considerar mais fáceis.
Não fique com dúvidas em relação à interpretação da prova.
Aula 17
Considerações sobre a prova
Aula destinada a correção da prova e tirar dúvidas em relação a avaliação.
Aula 18
Variáveis Homogêneas Unidimensionais (Vetores)
8. Introdução
A partir deste ponto do curso iremos quebrar o paradigma de que uma variável só pode
armazenar um valor por vez.
Quando o vetor a ser declarado for de tipo char, devemos informar primeiro o número
de caracteres que cada posição irá armazenar e logo após o número de posições.
Exemplo:
char vetor3[20] [12];
int main()
{
int vetor[5];
int i;
float soma;
Explicando o código:
O primeiro laço faz a leitura de dados do vetor de forma seqüencial (posição por
posição) onde a variável “i” serve de índice para o vetor.
O segundo laço faz o que chamamos de varredura no vetor (passar por todas as
posições) de modo que na variável soma seja acumulado o valor de cada posição
do vetor.
O programa poderia ser desenvolvido em apenas um laço, mas está disposto
desta maneira justamente para demonstrar que os dados continuam armazenados
no vetor, mesmo quando a leitura de informações já está posicionada em outra
linha.
Se em algum momento for necessário recuperar alguma informação digitada,
será possível.
3. Faça um algoritmo que leia um vetor real de 6 posições e retorne a média dos
valores positivos do vetor.
4. Faça um algoritmo que leia dois vetores reais de 5 posições. Gere um terceiro vetor
de mesmo tamanho e tipo que obedeça a seguinte regra de formação:
a) Na primeira posição do vetor 3 será armazenada a multiplicação entre a primeira
posição do vetor 1 e a primeira posição do vetor 2.
b) Na segunda posição do vetor 3 será armazenada a multiplicação entre a segunda
posição do vetor 1 e a segunda posição do vetor 2.
c) ...
5. Faça um algoritmo que leia um vetor string de 10 posições. Após a leitura de todo o
vetor o usuário deve informar mais uma palavra. Seu programa deve exibir quantas
vezes esta palavra existe no vetor.
Aula 19
Continuação dos Exercícios
6. Faça um algoritmo que leia dois vetores string de 10 posições equivalentes a grade
de respostas de um aluno e o gabarito da mesma prova feita pelo professor. Seu
programa deve informar a nota do aluno sabendo que cada acerto equivale a 1 ponto.
Seu programa também deve retornar uma mensagem para o usuário de acordo com o
seu número de acertos
a) Até 3 acertos: PRECISA MELHORAR
b) Até 5 acertos: REGULAR
c) Até 7 acertos: BOM
d) Acima de 8 acertos: CONTINUE ASSIM.
7. Faça um algoritmo que leia um vetor inteiro de 10 posições. Logo após a leitura de
todo o vetor, inverta os valores de todo o vetor.
8. Faça um algoritmo que leia um vetor real de 8 posições. Logo após a leitura exiba o
maior valor digitado no vetor.
10. Faça um algoritmo que leia um vetor de 6 posições inteiro e reorganize os dados
deste vetor de modo que seus dados sejam exibidos de maneira crescente.
Aula 20
Aula destinada à correção dos exercícios e remoção de dúvidas.
Aula 21
Variáveis Homogêneas Multidimensionais (Matrizes)
9. Introdução
Dentro da programação, vetores não são a única forma de se armazenar múltiplos
valores dentro de uma variável.
É indiferente pensarmos que cada posição da matriz é indexada pelo número de sua
coluna seguido por sua linha ou o seu inverso. Para uma maior facilidade de
compreensão, iremos trabalhar com o sistema de linha x coluna.
Quando a matriz a ser declarada for de tipo char, devemos informar primeiro o número
de caracteres que cada posição irá armazenar e logo após o número de linhas e colunas.
Exemplo:
char matriz3[20][8][5];
int main()
{
int matriz[3][3];
int linha,coluna;
float soma;
system("PAUSE");
return 0;
}
Explicando o código
Agora a entrada de dados é feita utilizando dois laços e não apenas um.
Repare que para cada volta do laço de linha, o laço de coluna faz três voltas.
Para a varredura da matriz o processo se repete
Para visualizarmos a matriz é interessante que a cada linha seja feita uma quebra
de linha (“\n”) entre os laços.
2. Faça um algoritmo que leia uma matriz 3x5 de tipo inteiro e exiba quantos valores
pares existem na matriz.
3. Faça um algoritmo que leia uma matriz 5x5 de tipo real e exiba a soma das linhas
pares e a média das linhas ímpares.
4. Faça um algoritmo que leia uma matriz 2x8 e coloque seus valores em uma matriz
8x2. Ambas as matrizes de tipo char.
5. Faça um algoritmo que leia uma matriz 6x6 e exiba a soma de sua diagonal
principal.
6. Faça um algoritmo que leia uma matriz 6x6 e exiba a soma de sua diagonal
secundária.
7. Faça um algoritmo que leia uma matriz 6x6 e exiba a soma dos seguintes valores da
matriz.
8. Faça um algoritmo que preencha uma matriz 10x10 de forma automática com os
valores de 1 a 100 de forma seqüencial. Obs.: Utilize apenas os contadores dos laços
e a matriz propriamente dita. Não utilize uma contadora auxiliar.
Aula 22
Aula destinada à conclusão e correção dos exercícios.
Aula 23
Continuação e Correção de Exercícios
9. Faça um algoritmo que leia uma matriz 3x3 de tipo real e adicione seus valores a um
vetor real de 9 posições.
10. Faça um algoritmo que ordene os valores de uma matriz 4x4 de forma decrescente.
O procedimento a ser executado deverá ser:
a) Ler a matriz
b) Adicionar seus dados a um vetor
c) Ordenar o vetor
d) Devolver os dados para a matriz.
11. Faça um algoritmo que ordene de forma crescente apenas os valores pares de uma
matriz inteira 5x5, sendo que os valores ímpares não devem ser deslocados.
Aula 24
Introdução a Programação Modular
10. Introdução
O conceito de programação modular consiste no desenvolvimento de rotinas de tal
forma que seja permitido o seu reaproveitamento.
10.2.1. Funções
Funções são blocos de algoritmo que devem possuir uma assinatura e que ao final
de sua execução, devem retornar algum valor de resposta.
10.2.2. Assinatura
Conjunto formado pelo nome, lista de argumentos (quando necessários) e tipo de
dado de saída.
10.2.3. Argumento
São todas as informações que devem ser enviadas pelo usuário da função, para que
esta possa ser executada de forma correta.
10.2.4. Parâmetro
São as informações que serão passadas para os argumentos das funções pelo
programa principal (usuário).
Explicando o código
int encontra_maior(int a, int b) Assinatura da função. Está sendo informado que
existe uma função chamada “encontra_maior”
que recebe dois valores inteiros como argumentos
(a e b) e devolve um valor inteiro no final
Return É a instrução que fará com que a devolução do
valor seja feita. No caso de “a” ser o maior valor
será retornado “a”, caso contrário a função
devolverá “b”.
maior = encontra_maior(v1, v2) Chamada da função. É feita a chamada da função
“encontra_maior” de modo que o conteúdo dos
parâmetros “v1” e “v2” sejam enviados para os
argumentos “a” e “b” e o retorno da função será
depositado na variável “maior”
Repare que em nenhum momento é feita a leitura dos valores dos argumentos dentro da
função. A leitura dos dados deve ser feita nos parâmetros, de modo que a função se
torne o mais independente possível. Exceto em funções específicas para captura de
dados do usuário.
int main()
{
int v1, v2, v3, maior;
printf ("Digite o primeiro valor: ");
scanf ("%d", &v1);
printf ("Digite o segundo valor: ");
scanf ("%d", &v2);
printf ("Digite o terceiro valor: ");
scanf ("%d", &v3);
maior = encontra_maior(encontra_maior(v1,v2),v3);
printf ("O maior valor é: %d \n", maior);
system("PAUSE");
return 0;
}
Com este método, foi possível reaproveitar o código da função anterior de modo que
encontramos o maior valor entre as variáveis “v1” e “v2” e comparamos este valor com
“v3” em uma segunda chamada da função.
Sendo assim, a função original não precisou sofrer nenhuma alteração na sua estrutura.
Podemos achar o maior valor entre qualquer grupo de valores utilizando a função
“encontra_maior” fazendo alterações apenas no programa principal.
Nada impede também, que façamos mais de uma função dentro de um código. Inclusive
de modo que uma função chame outra que esteja desenvolvida acima.
2. Faça um algoritmo que leia dois valores inteiros e retorna o triplo do maior valor.
4. Faça um algoritmo que lê dia, mês e ano vindos do usuário. Crie uma função que
retorne se estes valores formam uma data válida ou não.
5. Faça um algoritmo que lê um número inteiro e que chame uma função que retorne o
seu fatorial.
Aula 25
Continuação dos Exercícios
6. Faça um algoritmo que possua 5 funções
a) Uma que calcule a soma entre dois valores reais
b) Uma que calcule a multiplicação entre dois valores reais
c) Uma que calcule a subtração entre dois valores reais
d) Uma que calcule a divisão entre dois valores reais
e) Uma que de acordo com um código fornecido pelo usuário chama as funções
acima conforme a tabela abaixo:
Código Ação
1 Adição
2 Multiplicação
3 Subtração
4 Divisão
Crie um programa principal que deve apenas ler o código da operação e dois valores
reais e exiba o resultado da operação.
int main()
{
int a,b;
printf ("Digite o primeiro valor: ");
scanf("%d", &a);
printf ("Digite o segundo valor: ");
scanf("%d", &b);
inverte (a, b);
printf ("O novo valor de A é: %d\n", a);
printf ("O novo valor de B é: %d\n", b);
system("PAUSE");
return 0;
}
#include <stdio.h>
void inverte(int *a, int *b)
{
int aux;
aux = *a;
*a = *b;
*b = aux;
}
int main()
{
int a,b;
printf ("Digite o primeiro valor: ");
scanf("%d", &a);
printf ("Digite o segundo valor: ");
scanf("%d", &b);
inverte (&a, &b);
printf ("O novo valor de A é: %d\n", a);
printf ("O novo valor de B é: %d\n", b);
system("PAUSE");
return 0;
}
Explicando o código
Na função a única diferença é que nossos argumentos devem ser precedidos pelo
operador “*”, assim estamos nos referenciando diretamente ao endereço do argumento
na memória.
No programa principal, os parâmetros devem ser precedidos pelo operador “&” para
que seja passado para o argumento a posição da variável na memória em vez do seu
conteúdo propriamente dito.
8. Faça um algoritmo que leia dois valores reais e possua uma função que retorna o
dobro do maior valor e a metade do menor.
Aula 26
Tratando Vetores Através de Funções
Para tratarmos vetores (ou qualquer estrutura de dados) de uma forma eficiente e
organizada, é aconselhável que utilizemos funções de manipulação para estes dados.
Faremos agora um exemplo prático implementando a manipulação de um vetor de
modo que sejam feitas as quatro operações básicas para um sistema.
Inserção
Alteração
Exclusão
Pesquisa
Este projeto deve ser bem planejado, para que seu desenvolvimento seja de fácil
compreensão. Sendo assim, iremos trabalhar passo a passo o código fonte.