Gustavo Quirino Ferreira FATEC

quarta-feira, 27 de outubro de 2010

Lista 25 out. 2

Faça um programa que mostre na tela o(s) número(s) dentro do intervalo entre 600 e 700 que sejam múltiplos de 5 e também de 7.

algoritmo "25 Outubro 2"
// Função : Procurar numeros multiplos de 5 entre 600 e 700
// Autor : Gustavo Ferreira
// Data : 26/10/2010
// Seção de Declarações 
var
   i:inteiro
inicio
// Seção de Comandos
   escreval("O numeros abaixo sao multiplos de 5 e tambem de 7")
   para i de 600 ate 700 passo 1 faca
        se ((i mod 5) = 0) entao
           se ((i mod 7) = 0) entao
              escreval(i)
           fimse
        fimse
   fimpara
fimalgoritmo

Lista 25 out. 1

Faça um programa que calcule a média aritmética de 35 alunos do curso de Algoritmos. Use comandos de repetição.

algoritmo "25 outubro 1"
// Função :
// Autor : Gustavo Ferreira
// Data : 26/10/2010
// Seção de Declarações 
var
   soma, aux :real
   i :inteiro
inicio
// Seção de Comandos
   para i de 1 ate 35 passo 1 faca
        escreval("Informe a media do aluno ",i,":")
        leia(aux)
        soma<- soma+aux
   fimpara
   escreva("A media aritmetica da turma foi: ",soma/35)
fimalgoritmo

Capitulo 4 Homens e mulheres

algoritmo "Homens e mulheres"
// Função :
// Autor : Gustavo Ferreira
// Data : 15/10/2010
// Seção de Declarações 
var
   quantidadeHomens,quantidadeMulheres,idadeHomens,idadeMulheres,idade:inteiro
   pesoMulheres,pesoHomens,peso:real
   sexo:caracter
inicio
   idade<-1
   quantidadeHomens<-0
   quantidadeMulheres<-0
   pesoMulheres<-0
   pesoHomens<-0
   repita
      escreva("Informe o sexo:")
      leia(sexo)
      se (sexo = "M") entao
         quantidadeHomens<-quantidadeHomens +1
         escreval("Informe o peso do homem:")
         leia(peso)
         pesoHomens<- pesoHomens + peso
         escreval("Informe a idade do homem:")
         leia(idade)
         idadeHomens<- idadeHomens + idade
      senao
         quantidadeMulheres<-quantidadeMulheres +1
         escreval("Informe o peso da mulher:")
         leia(peso)
         pesoMulheres<- pesoMulheres + peso
         escreval("Informe a idade da mulher:")
         leia(idade)
         idadeMulheres<- idadeMulheres + idade
      fimse
   ate (idade=0)
   
   escreval("Media de idade das mulheres:",idadeMulheres/quantidadeMulheres)
   escreval("Peso medio dos homens:",pesoHomens/quantidadeHomens)
   escreval("Media de idade de todos:",(idadeHomens+idadeMulheres)/(quantidadeHomens+quantidadeMulheres))
   escreval("Quantidade homens (%): ",(100*quantidadeHomens)/(quantidadeHomens+quantidadeMulheres))
   escreval("Quantidade mulheres (%): ",(100*quantidadeMulheres)/(quantidadeMulheres+quantidadeMulheres))
fimalgoritmo

Exercicio capitulo 4 Tabuada

Criar um algoritmo que peça um numero e faça a tabuada para ele.

algoritmo "Calcular tabuada"
// Função :
// Autor : Gustavo Ferreira
// Data : 15/10/2010
// Seção de Declarações 
var
   numero,contador:inteiro
inicio
   contador <- 1;
   escreval("Informe o numero para trabalhar")
   leia(numero)
   repita
      escreval(contador," X",numero," =",contador*numero)
      contador <- contador + 1
   ate (contador>10)
fimalgoritmo

Exercicio 18 capitulo 3

Tendo duas notas, quanto devera tirar na terceira para a media final ser maior que 6.

algoritmo "3.18"
// Função :
// Autor : Gustavo
// Data : 28/9/2010
// Seção de Declarações 
var
   nota1,nota2:real
inicio
   escreval("Informe a nota1:")
   leia(nota1)
   
   escreval("Informe a nota2:")
   leia(nota2)
   
   se (((nota1+nota2)/3)<6) entao
      escreva("Deve tirar ",(6-((nota1+nota2)/3))*3)
   senao
      escreva("Pode tirar 0 (zero) nessa prova, so com duas provas ja atingiu ",((nota1+nota2)/3):5:2)
   fimse
fimalgoritmo

Exercicio 17 capitulo 3

Quantas cartas você pode enviar.

