Informática Aplicada à Engenharia: 2011

sexta-feira, 25 de novembro de 2011

Aula 31 - 25.11.2011

algoritmo "Imóveis"

var
descricao: vetor [1..100] de caracter
rua: vetor [1..100] de caracter
bairro: vetor [1..100] de caracter
cidade: vetor [1..100] de caracter
uf: vetor [1..100] de caracter
aluguel: vetor [1..100] de logico
valor: vetor [1..100] de real
proxCod: inteiro

procedimento tituloSistema()
inicio
limpatela
escreval("================================")
escreval("Sistema de Comparação de Imóveis")
escreval("================================")
escreval("                __    ")
escreval("       _________||___ ")
escreval("      /____________\  ")
escreval("     /|   _     _  |\ ")
escreval("      |  | |   |_| |  ")
escreval("      |  | |       |  ")
escreval("--------------------------------")
fimprocedimento

procedimento menuPrincipal()
var op: caracter
inicio
enquanto (op <> "9") faca
   tituloSistema()
   escreval(".: MENU PRINCIPAL :. ")
   escreval("    1 - Incluir novo imóvel")
   escreval("    2 - Alterar imóvel")
   escreval("    3 - Remover imóvel")
   escreval("    4 - Listar imóveis")
   escreval("    5 - Escolher melhor imóvel")
   escreval("    9 - Sair")
   escreval("--------------------------------")
   op <- lerCaracter("Opção: ")
   se (op = "1") entao
      incluirNovoImovel()
   fimse
   se (op = "2") entao
      alterarImovel()
   fimse
   se (op = "3") entao
      excluirImovel()
   fimse
   se (op = "4") entao
      listarImoveis()
   fimse
fimenquanto
fimprocedimento

procedimento incluirNovoImovel()
var op: caracter
inicio
tituloSistema()
escreval("Inclusão de Imóvel")
escreval("------------------")
proxCod <- proxCod + 1
descricao[proxCod] <- lerCaracter("Digite a Descrição: ")
rua[proxCod] <- lerCaracter("Digite a Rua: ")
bairro[proxCod] <- lerCaracter("Digite o Bairro: ")
cidade[proxCod] <- lerCaracter("Digite a Cidade: ")
uf[proxCod] <- lerCaracter("Digite a UF: ")
aluguel[proxCod] <- lerLogico("É imóvel de aluguel (S/N): ")
valor[proxCod] <- lerReal("Valor: ")
escreval("------------------")
escreval("Imóvel cadastrado com sucesso!")
escreval("------------------")
escreval("Pressione ENTER para voltar ao menu.")
leia(op)
fimprocedimento

procedimento alterarImovel()
var op: caracter
cod: inteiro
inicio
tituloSistema()
escreval("Alteração de Imóvel")
escreval("-------------------")
cod <- lerInteiro("Digite o código a ser alterado: ")
se (cod < 1) ou (cod > proxCod) entao
   escreval("Código inválido! Pressione ENTER para voltar ao menu.")
   leia(op)
senao
   mostrarImovel(cod)
   escreval("------------------")
   descricao[cod] <- lerCaracter("Nova Descrição: ")
   rua[cod] <- lerCaracter("Nova Rua: ")
   bairro[cod] <- lerCaracter("Novo Bairro: ")
   cidade[cod] <- lerCaracter("Nova Cidade: ")
   uf[cod] <- lerCaracter("Nova UF: ")
   aluguel[cod] <- lerLogico("É imóvel de aluguel (S/N): ")
   valor[cod] <- lerReal("Novo Valor: ")
   escreval("------------------")
   escreval("Imóvel alterado com sucesso!")
   escreval("------------------")
   escreval("Pressione ENTER para voltar ao menu.")
   leia(op)
fimse
fimprocedimento

procedimento excluirImovel()
var op: caracter
confirmacao: logico
cod: inteiro
inicio
tituloSistema()
escreval("Exclusão de Imóvel")
escreval("------------------")
cod <- lerInteiro("Digite o código a ser excluído: ")
se (cod < 1) ou (cod > proxCod) entao
   escreval("Código inválido! Pressione ENTER para voltar ao menu.")
   leia(op)
senao
   mostrarImovel(cod)
   escreval("------------------")
   confirmacao <- lerLogico("Realmente excluir este imóvel? (S/N) ")
   se (confirmacao = VERDADEIRO) entao
      descricao[cod] <- ""
      escreval("------------------")
      escreval("Imóvel excluído com sucesso!")
      escreval("------------------")
      escreval("Pressione ENTER para voltar ao menu.")
      leia(op)
   fimse
fimse
fimprocedimento

procedimento listarImoveis()
var i: inteiro
op: caracter
inicio
tituloSistema()
escreval("Lista de Imóveis")
para i de 1 ate proxCod faca
   se (descricao[i] <> "") entao
      mostrarImovel(i)
   fimse
fimpara
escreval("----------------")
escreval("Pressione ENTER para voltar ao menu.")
leia(op)
fimprocedimento

procedimento mostrarImovel(cod: inteiro)
inicio
escreval("----------------")
escreval("Código ", cod)
escreval("   Descrição: ", descricao[cod])
escreval("   Rua: ", rua[cod], ", ", bairro[cod])
escreval("   Cidade: ", cidade[cod], "/", uf[cod])
escreval("   Aluguel: ", aluguel[cod])
escreval("   Valor: R$ ", valor[cod])
fimprocedimento

funcao lerCaracter(m: caracter): caracter
var v: caracter
inicio
escreva(m)
leia(v)
retorne v
fimfuncao

funcao lerInteiro(m: caracter): inteiro
var v: inteiro
inicio
escreva(m)
leia(v)
retorne v
fimfuncao

funcao lerReal(m: caracter): real
var v: real
inicio
escreva(m)
leia(v)
retorne v
fimfuncao

funcao lerLogico(m: caracter): logico
var v: caracter
inicio
escreva(m)
leia(v)
se (v = "S") ou (v = "s") entao
   retorne verdadeiro
senao
   retorne falso
fimse
fimfuncao

procedimento carregarValoresParaTeste()
inicio
proxCod <- proxCod + 1
descricao[proxCod] <- "apto 2q"
rua[proxCod] <- "ipiranga"
bairro[proxCod] <- "azenha"
cidade[proxCod] <- "poa"
uf[proxCod] <- "rs"
aluguel[proxCod] <- VERDADEIRO
valor[proxCod] <- 1000.0

