SOP-2010-2-tiago
Diário de aula de SOP - 2010-2 - Prof. Tiago Semprebom
Instrutor
Professor: Tiago Semprebom
Email: tisemp@ifsc.edu.br
Atendimento paralelo: 2a feira 10h - 11 h e 5a feira 15h - 17h (Lab. de Desenvolvimento de Tele)
Referências adicionais
- Antiga página da disciplina
- Valle, Odilson Tadeu. Gerência de Redes. IFSC - Unidade São José. 2009. (ver capítulos 1 a 9)
- Ubuntu Documentation
- Guia Foca Linux (iniciante)
- Apostila sobre Lógica de Programação
- Demais referências contidas na página principal de SOP.
29/07: Sistemas Operacionais
- Tópicos: Apresentação da disciplina, plano de aula, trabalhos e métodos de avaliação.
02/08: Introdução à computação
Sistemas computacionais; visão geral de sistemas operacionais; histórico de sistemas operacionais (resumo).
Videos ilustrativos:
- Eniac
- A Saga do Windows
- Funcionamento de um processador
- Funcionamento de um disco rígido
- Outro video sobre funionamento de um HD
Alguns textos interessantes sobre história dos sistemas operacionais:
- The Unix Operating System: um artigo publicado em 1974 pelos criadores do Unix, Ken Thompson e Dennis Ritchie.
- História do Linux (português)
- Visão geral sobre o Linux
- História dos Sistemas Operacionais (em português)
- Os 10 piores sistemas operacionais de toda a história (inglês)
05/08: Introdução ao Linux
- Iniciar e encerrar uma sessão no Linux;
- Se familizarizar com a interface do GNOME;
- Usar o navegador de arquivos Nautilus;
- Operar sobre diretórios: navegar, criar, remover, remover recursivamente, listar, copiar e renomear;
- Trabalhar o conceito de nomes absolutos e relativos usando ".", "..", "~" e "-"
- Trabalhar o conceito de diretório de trabalho e de diretório de entrada;
- Criar, remover, renomear e listar arquivos ordinários;
- Outros: trabalhar o conceito de arquivo escondido e usar TAB para autocompletar nomes no shell;
- Usar o manual online (man);
Roteiro desta aula:
Lógica de Programação
Segundo módulo da disciplina de Sitemas Operacionais. Baseado no material Lógica de Programação, de Paulo Sérgio de Moraes - uma das referências bibliográficas da disciplina.
08/04: Introdução
- Tópicos: instrução, sequência, problemas do dia a dia.
- Páginas da apostila: 4 a 7.
09/04: Desenvolvendo algoritmos
- Tópicos: resolvendo problemas, linguagens e instrução disponíveis (vocabulário).
- Páginas da apostila: 8 a 11.
Exercícios: desenho de figuras geométricas
- Usando apenas as instruções:escreva algoritmos para desenhar as seguintes figuras:
limpa avança X giraDireita angulo giraEsquerda angulo
- triângulo equilátero
- triângulo isósceles
- triângulo escaleno
- quadrado
- hexágono
- octógono
- 7 hexágonos interligados (um central e seis periféricos).
- kturtle é um software educacional para ajudar no ensino de matemática, geometria e introdução à programação. Ele possibilita fazer desenhos facilmente, seguindo um programa com instruções de desenho. Usando as instruções: ... escreva programas para os algoritmos criados no ítem anterior.
reset forward X turnright angulo turnleft angulo
15/04: Pseudocódigo e diagrama de blocos (fluxograma)
- Adoção do Portugol IDE como ferramenta didática.
- Páginas da apostila: 12 a 14.
Portugol
As aulas de Lógica de Programação usarão um software de auxílio ao ensino de algoritmos chamado Portugol, desenvolvido na Escola Superior de Engenharia do Instituto Politécnico de Tomar, em Portugal.
Guia rápido de instalação e utilização do Portugol
Abaixo segue uma breve ajuda de como obtê-lo, instalá-lo e usá-lo. Esse guia assume que você esteja usando o Ubuntu Linux 9.04 ou superior.
- Faça o download do Portugol.
- Descompacte-o com o seguinte comando:
tar xzf portugol23.tar.gz
- Repare que existe agora um subdiretório portugol no diretório onde você o descompactou. Execute o Portugol com o seguinte comando: Obs: você precisará ter Java instalado. Caso não o tenha, execute o comando:
java -jar portugol/Portugol.jar
sudo apt-get install openjdk-6-jre
- Copie esse arquivo para poder ver fluxogramas coloridos, e grave-o no memso diretório onde está o Portugol.
- Veja a ajuda do Portugol, e use-a sempre que tiver dúvidas !
A tela inicial do Portugol segue abaixo, junto com um programa demonstrativo.
Exemplos de programas iniciais em Portugol:
- Lendo um número e mostrando-o na tela em seguida:
Inicio inteiro x Escrever "Digite um numero: ", Ler X Escrever "Numero digitado: ", x Fim
- Lendo dois números, somando-os e mostrando o resultado na tela: O programa abaixo é equivalente:
Inicio inteiro x, y Escrever "Digite um numero: ", Ler x Escrever "Digite outro numero: ", Ler y Escrever "Soma = ", x+y Fim
Inicio inteiro x, y, z Escrever "Digite um numero: ", Ler x Escrever "Digite outro numero: ", Ler y z <- x + y Escrever "Soma = ", z Fim
Atividades
- Média de três números: escreva um programa para calcular a média de três números.
Inicio Inteiro n1, n2, n3, r Escrever "Primeiro numero: " ler n1 Escrever "Segundo numero: " ler n2 Escrever "Terceiro numero: " ler n3 r <- (n1 + n2 + n3) /3 Escrever "Media=", r Fim
- Sequência de Fibonacci: em matemática corresponde aos números: ... que pode ser descrita pela relação de recorrência
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
... com valores iniciais e .
Numerosas formas na natureza apresentam essa sequência, como neste girassol (cujas flores se dispõem em uma espiral):
Usando o Portugol escreva um programa que mostre os 10 primeiros números dessa sequência.
16/04: Fluxogramas, constantes e Variáveis
- Diagrama de blocos (fluxograma)
- Variáveis e constantes
Fluxogramas
Diagramas de bloco para auxiliar a descrição de algoritmos. Ajudam na compreensão do algoritmo, por poder visualizar o fluxo de execução.
Fluxograma para o algoritmo da média de trẽs números.
Blocos de uso mais comum
Obs: Arquivo de configuração das cores do fluxograma do Portugol.
Variáveis e constantes
- Variável: capaz de guardar um dado a ser usado no algoritmo. Pode ser entendida como uma caixa, onde se coloca um dado e se pode consultá-lo quantas vezes for necessário. O dado pode ser modificado (substituído por outro). Exemplo em Portugol: Nesse exemplo há duas variáveis: dias e anos
Inicio inteiro anos, dias Escrever "Quantos anos se passaram ? " Ler anos dias <- anos * 365 Escrever "... então se passaram ", dias, " dias" Fim
- Constante: semelhante à variável, porém o dado armazenado não pode ser modificado. Exemplo em Portugol:Nesse exemplo há uma constante: diasPorAno
Inicio constante inteiro diasPorAno <- 365 inteiro anos, dias Escrever "Quantos anos se passaram ? " Ler anos dias <- anos * diasPorAno Escrever "... então se passaram ", dias, " dias" Fim
Variáveis e constantes devem ser declaradas antes de serem usadas (algumas poucas linguagens, como Python e Perl, não exigem isto). A declaração consiste do tipo e identificador da variável. O tipo corresponde ao tipo de valor que pode ser guardado, e o identificador é o nome da variável. No exemplo abaixo:
constante inteiro diasPorAno <- 365
inteiro anos, dias
Fim
Há duas variáveis do tipo inteiro, e seus identificadores são dias e anos. O tipo inteiro indica que essas variáveis podem guardar somente números inteiros.
Tipos de variáveis e constantes no Portugol:
Tipo | Descrição | Exemplo |
---|---|---|
Inteiro | Número inteiro entre -2 147 483 648 e 2 147 483 647 begin_of_the_skype_highlighting 2 147 483 647 end_of_the_skype_highlighting begin_of_the_skype_highlighting 2 147 483 647 end_of_the_skype_highlighting begin_of_the_skype_highlighting 2 147 483 647 end_of_the_skype_highlighting begin_of_the_skype_highlighting 2 147 483 647 end_of_the_skype_highlighting begin_of_the_skype_highlighting 2 147 483 647 end_of_the_skype_highlighting begin_of_the_skype_highlighting 2 147 483 647 end_of_the_skype_highlighting begin_of_the_skype_highlighting 2 147 483 647 end_of_the_skype_highlighting begin_of_the_skype_highlighting 2 147 483 647 end_of_the_skype_highlighting begin_of_the_skype_highlighting 2 147 483 647 end_of_the_skype_highlighting | Inteiro x <- 10 |
Real | Número real entre -1.7 E 308 e 1.7 E 308 | Real y <- 10.789 |
Lógico | Valor booleano, com valores "Verdadeiro" e "Falso" | Logico ok <- Falso |
Caracter | Um caractere da tabela ASCII | Caracter letra <- "A" |
Texto | Uma sequência de caracteres (ou string) | Texto palavra <- "um teste" |
A declaração de constantes é semelhante à de variáveis, bastanto prefixá-las com a palavra-chave constante.
Atividade
Para os exercícios abaixo, desenhe o fluxograma e escreva o algoritmo no Portugol.
- Faça um algoritmo que calcule a média de quatro números, porém mostrando as casas decimais (caso existam).
- Escreva um algoritmo que mostre, em sequência: 9, 9^2 (ao quadrado), 9^3 (ao cubo) e a soma desses 3 números.
- Escreva um algoritmo que leia o nome, sobrenome e idade de uma pessoa, e escreva na tela:
sobrenome, nome idade anos
22/04: Expressões lógicas e aritméticas
Expressão aritmética: um conjunto de operações sobre variáveis, constantes e funções numéricas, e que gera um determinado resultado numérico.
Exemplos de expressões aritméticas:
# Uma expressão que calcula quantos segundos existem em um horário do tipo horas, minutos e segundos
3600*horas + 60*minutos + segundos
# Uma expressão que calcula a velocidade instantânea, segundo um MRV
vel_inicial + aceleracao*tempo;
# Uma expressão que calcula o módulo de um vetor bidimensional, que possui coordenadas x e y
raiz(x^2 + y^2)
Os resultados de expressões podem ser mostrados na tela, ou armazenados em variáveis:
# Uma expressão que calcula quantos segundos existem em um horário do tipo horas, minutos e segundos
segundos <- 3600*horas + 60*minutos + segundos
# Uma expressão que calcula a velocidade instantânea, segundo um MRV
escrever 'Velocidade no instante ', tempo, ' = ', vel_inicial + aceleracao*tempo;
# Uma expressão que calcula o módulo de um vetor bidimensional, que possui coordenadas x e y
modulo <- raiz(x^2 + y^2)
Repare que uma expressão fica sempre do lado direito, quando atribuída a uma variável. A expressão é primeiro calculada, e em seguida seu resultado é armazenado na variável:
segundos <- 3600*horas + 60*minutos + segundos
Operadores aritméticos
Expressões aritméticas sao compostas por números e operadores aritméticos:
Obs: para os exemplos abaixo são usadas estas variáveis:
Real x, area, lado
inteiro dias, horas
Operador | Descrição | Exemplo |
---|---|---|
+ | Adição | x <- x + 1 |
- | Subtração | x <- x - 1 |
* | Multiplicação | x <- x*x*xhttp://www.facebook.com/profile.php?id=100000215067732&ref=profile#!/?ref=home |
/ | Divisão | dias <- horas / 24 |
% | Módulo (resto de divisão) | horas <- horas % 24 |
^ | Potenciação | area <- lado^2 |
Precedência dos operadores (nesta ordem): ^, *, /, %, + e -
A precedência pode ser modificada com o uso de parênteses. Ex:
escrever 1 + 2 * 3
escrever (1 + 2)*3
No Portugol, existem também algumas funções úteis, como a função raiz:
r <- raiz(x^2 + y^2)
O resultado de expressões aritméticas depende dos tipos numéricos das variáveis e constantes:
inicio
real x
inteiro y
inteiro resultadoInteiro
real resultadoReal
x <- 9
y <- 9
escrever "O resultado de uma expressão aritmética depende dos tipos das variá¡veis e constantes\n"
escrever "usadas na expressão. Se forem todas inteiras, então o resultado será inteiro.\n"
escrever "Veja este exemplo: \n"
escrever "Variável inteira y=", y
escrever "\nExpressão: y/2=", y/2
escrever "\n\nNeste segundo exemplo, repete-se a mesma expressão, porém usando-se uma\n"
escrever "variável real:\n"
escrever "variável real x=", x
escrever "\nExpressão: x/2=", x/2
x <- 4
y <- 5
escrever "\n\nSe as variáveis de diferentes tipos forem combinadas, o resultado da\n"
escrever "expressão será real:\n"
escrever "Variável real x=", x, " e inteira y=", y
escrever "\nExpressão: (x+y)/2=", (x+y)/2
escrever "\n\nNo entanto, se uma expressão tiver um resultado real, mas este for\n"
escrever "atribuído a uma variável inteira, então apenas a parte inteira será guardada:\n"
escrever "Variável real x=", x, " e inteira y=", y
y <- (x+y)/2
escrever "\nExpressão: y <- (x+y)/2 ... após executada, y=", y
fim
Atividades
- Escreva um algoritmo que calcule a raiz de uma equação de 1o grau.
- Escreva um algoritmo que calcule as raízes de uma equação de 2o grau. Assuma que existam duas raízes reais.
- Um equipamento conta o tempo desde que foi ligado. No entanto, essa contagem é feita em segundos. Faça um algoritmo que converta o valor desse contador para horas, minutos e segundos.
- Faça um algoritmo que converta um número decimal para sua representação binária. Assuma que o número decimal tenha até dois dígitos.
23/04: Estruturas de decisão
Páginas da apostila: 26 a 31.
Estruturas de decisão possibilitam que se executem diferentes sequências de instruções de um programa, dependendo de uma condição a ser avaliada. Por exemplo, um jogo poderia armazenar a maior pontuação já obtida, e verificar se foi ultrapassada ao final de cada partida:
Se pontuacao > recorde então
recorde <- pontuação
FimSe
O exemplo acima mostra a estrutura de decisão Se condição entao comandos Fimse. Veja o próximo exemplo:
Se conceito > 70 entao
escrever 'Voce esta aprovado'
senao
escrever 'Desta vez não deu ... tente de novo !'
Fimse
O uso de Se condição entao comandos Senao comandos Fimse possibilita que se execute uma sequência de comandos se a condição for verdadeira, e outra sequência se for falsa.
Para fazer um bom uso de estruturas de decisão deve-se primeiro conseguir identificar as condições a serem avaliadas. Condições são escritas com expressões lógicas, e estas são compostas de operadores lógicos e relacionais aplicados a variáveis e constantes.
Condições
Obs: para os exemplos abaixo são usadas estas variáveis:
Logico correto, multa, aprovado, barato, bombear_agua
Logico descartar, baixo, reprovado, erro, enviado, recebido
inteiro erros, pontuacao, preco, endereco, velocidade
Real faltas, nivel_agua, altura
Operadores relacionais
Operador | Descrição | Exemplo |
---|---|---|
= | Igualdade | correto <- (erros = 0) |
> | Maior | multa <- (velocidade > 80) |
>= | Maior ou igual | aprovado <- (pontuacao >= 70) |
< | Menor | barato <- (preco < 100) |
<= | Menor ou igual | bombear_agua <- (nivel_agua <= 0.7) |
=/= | Diferente | descartar <- (endereco =/= 12345) |
Operadores lógicos
Operador | Descrição | Exemplo |
---|---|---|
NAO | Negação | baixo <- NOT (altura > 1.8) |
E | Conjunção | aprovado <- NOT (conceito = "D") E (faltas <= 0.25) |
OU | Disjunção | reprovado <- (conceito = "D") OU (faltas > 0.25) |
XOU | Disjunção exclusiva | erro <- enviado XOU recebido |
Precedência dos operadores (nesta ordem): NAO, E, OU e XOU
Lembre que a precedência pode ser modificada com o uso de parênteses.
Atividades
- Faça um programa que leia um número e então informe se ele é par ou ímpar.
- Faça um algoritmo que leia três números do teclado, e mostre o maior e menor números.
- Em uma rede de computadores, o firewall restringe o acesso a Internet, dependendo do horário e do tipo de usuário que faz o acesso. Os tipos de usuário abaixo têm as seguintes restrições:
- Funcionario: apenas entre 0:00 e 7:30, entre 18:30 e 0:00, e entre 12:00 e 13:30
- Financeiro: qualquer horario
- Diretoria: qualquer horário
Escreva um algoritmo que informe se um acesso foi permitido, em função do horário e do tipo de usuário.
- Modifique o algoritmo acima para adicionar a seguinte restrição:
- Funcionario: nao pode acessar sites de jornal (ex: www.rbs.com.br)
- Financeiro: nao pode acessar sites de jornal durante o expediente
- Diretoria: sem restrições a sites
- Faça um algoritmo para fazer a divisão de dois números reais. Antes de dividi-los deve ser feito um teste de validade. Caso não seja possível dividi-los, deve ser mostrada uma mensagem de erro. Se for possível, deve-se mostrar o resultado da divisão.
- Faça um jogo de par ou ímpar, em que o jogador aposta contra o computador. O jogador deve digitar um número entre 0 e 5 e optar entre par ou ímpar. O computador deve sortear um número também entre 0 e 5. Se a paridade da soma dos números do jogador e do computador for a mesma que o jogador optou, então ele ganha a partida, senão o computador vence.
Solução exercício 2 proposto.
inicio
inteiro num<-0,maior<-0,menor<-0, i<-0
constante inteiro valores<-2 //declaração da constante
escrever "Digite um valor: \n"
ler num
maior <- num
menor <- num
para i de 1 até valores passo 1
ler num
se (num > maior) então
maior <- num
fimse
se (num < menor) então
menor <- num
fimse
proximo
escrever "O maior valor digitado é: ", maior
escrever "\n"
escrever "O menor valor digitado é: ", menor
fim
23/04: Estruturas de decisão
Há situações em que se precisa fazer um conjunto de comparações, como mostrado abaixo:
// Lê a data no formato numérico dia, mes, ano, e mostra a data no formato
// dia, nome do mês, ano.
Inicio
inteiro dia, mes, ano
texto nome_mes
escrever "Dia: "
ler dia
escrever "Mes: "
ler mes
escrever "Ano: "
ler ano
se mes = 1 entao
nome_mes <- "Janeiro"
senao
se mes = 2 entao
nome_mes <- "Fevereiro"
senao
se mes = 2 entao
nome_mes <- "Março"
senao
se mes = 2 entao
nome_mes <- "Abril"
senao
se mes = 2 entao
nome_mes <- "Maio"
senao
se mes = 2 entao
nome_mes <- "Junho"
senao
se mes = 2 entao
nome_mes <- "Julho"
senao
se mes = 2 entao
nome_mes <- "Agosto"
senao
se mes = 2 entao
nome_mes <- "Setembro"
senao
se mes = 2 entao
nome_mes <- "Outubro"
senao
se mes = 2 entao
nome_mes <- "Novembro"
senao
nome_mes <- "Dezembro"
fimSe
fimSe
fimSe
fimSe
fimSe
fimSe
fimSe
fimSe
fimSe
fimSe
fimSe
escrever dia, " de ", nome_mes, " de ", ano
fim
Além de ser trabalhoso esse encadeamento de Se ... entao ... senao, o algoritmo resultante fica pouco legível. Quer dizer, ele fica feio e difícil de entender.
Existe uma estrutura de decisão criada justamente para casos como esse, e que resulta em um algoritmo mais limpo e compreensível:
// Lê a data no formato numérico dia, mes, ano, e mostra a data no formato
// dia, nome do mês, ano.
Inicio
inteiro dia, mes, ano
texto nome_mes
escrever "Dia: "
ler dia
escrever "Mes: "
ler mes
escrever "Ano: "
ler ano
Escolhe mes
caso 1:
nome_mes <- "Janeiro"
caso 2:
nome_mes <- "Fevereiro"
caso 3:
nome_mes <- "Março"
caso 4:
nome_mes <- "Abril"
caso 5:
nome_mes <- "Maio"
caso 6:
nome_mes <- "Junho"
caso 7:
nome_mes <- "Julho"
caso 8:
nome_mes <- "Agosto"
caso 9:
nome_mes <- "Setembro"
caso 10:
nome_mes <- "Outubro"
caso 11:
nome_mes <- "Novembro"
Defeito:
nome_mes <- "Dezembro"
fimEscolhe
escrever dia, " de ", nome_mes, " de ", ano
fim
A estrutura de decisão escolhe ... caso tem uma certa flexibilidade. No exemplo abaixo, mostra-se a possibilidade de testar mais de um valor no mesmo caso:
inicio
caracter sexo
escrever "Qual o seu sexo (f/m):"
ler sexo
escrever "Olá "
escolhe sexo
caso "m", "M" :
escrever "senhor"
caso "f","F" :
escrever "senhorita"
defeito :
escrever "Sexo indefinido"
fimescolhe
escrever ", benvindo ao portugol"
fim
Atividades
- Faça um algoritmo que converta um número de 1 a 7 para o respectivo dia da semana (ex: 1 = domingo, 2 = 2a feira, e assim por diante).
- Faça uma calculadora com as quatro operações aritméticas. Sua calculadora deve ler (nesta ordem) o primeiro número, a operação aritmética (que deve ser informada usando o símbolo da respectiva operação: +, -, * ou /), e depois o segundo número. Ao final, seu algoritmo deve mostrar o resultado, ou uma mensagem de erro se a operação não for possível de realizar (ex: divisão por zero).
- A previsão do tempo na costa brasileira pode ser feita de forma aproximada usando-se um barômetro e um termômetro. Uma estimativa com boa chance de acerto se baseia na tabela abaixo:
Faça um algoritmo que forneça uma estimativa da previsão do tempo, usando essa tabela. - Faça um algoritmo que mostre qual o último dia de um determinado mês informado pelo teclado. Caso seja informado o mês 2 (fevereiro), seu algoritmo deve identificar se é ano bissexto (assim o mês tem 29 dias), ou não (mês tem 28 dias). Obs: anos bissextos são dados pelas regras (segundo o calendário Gregoriano):
- De 4 em 4 anos é ano bissexto.
- De 100 em 100 anos não é ano bissexto.
- De 400 em 400 anos é ano bissexto.
- Prevalecem as últimas regras sobre as primeiras.
Solução Ex. 4
inicio
texto B, T
Escrever "O barômetro está: "
ler B
Escrever "O termômetro está: "
ler T
escolhe B
caso "+":
escolhe T
caso "+":
escrever "Tempo bom, ventos quentes e secos"
caso "=":
escrever "Tempo bom, ventos de leste frescos"
caso "-":
escrever "Tempo bom, ventos de sul a sudeste"
fimescolhe
caso "=":
escolhe T
caso "+":
escrever "Tempo mudando para bom, ventos de leste"
caso "=":
escrever "Tempo incerto, ventos variáveis"
caso "-":
escrever "Chuva provável, ventos de sul para sudeste"
fimescolhe
caso "-":
escolhe T
caso "+":
escrever "Tempo instável, aproximação de frente"
caso "=":
escrever "Frente quente, com chuvas prováveis"
caso "-":
escrever "Chuvas abundantes e ventos de sul a sudeste fortes"
fimescolhe
fimescolhe
fim
</syntaxhighlight>
29/04: Estruturas de repetição
Páginas da apostila: 32 a 35.
Alguns algoritmos vistos anteriormente possuem sequências repetitivas de instruções. Por exemplo, o algoritmo da média de quatro avaliações:
Inicio
real m1, m2, m3, m4
real media
escrever 'Avaliação 1:'
Ler m1
escrever 'Avaliação 2:'
Ler m2
escrever 'Avaliação 3:'
Ler m3
escrever 'Avaliação 4:'
Ler m4
media <- (m1 + m2 + m3 + m4) / 4
escrever 'Média: ', media
Fim
O algoritmo acima repete quatro vezes a sequência que lê uma nota do teclado. Porém há uma forma de expressar a repetição de sequências de instruções, usando-se o que se chama de estrutura de repetição. A estrutura de repetição enquanto condição faz repete todas as instruções enquanto a condição for verdadeira. A condição é escrita como uma expressão lógica, da mesma forma que na estrutura de decisão se condição então ... senão. Veja como fica o algoritmo acima ao ser reescrito para usar essa estrutura de repetição:
Inicio
constante inteiro NUMEROS <- 4
real m
real media
inteiro contador <- 0
enquanto contador < NUMEROS faz
escrever 'Avaliação ', contador, ':'
ler m
media <- media + m
contador <- contador + 1
fimEnquanto
escrever 'Média: ', media/NUMEROS
Fim
Esse algoritmo funciona somente para médias de quatro números. Porém calcular a média de qualquer quantidade de números usa a mesma lógica: ler os números, somá-los e dividir o total pela quantidade de números lidos. Por exemplo, para fazer com que ele calcule a média de 7 números é necessário escrevê-lo assim:
Inicio
constante inteiro NUMEROS <- 7
real m
real media
inteiro contador <- 0
enquanto contador < NUMEROS faz
escrever 'Avaliação ', contador, ':'
ler m
media <- media + m
contador <- contador + 1
fimEnquanto
escrever 'Média: ', media/NUMEROS
Fim
Note que o algoritmo praticamente não foi modificado, pois somente se alterou o valor da constante NUMEROS.
A estrutura de repetição junto com a sequência de instruções a ser repetida é comumente chamada de 'laço. Assim, no algoritmo acima o laço aparece em:
enquanto contador < NUMEROS faz
escrever 'Avaliação ', contador, ':'
ler m
media <- media + m
contador <- contador + 1
fimEnquanto
Um outro exemplo ainda mais simples é mostrar na tela uma contagem numérica:
inicio
inteiro contador
contador <- 0
enquanto contador < 10 faz
escrever contador , " "
contador <- contador + 1
fimenquanto
fim
Ao executar esse algoritmo, tem-se como resultado:
0 1 2 3 4 5 6 7 8 9
Repare no uso de uma variável auxiliar contador para controlar a quantidade de repetições. Essa é uma técnica comum para
controlar a estrutura de repetição, e já foi usada no exemplo da média. Ela pode também ser combinada com outras condições, como mostrado abaixo:
inicio
inteiro contador <- 1
caracter opcao <- "s"
enquanto ((opcao = "s") ou (opcao = "S")) e contador < 11 faz
escrever contador, "\n"
contador <- contador + 1
escrever "\nContinuar (S/N) ? "
ler opcao
fimenquanto
escrever "Terminou com contador = " , contador
fim
Nesse exemplo se usa um laço para mostrar uma contagem de 1 a 10. Porém há a possibilidade de encerrar o algoritmo. Observe a condição para continuidade do laço: ela é verdadeira somente se contador < 11 e se a variável opcao for igual a "s" ou "S".
Finalmente, apesar de ser comum o uso de contadores para controle do laço, pode-se usar qualquer condição para essa finalidade. Então podem existir laços que não usam contadores para controlar a quantidade de repetições, como no próximo exemplo:
inicio
constante texto segredo <- "secreto"
texto senha
ler senha
enquanto senha =/= segredo faz
escrever "Voce continua preso ! Digite a senha correta: "
ler senha
fimenquanto
escrever "Voce foi liberado ..."
fim
Solução do problema proposto em sala (aula dia 29/04/2010) feita pelo Thiarles
inicio
inteiro opcao <- 0
real numero1 <- 0 , numero2 <- 0 , resultado <- 0
enquanto opcao =/= 5 faz
escrever "\n Entre com a opção desejada: 1- Adição; 2- Subtração; 3- Multiplicação; 4- Divisão , 5- Sair."
ler opcao
se opcao = 5 entao
escrever "\n Você saiu com sucesso!"
senao
escrever "\n Lembre-se: Na subtração e na divisão a ordem dos números é importante!"
escrever "\n Entre com o primeiro número: "
ler numero1
escrever "\n Entre com o segundo número: "
ler numero2
se opcao = 1 entao
resultado <- ( numero1 + numero2 )
escrever "\n A soma dos dois números é: " , resultado
fimse
se opcao = 2 entao
resultado <- ( numero1 - numero2 )
escrever "\n A subtração dos dois números é: " , resultado
fimse
se opcao = 3 entao
resultado <- ( numero1 * numero2 )
escrever "\n O produto dos dois números é: " , resultado
fimse
se opcao = 4 entao
se numero2 = 0 entao
escrever "\n Não existe divisão por 0 (zero)."
senao
resultado <- ( numero1 / numero2 )
escrever "\n A divisão dos dois números é: " , resultado
fimse
fimse
se ( opcao =/= 1 e opcao =/= 2 ) e ( opcao =/= 3 e opcao =/= 4 ) entao
escrever "\n Esta operação não está definida."
fimse
fimse
fimenquanto
fim
</syntaxhighlight>
Atividades
- Escreva um algoritmo que mostre a tabuada de um número fornecido pelo teclado. Esse número deve estar entre 1 e 10.
- Modifique o exemplo da média para que a quantidade de números a serem lidos seja previamente informada pelo teclado.
- Modifique novamente o exemplo da média para que ela funcione para um quantidade de números desconhecida de antemão. Quer dizer, o algoritmo deve ler os números para calcular a média, mas não sabe quantos números existem (e isto não pode ser informado pelo teclado).
- Modifique o exemplo da senha para que o usuário tenha somente três tentativas permitidas para digitar a senha correta. caso ao final as três senhas estejam erradas, o algoritmo deve informar que a conta foi bloqueada.
- Escreva um algoritmo que leia até 10 números do teclado, e informe ao final qual o maior e o menor deles.
- Escreva um algoritmo que teste se um número informado pelo teclado é primo.
30/04: Estruturas de repetição
Variáveis multidimensionais
Em matemática existem matrizes e vetores, que são variáveis multidimensionais. Por exemplo, uma matriz 3 x 3 (3 linhas e 3 colunas) pode ser:
Vetores são matrizes unidimensionais, portanto possuem somente uma linha ou uma coluna:
Cada elemento em uma matriz ou vetor é identificado pela sua posição. Por exemplo, na posição 1, 2 da matriz A acima está o valor 6, e na posição 4 do vetor v está o valor 18. Assim, a matriz A do exemplo pode ser entendida da seguinte forma:
... e o vetor v do exemplo:
Nas linguagens de programação em geral existe um conceito muito parecido, chamado de variáveis multidimensionais ou simplesmente matrizes (arrays em inglẽs). Para exemplificar, no Portugol se poderiam definir a matriz A e o vetor v:
inicio
inteiro A[2][2] <- {{1, 6}, {3, 5}}
inteiro M[3][2];
inteiro v[5] <- {1, 6, 2, 18, 5}
inteiro i, j
escrever "Valor de A[0][0]: ", A[0][0], "\n"
escrever "Valor de A[0][1]: ", A[0][1], "\n"
escrever "Valor de A[1][0]: ", A[1][0], "\n"
escrever "Valor de A[1][1]: ", A[1][1], "\n"
escrever "Valor de v[0]: ", v[0], "\n"
escrever "Valor de v[1]: ", v[1], "\n"
escrever "Valor de v[2]: ", v[2], "\n"
escrever "Valor de v[3]: ", v[3], "\n"
escrever "Valor de v[4]: ", v[4], "\n"
fim
A declaração da matriz se faz como uma variável comum, porém indicando-se suas dimensões:
inteiro A[2][2] <- {{1, 6}, {3, 5}}
inteiro M[3][2];
Exemplo de preenchimento e impressão de matrizes não quadradas
inicio
inteiro i,j, mat[2][4]
//leitura (preenchimento da matriz)
para i de 0 ate 1 passo 1
para j de 0 ate 3 passo 1
ler mat[i][j]
proximo
proximo
//impressão da matriz
para i de 0 ate 1 passo 1
para j de 0 ate 3 passo 1
escrever "O valor na linha: ",i, "Coluna: ", j, "eh: ", mat[i][j]
escrever "\n"
proximo
proximo
fim
Veja que a matriz M foi declarada sem valores iniciais, porém a matriz A foi inicializada na declaração.
O acesso aos elementos da matriz se faz usando-se índices, que funcionam como coordenadas dos elementos que se quer acessar. Os índices iniciam em 0:
# índice 0,0
escrever "Valor de A[0][0]: ", A[0][0], "\n"
O exemplo acima pode ser reescrito usando-se estruturas de repetição:
inicio
inteiro A[2][2] <- {{1, 6}, {3, 5}}
inteiro v[5] <- {1, 6, 2, 18, 5}
inteiro i, j
enquanto i < 2 faz
j <- 0
enquanto j < 2 faz
escrever "Valor do elemento de A na posição ", i, ", ", j, ": ", A[i][j], "\n"
j <- j + 1
fimenquanto
i <- i + 1
fimenquanto
i <- 0
enquanto i < 5 faz
escrever "valor de v na posição ", i, ": ", v[i], "\n"
i <- i + 1
fimenquanto
fim
Como se vê, matrizes e vetores casam perfeitamente com estruturas de repetição, e são úteis para a resolução de inúmeros problemas. Por exemplo, o problema de mostrar o nome do mês a partir do número do mês, feito anteriormente com escolhe ... caso pode ser feito assim com um vetor:
inicio
texto nome_mes[12] <- {"Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro",
"Outubro", "Novembro, "Dezembro"}
inteiro dia, mes, ano
escrever "Dia: "
ler dia
escrever "Mes: "
ler mes
escrever "Ano: "
ler ano
escrever dia, " de ", nome_mes[mes], " de ", ano
fim
Outro problema comum é precisar guardar um conjunto de valores, e depois ordená-los:
inicio
inteiro v[10]
inteiro i
inteiro quantidade
escrever "Quantos valores serão digitados (máximo = 10) ? "
ler quantidade
i <- 0
enquanto i < quantidade faz
escrever "valor ", i, ": "
ler v[i]
i <- i + 1
fimenquanto
// ordena os valores ...
escrever "valores ordenados: "
i <- 0
enquanto i < quantidade
escrever v[i], " "
i <- i + 1
fimenquanto
fim
Atividades
- Escreva um algoritmo que leia 5 números do teclado, e depois mostre-os em ordem inversa à que foi digitada.
- Escreva um algoritmo que leia dois vetores de 5 números, e depois mostre se os vetores são iguais.
- Escreva um algoritmo que leia um palavra do teclado e depois procure-a numa lista de palavras preexistente. Essa lista deve ser implementada usando um vetor.
- Escreva um algoritmo que leia 5 números, e mostre-os em ordem crescente.
- Modifique o algoritmo anterior para mostrá-los em ordem decrescente.
- Em um jogo de bingo devem-se contar quantos números de uma aposta foram sorteados no bingo. Faça um algoritmo que, dados os números sorteados e uma aposta, conta quantos números apostados forma sorteados.
Solução exercício 4 e 6 propostos pelo Luiz Gustavo
inicio
//declaração da variáveis
inteiro v [ 5 ] , i , j , troca
//entrada de dados
para i de 0 ate 4 passo 1
ler v [ i ]
proximo
//organizar em ordem crescente
para i de 0 ate 4 passo 1
para j de 0 ate 4 passo 1
se v [ i ] > v [ j ] entao
troca <- v [ i ]
v [ i ] <- v [ j ]
v [ j ] <- troca
fimse
proximo
proximo
//impressão dos dados
para i de 0 ate 4 passo 1
escrever "\n" , v [ i ]
proximo
fim
</syntaxhighlight>
inicio
//declaração das variáveis
inteiro lista_num [5][5] <- {{10, 5, 20, 31, 33}, {51, 12, 13, 15, 29}, {25, 28, 22, 26, 36},
{11, 24, 34, 54, 44}, {1, 2, 55, 3, 5}}
inteiro numero [5][5],i,j,cont
//entrada de dados
escrever "Informe os números do Bingo: "
enquanto i < 5 faz
j <- 0
enquanto j < 5 faz
ler numero [ i ] [ j ]
j <- j + 1
fimenquanto
i <- i + 1
fimenquanto
//verificando quantos números são iguais
i <- 0
enquanto i < 5 faz
j <- 0
enquanto j < 5 faz
se (numero [i][j] = lista_num [i][j]) entao
cont <- cont + 1
fimse
j <- j + 1
fimenquanto
i <- i + 1
fimenquanto
//Imprimindo os dados
escrever "A quantidade de números sorteados nesta aposta foi: " , cont
fim
</syntaxhighlight>
06/05: Revisão para avaliação de Lógica de Programação
1. Crie um programa que lê três inteiros e informa VERDADEIRO se apenas o maior deles é par ou se o menor deles é ímpar ou informa FALSO em caso contrário.
2. Desenvolva um programa que recebe do usuário o placar de um jogo de futebol (os gols de cada time) e informa se o resultado foi um empate, a vitória do primeiro time ou do segundo time.
3. Elabore um programa que recebe do usuário três cadeias de caracteres e informa VERDADEIRO se há pelo menos duas diferentes cadeias iguais aos valores 'azul', 'preto'ou 'vermelho' ou FALSO em caso contrário. Exemplos: {'azul', 'preto', 'branco'} é VERDADEIRO; {'azul', 'roxo', 'azul'} é FALSO; {'preto', vermelho', 'vermelho'} é VERDADEIRO.
4. Tendo-se como dados de entrada a altura e o sexo de uma pessoa, construa um algoritmo que calcule seu peso ideal, utilizando as seguintes fórmulas:
- para homens: (72,7 * h) – 58;
- para mulheres: (62,1 * h) – 44,7.
5. Escrever um algoritmo, que leia um conjunto de 23 dados, cada um, contendo o peso e o código do sexo ("F" ou "M") dos alunos de uma classe, calcule e imprima:
- Maior e o menor peso da turma;
- A média de peso dos homens;
- A média de peso da turma;
Solução proposta pelo Manfred Ex. 1
inicio
inteiro n1 <- 0 , n2 <- 0 , n3 <- 0 , maior <- 0 , menor <- 0
escrever "Digite o primeiro número: "
ler n1
escrever "Digite o segundo número: "
ler n2
escrever "Digite o terceiro número: "
ler n3
maior <- n1
se ( n2 > maior ) entao
maior <- n2
fimse
se ( n3 > maior ) entao
maior <- n3
fimse
menor <- n1
se ( n2 < menor ) entao
menor <- n2
fimse
se ( n3 < menor ) entao
menor <- n3
fimse
se ( maior % 2 ) = 0 ou ( menor % 2 ) =/= 0 entao
escrever "Verdadeiro"
senao
escrever "Falso"
fimse
fim
</syntaxhighlight>
Proposta do Luiz para exercício 5
inicio
//declaração das variaveis
real peso [ 5 ] <- 0 , menor <- 0 , maior <- 0 , pesom <- 0 , pesot <- 0
inteiro i , cont <- 0
caracter sexo [ 5 ]
//entrada de dados
para i de 0 ate 4 passo 1
escrever "Informe o peso do " , ( i + 1 ) , "º aluno: "
ler peso [ i ]
escrever "Informe o código do sexo do " , ( i + 1 ) , "º aluno (Masculino= M; Feminino= F): "
ler sexo [ i ]
escrever "\n"
proximo
//testando o maior e menor peso
maior <- peso [ 1 ]
menor <- peso [ 1 ]
para i de 0 ate 4 passo 1
se ( peso [ i ] > maior ) entao
maior <- peso [ i ]
fimse
se ( peso [ i ] < menor ) entao
menor <- peso [ i ]
fimse
proximo
//calculando a media de peso dos homens
para i de 0 ate 4 passo 1
se ( sexo [ i ] = "M" ) ou ( sexo [ i ] = "m" ) entao
pesom <- ( pesom + peso [ i ] )
cont <- ( cont + 1 )
fimse
proximo
//calculando a media de peso da turma
para i de 0 ate 4 passo 1
pesot <- ( peso [ i ] + pesot )
proximo
//impressão dos dados
escrever "\nO maior peso é: " , maior , "\nO menor peso é: " , menor
escrever "\nA média de peso dos homens é: " , ( pesom / cont )
escrever "\nA média de peso da turma é: " , ( pesot / 5 )
fim
07/05: Revisão Lógica de Programação, com respostas :)
1. Desenvolver um programa que efetue a leitura de 5 elementos de uma matriz A do tipo vetor. Construir uma matriz B de mesmo tipo, observando a seguinte lei de formação: Se o valor do índice for par, o valor deverá ser multiplicado por 5, sendo ímpar deverá ser somado por 5. Ao final mostrar os conteúdos das duas matrizes.
inicio
//declaração dos vetores A e B
inteiro i,a[5],b[5]
//formação do vetor A
para i de 0 ate 4 passo 1
ler a[i]
proximo
//guarda valor na posição par
para i de 0 ate 4 passo 2
b[i]<-a[i]*5
proximo
//guarda valor na posição ímpar
para i de 1 ate 4 passo 2
b[i]<-a[i]+5
proximo
//apresenta valor B resposta
escrever "Formação do vetor B (vetor respota):"
escrever "\n"
para i de 0 ate 4 passo 1
escrever "O valor da posição ",i, " é: ", b[i]
escrever "\n"
proximo
fim
</syntaxhighlight>
Solução para o exercício 1 desenvolvida pelo Thiarlles e Manfred:
inicio
real matrizA[10], matrizB[10]
inteiro i<-0
escrever "\n Construa a matriz A."
enquanto i <= 9 faz
escrever "\n Entre com a posição ", i
ler matrizA[i]
i <- i+1
fimEnquanto
i <- 0
enquanto i <= 9 faz
escrever matrizA[i], " "
i <- i+1
fimEnquanto
escrever "\n "
i <- 0
enquanto i <= 9 faz
matrizB[i] <- ((matrizA[i])*5)
matrizB[i+1] <- ((matrizA[i+1])+5)
i <- i+2
fimEnquanto
i <- 0
escrever "\n A matriz B será: "
enquanto i <= 9 faz
escrever matrizB[i], " "
i <- i+1
fimenquanto
fim
</syntaxhighlight>
2. Desenvolver um programa que efetue a leitura de 5 elementos de uma matriz A do tipo vetor. No final, apresente o total da soma de todos os elementos que sejam ímpares.
inicio
//declaração das variáveis
inteiro a [5] , i , soma <- 0
//entrada de dados
para i de 0 ate 4 passo 1
ler a [i]
proximo
//construindo a matriz "B"
para i de 0 ate 4 passo 1
se ( a [i] % 2 =/= 0 ) entao
soma <- soma + a [ i ]
fimse
proximo
//impressão dos dados
escrever "O valor da soma dos numero ímpares é: " , soma
fim
</syntaxhighlight>
3. Ler 15 elementos de uma matriz A do tipo vetor. Construir uma matriz B de mesmo tipo. Observando a seguinte lei de formação: “Todo elemento de B deverá ser o quadrado do elemento de A correspondente”.
inicio
//declaração das variáveis
inteiro a[15] ,b[15] ,i
//entrada de dados
para i de 0 ate 14 passo 1
ler a[i]
proximo
//construindo a matriz "B"
para i de 0 ate 14 passo 1
b[i] <- a[i] * a[i]
proximo
//impressão dos dados
escrever "\nMatriz A:"
para i de 0 ate 14 passo 1
escrever "" , a[i]
proximo
escrever "\nMatriz B:"
para i de 0 ate 14 passo 1
escrever "" , b [i]
proximo
fim
</syntaxhighlight>
4. Escreva um algoritmo que:
- Leia uma matriz 5 x 5 de elementos reais;
- Divida cada elemento de uma linha da matriz pelo elemento da diagonal principal desta linha;
- Imprima a matriz assim modificada.
inicio
//declaração das variáveis
real a [5] [5] , b [5] [5]
inteiro i , j
//entrada de dados
para i de 0 ate 4 passo 1
para j de 0 ate 4 passo 1
ler a [i] [j]
proximo
proximo
//dividindo a linha da matriz por sua diagonal principal
para i de 0 ate 4 passo 1
para j de 0 ate 4 passo 1
b [i] [j] <- ( a [i] [j] / a [i] [i] )
proximo
proximo
//impressão dos dados
escrever "\nMatriz: "
escrever "\n"
para i de 0 ate 4 passo 1
escrever "\n" , a [i] [0] , " " , a [i] [1] , " " , a [i] [2] , " " , a [i] [3] , " " , a [i] [4]
proximo
escrever "\n\nMatriz modificada: "
escrever "\n"
para i de 0 ate 4 passo 1
escrever "\n" , b [i] [0] , " " , b [i] [1] , " " , b [i] [2] , " " , b [i] [3] , " " , b [i] [4]
proximo
fim
</syntaxhighlight>
5. Elabore um algoritmo para corrigir provas de múltipla escolha. Assuma que em cada prova encontraremos os seguintes dados: RM, NOME DO ALUNO, MATÉRIA e BIMESTRE, além de 10 questões numeradas de 1 até 10 e que cada questão possui 5 alternativas identificadas pelas letras de “a” até “e”. Primeiramente, o algoritmo deve ler o gabarito e o número de provas a serem corrigidas . A seguir, os dados das provas a serem corrigidas devem ser lidas. Ainda, o algoritmo deverá calcular e escrever:
- O RM, NOME DO ALUNO, MATÉRIA, BIMESTRE e a NOTA de cada aluno (assumindo que cada questão correta vale 1 ponto).
- A porcentagem de aprovação, assumindo que a nota mínima para aprovação é 6.
inicio
//declaração das variáveis
caracter gab [10] , resp [10]
inteiro i , qtdprova , cont <- 0 , aprovados <- 0
real nota <- 0
texto rm <- "" , aluno <- "" , mat <- "" , bimestre <- ""
//entrada de dados
para i de 0 ate 9 passo 1
escrever "Informe o gabarito da " , (i + 1) , "ª questão:"
ler gab [i]
proximo
escrever "Informe a quantidade de provas: "
ler qtdprova
//dados das provas
enquanto cont < qtdprova faz
escrever "**************************************************"
escrever "\nInforme RM: "
ler rm
escrever "Informe o nome do aluno: "
ler aluno
escrever "Informe a matéria: "
ler mat
escrever "Informe o bimestre: "
ler bimestre
//informando as respostas
para i de 0 ate 9 passo 1
escrever "Informe a resposta da " , (i + 1) , "ª questão:"
ler resp [i]
proximo
//corrigindo a prova
nota <- 0
para i de 0 ate 9 passo 1
se ( gab [i] = resp [i] ) entao
nota <- nota + 1
fimse
proximo
//informando a nota
escrever "A nota do(a) " , aluno , " é: " , nota , "\n\n"
//verificando aprovação do aluno
se ( nota >= 6 ) entao
aprovados <- ( aprovados + 1 )
fimse
cont <- ( cont + 1 )
fimenquanto
//imprimindo valores
escrever "\n**************************************************"
escrever "\nA quantidade de aprovados é: " , aprovados
fim
</syntaxhighlight>
13/05: Avaliação de Lógica de Programação (não será alterada)
Dicas para a avaliação (vale a pena revisar conceitos):
- Números primos
- Fatorial
- MDC: Máximo Divisor Comum
- MMC: Mínimo Múltiplo Comum
- Cálculo para série de Fibonacci
14/05: Linguagem C
- Introdução a linguagem C
- Primeiros Programas
- Compilador Gcc
- Para provocar: Teach Yourself Programming in Ten Years
- Apostila adotada: Curso de Linguagem C - Engenharia Elétrica - UFMG
20/05: Projeto Final da Disciplina
- Etapas de desenvolvimento:
- Desenha 1 onda
- Desenha 1 linha de ondas
- Desenha 1 matriz de tamanho fixo de ondas
- Desenha 1 matriz de tamanho variável de ondas (o usuário informa as dimensões)
- Mapeia 1 barco: latitude e longitude (vetor)
- Desenha o mar com 1 barco
- Mapeia 10 barcos: latitude e longitude (matriz)
- Desenha os 10 barcos
- Mapeia 10 barcos: latitude, longitude e se já foi atingido
- Pede ao usuário atirar
- Se o barco foi atingido, desenhar um X
- Ao final (todo os barcos atingidos): informar o usuário que venceu em 'n' movimentos
- Proposta de código que contempla:
- Bibliotecas e definições
- Declaração de constantes e variáveis
- Uso de variáveis com mesmo nome e diferentes escopos
- Vetor e matriz
- Operadores lógicos e matemáticos
- Expressões
- E/S
- Estruturas de decisão e repetição
- Funções
- Passagem de parâmetro por valor e por referência
- Acesso a uma matriz através de um vetor linear (função iniciaJogo)
- Ponteiros
Introdução a Linguagem C
Compilando o primeiro programa
- O clássico Hello World!
#include <stdio.h>
int main(int argc, char *argv[])
{
printf("Alô mundo!\n");
}
- Mostrando mensagens de na tela: puts e printf:
#include <stdio.h>
int main() {
int n;
n = 5;
puts("Demonstração de puts e printf");
printf("Valor de n: %d\n", n);
n = n + 1;
printf("Novo valor de n: %d\n", n);
return 0;
}
- Lendo dados do teclado: scanf
#include <stdio.h>
int main() {
int n;
printf("Digite um número inteiro: ");
scanf("%d", &n);
printf("Valor digitado foi %d\n", n);
return 0;
}
- Tipos de dados:
Portugol
C
Exemplo
inteiro
int
int x;
caracter
char
char letra;
real
float ou double
float pi = 3.1416;
texto
char * ou vetor de char
char * mensagem = "Hello world";
char palavra[16];
logico
qualquer tipo (valor 0 = Falso, qualquer outro valor = Verdadeiro)
int ok = 1;
char teste = 0;
Atividades
- Traduza para C os seguintes algoritmos Portugol:
1.
Inicio
inteiro x, y
Escrever "Digite um numero: ",
Ler x
Escrever "Digite outro numero: ",
Ler y
Escrever "Soma = ", x+y
Fim
2.
Inicio
inteiro x, y, z
Escrever "Digite um numero: ",
Ler x
Escrever "Digite outro numero: ",
Ler y
z <- x + y
Escrever "Soma = ", z
Fim
3.
Inicio
Inteiro n1, n2, n3, r
Escrever "Primeiro numero: "
ler n1
Escrever "Segundo numero: "
ler n2
Escrever "Terceiro numero: "
ler n3
r <- (n1 + n2 + n3) /3
Escrever "Media=", r
Fim
4.
Inicio
inteiro anos, dias
Escrever "Quantos anos se passaram ? "
Ler anos
dias <- anos * 365
Escrever "... então se passaram ", dias, " dias"
Fim
5.
Inicio
constante inteiro diasPorAno <- 365
inteiro anos, dias
Escrever "Quantos anos se passaram ? "
Ler anos
dias <- anos * diasPorAno
Escrever "... então se passaram ", dias, " dias"
Fim
21/05: Constantes e Variáveis
- Leitura das páginas da apostila online de C:
Atividade
- Traduza para C os seguintes algoritmos Portugol:
1
inicio
//declaração da variáveis
inteiro v [ 5 ] , i , j , troca
//entrada de dados
para i de 0 ate 4 passo 1
ler v [ i ]
proximo
//organizar em ordem crescente
para i de 0 ate 4 passo 1
para j de 0 ate 4 passo 1
se v [ i ] > v [ j ] entao
troca <- v [ i ]
v [ i ] <- v [ j ]
v [ j ] <- troca
fimse
proximo
proximo
//impressão dos dados
para i de 0 ate 4 passo 1
escrever "\n" , v [ i ]
proximo
fim
</syntaxhighlight>
2
inicio
//declaração dos vetores A e B
inteiro i,a[5],b[5]
//formação do vetor A
para i de 0 ate 4 passo 1
ler a[i]
proximo
//guarda valor na posição par
para i de 0 ate 4 passo 2
b[i]<-a[i]*5
proximo
//guarda valor na posição ímpar
para i de 1 ate 4 passo 2
b[i]<-a[i]+5
proximo
//apresenta valor B resposta
escrever "Formação do vetor B (vetor respota):"
escrever "\n"
para i de 0 ate 4 passo 1
escrever "O valor da posição ",i, " é: ", b[i]
escrever "\n"
proximo
fim
</syntaxhighlight>
3
inicio
real matrizA[10], matrizB[10]
inteiro i<-0
escrever "\n Construa a matriz A."
enquanto i <= 9 faz
escrever "\n Entre com a posição ", i
ler matrizA[i]
i <- i+1
fimEnquanto
i <- 0
enquanto i <= 9 faz
escrever matrizA[i], " "
i <- i+1
fimEnquanto
escrever "\n "
i <- 0
enquanto i <= 9 faz
matrizB[i] <- ((matrizA[i])*5)
matrizB[i+1] <- ((matrizA[i+1])+5)
i <- i+2
fimEnquanto
i <- 0
escrever "\n A matriz B será: "
enquanto i <= 9 faz
escrever matrizB[i], " "
i <- i+1
fimenquanto
fim
4
inicio
//declaração das variáveis
inteiro a [5] , i , soma <- 0
//entrada de dados
para i de 0 ate 4 passo 1
ler a [i]
proximo
//construindo a matriz "B"
para i de 0 ate 4 passo 1
se ( a [i] % 2 =/= 0 ) entao
soma <- soma + a [ i ]
fimse
proximo
//impressão dos dados
escrever "O valor da soma dos numero ímpares é: " , soma
fim
5
inicio
//declaração das variáveis
inteiro a[15] ,b[15] ,i
//entrada de dados
para i de 0 ate 14 passo 1
ler a[i]
proximo
//construindo a matriz "B"
para i de 0 ate 14 passo 1
b[i] <- a[i] * a[i]
proximo
//impressão dos dados
escrever "\nMatriz A:"
para i de 0 ate 14 passo 1
escrever "" , a[i]
proximo
escrever "\nMatriz B:"
para i de 0 ate 14 passo 1
escrever "" , b [i]
proximo
fim
Para referência: apostila online sobre linguagem C.
- Etapas de desenvolvimento:
- Desenha 1 onda
- Desenha 1 linha de ondas
- Desenha 1 matriz de tamanho fixo de ondas
- Desenha 1 matriz de tamanho variável de ondas (o usuário informa as dimensões)
- Mapeia 1 barco: latitude e longitude (vetor)
- Desenha o mar com 1 barco
- Mapeia 10 barcos: latitude e longitude (matriz)
- Desenha os 10 barcos
- Mapeia 10 barcos: latitude, longitude e se já foi atingido
- Pede ao usuário atirar
- Se o barco foi atingido, desenhar um X
- Ao final (todo os barcos atingidos): informar o usuário que venceu em 'n' movimentos
- Proposta de código que contempla:
- Bibliotecas e definições
- Declaração de constantes e variáveis
- Uso de variáveis com mesmo nome e diferentes escopos
- Vetor e matriz
- Operadores lógicos e matemáticos
- Expressões
- E/S
- Estruturas de decisão e repetição
- Funções
- Passagem de parâmetro por valor e por referência
- Acesso a uma matriz através de um vetor linear (função iniciaJogo)
- Ponteiros
- Uma versão do jogo implementado:
#include <stdio.h>
#define QTDE_BARCOS 2
int iniciaJogo(int *barcos, int *tiros, int *atingidos)
{
int barco;
for(barco=0; barco<QTDE_BARCOS; barco++)
{
printf("\nBarco número %d:\n", barco + 1); // O primeiro barco é o de no. zero :-)
printf("Informe a latitude do barco: ");
scanf("%d", barcos + 3*barco); // end. inicial (barcos)
// + qtde. objetos por linha
// * linhas
// + coluna (1o. elemento)
printf("Informe a longitude do barco: ");
scanf("%d", barcos + 3*barco + 1); // end. inicial (barcos)
// + qtde. objetos por linha
// * linhas
// + coluna (2o. elemento)
*(barcos + 3*barco + 2) = 0; // endereço inicial (barcos)
// + qtde. objetos por linha
// * linhas
// + coluna (3o. elemento)
}
*tiros = 0;
*atingidos = 0;
}
char desenhaPonto(int linha, int coluna, int barcos[QTDE_BARCOS][3])
{
int barco;
for (barco=0; barco<QTDE_BARCOS; barco++)
{
if (linha==barcos[barco][0] & coluna==barcos[barco][1])
{
if (barcos[barco][2] == 1)
{
return 'X';
}
}
}
return '~';
}
desenhaMar(int linhas, int colunas, char onda, int barcos[QTDE_BARCOS][3])
{
int linha;
int coluna;
int barco;
int tinhaBarco;
for (linha=1; linha<linhas; linha++)
{
for (coluna=1; coluna<colunas; coluna++)
{
printf("%c", desenhaPonto(linha, coluna, barcos));
}
printf("\n");
}
}
int seVenceu(int barcos[QTDE_BARCOS][3])
{
int barco;
int atingidos = 0;
for (barco=0; barco<QTDE_BARCOS; barco++)
{
if (barcos[barco][2] == 1)
atingidos++;
}
return atingidos;
}
int main(int argc, char* argv[])
{
const char onda= '~';
int barcos[QTDE_BARCOS][3];
int latitude;
int longitude;
int barco;
int tiros;
int atingidos;
if (argc < 3)
{
printf("Use: %s (qtde. de linhas) (qtde. de colunas).\n", argv[0]);
return -1;
}
// Inicia o jogo
iniciaJogo(&barcos, &tiros, &atingidos);
// Estrutura principal de repetição: vai atirando sem parar... :-P
while (1)
{
// Limpa a tela
system("clear");
// Desenha o mar
desenhaMar(atoi(argv[1]), atoi(argv[2]), onda, barcos);
atingidos = seVenceu(barcos);
if (atingidos == QTDE_BARCOS)
{
printf("\nParabéns! Venceu o jogo com %d tiros!\n", tiros);
return 0;
}
else
{
printf("\nTiros: %d\n", tiros);
printf("Alvos atingidos: %d.\n", atingidos);
printf("\nDigite latitude e longitude:\n");
printf("- Latitude: ");
scanf("%d", &latitude);
printf("- Longitude: ");
scanf("%d", &longitude);
for (barco=0; barco<QTDE_BARCOS; barco++)
{
if (latitude == barcos[barco][0] & longitude == barcos[barco][1])
{
barcos[barco][2] = 1;
atingidos++;
}
}
tiros++;
}
}
}
O tabuleiro
Representar o tabuleiro: etapas 1 a 4.
Etapa 1: desenhar uma onda
Conteúdos abordados:
Nessa etapa se deseja mostrar o estado de uma única posição do tabuleiro. Se o estado for "água", mostra-se uma onda (símbolo ~), e se for "navio" mostra-se X.
#include <stdio.h>
int main() {
// 0: agua
// 1: navio
int posicao = 1;
if (posicao == 0) {
printf("~");
} else {
printf("X");
}
}
Usou-se uma variável inteira para representar o estado da posição do tabuleiro. O valor 0 (zero) corresponde a "água", e 1 corresponde a "navio". Para testar o valor dessa variável, e mostrar ~ ou X, precisou-se de uma estrutura de decisão do tipo se (condição) então bloco_de instruções senão outro_bloco_de_instruções. Na linguagem C isso se faz com if (condição) { bloco de instruções } else {outro bloco de instruções}.
Etapa 2: desenhar uma linha de ondas
Nessa etapa deseja-se mostrar uma linha do tabuleiro. Por exemplo, para um tabuleiro de 10 colunas, uma linha deve aparecer assim (se tiver só "água'":
~ ~ ~ ~ ~ ~ ~ ~ ~ ~
O problema é parecido com o da etapa 1, mas agora deve-se mostrar o estado de cada posição de uma linha. Foi sugerido o uso de um vetor para representar os estados das posições em uma linha. Assim, imaginando-se uma linha com 10 posições, o vetor abaixo poderia ser usado para representar seus estados:
int linha[10];
Repare na semelhança entre a declaração de um vetor em C e em Portugol. A ideia é a mesma: ao declarar o vetor deve-se informar sua capacidade (quantas posições ele possui, o que corresponde a quantos valores ele é capaz de armazenar). No exemplo acima, o vetor de inteiros linha possui 10 posições, e assim é capaz de guardar 10 números inteiros.
A tarefa da etapa 2 portanto é testar cada posição do vetor linha: se for 0 deve-se mostrar ~(água), e se for 1 deve-se mostrar X (navio).
Conteúdos abordados:
#include <stdio.h>
int main() {
// 0: agua
// 1: navio
int linha[10] = {0,1,0,0,0,0,0,0,0,0};
int y;
y = 0;
while (y < 10) {
// Mostra ~ se posicao for agua, e X se for navio
if (linha[y] == 0) {
printf("~ ");
} else {
printf("X ");
}
y = y + 1;
}
}
28/05: O tabuleiro (etapas 3 e 4)
Conteúdos abordados:
Desenhando o tabuleiro completo
Dando continuidade à visualização do tabuleiro, agora deve-se desenhá-lo por completo na tela. Quer dizer, mostrar um tabuleiro com 10 linhas e 10 colunas, seguindo a abordagem das etapas 1 e 2.
- Para mostrar uma única casa do tabuleiro (etapa 1) usou-se uma variável inteira, cujo conteúdo representa o estado daquela casa (se água ou navio). Para mostrar uma linha usou-se um vetor com capacidade 10, com cada posição do vetor representando o estado da casa correspondente. Como se deve então fazer para mostrar todo o tabuleiro ?
Possível solução: usando uma matriz bidimensional para representar todas suas casas: #include <stdio.h>
int main() {
// 0: agua
// 1: navio
int tabuleiro[10][10] = {{0,1,1,0,1,0,0,0,0,0}, {0,0,1,0,0,0,0,0,0,0},
{0,0,0,0,1,0,0,0,0,1}, {0,1,1,0,1,0,0,0,0,0},
{0,0,0,0,1,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0},
{0,1,0,0,0,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0}};
int linha, coluna;
linha = 0;
while (linha < 10) {
coluna = 0;
while (coluna < 10) {
// Mostra ~ se posicao for agua, e X se for navio
if (tabuleiro[linha][coluna] == 0) {
printf("~ ");
} else {
printf("X ");
}
coluna = coluna + 1;
}
printf("\n");
linha = linha + 1;
}
}
- Mostrar o tabuleiro na tela parece ser em si um algoritmo. Ele precisa apenas que se informem quais os estados das casas do tabuleiro. Esse algoritmo ficaria bem se implementado em uma função.
#include <stdio.h>
// 0: agua
// 1: navio
// Obs: a matriz "tabuleiro" foi tornada uma variável global porque é difícil
// passar uma matriz como argumento de função. Assim ela pode ser acessada
// pela função "mostra_tabuleiro".
int tabuleiro[10][10] = {{0,1,1,0,1,0,0,0,0,0}, {0,0,1,0,0,0,0,0,0,0},
{0,0,0,0,1,0,0,0,0,1}, {0,1,1,0,1,0,0,0,0,0},
{0,0,0,0,1,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0},
{0,1,0,0,0,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0}, {0,1,1,0,1,0,0,0,0,0}};
int mostra_tabuleiro() {
int linha, coluna;
linha = 0;
while (linha < 10) {
coluna = 0;
while (coluna < 10) {
// Mostra ~ se posicao for agua, e X se for navio
if (tabuleiro[linha][coluna] == 0) {
printf("~ ");
} else {
printf("X ");
}
coluna = coluna + 1;
}
printf("\n");
linha = linha + 1;
}
}
int main() {
mostra_tabuleiro();
}
Funções
A função mostra_tabuleiro corresponde ao algoritmo para desenhar o tabuleiro na tela. O tabuleiro em si é representado pela variável tabuleiro, que tem escopo global (visível em todas as funções do programa). Neste momento é bom ler um pouco mais sobre funções na linguagem C:
Escopo de variáveis
- Texto obtido de: Uso de funções em C
Por escopo de uma variável entende-se o bloco de código onde esta variável é válida. Com base nisto, temos as seguintes afirmações:
- As variáveis valem no bloco que são definidas;
- As variáveis definidas dentro de uma função recebem o nome de variáveis locais
- As variáveis declaradas fora de qualquer função são chamadas de variáveis globais
- Os parâmetros formais de uma função (também conhecidos como argumentos da função) valem também somente dentro da função;
- Uma variável definida dentro de uma função não é acessível em outras funções, MESMO QUE ESSAS VARIÁVEIS TENHAM NOMES IDÊNTICOS.
Variáveis locais
No trecho de código a seguir tem-se um exemplo com funções e variáveis com nomes iguais.
#include <stdio.h>
void FUNC1() {
int B;
B = -100;
printf("Valor de B dentro da função FUNC1: %d\n", B);
}
void FUNC2() {
int B;
B = -200;
printf("Valor de B dentro da função FUNC2: %d\n", B);
}
void main() {
int B;
B = 10;
printf("Valor de B: %d\n", B);
B = 20;
FUNC1();
printf("Valor de B: %d\n", B);
B = 30;
FUNC2();
printf("Valor de B: %d\n", B);
}
O resultado de sua execução deve ser:
Valor de B: 10
Valor de B dentro da função FUNC1: -100
Valor de B: 20
Valor de B dentro da função FUNC2: -200
Valor de B: 30
Variáveis globais
O seguinte exemplo mostra o mesmo programa, porém fazendo com que a variável B seja global:
#include <stdio.h>
// Declaração da variável global B
int B;
void FUNC1() {
B = -100;
printf("Valor de B dentro da função FUNC1: %d\n", B);
}
void FUNC2() {
B = -200;
printf("Valor de B dentro da função FUNC2: %d\n", B);
}
void main() {
B = 10;
printf("Valor de B: %d\n", B);
B = 20;
FUNC1();
printf("Valor de B: %d\n", B);
B = 30;
FUNC2();
printf("Valor de B: %d\n", B);
}
O resultado de sua execução deve ser:
Valor de B: 10
Valor de B dentro da função FUNC1: -100
Valor de B: -100
Valor de B dentro da função FUNC2: -200
Valor de B: -200
E se existir um variável local com mesmo nome que uma global ? nesse caso, a variável local vai esconder a sua homônima global:
#include <stdio.h>
// Declaração da variável global B
int B;
void FUNC1() {
// no escopo desta função, esta variável local vai esconder a variável global B!
int B;
B = -100;
printf("Valor de B dentro da função FUNC1: %d\n", B);
}
void FUNC2() {
B = -200;
printf("Valor de B dentro da função FUNC2: %d\n", B);
}
void main() {
B = 10;
printf("Valor de B: %d\n", B);
B = 20;
FUNC1();
printf("Valor de B: %d\n", B);
B = 30;
FUNC2();
printf("Valor de B: %d\n", B);
}
O resultado de sua execução deve ser:
Valor de B: 10
Valor de B dentro da função FUNC1: -100
Valor de B: 20
Valor de B dentro da função FUNC2: -200
Valor de B: -200
Outra solução seria:
#include <stdio.h>
void main(void) {
int tabuleiroLinhas, tabuleiroColunas;
printf("Por favor, digite quantas linhas para o mar: ");
scanf("%d", &tabuleiroLinhas);
printf("Agora, digite quantas colunas para o mar: ");
scanf("%d", &tabuleiroColunas);
char mar[tabuleiroLinhas][tabuleiroColunas];
int barcoLinha, barcoColuna;
printf("Informe a linha do barco: ");
scanf("%d", &barcoLinha);
printf("E a coluna (do barco): ");
scanf("%d", &barcoColuna);
int linha, coluna;
for (linha = 0; linha < tabuleiroLinhas; linha++) {
for (coluna = 0; coluna < tabuleiroColunas; coluna++) {
mar[linha][coluna] = '~';
if (linha == barcoLinha-1 && coluna == barcoColuna-1) {
printf("*");
} else {
printf("%c", mar[linha][coluna]);
}
}
printf("\n");
}
}
Para fixar
- Escreva o programa para mostrar a tabuada de um número lido do teclado.
#include <stdlib.h>
#include <stdio.h>
/*
*
*/
int main(int argc, char** argv) {
int numero, c;
printf("Numero: ");
scanf("%d", &numero);
c = 1;
while (c < 11) {
printf("%d X %d = %d\n", numero, c, numero*c);
c++;
}
return (EXIT_SUCCESS);
}
- Reescreva o programa anterior, mas usando uma função para mostrar a tabuada.
#include <stdio.h>
int tabuada(int num) {
int c = 1;
while (c < 11) {
printf("%d X %d = %d\n", num, c, num*c);
c++;
}
}
int main(int argc, char** argv) {
int numero, c;
printf("Numero: ");
scanf("%d", &numero);
tabuada(numero);
return (EXIT_SUCCESS);
}
- Modifique o programa anterior para mostrar a tabuada de todos os números entre 1 e 10. Obs: não modifique a função tabuada!
- Escreva um programa para ler 10 números do teclado, e em seguida mostrar o maior e o menor número.
- Reescreva o programa anterior, mas criando as função "maior" e "menor", que retornam o maior e menor número de um vetor de tamanho arbitrário.
03/06 e 04/06: Feriado Nacional
- Continuando a representar os navios ... por enquanto somente os submarinos
- Ainda há o problema de esconder as casas do tabuleiro ainda não acertadas por tiros: a existência de um navio ou água em uma casa somente pode ser revelada após ser atingida por um tiro.
- A primeira versão do jogo: atirando no tabuleiro até descobrir todos os submarinos
- Como ler do teclado as coordenadas de um tiro ?
- Como contabilizar se acertou em mais um submarino, ou se foi água ?
- Como identificar que o jogador acertou todos os submarinos, e assim terminar o jogo ?
- Como contabilizar quantos tiros foram dados até descobrir todos os submarinos ?
- Tópico sobre linguagem C: continuando funções
- ... mais especificamente: passagem de parâmetros por valor e por referência
O laço principal do jogo ...
O jogo funciona com um laço principal, que lê as coordenadas do tiro e atualiza o tabuleiro apropriadamente:
Note que nesse laço devem-se contabilizar tanto quantos tiros já foram dados, quanto os navios que foram acertados. Esse último valor é necessário para decidir se o jogo já acabou.
11/06: Desenvolvimento do Projeto Final
Expansões Propostas
- Limitar a quantidade de tiros (dobro do número de barcos, por exemplo) e, caso o usuário não atinja todos os barcos, deve-se mostrá-los na tela.
- Oferecer a opção para o usuário escolher a dificuldade do jogo:
- '1' - Nível Fácil (número de tiros igual ao número de posições da matriz),
- '2' - Nível Normal (número de tiros igual a 3 vezes o número de barcos no tabuleiro),
- '3' - Nível Difícil (número de tiros igual a quantidade de barcos inseridos no tabuleiro).
- Tratar exceções de E/S, incluindo números fora dos limites - como por exemplo um barco fora do "mar".
- Alterar a interface para utilizar números para linhas e letras para colunas, além de permitir barcos de 3 tamanhos (sempre desenhados na horizontal): uma "casa", três "casas" e quatro "casas".
- Os barcos podem ser desenhados tanto na horizontal como na vertical.
- Gerar tiros aleatórios caso seja solicitado pelo usuário.
- Posicionamento dos barcos no tabuleiro também de forma aleatória caso seja solicitado pelo usuário.
- Informar a posição dos tiros e barcos por letra e número (como no jogo tradicional). Ex.: posição A1.
Dicas
- Entenda o problema, modele-o: utilize sempre que possível pseudocódigo / diagrama de bloco.
- Defina entradas, processamento e saídas do programa.
- Primeiro declare as variáveis, depois realize as expressões lógicas e matemáticas.
- Deixe claro (documente e idente o seu código) o escopo de cada função (principalmente o fim) das estrutura de decisão e de repetição (quando não forem visíveis início e fim na mesma tela).
17/06: Desenvolvimento do Projeto Final
- Dicas para utilização da função rand():
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main (){
srand(time(NULL)); //Plantando a semente :) função time() utiliza a biblioteca <time.h>
printf ("Um numero entre 0 e RAND_MAX (%d): %d\n", RAND_MAX, rand());
printf ("Um numero entre 0 e 99: %d\n", rand()%100);
printf ("Um numero entre 20 e 29: %d\n", rand()%10+20);
printf ("Um numero entre 0 e 5: %d\n", rand()%6); //pode ser interessante usar algo nesse estilo para o projeto.
printf("\a");
return 0;
}
- para atribuir os valores aleatórios gerados pode-se utilizar a função da seguinte forma:
variavel1 = rand() % 10; // até 10.
variavel2 = rand() % 30; // até 30.
18/06: Desenvolvimento do Projeto Final
24/06: Desenvolvimento do Projeto Final
25/06: Desenvolvimento do Projeto Final
- Em virtude do jogo do Brasil x Portugal, as aulas nesse dia terão início as 14:15 h.
01/07: Entrega do Projeto Final
- Itens a serem avaliados:
- Funcionalidades básicas:
- Organização e legibilidade do código (indentação e comentários).
- E/S: Montagem do tabuleiro.
- Posicionamento dos barcos no tabuleiro.
- Tiros disparados pelo usuário e contabilização de erros e acertos.
- Finalização do jogo quando forem acertados todos os barcos.
- Funcionalidades desejadas (expansões propostas).
- Entrevista com cada integrante da equipe:
- Cada integrante será arguido pelo professor com duas ou três questões.
- Cada integrante participará do processo de avaliação do colega de equipe.
02/07: Recuperação
- Atenção alunos que não conseguiram conceito mínimo (conceito C), no módulo de Lógica de programação:
- Avaliação de recuperação de lógica, utilizando linguagem C. Serão propostos dois problemas.
- Atenção alunos que não conseguiram conceito mínimo (conceito C) no projeto final da disciplina:
- Avaliação de recuperação de programação C. Serão propostos dois problemas.
08/07: Encerramento Disciplina
- Entrega de provas, conceitos finais.
- Discussões sobre os tipos de linguagens de programação utilizadas atualmente no mercado e as tendências para a área de telecomunicações.