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

12) Escreva um que leia um número e escreva sua representação em binário.

Para tal, o número decimal deve ser dividido (divisão inteira) sucessivamente por 2, até que não seja mais possível dividi-lo. O resto de cada divisão fornece cada bit da representação em binário. O primeiro resto corresponde ao bit mais à direita (menos significativo); o último resto corresponde ao bit mais à esquerda (mais significativo). Por exemplo, a representação em binário do número 10421 será obtida através da seguinte seqüência de divisões:

1ª divisão 10421 ÷ 2 = 5210; resto 1 (bit mais à direita);
2 ª divisão 5210 ÷ 2 = 2605; resto 0;
3 ª divisão 2605 ÷ 2 = 1302; resto 1;
4 ª divisão 1302 ÷ 2 = 651; resto 0;
5 ª divisão 651 ÷ 2 = 325; resto 1;
6 ª divisão 325 ÷ 2 = 162; resto 1;
7 ª divisão 162 ÷ 2 = 81; resto 0;
8 ª divisão 81 ÷ 2 = 40; resto 1;
9 ª divisão 40 ÷ 2 = 20; resto 0;
10 ª divisão 20 ÷ 2 = 10; resto 0;
11 ª divisão 10 ÷ 2 = 5; resto 0;
12 ª divisão 5 ÷ 2 = 2; resto 1;
13 ª divisão 2 ÷ 2 = 1; resto 0;
14 ª divisão 1 ÷ 2 = 0; resto 1 (bit mais à esquerda);

Logo, 10421

10 corresponde a 101000101101012

 

(em construção rs rs)
algoritmo “Conversão de decimal para binário”
var
  numero,bit,x,y:inteiro
inicio
  escreva(“Digite um número que corresponde na base 10: “)
  leia(numero)
  repita
    y<-numero mod 2
    escreva(y)
    x<-numero div 2
    numero<-x
  ate(numero<1)
fimalgoritmo

11) Escreva um algoritmo que leia um valor composto apenas de 0’s e 1’s representando um número na base decimal.

10) Decidiu-se, em uma linha de produção, fazer uma verificação da taxa diária de uso dos equipamentos.

Escreva um algoritmo que leia o código do equipamento e sua taxa de uso diária (número horas/dia). O algoritmo deve escrever:

a) a taxa de uso diária do equipamento mais usado; e

b) a soma das taxas de uso dos equipamentos cuja taxa é igual ou inferior a 5 horas/dia.

A entrada de dados deve ser finalizada quando o código de equipamento informado for negativo.

 

algoritmo “Equipamentos mais utilizados”

 var
  codigo:inteiro
  minuto,maior,total:real
inicio
  total<-0
  escreva(“Digite o código do equipamento. Para terminar, digite um número negativo: “)
  leia(codigo)
  repita
    escreva(“Digite a quantidade de minutos utilizado por dia: “)
    leia(minuto)
    se (maior
      maior<-minuto
    fimse
    se (minuto<=300)entao
      total<-total+minuto
    fimse
    escreva(“Digite o códgo do equipamento: “)
    leia(codigo)
  ate (codigo<0)
  escreval(“Quantidade de tempo do equipamento mais utilizado:”, maior,” minutos/d.”)
  escreval(“Soma das horas dos equipamentos menos utilizados:”,total,” minutos/d.”)

fimalgoritmo

9) Foi feita uma pesquisa para determinar a relação entre o peso das crianças nascidas em um certo período em uma certa região e o tipo de parto.

Para tal, foram tabulados os seguintes dados para cada criança: sexo (“M” para masculino e “F” para feminino), tipo de parto (“N” para normal e “C” para cesariana) e peso (em gramas).Escreva um algoritmo que fique lendo tais dados até que o sexo informado seja vazio (“ “). Após, o algoritmo deve calcular e escrever:

a) a porcentagem de crianças nascidas de parto normal e cesariana;