proxCod <- proxCod + 1
descricao[proxCod] <- "apto 3q"
rua[proxCod] <- "azenha"
bairro[proxCod] <- "azenha"
cidade[proxCod] <- "poa"
uf[proxCod] <- "rs"
aluguel[proxCod] <- FALSO
valor[proxCod] <- 120000.0

proxCod <- proxCod + 1
descricao[proxCod] <- "casa"
rua[proxCod] <- "borges"
bairro[proxCod] <- "centro"
cidade[proxCod] <- "poa"
uf[proxCod] <- "rs"
aluguel[proxCod] <- VERDADEIRO
valor[proxCod] <- 1500.0

fimprocedimento

inicio
carregarValoresParaTeste()
menuPrincipal()
fimalgoritmo

quarta-feira, 23 de novembro de 2011

Aula 30 - 23.11.2011

Trabalho final
Continuação
- Procedimentos alterar() e excluir()

sexta-feira, 18 de novembro de 2011

Aula 29 - 18.11.2011

Projeto "Sistema de Comparação de Imóveis"

algoritmo "Imóveis"

var
descricao: vetor [1..100] de caracter
rua: vetor [1..100] de caracter
bairro: vetor [1..100] de caracter
cidade: vetor [1..100] de caracter
uf: vetor [1..100] de caracter
aluguel: vetor [1..100] de logico
valor: vetor [1..100] de real
proxCod: inteiro

procedimento tituloSistema()
inicio
limpatela
escreval("================================")
escreval("Sistema de Comparação de Imóveis")
escreval("================================")
escreval("            __    ")
escreval("   _________||___ ")
escreval("  /____________\  ")
escreval(" /|   _     _  |\ ")
escreval("  |  | |   |_| |  ")
escreval("  |  | |       |  ")
escreval("================================")
fimprocedimento

procedimento menuPrincipal()
var op: caracter
inicio
enquanto (op <> "9") faca
   tituloSistema()
   escreval("1 - Incluir novo imóvel")
   escreval("2 - Alterar imóvel")
   escreval("3 - Remover imóvel")
   escreval("4 - Listar imóveis")
   escreval("5 - Comparar imóveis")
   escreval("6 - Escolher imóvel")
   escreval("9 - Sair")
   escreval("================================")
   op <- lerCaracter("Opção: ")
   se (op = "1") entao
      incluirNovoImovel()
   fimse
   se (op = "4") entao
      listarImoveis()
   fimse
fimenquanto
fimprocedimento

procedimento incluirNovoImovel()
var op: caracter
inicio
tituloSistema()
escreval("Inclusão de Imóvel")
escreval("------------------")
proxCod <- proxCod + 1
descricao[proxCod] <- lerCaracter("Digite a Descrição: ")
rua[proxCod] <- lerCaracter("Digite a Rua: ")
bairro[proxCod] <- lerCaracter("Digite o Bairro: ")
cidade[proxCod] <- lerCaracter("Digite a Cidade: ")
uf[proxCod] <- lerCaracter("Digite a UF: ")
aluguel[proxCod] <- lerLogico("É imóvel de aluguel (S/N): ")
valor[proxCod] <- lerReal("Valor: ")
escreval("------------------")
escreval("Imóvel cadastrado com sucesso!")
escreva("Deseja cadastrar outro? (S/N) ")
leia(op)
se (op = "S") ou (op = "s") entao
   incluirNovoImovel()
fimse
fimprocedimento

procedimento listarImoveis()
var i: inteiro
op: caracter
inicio
tituloSistema()
escreval("Lista de Imóveis")
para i de 1 ate proxCod faca
   escreval("----------------")
   escreval("Código ", i)
   escreval("   Descrição: ", descricao[i])
   escreval("   Rua: ", rua[i], ", ", bairro[i])
   escreval("   Cidade: ", cidade[i], "/", uf[i])
   escreval("   Aluguel: ", aluguel[i])
   escreval("   Valor: R$ ", valor[i])
   escreval("----------------")
fimpara
escreval("Digite  para voltar ao menu principal.")
leia(op)
fimprocedimento

funcao lerCaracter(m: caracter): caracter
var v: caracter
inicio
escreva(m)
leia(v)
retorne v
fimfuncao

funcao lerInteiro(m: caracter): inteiro
var v: inteiro
inicio
escreva(m)
leia(v)
retorne v
fimfuncao

funcao lerReal(m: caracter): real
var v: real
inicio
escreva(m)
leia(v)
retorne v
fimfuncao

funcao lerLogico(m: caracter): logico
var v: caracter
inicio
escreva(m)
leia(v)
se (v = "S") ou (v = "s") entao
   retorne verdadeiro
senao
   retorne falso
fimse
fimfuncao

inicio
menuPrincipal()
fimalgoritmo

quarta-feira, 16 de novembro de 2011

Aula 28 - 16.11.2011

Início do trabalho final

Biblioteca pessoal

Código do livro, Título, Autor, Ano de publicação, Já lido, Páginas e Preço

Cadastro de filmes

Código, Título, Rating, Ano, Gênero, Já visto e Tempo total.

Cadastro de veículos

Código, Marca, Modelo, Ano, Cor, Portas, Opcionais e Preço.

Cadastro de pessoas

CPF, Nome, Sexo, Fone, Email, Dia e Mês de nascimento, Altura e Peso.

Cadastro de endereços

CEP, Rua, Bairro, Cidade, Estado, País,

Cadastro de cidades

Código, Nome, Estado, Qtde habitantes, Já fui, É capital e PIB anual

Cadastro de objetos pessoais

Código, Nome, Tipo, Comprado em (mm/aaaa), Preço, Onde está e Perdido.

Cadastro de computadores

Código, Marca, Processador, Qtde RAM, Qtde HD, É notebook e Preço.

Registro de Atendimento em Clínica Médica

Dia, mês e ano do atendimento, CPF ou RG, Nome, Sexo, Idade, Convênio e Valor.

Controle de pet-shop

Dia e mês, hora e minuto, nome do pet, raça, peso e descrição do serviço.

Controle de alimentação

Dia e mês, turno, alimento, quantidade, calorias e peso.

Controle de Treino de Academia

Dia, mês e ano, aparelho, exige peso, peso, séries e repetições.

Sistema de avaliações

Nome do aluno, Pergunta, Resposta 1, Resposta 2, Resposta 3, Resposta 4, Resposta 5, Resposta, Resposta certa. Ao final, calcular a nota do aluno.