algoritmo "3.17"
// Função : Calcular quantos cartas voce pode enviar
// Autor : Gustavo
// Data : 28/9/2010
// Seção de Declarações 
// Obs: Parece um algoritmo grande devido à quantidade de comentarios e o tamanho do nome das variaveis.
var
   dinheiro,precoEnvelope,precoSelo:real
   qtdeCartas,qtdeEnvelopes,qtdeSelos:real
   
   precoDuplaSeloEnvelope:real
   qtdeDuplaSeloEnvelope:real
inicio
   escreval("Informe a quantia em dinheiro:")
   leia(dinheiro)
   
   escreval("Informe o preco do selo:")
   leia(precoSelo)
   
   escreval("Informe o preco do envelope:")
   leia(precoEnvelope)
   
   escreval("Informe a quantidade de envelopes que voce tem:")
   leia(qtdeEnvelopes)
   
   escreval("Informe a quantidade de selos que voce tem:")
   leia(qtdeSelos)
   
   se (qtdeEnvelopes0) entao //sobrou envelopes...
      //Bom... vamos imaginar que sobrou 10 envelopes e nenhum selo, preciso nivelar esse déficit...
      //Tenho dinheiro para comprar selos para selar os envelopes que sobrou?
      //Parece confuso eu multiplicar o preco do selo pela qtde de envelopes, mas é que a quantidade de envelopes que sobrou é a quantidade de selos que terei que comprar
      se ((precoSelo*qtdeEnvelopes)<=dinheiro) entao //ufa... ou sobrou dinheiro ou foi a quantia exata, enfim, resoloveu o défit de selos
          qtdeDuplaSeloEnvelope<- qtdeDuplaSeloEnvelope + qtdeEnvolopes // mais cartas seladas...
          dinheiro<- dinheiro - (precoSelo*qtdeEnvelopes) //debitando a bufunfa...
          qtdeEnvelope<- 0
      senao
         //Bom... nao deu para comprar todos os selos..
         //imaginemos que cada selo custe 1 real, tenho 5 reais sobrando e preciso selar 10 envelopes. É óbvil que só vou conseguir selar metade, ou seja, 0.5 dos envelopes. Essa porcentagem de envelopes vezes o preco de cada selo dá a quantidade de selos que posso comprar.
         qtdeDuplaSeloEnvelope<- qtdeDuplaSeloEnvelope +  ((dinheiro)/(qtdeEnvelopes*precoSelo))*qtdeEnvelopes
         //Descontando dos envelopes que sobrou.
         qtdeEnvelopes<- qtdeEnvelopes - ((dinheiro)/(qtdeEnvelopes*precoSelo))*qtdeEnvelopes
         //debitando do dinheiro...
         dinheiro<- dinheiro - (((dinheiro)/(qtdeEnvelopes*precoSelo))*qtdeEnvelopes)*precoSelo
      fimse
   senao
      se (qtdeSelos>0) entao //sobrou selos...
         //Bom... vamos imaginar que sobrou 10 selos e nenhum envelope, preciso nivelar esse déficit...
         //Tenho dinheiro para comprar evelopes suficientes para usar os selos que sobrou?
         //Parece confuso eu multiplicar o preco do envelope pela qtde de selos que sobrou, é que precisarei comprar de envelopes a qtde de selos que sobrou.
         se ((precoEnvelope*qtdeSelos)<=dinheiro) entao //ufa... ou sobrou dinheiro ou foi a quantia exata, enfim, resoloveu o défit de envelopes
             qtdeDuplaSeloEnvelope<- qtdeDuplaSeloEnvelope + qtdeSelos // mais cartas seladas...
             dinheiro<- dinheiro - (precoEnvelope*qtdeSelos) //debitando a bufunfa...
             qtdeSelos<- 0
         senao
            //Bom... nao deu para comprar todos os envelopes..
            //imaginemos que cada envelope custe 1 real, tenho 5 reais sobrando e preciso usar meus 10 selos sobrando. É óbvil que só vou conseguir comprar metade dos envelopes necessarios, ou seja, 0.5 dos selos. Essa porcentagem de selo vezes o preco de cada envelope dá a quantidade de envelopes que posso comprar.
            qtdeDuplaSeloEnvelope<- qtdeDuplaSeloEnvelope +  ((dinheiro)/(qtdeSelos*precoEnvelope))*qtdeSelos
            //Descontando dos selos que sobrou.
            qtdeSelos<- qtdeSelos - (dinheiro)/(qtdeSelos*precoEnvelope))*qtdeSelos
            //debitando do dinheiro...
            dinheiro<- dinheiro - ((dinheiro)/(qtdeSelos*precoEnvelope))*qtdeSelos)*precoEnvelope
         fimse
      fimse
   fimse
   // No teste acima, veja que nao testei se sobrou os dois (selos e envelopes), pois é impossivel, pois se sobrou dos dois dari para fazer mais pares. (aula do joao, ou sobrou selo, ou e se somente selos, mas nao ambos)
   // Tambem nao testei se selos e envelopes foram zerados, pois se isso aconteceu, nao precisaria nivelar o deficit.
   // Bom, deficit's nivelado ou quase.
   
   //Agora vamos ver se sobrou dinheiro e ver quantos pares (1 envelope e 1 selo) posso comprar
   se (dinheiro>0) entao
      precoDuplaSeloEnvelope<- precoSelo+precoEnvelope
      escreval(dinheiro div precoDuplaSeloEnvelope)
      qtdeDuplaSeloEnvelope<- qtdeDuplaSeloEnvelope + (dinheiro div precoDuplaSeloEnvelope) // sem casas decimas, nao existe meia carta.
      //pronto, ja sabemos quantas cartas voce pode enviar usando somente o seu dinheiro.
      dinheiro<- dinheiro - (dinheiro div precoDuplaSeloEnvelope):5:2
   fimse
   
   //escreval(98.89871 div 1)
   escreval("Voce pode enviar ",qtdeDuplaSeloEnvelope," cartas")
   escreval("Sobrou ",qtdeEnvelopes," envelopes")
   escreval("Sobrou ",qtdeSelos," selos")
   escreva("Sobrou R$ ",dinheiro:5:2)
   
