Profº Piva - Algoritmos - Capitulo 5.7) Escreva algoritmo que leia a 1ª prestação de uma conta e a taxa de juros e calcule e coloque em um vetor os valores das próximas 10 prestações.

algoritmo "taxa de juros de uma parcela"

var

parcela: vetor[1..10] de real

juros: real

i: inteiro

inicio

escreval ( "Informe o valor da primeira prestação: ")

leia (parcela[1])

escreva ("Informe o juros: ")

leia(juros)

parcela[1] <- parcela[1] + (parcela[1]*(juros/100))

 para i de 2 ate 10 faca

   parcela[i] <- parcela[1]

 fimpara

escreval ("O valor de todos as parcelas será: ", parcela[1])

fimalgoritmo

Profº Piva - Algoritmos - Capitulo 5.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).

Profº Piva - Algoritmos - Capitulo 5.5) Escreva 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“}

Profº Piva - Algoritmos - Capitulo 5.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  “União de vetores”
var
   vetA:vetor[1..5] de literal
   vetB:vetor[1..5] de literal
   vetC:vetor[1..5] de literal
   i, j, k : numérico
   achou : lógico
início
    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
  até i > 5
  i <-1
  repita
    vetC[i] <- vetA[i] 
     i <- i + 1
  até i > 5
   i <- 1
   k <- 5
repita
   j <- 1
   achou <- FALSO
   repita
      se vetB[i] = vetA[j] então
         achou <- VERDADEIRO
      fimse  
      j <- j+1
  até (j > 5) ou achou
     se não achou então
         vetC[k] <- vetB[i]
          k <- k+1
     fimse 
     i <- i+1
até i > 5
fimalgoritmo

Profº Piva - Algoritmos - Capitulo 5.8) A média (aritmética) móvel é uma média efetuada sobre um número especificado de pontos ou amostras. Quando se introduz uma nova amostra, descarta-se o valor da mais antiga, dando-se lugar à nova amostra. Quanto menor o número de amostras, mais sensível será a média em relação à nova amostra. Esse esquema de substituição faz da média móvel um instrumento valioso na análise de tendências. Escreva um algoritmo que calcule e escreva a média móvel. O algoritmo deverá executar um laço de leitura de valores maiores ou iguais a zero (as amostras); a introdução de um valor negativo servirá como indicador de término de leitura. Os valores lidos são colocados em um vetor V de 10 posições. Para cada valor fornecido, o algoritmo deverá escrever a média móvel calculada. Considere para a solução desse problema uma média móvel realizada sobre as 10 amostras mais recentes, armazenadas em um vetor. Supondo que em um determinado momento o vetor V tem os seguintes valores 8.9, 9.0, 9.5, 9.4, 8.7, 8.6, 8.7, 8.5, 8.8, 8.7 e o novo valor lido foi 9.1, o vetor V agora conterá 9.0, 9.5, 9.4, 8.7, 8.6, 8.7, 8.5, 8.8, 8.7, 9.1 A média móvel será 9.0 + 9.5+9.4+8.7+8.6+8.7+8.5+8.8+8.7+9.1/10 = 8.9 Se o próximo valor lido for 8.0, então o conteúdo do vetor V será: 9.5, 9.4, 8.7, 8.6, 8.7, 8.5, 8.8, 8.7, 9.1, 8.0 A média móvel será 9.5+9.4+8.7+8.6+8.7+8.5+8.8+8.7+9.1+8.0/10 = 8.8

algoritmo "Media Movel"
var
  valor,media,soma:real
  amostras:vetor [1..10] de real
  i,k,n:inteiro
  fim:logico
inicio
  n<-0
  fim<- falso
  i<-0
    Repita
      escreva ("Entra com amostra")
      leia (valor)
        se (valor < 0) entao
           fim <- verdadeiro
            senao
              se (n=10) entao
                para i de 1 ate 9 faca
                  amostras [i] <- amostras [i+1]
                fimpara
                 amostras [n] <- valor
                 k<-0
                 soma<-0
                para i de 1 ate 10 faca
                  se (amostras [i] >0) entao
                    soma <- soma + amostras[i]
                    k<-k+1
                  fimse
                fimpara
                media <- soma/k
                escreval ("A media movel =", media)
                 senao
                 n<-n+1
                  amostras [n] <- valor
                  k<-0
                  soma <-0
                  para i de 1 ate 10 faca
                    se (amostras [i] > 0) entao
                      soma <- soma + amostras [i]
                      k<- k+1
                    fimse
                  fimpara
                  media <- soma/k
                 escreval ("A media movel=", media)
             fimse
       fimse
       ate fim