b) a porcentagem de crianças do sexo masculino nascidas de parto normal e cesariana;
c) a porcentagem de crianças do sexo feminino nascidas de parto normal e cesariana;
d) a porcentagem de crianças nascidas de partos normal com peso inferior a 2 kg; e

e) a porcentagem de crianças nascidas de cesariana com peso inferior a 2Kg.

algoritmo “Parto normal ou cesariana”
var
  sexo,f,m,x: literal
  parto,n,c: literal
  peso,pn,pc,normal,cesariana,mn,mc,fn,fc: real
  a,b,j,d,l,g,h,i,p: inteiro
inicio
a<-0
b<-0
j<-0
d<-0
l<-0
g<-0
h<-0
i<-0
p<- -1
 repita
  escreva(“Digite o sexo (m/f) ou x para terminar: “)
  leia(sexo)
  se (sexo=”m”)entao
    escreva(“Digite o tipo de parto (n/c): “)
    leia(parto)
      se (parto=”n”)entao
        a<-a+1
        escreva(“Digite o peso em gramas: “)
        leia(peso)
        se (peso<2000)entao
          b<-b+1
        fimse
      senao
        j<-j+1
        escreva(“Digite o peso em gramas: “)
        leia(peso)
        se (peso<2000)entao
          d<-d+1
        fimse
      fimse
  fimse
  se (sexo=”f”)entao
    escreva(“Digite o tipo de parto (n/c): “)
    leia(parto)
    se (parto=”n”)entao
      l<-l+1
      escreva(“Digite o peso em gramas: “)
      leia(peso)
      se (peso<2000)entao
        g<-g+1
      fimse
    senao
      h<-h+1
      escreva(“Digite o peso em gramas: “)
      leia(peso)
      se(peso<2000)entao
        i<-i+1
      fimse
    fimse
  fimse
 p<-p+1
 ate (sexo=”x”)
  normal<-(a+l)*100/p
  cesariana<-(j+h)*100/p
  mn<-a*100/p
  mc<-j*100/p
  fn<-l*100/p
  fc<-h*100/p
  pn<-(b+g)*100/p
  pc<-(d+i)*100/p
 escreval(“Porcentagem de crianças nascidas de parto normal e cesariana: “,normal,cesariana)
 escreval(“Porcentagem de meninos nascidos de parto normal e cesariana: “,mn,mc)
 escreval(“Porcentagem de meninas nascidas de parto normal e cesariana: “,fn,fc)
 escreval(“Porcentagem de crianças nascida de parto normal com menos de 2000 gramas: “,pn:2:3)
 escreval(“Porcentagem de crianças nascidas de parto cesariana com menos de 2000 gramas: “,pc:2:3)
fimalgoritmo

8) Escreva um algoritmo que lê o número de aulas ministradas (encontros) em uma determinada disciplina.

 A seguir, para cada aluno da disciplina, o algoritmo deve ler o código do aluno, suas notas nas três avaliações da disciplina e seu número de faltas. Com esses dados, o algoritmo calcula a média ponderada, com pesos respectivos de 4 para a maior nota e 3 para as outras duas, e escreve o código do aluno, suas três notas, a média calculada e uma mensagem “Aprovado”

a) se sua nota for maior ou igual a 6 e ele compareceu, ao menos, a 75% dos encontros; ou

b) se sua nota for maior ou igual a 8 e ele compareceu, ao menos a 50% dos encontros.

Em caso contrário, a mensagem mostrada é “Exame” se sua nota for menor do que 6 (mas o aluno compareceu a, no mínimo, 75% dos encontros) ou “Reprovado” se ele não compareceu a 75% dos encontros. O algoritmo pára de ler dados quando o código fornecido for 0 (não existe nenhum aluno com código zero; esse valor é apenas para indicar que não há mais alunos).

