sexta-feira, 10 de dezembro de 2010

6)Escreva algoritmo que leia os nomes e conceitos dos alunos de uma turma de tamanho máximo 60. O algoritmo deverá, para todos os alunos lidos, colocar em uma matriz o nome do aluno na primeira coluna e sua situação na segunda coluna: "aprovado", se o conceito do aluno for superior a 0; "reprovado" caso contrário. Os conceitos vão de 0 a 4, estando reprovados os alunos cujo conceito é o 0. O algoritmo pára de ler quando o nome informado for "fim" ou tenham sido lidos o nome e o conceito de 60 alunos (tamanho máximo da turma)

algoritmo "Lista"

var
  nome: vetor [1..60] de literal
  conceito: vetor [1..60] de real
  mat: vetor [1..60,1..3] de literal
  i: inteiro
Inicio

  i <- 1
  Repita
    Escreva("Informe o Nome ",i, " : ")
    Leia(nome[i])
    Se(nome<>"fim")entao
      mat[i,1] <- nome[i]
      Escreva("Conceito (0-4): ")
      Leia(conceito[i])
      Enquanto (conceito[i] < 0) ou (conceito[i] > 4) FACA
        Escreval("O conceito deve estar entre 0 e 4.")
        Escreva("Conceito (0-4): ")
          Leia(conceito[i])
      Fimenquanto
      mat[i,2] <- conceito[i]
    Se(conceito[i]>0)entao
      mat[i,3] <- "Aprovado"
    Senao
      mat[i,3] <- "Reprovado"
    Fimse
    Fimse
    i <- i + 1
    Ate(nome[i]= "fim") ou (i > 60)

Fimalgoritmo

5) algoritmo que leia caracteres em dois vetores vetA e vetB, de cinco posições.

Após os dois vetores terem sido lidos, o algoritmo deverá colocar em um terceiro vetor vetC a diferença dos dois primeiro, i.e., os caracteres que estão contido em vetA e não estão contido em vetV. Por exemplo, se
vetA = { “A”, “E”, “F”, “6“,“?”}
e
vetB = { “F”, “3”, “?”, “F“,“H”,“E”}
então
vetC = { “A”,“6“}

algoritmo “Seleção”
var
  vetA: vetor [1..5] de caracter
  vetB: vetor[1..5] de caracter
  vetC: vetor[1..5] de caracter
  i,j,l: inteiro
inicio
  para i de 1 ate 5 faca
    escreva(“Digite o”,(i),” elemento do conjunto A: “)
    leia(vetA[i])
  fimpara
  para j de 1 ate 5 faca
    escreva(“Digite o”,(j),” elemento do conjunto B: “)
    leia(vetB[j])
  fimpara
  i<-1
  j<-1
  l<-1
  repita
    se (vetA[i]<>vetB[j])entao
      vetC[l]<-vetA[i]
      escreval(vetC[l])
    fimse
   i<-i+1
  ate(i=5)
fimalgoritmo

4) Escreva um algoritmo que leia caracteres em dois vetores vetA e vetB, de cinco posições.

Após os dois vetores terem sido lidos, o algoritmo deverá colocar em um terceiro vetor vetC o resultado da união dos dois primeiros, i.e., os caracteres que estão contidos em um ou outro vetor. Assuma que em um mesmo vetor não haverá caracteres repetidos, mas uma caracter contido em vetA poderá também estar contido em vetB. Nesse caso, apenas uma ocorrência é colocada em vetC. Por exemplo, se
vetA = { “A”, “E”, “F”, “6“,“?”}
e
vetB = { “F”, “3”, “?”, “F“,“H”,“E”}
então
vetC = { “A”, “E”, “F”, “6“,“?”,”E”,“H”}
algoritmo “Conjunto”
var
  vetA,vetB: vetor [1..5] de literal
  vetC: vetor [1..10] de literal
  i,j,k: inteiro
  log: logico