Cadastro de músicas

Nome, Artista, Gênero, Ano, Tempo e se É ao vivo.

sexta-feira, 11 de novembro de 2011

[Lista de Exercícios]

1) Faça um procedimento que receba um valor inteiro e escreva, dentro do procedimento, se o número é positivo ou negativo.

2) Faça uma função que receba um valor inteiro e retorne se o valor é positivo ou negativo.

3) Faça um procedimento que receba um parâmetro por referência do tipo inteiro e o altere internamente para um valor 3 vezes maior caso seja ímpar e 2 vezes menor cada seja par. Mostrar o número ao final do algoritmo.

4) Faça uma função que receba um número inteiro positivo N como parâmetro e retorne a soma dos N números inteiros existentes entre o número 1 e esse número.

5) Faça um procedimento que substitua todos os valores negativos de um vetor de 25 números inteiros por zero sempre que a posição i do vetor for menor que zero. Faça outro procedimento que liste os 25 novos valores do vetor. Utilize os dois procedimentos no algoritmo.

quarta-feira, 9 de novembro de 2011

Aula 26 - 09.11.2011

Procedimentos e Funções
Forma de organizar o código que permite reutilizar operações repetitivas.

Procedimentos
Não retorna valores, apenas executa algo.
Pode receber parâmetros de entrada ou não.
Estes parâmetros podem ser por valor ou por referência.
---------------------------------------------
Passagem de parâmetros por valor:
---------------------------------------------

algoritmo "semnome"
var
 salario: real
procedimento darAumento(s: real)
inicio
  s <- s + (s * 0.1)
fimprocedimento
inicio
 leia(salario)
 darAumento(salario)
 escreval("Infelizmente seu salário não foi aumentado: ", salario)
fimalgoritmo

---------------------------------------------
Passagem de parâmetros por referência:
---------------------------------------------

algoritmo "semnome"
var
 salario: real
procedimento darAumento(var s: real)
inicio
  s <- s + (s * 0.1)
fimprocedimento
inicio
 leia(salario)
 darAumento(salario)
 escreval("Parabéns! Seu salário foi aumentado: ", salario)
fimalgoritmo

---------------------------------------------

Funções
Além de executar algo, retorna valor. Pode receber parâmetro de entrada ou não. Estes parâmetros podem ser por valor ou por referência.
---------------------------------------------
Exemplo:
---------------------------------------------

algoritmo "semnome"
var
 salario: real
funcao darAumento(s: real): real
inicio
  retorne s + (s * 0.1)
fimfuncao
inicio
 leia(salario)
 escreval("Parabéns! Seu salário foi aumentado: ", darAumento(salario))
fimalgoritmo

---------------------------------------------
[Lista de Exercícios]

1) Faça um procedimento que receba um valor inteiro e escreva, dentro do procedimento, se o número é positivo ou negativo.

2) Faça uma função que receba um valor inteiro e retorne se o valor é positivo ou negativo.

3) Faça um procedimento que receba um parâmetro por referência do tipo inteiro e o altere internamente para um valor 3 vezes maior caso seja ímpar e 2 vezes menor cada seja par. Mostrar o número ao final do algoritmo.

4) Faça uma função que receba um número inteiro positivo N como parâmetro e retorne a soma dos N números inteiros existentes entre o número 1 e esse número.

5) Faça um procedimento que substitua todos os valores negativos de um vetor de 25 números inteiros por zero sempre que a posição i do vetor for menor que zero. Faça outro procedimento que liste os 25 novos valores do vetor. Utilize os dois prccedimentos no algoritmo.

Aula 26 - 09.11.2011 - Extra

Segue abaixo um algoritmo feito no VisualG para servir de base para o estudo.

Para quem quiser fazer um "a mais" neste algoritmo, eu gostaria de vê-lo tendo a possibilidade de executar o jogo no formato "jogador x computador".

algoritmo "Jogo da Velha"
var
   matriz: vetor[1..3,1..3] de caracter
   coluna, linha: inteiro
   jogador1, jogador2, jogando, ganhador, letra, m: caracter
   fim_do_jogo: logico
   
inicio
escreval(" ==== JOGO DA VELHA ==== ")
// Lendo o nome dos jogadores...
escreva("Informe nome do jogador 1: ")
leia(jogador1)
escreva("Informe nome do jogador 2: ")
leia(jogador2)
// Mostrando matriz vazia...
para linha de 1 ate 3 faca
   m <- ""
   para coluna de 1 ate 3 faca
      m <- m + "   "
      se (coluna < 3) entao
         m <- m + "|"
      fimse
   fimpara
   escreval(m)
   escreval("---|---|---")