algoritmo “Aprovado ou reprovado”
var
  aulas,faltas:inteiro
  codigo,n1,n2,n3,media,presenca,por,maior,menor1,menor2: real
inicio
  escreva(“Digite a quantidade de aulas ministradas: “)
  leia(aulas)
  escreva(“Digite o código do aluno: “)
  leia(codigo)
  repita
    escreva(“Digite as três notas: “)
    leia(n1,n2,n3)
      se(n1>n2)entao
        se (n1>n3)entao
          maior<-n1
          menor1<-n2
          menor2<-n3
        senao
          maior<-n3
          menor1<-n1
          menor2<-n2
        fimse
      senao
        se(n2>n3)entao
          maior<-n2
          menor1<-n1
          menor2<-n3
        senao
          maior<-n3
          menor1<-n1
          menor2<-n2
        fimse
      fimse
    escreva(“Digite a quantidade de faltas: “)
    leia(faltas)
    media<-((maior*4)+(menor1*3)+(menor2*3))/10
    presenca<-aulas-faltas
    por<-presenca*100/aulas
    se (media>=6) e (por>=75)entao
      escreval(“Aluno: “,codigo)
      escreval(“Notas: “,n1,n2,n3)
      escreval(“Média: “,media)
      escreval(“Presença: “,por,”%”)
      escreval(“Aprovado.”)
    senao
      se (media>=8) e (por>=50)entao
        escreval(“Aluno: “,codigo)
        escreval(“Notas: “,n1,n2,n3)
        escreval(“Média: “,media)
        escreval(“Presença: “,por,”%”)
        escreval(“Aprovado.”)
      senao
        se (media<6) e (por>=75) entao
          escreval(“Aluno: “,codigo)
          escreval(“Notas: “,n1,n2,n3)
          escreval(“Média: “,media)
          escreval(“Presença: “,por,”%”)
          escreval(“Exame.”)
        senao
          escreval(“Aluno: “,codigo)
          escreval(“Notas: “,n1,n2,n3)
          escreval(“Média: “,media)
          escreval(“Presença: “,por,”%”)
          escreval(“Reprovado.”)
        fimse
      fimse
    fimse
    escreva(“Digite o código do aluno: “)
    leia(codigo)
  ate (codigo=0)
fimalgoritmo

7) Escreva um algoritmo que leia 30 conjuntos de dois valores, representando o nome de um candidato ao Senado e sua votação.

6) Deseja-se fazer uma pesquisa a respeito do consumo mensal de energia elétrica em uma determinada cidade.

5) Escreva um algoritmo que leia o nome, o sexo (“M” ou “F”), a altura e o peso de um grupo de 50 pessoas e informe:

a) as médias harmônicas das alturas dos homens e dos pesos das mulheres; e

b) o nome do homem mais alto e da mulher mais gorda.

 algoritmo “Média”
var
  h,i,j,l,m,n,pessoas: inteiro
  nomem,nomefinalm,nomeh,nomefinalh,sexo, masculino,feminino: literal
  peso,pesototal,mediapeso,altura,alturatotal,mediaaltura:real
  alturamaior,pesomaior:real
inicio
  escreva (“Digite o número de pessoas: “)
  leia(pessoas)
  h<-0
  i<-0
  m<-0
  j<-0
  l<-0
  n<-0
  alturatotal<-0
  pesototal<-0
  alturamaior<-0
  pesomaior<-0
  para h de 1 ate pessoas faca
    escreva (“Digite o sexo: “)
    leia (sexo)
    se (sexo=”masculino”) entao
      i<-i+1
      escreva (“Digite o nome: “)
      leia (nomeh)
      l<-l+1
      escreva (“Digite a altura: “)
      leia (altura)
      alturatotal<-alturatotal+altura
      se (altura>alturamaior) entao
        alturamaior<-altura
        nomefinalh<-nomeh
      fimse
    senao
      m<-m+1
      escreva (“Digite o nome: “)
      leia (nomem)
      n<-n+1
      escreva (“Digite o peso: “)
      leia(peso)
      pesototal<-pesototal+peso
      se (peso>pesomaior) entao
        pesomaior<-peso
        nomefinalm<-nomem
      fimse
    fimse
  fimpara
  mediaaltura<-alturatotal/i
  mediapeso<-pesototal/m
  escreval(“Média da altura dos homens: “,mediaaltura)
  escreval(“Média do peso das mulheres: “,mediapeso)
  escreval(“O homem mais alto é o “, nomefinalh,” com”,alturamaior,” metros.”)
  escreval(“A mulher mais pesada é a “,nomefinalm,” com”,pesomaior,” quilos.”)