inicio
  escreva(“Elementos do conjunto A”)
  para i de 1 ate 5 faca
    escreva(“Digite o “,i,”o elemento de A: “)
    leia(vetA[i])
  fimpara
  escreval(“Elementos do conjunto B”)
  para i de 1 ate 5 faca
    escreva(“Digite o “,i, “o elemento de B: “)
    leia(vetB[i])
  fimpara
  k<-1
  para i de 1 ate 5 faca
    log <- FALSO
    para j de 1 ate 5 faca
      se (vetA[i]=vetA[j]) entao
         se(i>j) entao
            log <- VERDADEIRO
         fimse
      fimse
      se (vetA[i]=vetB[j]) entao
         log <- VERDADEIRO
      fimse
    fimpara
   se (log=FALSO) entao
      vetC[k] <- vetA[i]
      k <- k + 1
   fimse
  fimpara
  para i de 1 ate 5 faca
    log<- FALSO
    para j de 1 ate 5 faca
      se (vetB[i]=vetA[j]) entao
         log <- VERDADEIRO
      fimse
      se (vetB[i]=vetB[j]) entao
         se(i  > j) entao
            log <- VERDADEIRO
         fimse
      fimse
    fimpara
    se (log=FALSO) entao
      vetC[k] <- vetB[i]
      k <- k + 1
    fimse
  fimpara
fimalgoritmo

5-3) Seja o seguinte algoritmo:

algoritmo “semnome”
var
 veta: vetor[1..5] de literal
 vetb: vetor[1..5] de literal
 vetc: vetor[1..5] de literal
 i, j, k : inteiro
 achou:logico
inicio
 i <- 1
 repita
   escreva(“Entre com”, i, “o elemento do vetor A: “)
   leia(veta [i])
   escreva(“Entre com”, i, “o elemento do vetor B: “)
   leia(vetb[i])
   i<-i + 1
 ate (i>5)
 i <-1
 repita
   vetc[i] <- “”
   i<-i + 1
 ate (i > 5)
 i<-1
 k<-1
 repita
   j<-1
   achou<-FALSO
   repita
     se (veta[i]=vetb[i]) entao
       vetc[k] <- veta[i]
       escreval(vetc[k])
       k<-k+1
       achou<-VERDADEIRO
     fimse
   j <- j+1
   ate (j>5) ou (achou)
   i <-i+1
 ate (i>5)
fimalgoritmo
Determine o conteúdo final de vetC, mostrando o teste de mesa completo utilizado para tal,
supondo que os valores lido foram “k”, “d”, “j”, “s”, “d”, “k”, “s”, “j”, “h” e “m”, nessa ordem.
RESPOSTA: achou= falso

5-2) Escreva um algoritmo que leia o nome dos alunos de uma turma de tamanho indefinido

(mas não superior a 60) e sua nota em uma prova (0 a 10; o algoritmo deve verificar se a nota fornecida é válida). O algoritmo pára de ler quando o nome do aluno fornecido for vazio (“”). Para cada aluno, o algoritmo deve escrever seu nome e sua nota normalizada, dada pela fórmula: NNi = Ni X 10/Nmax (5.5)
Onde NNi é a nota normalizada do i-ésimo aluno, Ni é sua nota original, e Nmax é a nota máxima obtida dentre todos os alunos da turma.
algoritmo “Nota normalizada”
var
  nome:vetor[1..60] de literal
  nota:vetor[1..60] de real
  nn:vetor[1..60] de real
  i,j:inteiro
  maior:real
inicio
  i<-1
  j<-0
  maior<-0
  escreva(“Digite o nome do aluno: “)
  leia(nome[i])
  repita
  j<-j+1
    escreva(“Digite a nota: “)
    leia(nota[i])
    se(nota[i]>=0)e(nota[i]<=10)entao
      se(nota[i]>maior)entao
        maior<-nota[i]
      fimse
    senao
      escreval(“Nota inválida.”)
    fimse
  i<-i+1
    escreva(“Digite o nome do aluno: “)
    leia(nome[i])
  ate(nome[i]=”")
  para i de 1 ate j faca
    nn[i]<-nota[i]*10/maior
    escreval(nome[i],”:”,nn[i])
  fimpara
fimalgoritmo

5-1)Escreva um algoritmo que calcule e coloque em um vetor os números de 1 a n cuja raiz quadrada é um número inteiro ímpar. Por exemplo, 1, 9, 25, 49,…O valor de n deve ser lido, sendo que n ≤1000.

algoritmo “Raiz quadrada”
var
  x: vetor [1..1000] de inteiro
  n,i:inteiro
  total:real