fimalgoritmo

terça-feira, 28 de setembro de 2010

Escreva um algoritmo que leia os nomes dos três candidatos ao Senado (para uma vaga) com
suas respectivas votações. O algoritmo deve escrever o nome do candidato mais votado. Por
exemplo,
Maior votação: João da Silva
No caso de haver empate entre dois (os mais votados) ou entre os três candidatos, devem ser
escritos os nomes desses candidatos. Por exemplo,
Maior votação: João da Silva, Maria do Socorro

algoritmo "2.16"
// Função :
// Autor : Gustavo
// Data : 28/9/2010
// Seção de Declarações 
var
   nomeCandidato1,nomeCandidato2,nomeCandidato3:literal
   votacaoCand1,votacaoCand2,votacaoCand3:inteiro
inicio
   escreval("Informe o nome e a votacao do candidato 1:")
   escreva("Nome: ")
   leia(nomeCandidato1)
   escreva("Votacao: ")
   leia(votacaoCand1)

   escreval("Informe o nome e a votacao do candidato 2:")
   escreva("Nome: ")
   leia(nomeCandidato2)
   escreva("Votacao: ")
   leia(votacaoCand2)
   
   escreval("Informe o nome e a votacao do candidato 3:")
   escreva("Nome: ")
   leia(nomeCandidato3)
   escreva("Votacao: ")
   leia(votacaoCand3)
   
   escreval
   
   //todo mundo ganhou...
   se ((votacaoCand1 = votacaoCand2) e (votacaoCand2 = votacaoCand3)) entao
      escreva("Maior votacao: ",nomeCandidato1,", ",nomeCandidato2,", ",nomeCandidato3)
   senao
      //se o candidato 1 é igual ao candidato 2, estao empatados. Se os dois forem maior que o 3, sao os vencedores
      se((votacaoCand1=votacaoCand2) e (votacaoCand1>votacaoCand3)) entao
         escreva("Maior votacao: ",nomeCandidato1,", ",nomeCandidato2)
      senao
         //se o candidato 1 é igual ao candidato 3, estao empatados. Se os dois forem maior que o 2, sao os vencedores.
         se ((votacaoCand1=votacaoCand3) e (votacaoCand1>votacaoCand2)) entao
            escreva("Maior votacao: ",nomeCandidato1,", ",nomeCandidato3)
         senao
            //se o candidato 2 é igual ao candidato 3, estao empatados. Se os dois forem maior que o 1, sao os vencedores.
            se ((votacaoCand2=votacaoCand3) e (votacaoCand2>votacaoCand1)) entao
               escreva("Maior votacao: ",nomeCandidato2,", ",nomeCandidato3)
            senao
               //Nao. Nao temos empate, vamos ver quem foi o vencedor.
               se ((votacaoCand1>votacaoCand2) e (votacaoCand1>votacaoCand3)) entao
                  escreva("Maior votacao: ",nomeCandidato1)
               senao
                  se ((votacaoCand2>votacaoCand1) e (votacaoCand2>votacaoCand3)) entao
                     escreva("Maior votacao: ",nomeCandidato2)
                  senao
                     //Nem precisa testar agora né? Pelas regras da probabilidade o candidato 3 venceu
                     escreva("Maior votacao: ",nomeCandidato3)
                  fimse
               fimse
            fimse
         fimse
      fimse
   fimse
fimalgoritmo