fimalgoritmo

4) Num frigorífico existem 90 bois.

Cada boi traz preso no seu pescoço um cartão contendo um número de identificação e seu peso. Escreva um algoritmo que receba como entradas os números e pesos dos 90 bois. O algoritmo deve informar os números e os pesos do boi mais gordo e do boi mais magro.

algoritmo “Boi gordo e boi magro”
var
  i,j,l,boi: inteiro
  peso,pesomaior,pesomenor,identificacao:real
  identificacaog,identificacaom,identificacaofinalm,identificacaofinalg:real
inicio
  escreva(“Digite a quantidade de boi: “)
  leia(boi)
  i<-0
  j<-0
  l<-0
  pesomaior<-0
  pesomenor<-100000
  identificacaofinalg<-0
  identificacaofinalm<-0
  repita
    escreva(“Digite o número de identificação: “)
    leia(identificacao)
    escreva(“Digite o peso: “)
    leia(peso)
    i<-i+1
    se (peso>pesomaior)entao
      pesomaior<-peso
      identificacaofinalg<-identificacao
      j<-j+1
    fimse
    se (peso
      pesomenor<-peso
      identificacaofinalm<-identificacao
      l<-l+1
    fimse
   ate(i=boi)
  escreval(“O boi mais gordo é”,identificacaofinalg,” possui”,pesomaior,” quilos.”)
  escreval(“O boi mais magro é”,identificacaofinalm,” possui”,pesomenor,” quilos.”)
fimalgoritmo

3) Escreva um algoritmo que leia dois números inteiros positivos n e p e calcule e escreva o coeficiente binomial n de ordem p dado pela equação 1.2.

2) Escreva um algoritmo que leia um número n (n inteiro e n ≥ 0) e calcule seu fatorial.

 O fatorial de um número (representado por n!) é o produtório de 1 a n. É arbitrado que o fatorial de 0 é 1. Assim

 0! = 1 = 1

 

1! = 1 = 2
2! = 1 X 2 = 2
3! = 1 X 2 X 3 = 6
4! = 1 X 2 X 3 X 4 = 24
5! = 1 X 2 X 3 X 4 X 5 = 120
…
algoritmo “Fatorial”
var
  n,total,i,j:inteiro
inicio
  escreva (“Digite um número inteiro: “)
  leia(n)
    se (n=0)entao
      escreva (“O fatorial de 0 é: 1″)
    senao
      se (n>0)entao
      i<-0
      j<-1
      total<-1
        repita
          total<-total*j
          j<-j+1
          i<-i+1
        ate (i=n)
        escreva(“O fatorial de”,n,” é:”,total)
      fimse
    fimse
fimalgoritmo
ou
algoritmo “Fatorial”
var
  n,i,fatorial: inteiro
inicio
  escreva(“Digite um número: “)
  leia(n)
    fatorial<-1
    para i de 1 ate n faca
    fatorial<-fatorial*i
    fimpara
    escreval(“O fatorial de “,n,” é: “,fatorial)
fimalgoritmo

1)A operação de multiplicação, quando o multiplicador é um número inteiro, nada mais é do que??