fimpara
escreval(" ")
// Enquanto a variável 'fim_do_jogo' não for verdadeira, continue jogando...
enquanto (fim_do_jogo = falso) faca
   // Verifica qual é o jogador da jogada...
   se (jogando = jogador2) entao
      jogando <- jogador1
      letra <- "X"
   senao
      jogando <- jogador2
      letra <- "O"
   fimse
   // Solicita a coluna/linha da jogada...
   escreva(jogando, ", digite a coluna da jogada: ")
   leia(coluna)
   escreva(jogando, ", digite linha da jogada: ")
   leia(linha)
   // Verifica se a posição já não foi usada...
   enquanto (matriz[coluna, linha] <> "") faca
      escreval("Posição já utilizada. Tente novamente!")
      escreva(jogando, ", digite a coluna da jogada: ")
      leia(coluna)
      escreva(jogando, ", digite linha da jogada: ")
      leia(linha)
   fimenquanto
   // Atribui a letra na coluna/linha que foi informada
   matriz[coluna, linha] <- letra
   
   // Mostra a matriz na tela.
   para linha de 1 ate 3 faca
      m <- ""
      para coluna de 1 ate 3 faca
         letra <- matriz[coluna, linha]
         se (letra = "") entao
            letra <- " "
         fimse
         m <- m + " " + letra + " "
         se (coluna < 3) entao
            m <- m + "|"
         fimse
      fimpara
      escreval(m)
      escreval("---|---|---")
   fimpara
   // Verifica se jogo já não acabou...
   fim_do_jogo <- verdadeiro
   para linha de 1 ate 3 faca
      para coluna de 1 ate 3 faca
         se (matriz[coluna, linha] = "") entao
            fim_do_jogo <- falso
         fimse
      fimpara
   fimpara
   // Verifica se houve ganhador na jogada
   se (matriz[1,1] <> "") entao
      // Testando a 1a. coluna...
      se (matriz[1,1] = matriz[1,2]) e (matriz[1,1] = matriz[1,3]) entao
         ganhador <- jogando
      fimse
      // Testando na diagonal...
      se (matriz[1,1] = matriz[2,2]) e (matriz[1,1] = matriz[3,3]) entao
         ganhador <- jogando
      fimse
      // Testando a 1a. linha...
      se (matriz[1,1] = matriz[2,1]) e (matriz[1,1] = matriz[3,1]) entao
         ganhador <- jogando
      fimse
   fimse
   se (matriz[2,1] <> "") entao
      // Testando a 2a. coluna...
      se (matriz[2,1] = matriz[2,2]) e (matriz[2,1] = matriz[2,3]) entao
         ganhador <- jogando
      fimse
   fimse
   se (matriz[3,1] <> "") entao
      // Testando a diagonal invertida..
      se (matriz[3,1] = matriz[2,2]) e (matriz[3,1] = matriz[1,3]) entao
         ganhador <- jogando
      fimse
      // Testando a 3a. coluna...
      se (matriz[3,1] = matriz[3,2]) e (matriz[3,1] = matriz[3,3]) entao
         ganhador <- jogando
      fimse
   fimse
   se (matriz[1,2] <> "") entao
      // Testando a 2a. linha...
      se (matriz[1,2] = matriz[2,2]) e (matriz[1,2] = matriz[3,2]) entao
         ganhador <- jogando
      fimse
   fimse
   se (matriz[1,3] <> "") entao
      // Testando a 3a. linha...
      se (matriz[1,3] = matriz[2,3]) e (matriz[1,3] = matriz[3,3]) entao
         ganhador <- jogando
      fimse
   fimse
   // Verifica se houve ganhador e termina o jogo
   se (ganhador <> "") entao
      fim_do_jogo <- verdadeiro
   fimse
fimenquanto
// Testando para ver se tem um ganhador...
se (ganhador = "") entao
   escreval("Não houve ganhar!!")
senao
   escreval("Parabéns ", ganhador, ". Você foi o vencedor!!")
fimse
fimalgoritmo

sexta-feira, 4 de novembro de 2011

Aula 25 - 04.11.2011

Resolução dos Exercícios

sexta-feira, 28 de outubro de 2011

Aula 24 - 28.10.2011

Vetores

Um vetor é uma coleção de variáveis de um mesmo tipo. Cada um dos elementos do vetor possui um valor e é unicamente identificado por um número inteiro, chamado índice do vetor.

Desta forma, um vetor possui um índice e um valor, podendo ser acessado da seguinte maneira:
n[2] <- 23

| 1 2 3

| 12 23 65

Um vetor pode ter mais do que apenas 1 dimensão.

Exemplo de vetor com 2 dimensões (tabela):

n[2][3] <- 22

1 2 3

1 12 11 65

2 33 23 32

3 21 22 23


Se o vetor possuir 3 dimensões será considerado um cubo e poderá ser acessado da seguinte maneira:

n[1][2][2] <- 44

Exercícios

EM AULA!!!

1) Faça um algoritmo que tenha um vetor de 10 elementos inteiros, atribua um número aleatório para cada índice do vetor e, depois, apresente na tela os valores atribuídos utilizando um comando de repetição para percorrer o vetor.
DICA:
r <- int(rand*60)+1 // Gera um número aleatório entre 1 e 60.

2) Faça um algoritmo que declare um vetor de seis elementos numéricos inteiros previamente preenchidos e mostre:
a)      A quantidade e a lista com os números pares encontrados;
b)      A quantidade e a lista com os números ímpares encontrados.

3) Escreva um algoritmo para ler 8 números inteiros que serão colocados em um vetor; terminada a leitura, calcular e imprimir o somatório e a média deles.

4)  Faça um algoritmo que carregue um vetor com 15 elementos inteiros e que verifique a existência de elementos iguais a outro inteiro a ser definido, mostrando as posições em que esses elementos ocorrem. Mostrar -1 caso o número não esteja presente no vetor.

VALENDO NOTA!!!
1) Faça um algoritmo que simule um menu de sistema com as seguintes opções:

..: Bem-vindo ao Sistema de Cadastros :..
1 - Arquivo
2 - Editar
9 - Sair

Ao escolher 1, mostrar o seguinte:

..: Bem-vindo ao Sistema de Cadastros :..
Arquivo
    1 - Abrir
    2 - Fechar
    9 - Voltar

Ao escolher 2, mostrar o seguinte:

..: Bem-vindo ao Sistema de Cadastros :..
Editar
    1 - Recortar
    2 - Copiar
    3 - Colar
    9 - Voltar

Ao escolher 9, perguntar: "Deseja realmente sair (S/N)?"
   Se escolher "s" ou "S", sai do sistema.

2) Desenvolver um algoritmo que gera as 6 dezenas da megasena, aleatoriamente. Importante: todos os números devem ser entre 1 e 60 e devem ser únicos, ou seja, não podem repetir.

Dica: o código abaixo gera em "r" um valor aleatório entre 1 e 60.

algoritmo "semnome"
var r: inteiro
inicio
r <- int(rand*60)+1
escreval(r)
fimalgoritmo

3)      Escreva um algoritmo que leia um vetor x[20] de reais e retorne:
a)      O maior valor e em qual posição ocorre
b)      O menor valor e em qual posição ocorre

4)      Dados dois vetores A e B, construa um algoritmo para intercalar os vetores de tal modo que um novo vetor C resultante possua todos os elementos existentes em A e B, conforme o exemplo: A{1,3,4,7} e B{2,5,6,8} = C{1,2,3,4,5,6,7,8}

5)      Dados dois vetores A e B, construa um algoritmo para fazer a diferença entre os vetores de tal modo que um novo vetor C resultante possua somente os elementos que existentes somente em A ou em B, conforme o exemplo: A{1,3,4,7} e B{1,5,7,8} = C{3,4,8}

quarta-feira, 26 de outubro de 2011

Aula 23 - 26.10.2011

Semana Acadêmica

quarta-feira, 19 de outubro de 2011

Aula 22 - 21.10.2011 (Exercícios)