inicio
    escreva(“Digite um número: “)
    leia(n)
    i<-1
    se (n<=1000) entao
      para i de 1 ate n faca
        se (i mod 2<>0)entao
          total<-raizq(i)
          se (total*total=i)entao
            escreval(“A raíz quadrada de”,i,” é”,total)
          fimse
        fimse
      fimpara
    senao
      escreva(“Número inválido.”)
    fimse
fimalgoritmo

domingo, 5 de dezembro de 2010

8) Fazer um programa para calcular a soma dos N primeiros números, onde N é lido.

algoritmo "Calcula a soma do número e seus antecessores"

var
  n,i,soma: inteiro

inicio
  escreva("Digite um número ")
  leia(n)
    para i de n ate 1 passo -1 faca
      soma<-i+soma
    fimpara
      escreval("A soma dos seus antecessores é:", soma)
fimalgoritmo

7) Leia um numero N (inteiro, positivo >5). Depois, leia para um determinado grupo de pessoas (N) as seguintes informações:

Idade
Peso
Sexo
Este programa deve fornecer como saída:
a) A média dos pesos dos homens;
b) A média das idades das mulheres;
c) Quantas mulheres acima de 25 anos;
algoritmo “Média de pesos e de idades”
var
  quantidadedepessoas,idade,m,idadetotal,mais25,l:inteiro
  peso,pesototal,mediapeso,mediaidade:real
  sexo:literal
inicio
   idade<-1
   l<-0
   mediapeso<-0
   escreva(“Digite a quantidade de pessoas:”)
   leia(quantidadedepessoas)
   se(quantidadedepessoas>5) entao
     para quantidadedepessoas de quantidadedepessoas ate 1 passo – 1 faca
       escreva(“Digite o sexo:”)
       leia(sexo)
       se (sexo = “masculino”) entao
         l<-l+1
         escreva(“Digite o peso:”)
         leia(peso)
         pesototal<-pesototal+peso
         escreva(“Informe a idade:”)
         leia(idade)
       senao
        m<-m+1
        escreva(“Informe o peso:”)
        leia(peso)
        escreva(“Informe a idade:”)
        leia(idade)
        idadetotal<-idadetotal+idade
        se(idade<25) entao
          mais25<-mais25+1
        fimse
       fimse
     fimpara
     mediapeso<-pesototal/l
     mediaidade<-idadetotal/m
     escreval(“Média do peso dos homens:”,mediapeso)
     escreval(“Média da idade das mulheres:”, mediaidade)
     escreval(“Mulheres acima de 25 anos:”,mais25 )
   senao
    escreval(“Número insuficiente de pessoas.”)
   fimse
fimalgoritmo

6) Faça um programa que seja capaz de calcular o resultado de uma operação de divisão inteira (x dividido y), utilizando-se para isso apenas do operador de subtração (-).

algoritmo "Calcula Divisão com subtração"

  var
    x,y,vezes,soma:inteiro

inicio
  y<-0
  soma<- 0
  escreva("Entre com um número:")
  leia(x)
  escreva("Entre com um número divisor:")
  leia(y)
   se(x
     escreva("Não é possível realizar uma divisão inteira")
   senao
     soma<-x
     vezes<-0
       repita
         soma<-soma-y
         vezes<-vezes+1
       ate(soma=0)
         escreval(x," / ",y," = ",vezes)
   fimse
fimalgoritmo

5) Faça um programa que seja capaz de calcular o resultado de uma operação de multiplicação (x vezes y), utilizando-se para isso apenas do operador de soma (+).

Ex.: 12 * 3 = 36 = 12+12+12 (3 vezes)
algoritmo “Multiplicação com operador de soma”
var
  total,multiplicador,multiplicando,i: inteiro
inicio
  total<-0
  i<-0
  escreva(“Digite o multiplicador:”)
  leia(multiplicador)
  escreva(“Digite o multiplicando:”)
  leia(multiplicando)
  se (multiplicando>0) entao
    repita
      total<-total+multiplicador
      i<-i+1
    ate (i=multiplicando)
      escreva (“O resultado é”,total)
  senao
    escreva (“O resultado é”,multiplicando)
  fimse
fimalgoritmo