uma sucessão de somas. Assim, por exemplo, 4X5 = 5+5+5+5 = 20. Escreva um algoritmo que leia o multiplicando e o multiplicador e, através de uma sucessão de somas, calcule e escreva o produto. O multiplicador é, necessariamente, um número inteiro. Porém, multiplicador e multiplicando podem ser 0 ou negativos. 

algoritmo “Multiplicando”
var
  multiplicador,multiplicando,i,total: inteiro
inicio
   escreva(“Digite o multiplicador:”)
   leia (multiplicador)
   escreva(“Digite o multiplicando:”)
   leia (multiplicando)
   total<-0
   i<-0
   se (multiplicador>=0) e (multiplicando>=0) entao
     se (multiplicando=0) entao
       escreva (“O total é:0″)
     senao
       repita
         total<-total+multiplicador
         i<-i+1
       ate (i=multiplicando)
       escreva (“O total é:”,total)
     fimse
   senao
     se (multiplicador<0) entao
       repita
         total<-total+multiplicador
         i<-i+1
       ate (i=multiplicando)
         escreva(“O total é:”,total)
     fimse
     se (multiplicando<0) entao
       repita
         total<-total+multiplicando
         i<-i+1
       ate (i=multiplicador)
         escreva (“O total é:”,total)
     fimse
   fimse
fimalgoritmo

18)Escreva um algoritmo que leia as notas das duas primeiras provas de um aluno (p1 e p2) e calcule qual o valor mínimo da terceira nota (p3), para que este aluno seja aprovado, considerando que a média aritmética mínima das três provas deva ser 6.0 para que o aluno seja aprovado.

algoritmo “Calcula a última nota”
var
  n1,n2,n3:real
inicio
  escreva(“Digite a primeira nota:”)
  leia (n1)
  escreva (“Digite a segunda nota:”)
  leia (n2)
  n3<-(18-(n1+n2))
  se (n3<=0)e(n3>=-2)entao
    escreva(“Aprovado. O aluno já atingiu a média.”)
  senao
    se (n3>=10.50)entao
    escreva (“Reprovado. A última nota terá que ser”,n3:4:2)
    fimse
  fimse
fimalgoritmo

17)Escreva um algoritmo que leia a quantia R$ em dinheiro que uma pessoa tem para enviar cartas, o preço PE de um envelope, o preço PS de um selo, a quantidade QS de selos que a pessoa já dispõe e a quantidade de envelopes QE que a pessoa também já dispõe. O algoritmo deve calcular e informar quantas cartas a pessoa pode enviar.

algoritmo “Quantidade de cartas enviadas”
var
  rs,pe,ps,ce:real
  qs,qe,qer,qce,qca,qsa,qea:real
inicio
   escreva(“Informe o dinheiro:”)
   leia(rs)
   escreva(“Informe o preco do envelope:”)
   leia(pe)
   escreva(“Informe o preco do selo:”)
   leia(ps)
   escreva(“Informe a quantidade de selos:”)
   leia(qs)
   escreva(“Informe o custo de envio:”)
   leia(ce)
   escreva(“Informe a quantidade de envelopes:”)
   leia(qe)
   ce<- pe+ps
   se(qe>qs) entao
     qer<-qe-qs
     se (qer*ps) <=rs entao
       rs<- rs-(qer*ps)
       qce<-qs
       qca<- rs div ce
       qce<-qce+qca
       senao
        qsa<- rs div ps
        qce<- qs+qsa
      fimse
      senao
      se (qs>qe) entao
          qer<- qs-qe
          se ((qer*pe)<= rs) entao
             rs<- rs – (qer *pe)
             qce <-qe
             qca<-rs div ce
             qce<- qce+qca
             senao
             qea <- rs div pe
             qce <- qe+qea
           fimse
           senao
              qce<-qs
              qca<-rs div ce
              qce<-qce +qca
           fimse
          fimse
       escreva(“Quantidade de cartas enviadas:”, qce)
fimalgoritmo