1. Faça um algoritmo que leia 1 nome de aluno e 2 notas, calcule a média e, usando um comando ENQUANTO, pare de ler nomes e notas somente quando encontrar uma média maior do que 9. Ao final, mostrar a quantidade de alunos que foram lidos, a média geral das notas lidas e dar parabéns para o nome do aluno que atingiu a média mais alta.

2. Faça um algoritmo que simule uma calculadora que leia 2 números e 1 comando (+, -, *, /) e realize a operação correta sobre os dois números, mostrando o resultado. Faça um laço que pergunte ao usuário "Deseja sair (S/N)?" e somente finaliza o programa se o usuário escolher "s" ou "S".

3. Faça um algoritmo que simule um menu de sistema com as seguintes opções:

..: Bem-vindo ao Sistema de Cadastros :..
1 - Arquivo
2 - Editar
9 - Sair

Ao escolher 1, mostrar o seguinte:

..: Bem-vindo ao Sistema de Cadastros :..
Arquivo
    1 - Abrir
    2 - Fechar
    9 - Voltar

Ao escolher 2, mostrar o seguinte:

..: Bem-vindo ao Sistema de Cadastros :..
Editar
    1 - Recortar
    2 - Copiar
    3 - Colar
    9 - Voltar

Ao escolher 9, perguntar: "Deseja realmente sair (S/N)?"
   Se escolher "s" ou "S", sai do sistema.

4 - Desenvolver um algoritmo que gera as 6 dezenas da megasena, aleatoriamente. Importante: todos os números devem ser entre 1 e 60 e devem ser únicos, ou seja, não podem repetir.

Dica: o código abaixo gera em "r" um valor aleatório entre 1 e 60.

algoritmo "semnome"
var r: inteiro
inicio
r <- int(rand*60)+1
escreval(r)
fimalgoritmo

Aula 21 - 19.10.2011

Repetição, Iteração ou Laços
Permite repetir um bloco de comandos até uma condição booleana seja atendida. Existem 3 tipos:

Para

algoritmo "para"

var
   i: inteiro

inicio
   para i de 1 ate 5 faca
      escreval(i)
   fimpara

fimalgoritmo

Enquanto

algoritmo "enquanto"

var
   i: inteiro

inicio
   i <- 1
   enquanto (i<=5) faca
      escreval(i)
      i <- i+1
   fimenquanto
fimalgoritmo

Repita

algoritmo "repita"

var
   i: inteiro

inicio
   i <- 1
   repita
      escreval(i)
      i <- i+1
   ate(i>5)
fimalgoritmo

* Os exemplos acima imprimem na tela os números de 1 até 5.

quinta-feira, 13 de outubro de 2011

Aula 20 - 14.10.2011

Dicas quentes de Excel

Exercício de hoje

Fazer uma planilha excel para um sistema simples de Contas a Pagar.
Deve conter o seguinte layout:

A coluna "Paga" deve possuir uma seleção em lista com as opções "SIM" e "NÃO".
A coluna situação deve ter as seguintes regras:

Se for paga, mostra "Paga"
Se não for paga e estiver vencida, mostrar "Vencida há xxx dias"
Se não for paga e não estiver vencida, mostrar "Por vencer em xxx dias"
Ainda, nesta coluna, aplicar a formatação condicional para as cores indicadas.

Na célula do total, somar somente os valores que não foram pagos ainda utilizando a função SOMASE()
Aplicar o autofiltro em todas as colunas definidas.

domingo, 9 de outubro de 2011

Aula 19 - 07.10.2011

Excel - Aula prática

quarta-feira, 5 de outubro de 2011

Aula 18 - 05.10.2011

Excel
http://www.unifesp.br/proex/dac/eaoc/apostilas/excel_2003/apostila.pdf

sexta-feira, 30 de setembro de 2011

Aula 17 - 30.09.2011

Revisão da Prova

terça-feira, 27 de setembro de 2011

Aula 16 - 28.09.2011

Prova

quinta-feira, 22 de setembro de 2011

Aula 15 - 23.09.2011

a) Revisão para a prova
- Converter Decimal/Binário e Binário/Decimal
- Tabela ASCII
- Bits e Bytes
- Soma de binários
- AND, OR e NOT
- Fluxograma
- Algoritmos
- Tipos de Dados, Variáveis, Operadores e Precedência de operadores
- Comandos SE e PARA

b) Simulado

quarta-feira, 21 de setembro de 2011

Aula 14 - 21.09.2011

Exercícios para a prova - continuação
1) Faça um algoritmo que leia dois números quaisquer e, usando um comando para, faça a impressão na tela de todos os números entre eles, porém, em ordem decrescente. Exemplo: 3 e 8, ficaria 8,7,6,5,4,3

2) Faça um algoritmo que leia um número e, baseado neste e utilizando um comando para, leia outros tantos números e, ao final, diga qual é o maior e menor entre eles, bem como a média de todos.

sexta-feira, 16 de setembro de 2011

Aula 13 - 16.09.2011 - Continuação dos Exercícios

1) Faça um algoritmo que leia uma quantidade e, utilizando este número, faça um comando para que leia o nome de x quantidade de pessoas, tantas quantas informadas na quantidade lida.

2) Faça um algoritmo que leia dois números que irão determinar os limites do comando para, de forma que ao ser executado deverá mostrar quais números são pares e quais são ímpares.

3) Faça um algoritmo que, usando o comando para, imprima na tela o seguinte:
1 1 1 1 1 1
2 2 2 2 2 2
3 3 3 3 3 3
4 4 4 4 4 4
5 5 5 5 5 5
6 6 6 6 6 6

4) Faça um algoritmo que, usando o comando para, imprima na tela o seguinte:
1 1 1 1 1 1
1 2 2 2 2 1
1 2 3 3 2 1
1 2 3 3 2 1
1 2 2 2 2 1
1 1 1 1 1 1

quarta-feira, 14 de setembro de 2011

Aula 12 - 14.09.2011 - Exercícios

1) Faça um algoritmo que leia 2 números, verifica se o primeiro é menor que o segundo e, caso positivo, inicia um comando para somando todos contra todos. Exemplo: 2 e 5 ficaria 2 + 3 + 4 + 5 = 14

2) Faça um algoritmo que, usando o comando para, imprima na tela o seguinte:
1 1 1 1 1 1
2 2 2 2 2 2
3 3 3 3 3 3
4 4 4 4 4 4
5 5 5 5 5 5
6 6 6 6 6 6