fimalgoritmo

Profº Piva - Algoritmos - Capitulo 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
n,q,i,k:inteiro
vet:vetor[1..1000] de inteiro
inicio
      repita
            escreva("digite um numero(1-1000) :")
            leia(n)
      ate((n<1000) e (n>0))
      k<-1
      para i de 1 ate n faca
           se((i mod 2)=1)entao
           q<-i*i
             vet[k]<-q
             k<-k+1
           fimse
           fimpara
para i de 1 ate (k-1) faca
     escreval(vet[i])
     fimpara
      
fimalgoritmo

Profº Piva - Algoritmo - Capitulo 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 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
  nomes:vetor[1..6] de literal
  notas:vetor[1..6] de real
  n,nmax,nn:real
  i,k:inteiro
inicio
  i<-0
  repita
    i<-i+1
    escreval("Digite o nome")
    leia (nomes[i])
     se (nomes[i] <> " ") entao
       repita
         escreval ("Digite a nota")
         leia (notas [i])
       ate ((notas[i]<=10) e (notas [i]>=0))
     fimse
  ate ((i>5) ou (nomes [i]= " "))
       se (i>5) entao
       i<-5
       fimse
       k<-i
       nmax<-notas [i]
       para i de 2 ate k faca
           se (notas [i] >nmax) entao
             nmax <-notas [i]
           fimse
       fimpara
    escreval ("A listagem dos nomes e nn:")
    para i de 1 ate k faca
      nn<-notas [i]*(10/nmax)
      escreval (nomes [i], " - ", nn)
    fimpara       
fimalgoritmo

Profº Piva - Lista de Exercícios - 4)Faça um programa para achar todos os números inteiros e positivos entre dois números lidos (N1 e N2), tais que: a)Não terminem em zero; b)Se o dígito à direita for removido, o número restante seja divisor do número original. (ex: 39 (3 é divisor de 39).

Esse exercício não da certo!!
Não estou conseguindo fazer...alguém conseguiu???
obrigado
Silvia

Profº Piva - Lista de Exercícios - 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 (-). Ex.: 12 / 3 = 4 = 12-3=9-3=6-3=3-3=0 (4 vezes)

algoritmo "Subtração"
var
contador,n1,n2,divisao:real
inicio
contador<-0

escreva("Digite o divisor. ")

leia(n1)

escreva("Digite o dividendo. ")

leia(n2)

   se (n1>n2) entao
divisao<-n1
repita
divisao<-divisao-n2
contador<-contador+1
ate (divisao<N2)
    senao
    contador<-0
    fimse

escreval(n1," /",n2," =",contador)
fimalgoritmo

Profº Piva - Lista de Exercícios - 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 "Multiplicacao"
var
  conti,n1,n2,multiplicacao:inteiro
inicio
  multiplicacao<-0
  conti<-0
  escreva("Digite o numero:")
  leia (n1)
  escreva("Multplicado por:")
  leia (n2)
  Repita
  multiplicacao<-multiplicacao+n1
  conti<-conti+1
  ate (conti=n2)
  escreval(n1,"x",n2,"=",multiplicacao)
 fimalgoritmo

Profº Piva - Lista de Exercícios - 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 "Multiplos de 5 e 7 no intervalo de 600 a 700"
var  multiplos:inteiro
inicio 
  multiplos <-600 
  para multiplos de 600 ate 700 faca 
  se ((multiplos mod 5)=0) entao
  escreval ("Os multiplos de 5", multiplos)
  se ((multiplos mod 7)=0) entao
  escreval ("Os multiplos de 7", multiplos)
  fimse
  fimse
  multiplos <-multiplos+1 
 fimpara
fimalgoritmo