3) Faça um algoritmo que, usando o comando para, imprima na tela o seguinte:
1 1 1 1 1 1
1 2 2 2 2 1
1 2 3 3 2 1
1 2 3 3 2 1
1 2 2 2 2 1
1 1 1 1 1 1

Curiosidade:

http://pt.wikipedia.org/wiki/Dia_do_Programador

segunda-feira, 12 de setembro de 2011

Aula 12 - 14.09.2011

4) Repetição, Iteração ou Laços
Permite repetir um bloco de comandos até uma condição booleana seja atendida. Existem 3 tipos:

Para

algoritmo "para"

var
   i: inteiro

inicio
   para i de 1 ate 5 faca
      escreval(i)
   fimpara

fimalgoritmo

Enquanto

algoritmo "enquanto"

var
   i: inteiro

inicio
   i <- 1
   enquanto (i<=5) faca
      escreval(i)
      i <- i+1
   fimenquanto
fimalgoritmo

Repita

algoritmo "repita"

var
   i: inteiro

inicio
   i <- 1
   repita
      escreval(i)
      i <- i+1
   ate(i>5)
fimalgoritmo

* Os exemplos acima imprimem na tela os números de 1 até 5.

Aula 11 - 09.09.2011

Conferência do exercício da aula passada.

quinta-feira, 1 de setembro de 2011

Aula 10 - 02.09.2011

Olá turma,
Conforme combinado, no dia 02.09 a aula será não-presencial e a presença estará vinculada à entrega de um trabalho. Abaixo estou trazendo os itens do trabalho que deverá ser entregue por e-mail até dia 08.09, quinta-feira da semana que vem, para que na aula do dia 09.09, sexta-feira, possamos corrigir.

O objetivo é gerar um arquivo .alg para cada um dos exercícios, por exemplo, _1.alg para o primeiro, _2.alg para o segundo e assim por diante.

Lista de Exercícios:

Algoritmo que receba um número e mostre uma mensagem caso este número seja maior que 10.
Algoritmo que leia dois valores distintos e informe qual é o maior.
Algoritmo que receba um número e diga se este número está no intervalo entre 100 e 200.
Algoritmo que receba dois números e, ao final, mostre a soma, subtração, multiplicação e a divisão dos números lidos.
Algoritmo que receba um número e mostre uma mensagem caso este número seja maior que 80, menor que 25 ou igual a 40.
Algoritmo que leia 10 números e mostre, a cada leitura, se o mesmo é positivo, negativo ou zero (usar o comando PARA).
Algoritmo para determinar o consumo médio de um automóvel, sendo fornecida a distância total percorrida pelo automóvel e o total de combustível gasto.
Algoritmo que lê o nome de um vendedor, o seu salário fixo e o total de vendas efetuadas por ele no mês (em dinheiro). Sabendo que este vendedor ganha 15% de comissão sobre suas vendas efetuadas, informar o seu nome e o salário que irá recebero ao final do mês.
Algoritmo que lê o nome de um aluno e as notas das três provas que ele obteve no semestre. Ao final, informar o nome do aluno, a sua média aritmética e se for aprovado ou não com média 7,0.
Ler uma temperatura em graus Celsius e apresentá-la convertida em graus Fahrenheit. A fórmula de conversão é °F = °C × 1,8 + 32, sendo F a temperatura em Fahrenheit e C a temperatura em Celsius.
Ler uma temperatura em graus Fahrenheit e apresentá-la convertida em graus Celsius. A fórmula de conversão é °C = (°F - 32)/1,8, sendo F a temperatura em Fahrenheit e C a temperatura em Celsius.
Algoritmo que efetue a apresentação do valor da conversão em real (R$) de um valor lido em dólar (US$). O algoritmo deverá solicitar o valor da cotação do dólar e também a quantidade de dólares disponíveis com o usuário.

IMPORTANTE:
* Para ter a presença na aula, o aluno terá que entregar 12 arquivos .alg pelo menos com a tentativa de resolução do exercício.
* Quem acertar todos, ganhará uma estrela.

quarta-feira, 31 de agosto de 2011

Aula 9 - 31.08.2011

4) Repetição, Iteração ou Laços
Permite repetir um bloco de comandos até uma condição booleana seja atendida. Existem 3 tipos:

Para

algoritmo "para"

var
   i: inteiro

inicio
   para i de 1 ate 5 faca
      escreval(i)
   fimpara

fimalgoritmo

Enquanto

algoritmo "enquanto"

var
   i: inteiro

inicio
   i <- 1
   enquanto (i<=5) faca
      escreval(i)
      i <- i+1
   fimenquanto
fimalgoritmo

Repita

algoritmo "repita"

var
   i: inteiro

inicio
   i <- 1
   repita
      escreval(i)
      i <- i+1
   ate(i>5)
fimalgoritmo

* Os exemplos acima imprimem na tela os números de 1 até 5.

quinta-feira, 25 de agosto de 2011

Aula 8 - 26.08.2011

VisuALG
Ambiente computacional didático que permite o estudo mais aprofundado dos algoritmos, através da codificação direta para execução em um computador.

<<Download aqui>>
- IMPORTANTE: descompactar o arquivo em um diretório qualquer do computador. Depois, execute-o normalmente (duplo clique sobre o arquivo .exe).

Links úteis:

VisualG - A linguagem: http://www.apoioinformatica.inf.br/visualg/linguagem.htm
VisualG - Funções: http://www.apoioinformatica.inf.br/visualg/funcoes.htm
Manual do Visual G: http://www.sudotec.org.br/upload/documentos/cartevg.pdf
Tutorial bem completo: www.guanabara.info/logica/Apostilas/VisuAlg_Ref.pdf

1) Forma padrão de um algoritmo

2) Variáveis

Forma intuitiva de armazenar os dados.
Consta de Identificação, Declaração e Atribuição.

Exemplos:
var
i: Inteiro;
nome: Caracter;
salario: Real;
casado: Lógico;

3) Desvios, Seleção ou Condição
Permite alterar o fluxo ou a sequência de execução natural do programa.

algoritmo "se"

var
   i: inteiro

inicio
   leia(i)
   se (i > 10) entao
      escreval("Número maior que 10")
   senao
      escreval("Número menor que 10")
   fimse
fimalgoritmo

segunda-feira, 22 de agosto de 2011

Aula 7 - 24.08.2011

1) Dados

Numéricos:

Inteiro: {0, 1, 2, 3, -5}
Reais: {0.5, 1.2, -0.645}

Literais:

Caracter: {'a', 'b', '1', '2'}
Cadeia de Caracteres: {"Brasil", "RS", "abc123"}

Lógico:

Valores possíveis: {verdadeiro, falso}

2) Operadores

Aritméticos: {+, -, *, /, \, %, ^}

+ soma numéricos e concatena literais: 3+2 = 5
- subtrai numéricos e altera o sinal de um numérico: 3-2 = 1
* multiplica numéricos: 3*2 = 6
/ divide numéricos: 3/2 = 1.5
\ divisão inteira: 3/2 = 1
% resto da divisão: 3%2 = 1 (também conhecido por MOD)
^ potenciação: 5^2 = 25

Relacionais: {=, <>, >, >=, <, <=}

= igualdade
<> diferença
> maior
>= maior ou igual
< menor
<= menor ou igual

Lógicos:

{E, OU, OU EXCLUSIVO e NÃO}

F	F	F
F	V	F
V	F	F
V	V	V

F	F	F
F	V	V
V	F	V
V	V	V

OU EXCLUSIVO

F	F	F
F	V	V
V	F	V
V	V	F

NÃO

F	V
V	F

3) Precedência de operadores

Parênteses ()
Potenciação
Multiplicação, Divisão, Divisão inteira, Resto
Adição, Subtração

4) Exercícios
Diga se é V ou F (Verdadeiro ou Falso):

2>3 =
5/2>2 =
5\2>2 =
11%2=1 =
8%3>2 =
5*3-4<>11 =
5*(3-4)<>11 =
(3^3=9) e (2^2=4) =
(6<8) ou (3>7) =
não (2<3) =
(5>=6 ou 6<7 ou não (a+5-6=8)) = {onde a=5}
((34>9 e 5+u=34) ou (5=15/3 e 8>12) = ((u = 29) e 8>12)) = {onde u=29}

sexta-feira, 19 de agosto de 2011

Aula 6 - 19.08.2011

Fluxograma
Desenvolva algoritmos em formato de fluxograma para as seguintes situações:

Algoritmo que receba um número e mostre uma mensagem caso este número seja maior que 10.
Algoritmo que leia dois valores distintos e informe qual é o maior.
Algoritmo que receba um número e diga se este número está no intervalo entre 100 e 200.
Algoritmo que receba dois números e, ao final, mostre a soma, subtração, multiplicação e a divisão dos números lidos.
Algoritmo que receba um número e mostre uma mensagem caso este número seja maior que 80, menor que 25 ou igual a 40.
Algoritmo que leia 10 números e mostre, a cada leitura, se o mesmo é positivo, negativo ou zero.
Algoritmo para determinar o consumo médio de um automóvel, sendo fornecida a distância total percorrida pelo automóvel e o total de combustível gasto.
Algoritmo que lê o nome de um vendedor, o seu salário fixo e o total de vendas efetuadas por ele no mês (em dinheiro). Sabendo que este vendedor ganha 15% de comissão sobre suas vendas efetuadas, informar o seu nome e o salário que irá recebero ao final do mês.
Algoritmo que lê o nome de um aluno e as notas das três provas que ele obteve no semestre. Ao final, informar o nome do aluno, a sua média aritmética e se for aprovado ou não com média 7,0.
Ler uma temperatura em graus Celsius e apresentá-la convertida em graus Fahrenheit. A fórmula de conversão é F = 9/5 (C+32), sendo F a temperatura em Fahrenheit e C a temperatura em Celsius.
Ler uma temperatura em graus Fahrenheit e apresentá-la convertida em graus Celsius. A fórmula de conversão é C = (5/9)*(F-32), sendo F a temperatura em Fahrenheit e C a temperatura em Celsius.
Algoritmo que efetue a apresentação do valor da conversão em real (R$) de um valor lido em dólar (US$). O algoritmo deverá solicitar o valor da cotação do dólar e também a quantidade de dólares disponíveis com o usuário.

quarta-feira, 17 de agosto de 2011

Aula 5 - 17.08.2011

Fluxogramas
Exercícios.

sexta-feira, 12 de agosto de 2011

Aula 4 - 12.08.2011

Algoritmo
Um algoritmo é uma sequência finita de instruções bem definidas e não ambíguas, cada uma das quais pode ser executada mecanicamente num período de tempo finito e com uma quantidade de esforço finita.

Um algoritmo deve ser construído da forma mais clara e objetiva possível, de maneira a permitir que qualquer pessoa/computador possa entendê-lo e executá-lo corretamente. A programação pode ser vista como a implementação de algoritmos para serem executados por um computador.

"Construir um algoritmo significa descrever passo-a-passo como resolver um problema".

Alguns links de apoio:

Abaixo, é mostrada uma animação do algoritmo de ordenação quicksort em ação:

Fluxograma

Fluxograma é uma representação gráfica que apresenta a sequência de um trabalho de forma analítica, caracterizando as operações, os responsáveis e/ou unidades organizacionais envolvidos no processo.

Notação básica:

Estruturas:

Exemplo:

sexta-feira, 5 de agosto de 2011

Aula 3 - 10.08.2011

Soma de Binários

0+0=0
0+1=1
1+0=1
1+1=fica 0 e transporte de 1 (para somar ao digito imediatamente à esquerda)
1+1+1= fica 1 e transporte de 1(para somar ao digito imediatamente à esquerda)

Exemplo:

Lógica Binária

NOT

O operador unário NOT, ou negação binária resulta no complemento do operando, ou seja, será um bit '1' se o operando for '0', e será '0' caso contrário, conforme podemos confirmar pela tabela de verdade, onde A é o bit de entrada e R é o bit-resposta, ou bit de saída:

|  A  |  R  |
 --+-----+-----+
   |  0  |  1  |
 --+-----+-----+
   |  1  |  0  |
 --+-----+-----+

AND

O operador binário AND, ou conjunção binária devolve um bit 1 sempre que ambos operandos sejam '1', conforme podemos confirmar pela tabela de verdade, onde A e B são bits de entrada e R é o bit-resposta, ou bit de saída:

|  A  |  B  |  R  |
 +-----+-----+-----+
 |  0  |  0  |  0  |
 +-----+-----+-----+
 |  0  |  1  |  0  |
 +-----+-----+-----+
 |  1  |  0  |  0  |
 +-----+-----+-----+
 |  1  |  1  |  1  |
 +-----+-----+-----+

OR

O operador binário OR, ou disjunção binária devolve um bit 1 sempre que pelo menos um dos operandos seja '1', conforme podemos confirmar pela tabela de verdade, onde A e B são os bits de entrada e R é o bit-resposta, ou bit de saída:

|  A  |  B  |  R  |
 +-----+-----+-----+
 |  0  |  0  |  0  |
 +-----+-----+-----+
 |  0  |  1  |  1  |
 +-----+-----+-----+
 |  1  |  0  |  1  |
 +-----+-----+-----+
 |  1  |  1  |  1  |
 +-----+-----+-----+

XOR

O operador binário XOR, ou disjunção binária exclusiva devolve um bit 1 sempre que o número de operandos igual a 1 é ímpar, conforme podemos confirmar pela tabela de verdade:

|  A  |  B  |  S  |
 +-----+-----+-----+
 |  0  |  0  |  0  |
 +-----+-----+-----+
 |  1  |  0  |  1  |
 +-----+-----+-----+
 |  0  |  1  |  1  |
 +-----+-----+-----+
 |  1  |  1  |  0  |
 +-----+-----+-----+

Link interessante e completo:

http://www.ebah.com.br/content/ABAAABUHMAK/apostila-informatica-cap-2-informatica-basica

quinta-feira, 4 de agosto de 2011

Aula 2 - 05.08.2011

Bit
Bit siginifica digito binário (Binary Digit). É a menor unidade de informação que o computador utiliza para processar e armazenar os dados. Um bit pode apresentar a informação em duas possibilidades: ou o bit é considerado "0" (desligado) ou o bit é considerado "1" (ligado). O bit pode ser apresentado de forma abreviada. Para abreviar o bit utilizamos o "b" (minúsculo). Exemplo: 10Mbps (10 Megabits por segundo).

Byte
Um Byte representa um conjunto de 8 bits. O byte pode aparecer abreviado. A abreviação do "B" (maiúsculo) indica o byte. Exemplo: 4GB (4 Gigabytes)

Byte (B)
    1 Byte = 8 bits

Kilobyte (KB)
    1 KByte = 1024 Bytes (2^10) Bytes.
    1 024 Byte = 8 192 Bits

Megabyte (MB)
    1 024 KB
    1 048 576 (2^20)Bytes
    8 388 608 Bits

Gigabyte (GB)
    1 024 MB
    1 048 576 KB
    1 073 741 824 (2^30) Byte
    8 589 934 592 begin_of_the_skype_highlighting            8 589 934 592      end_of_the_skype_highlighting Bits

Terabyte (TB)
    1 024 GB
    1 048 576 MB
    1 073 741 824 KB
    1 099 511 627 776 (2^40) Bytes
    8 796 093 022 208 Bits

Tabela ASCII - American Standard Code for Information Interchange
É uma codificação de caracteres de oito bits baseada no alfabeto inglês. Os códigos ASCII representam texto em computadores, equipamentos de comunicação, entre outros dispositivos que trabalham com texto. Desenvolvida a partir de 1960, grande parte das codificações de caracteres modernas a herdaram como base.

The ASCII table is divided in 3 sections:

Non printable, system codes between 0 and 31.
Lower ASCII, between 32 and 127. This part of the table (as shown below) originates from older, American systems, which worked on 7-bit character tables. Foreign letters, like and were not available then.
Higher ASCII, between 128 and 255. This part is programmable, in that you can exchange characters based on language you want to write in. Foreign letters are placed in this part and an example is shown below.

Dec	Char	Dec	Char	Dec	Char	Dec	Char	Dec	Char	Dec	Char
33	!	49	1	65	A	81	Q	97	a	113	q
34	"	50	2	66	B	82	R	98	b	114	r
35	#	51	3	67	C	83	S	99	c	115	s
36	$	52	4	68	D	84	T	100	d	116	t
37	%	53	5	69	E	85	U	101	e	117	u
38	&	54	6	70	F	86	V	102	f	118	v
39	'	55	7	71	G	87	W	103	g	119	w
40	(	56	8	72	H	88	X	104	h	120	x
41	)	57	9	73	I	89	Y	105	i	121	y
42	*	58	:	74	J	90	Z	106	j	122	z
43	+	59	;	75	K	91	[	107	k	123	{
44	,	60	<	76	L	92	\	108	l	124	\|
45	-	61	=	77	M	93	]	109	m	125	}
46	.	62	>	78	N	94	^	110	n	126	~
47	/	63	?	79	O	95	_	111	o	127	_
48	0	64	@	80	P	96	`	112	p

Mas afinal, como um byte pode armazenar 256 valores somente com 8 bits? É possível porque 2^8 = 256. O cálculo binário para decimal é relativamente simples, basta saber qual bit está ligado e somar:

Converter Binário para Decimal:

00000000 = 0
11111111 = 255

bit 0 = 2^0 = 1
bit 1 = 2^1 = 2
bit 2 = 2^2 = 4
bit 3 = 2^3 = 8
bit 4 = 2^4 = 16
bit 5 = 2^5 = 32
bit 6 = 2^6 = 64
bit 7 = 2^7 = 128
---
Total.......: 256 possibilidades

Exemplo:
- bit 5 ligado.....: 00100000 = 32
- bit 5 e 0 ligados: 00100001 = 33
- bit 6 e 0 ligados: 01000001 = 65

Se analisarmos na tabela ASCII:
- O decimal 32 é o espaço em branco.
- O decimal 33 é o (!).
- O decimal 65 é o (A).

Converter Decimal para Binário:

Para realizar a conversão utilizamos método de Divisão Repetida. Para converter por exemplo, o número decimal 1985 em binário procedemos como segue:
- Divida o número decimal por 2 (dois), se o resultado for exato anote o valor 0 (zero), se não for exato anote o valor 1 (um), lembrando que esse valor deve ser anotado da direita para a esquerda ou como explicado abaixo do exemplo;
- Pegue a parte inteira do resultado e repita a operação sucessivamente até se obter 0 (zero) como parte inteira, como segue o exemplo abaixo:

1985 / 2 = 992,5 = 1
 992 / 2 =  496  = 0
 496 / 2 =  248  = 0
 248 / 2 =  124  = 0
 124 / 2 =   62  = 0
  62 / 2 =   31  = 0
  31 / 2 =  15,5 = 1
  15 / 2 =  7,5  = 1
   7 / 2 =  3,5  = 1
   3 / 2 =  1,5  = 1
   1 / 2 =  0,5  = 1

1985 = 11111000001