Algoritmos - Lógica para Desenvolvimento de Programação de Computadores (Resposta Dos Exercícios)

Gabarito dos Exerccios de Fixao do livro
Gabarito dos Exerccios

de Fixao do Livro
28 Edio
Sumrio
1 - Informaes Gerais .................................................................................................................................................................................. 4
1.1 - Base Tecnolgica para o Ensino de Lgica de Programao .......................................................................................................... 4
1.2 - Competncias e Habilidades ............................................................................................................................................................ 4
1.3 - Contedo de Programao de Computadores Abordado na Obra ................................................................................................... 4
2 - Gabarito dos Exerccios ........................................................................................................................................................................... 6
3 - Exerccios de Fixao do Captulo 3 ........................................................................................................................................................ 6
4 - Exerccios de fixao do captulo 4 ........................................................................................................................................................ 14
5.1 - Lao de repetio pr-teste - controle condicional verdadeiro ....................................................................................................... 23
5.2 - Lao de repetio pr-teste - controle condicional falso ................................................................................................................. 35
5.3 - Lao de repetio ps-teste - controle condicional falso ................................................................................................................ 47
5.4 - Lao de repetio ps-teste - controle condicional verdadeiro ....................................................................................................... 58
5.5 - Lao de Repetio Condicional Seletivo ........................................................................................................................................ 70
5.6 - Lao de Repetio Incondicional .................................................................................................................................................... 81
7 - Exerccios de fixao do captulo 7 ...................................................................................................................................................... 103
10 - Exerccios de fixao do captulo 10 .................................................................................................................................................. 162
Algoritmos - Lgica para Desenvolvimento de Programao de Computadores
1 - Informaes Gerais
1.1 - Base Tecnolgica para o Ensino de Lgica de Programao
Normalmente a base tecnolgica da lgica de programao para computadores ministrada em vrios cursos da rea de Tecnologia
da Informao (tambm denominada por algumas pessoas como rea de Informtica), seja em nvel tcnico (cursos tcnicos de nvel
mdio), nvel tecnolgico (cursos tcnicos de nvel superior), bacharelado (cursos de nvel superior, tais como Sistemas de Informao,
Cincia da Computao, Engenharia da Computao, entre outros), cursos de treinamento empresarial e cursos livres, com algumas
denominaes diferentes, a saber:
Algoritmos e Lgica de Programao;

Algoritmos e Pseudocdigos;
Algoritmos;
Lgica Computacional;
Lgica de Programao de Computadores;
Lgica de Programao;
Lgica;
Tcnicas de Programao - Lgica;
Estudo de Algoritmos Computacionais;
Introduo Lgica de Programao;
Introduo ao Algoritmo;
Linguagem e Tcnica de Programao;
Lgica Aplicada Programao de Computadores;
Lgica de Programao - Algoritmos;
Tcnicas Bsicas de Programao de Computadores;
Tcnicas de Programao - Algoritmos;
Entre outras possveis denominaes.
Independentemente da nomenclatura utilizada para design-la, fica evidente a necessidade de desenvolver as habilidades de raciocnio
lgico aplicado programao de computadores, por meio da utilizao e implementao de algoritmos computacionais. Neste sentido,
a obra qual este gabarito pertence busca atender seu pblico, respeitando as estruturas definidas de programao de acordo com a
norma internacional ISO 5807:1985 no que tange elaborao de diagramas de blocos (e no fluxogramas) e com as estruturas de
PDL (Program Design Language) propostas por Caine e Gordon na elaborao dos cdigos em portugus estruturado.
1.2 - Competncias e Habilidades

O aprendizado da lgica de programao de computadores baseado na obteno preliminar das seguintes competncias:
Desenvolver algoritmos por meio da diviso estruturada com sub-rotinas e tambm com orientao a objetos;
Desenvolver algoritmos por meio da ao de refinamento sucessivo;
Interpretar pseudocdigos (algoritmos textuais) como base de documentao do raciocnio lgico para o desenvolvimento de
software;
Interpretar algoritmos grficos baseados na norma ISO 5807:1985 (E);
Interpretar algoritmos textuais baseados na tcnica PDL;
Avaliar resultados de teste dos algoritmos desenvolvidos;
Integrar mdulos de programas desenvolvidos separadamente;
Desenvolver algoritmos segundo paradigma da orientao a objetos.
O aprendizado da lgica de programao de computadores baseado na obteno preliminar das seguintes habilidades:
Selecionar e utilizar tcnicas de programao estruturada e/ou orientada a objetos na resoluo de problemas computacionais;
Fazer uso de modelos, pseudocdigos, diagramas de blocos na representao da soluo de problemas computacionais;
Executar procedimentos de testes de programas.
1.3 - Contedo de Programao de Computadores Abordado na Obra

Captulo 1. Introduo Computao
Captulo 2. Mercado Computacional
Captulo 3. Linguagens de Programao
Captulo 4. Algoritmos Computacionais
Captulo 5. Lgica de Programao de Computadores

Captulo 6. Compiladores, Interpretadores e Tradutores
Captulo 7. Programao com Estrutura Sequencial
7.1. Etapas de Ao de um Computador
7.2. Tipos de Dados Primitivos
7.3. O Uso de Variveis
7.4. O Uso de Constantes
7.5. Os Operadores Aritmticos
7.6. Expresses Aritmticas
7.7. Instrues e Comandos
7.8. Exerccio de Aprendizagem
7.9. Exerccios de Fixao
Captulo 8. Programao com Tomada de Deciso
8.1. Decises, Condies e Operadores Relacionais
8.2. Tomada de Deciso Simples
8.3. Desvio Condicional Composto
8.4. Outras Formas de Tomada de Deciso
8.5. Operadores Lgicos
8.6. Divisibilidade: Mltiplos e Divisores
Captulo 9. Programao com Laos
9.1. Laos ou Malhas de Repetio (Loopings ou Loops)
9.2. Lao de Repetio Condicional Pr-Teste
9.3. Lao de Repetio Condicional Ps-Teste
9.4. Lao de Repetio Condicional Seletivo
9.5. Lao de Repetio Incondicional
9.6. Consideraes entre Tipos de Laos
Captulo 10. Estruturas de Dados Homogneas
10.1. Matrizes de Uma Dimenso (Vetores)
10.2. Classificao de Elementos
10.3. Mtodos de Pesquisa de Elementos
10.4. Matrizes com Mais de Uma Dimenso (Tabelas)
10.5. Tipo de Dado Derivado: Estrutura de Registro
10.6. Estrutura de Registro de Matriz
10.7. Estrutura de Matriz de Registros
Captulo 11. Subprogramas
11.1. Modularidade
11.2. Mtodos Top-Down e Bottom-Up
11.3. Procedimentos
11.4. Escopo de Variveis
11.5. Passagens de Parmetros
11.6. Funes e Recursividade
Captulo 12. Introduo Programao Orientada a Objetos
12.1. Origem da Programao Orientada a Objetos
12.2. Programao Estruturada versus Programao Orientada a Objetos
12.3. Classes, Objetos, Atributos, Mtodos, Herana e Encapsulamento
12.4. Poliformismo (Polimorfismo)
2 - Gabarito dos Exerccios

O material apresentado de uso exclusivo do professor, com o objetivo de ajudar na preparao de aulas, bem como na escolha dos
exerccios a serem aplicados durante o curso ministrado, tanto para fixao como para avaliao.
So apresentadas as respostas dos exerccios de fixao do livro "Algoritmos - Lgica para o Desenvolvimento de Programao de
Computadores". Para cada exerccio de programao so descritos o diagrama de bloco [de acordo com norma ISO 5807:1985 (E)] e o
cdigo de programa correspondente escrito em PDL - Program Design Language (Portugus Estruturado).
As solues fornecidas neste gabarito caracterizam-se por serem as mais genricas possveis, a fim de que fique fcil implementar
qualquer algoritmo em qualquer linguagem de programao de computadores. No h inteno ou pretenso de que este gabarito
contenha a melhor resposta para um determinado exerccio ou problema, mas apenas uma ideia de como conseguir determinada
resposta. Fica a critrio do professor trabalhar as questes de refinamento algortmico no sentido de buscar a melhor soluo para um
determinado problema apresentado na obra.
As respostas do exerccios seguem como nomenclatura de nomes de programas a estrutura Cap03_Ex03b_Pg057, em que Cap indica
o nmero do captulo, Ex o exerccio em uso e Pg a pgina onde o exerccio est posicionado no livro.
3 - Exerccios de Fixao do Captulo 3

Tpico 3.9 - Exerccio 1 - Pgina 56
456
INTEIRO
INTEIRO
.F.
LGICO
1.56
REAL
.Falso.
LGICO
1.56
REAL
.V.
LGICO
34
INTEIRO
"0.87"
CADEIA
45.8976
REAL
"0"
CARACTERE
465
INTEIRO
"9.12"
CADEIA
678
INTEIRO
"900"
CADEIA
678
INTEIRO
"Casa 8"
CADEIA
99.8
REAL
"Cinco"
CADEIA
.V.
LGICO
"V"
CARACTERE
1000
INTEIRO

(X) ENDEREO
(_) END*A-6
(_) 21BRASIL
(X) CIDADE3
(_) FONE$COM
(_) #CABEC
(X) NAMEUSER
(_) REAL
(X) NOME_USURIO
(_) REAL$
(_) NOME*USURIO
(_) SOBRE NOME
Tpico 3.9 - Exerccio 3 - Pginas 57 e 58

a) Diagrama de bloco
Portugus estruturado
programa Cap03_Ex3a_Pg057
var
C, F : real
incio
leia C
F (9 * C + 160) / 5
escreva F
fim
b) Diagrama de bloco
programa Cap03_Ex3b_Pg057
var
C, F : real
incio
leia F
C (F - 32) * (5 / 9)
escreva C
fim
c) Diagrama de bloco
programa Cap03_Ex3c_Pg057
var
VOLUME, R, ALTURA : real
incio
leia R, ALTURA
VOLUME 3.14159 * R 2 * ALTURA
escreva VOLUME
fim
d) Diagrama de bloco
programa Cap03_Ex3d_Pg057
var
DISTNCIA, TEMPO, VELOCIDADE, LITROS_USADOS : real
incio
leia TEMPO, VELOCIDADE
DISTNCIA TEMPO * VELOCIDADE
LITROS_USADOS DISTNCIA / 12
escreva VELOCIDADE, TEMPO, DISTNCIA, LITROS_USADOS
fim
e) Diagrama de bloco
programa Cap03_Ex3e_Pg057
var
PRESTAO, VALOR, TAXA, TEMPO : real
incio
leia VALOR, TAXA, TEMPO
PRESTAO VALOR + (VALOR * (TAXA / 100) * TEMPO)
escreva PRESTAO
fim
f) Diagrama de bloco
programa
Cap03_Ex3f_Pg057_verso_1
var
A, B, X : inteiro
incio
leia A, B
X A
A B
B X
escreva A, B
fim
Este programa tambm pode ser escrito da Este programa tambm pode ser escrito da
seguinte forma:
seguinte forma:
programa
var
A, B, X : real
incio
leia A, B
X A
A B
B X
escreva A, B
fim
programa
var
A, B, X : cadeia
incio
leia A, B
X A
A B
B X
escreva A, B
fim
g) Diagrama de bloco
programa Cap03_Ex3g_Pg057
var
A, B, C, D : inteiro
A1, A2, A3, A4, A5, A6 : inteiro
M1, M2, M3, M4, M5, M6 : inteiro
incio
leia A, B, C, D
A1 A + B
A2 A + C
A3 A + D
A4 B + C
A5 B + D
A6 C + D
M1 A * B
M2 A * C
M3 A * D
M4 B * C
M5 B * D
M6 C * D
escreva A1, A2, A3, A4, A5, A6
escreva M1, M2, M3, M4, M5, M6
fim
h) Diagrama de bloco
programa Cap03_Ex3h_Pg057
var
VOLUME, COMPRIMENTO, LARGURA, ALTURA : real
incio
leia COMPRIMENTO, LARGURA, ALTURA
VOLUME COMPRIMENTO * LARGURA * ALTURA
escreva VOLUME
fim
i) Diagrama de bloco
programa Cap03_Ex3i_Pg057
var
N, R : inteiro
incio
leia N
R N * N (ou R N 2)
escreva R
fim
j) Diagrama de bloco
programa Cap03_Ex3j_Pg057
var
A, B, R : inteiro
incio
leia A, B
R (A B) 2
escreva R
fim
k) Diagrama de bloco
programa Cap03_Ex3k_Pg057
var
R, US, COTAO : real
incio
leia US, COTAO
R US * COTAO
escreva R
fim
l) Diagrama de bloco
programa Cap03_Ex3l_Pg057
var
R, US, COTAO : real
incio
leia R, COTAO
US R / COTAO
escreva US
fim
m) Diagrama de bloco
programa Cap03_Ex3m_Pg057
var
R, A, B, C : inteiro
incio
leia A, B, C
R (A 2) + (B 2) + (C 2)
escreva R
fim
n) Diagrama de bloco
programa Cap03_Ex3n_Pg058
var
R, A, B, C : inteiro
incio
leia A, B, C
R (A + B + C) 2
escreva R
fim
o) Diagrama de bloco
programa Cap03_Ex3o_Pg058
var
A, B, C, D, P, S : inteiro
incio
leia A, B, C, D
P A * C
S B + D
escreva P, S
fim
p) Diagrama de bloco
programa Cap03_Ex3p_Pg058
var
SM, PR, NS : real
incio
leia SM, PR
NS SM + SM * PR / 100
escreva NS
fim
q) Diagrama de bloco
programa Cap03_Ex3q_Pg058
var
A, R : real
incio
leia R
A 3.14159 * R 2
escreva A
fim
10
r) Diagrama de bloco
programa Cap03_Ex3r_Pg058
var
VA, VB, VC, NL, BR, TE : inteiro
PV, PA, PB, PC, PNL, PBR : real
incio
leia VA, VB, VC, NL, BR
TE VA + VB + VC + NL + BR
PV (VA + VB + VC) * 100 / TE
PA VA * 100 / TE
PB VB * 100 / TE
PC VC * 100 / TE
PNL NL * 100 / TE
PBR BR * 100 / TE
escreva TE, PV, PA, PB, PC, PNL, PBR
fim
s) Diagrama de bloco
programa Cap03_Ex3s_Pg058
var
A, B, R1, R2, R3, R4 : real
incio
leia A, B
R1 A + B
R2 A - B
R3 A * B
R4 A / B
escreva R1, R2, R3, R4
fim
t) Diagrama de bloco
programa Cap03_Ex3t_Pg058
var
VELOCIDADE, DISTNCIA, TEMPO : real
incio
leia DISTNCIA, TEMPO
VELOCIDADE (DISTNCIA * 1000) / (TEMPO * 60)
escreva VELOCIDADE
fim
11
u) Diagrama de bloco
programa Cap03_Ex3u_Pg058
var
VOLUME, RAIO : real
incio
leia RAIO
VOLUME (4 / 3) * 3.14159 * (RAIO 3)
escreva VOLUME
fim
v) Diagrama de bloco
programa Cap03_Ex3v_Pg058
var
BASE, EXPOENTE, POTNCIA : inteiro
incio
leia BASE, EXPOENTE
POTNCIA BASE EXPOENTE
escreva POTNCIA
fim
w) Diagrama de bloco
programa Cap03_Ex3x_Pg058
var
PS, METROS : real
incio
leia PS
METROS PS * 0,3048
escreva METROS
fim
x) Diagrama de bloco
var
RAIZ, BASE, NDICE : REAL
incio
leia BASE, NDICE
RAIZ BASE (1 / NDICE)
escreva RAIZ
fim
12
y) Diagrama de bloco
programa Cap03_Ex3y_Pg058
var
VALOR, SUCESSOR, ANTECESSOR : INTEIRO
incio
leia VALOR
SUCESSOR VALOR + 1
ANTECESSOR VALOR - 1
escreva SUCESSOR, ANTECESSOR
fim
4 - Exerccios de fixao do captulo 4

Tpico 4.7 - Exerccio 1 - Pginas 97 e 98
a) Verdadeiro
b) Falso
c) Verdadeiro
d) Verdadeiro
e) Verdadeiro
f) Falso
g) Falso
h) Verdadeiro
i) Falso
j) Falso
ideal que nestes exerccios o aluno perceba a posio das condies verdadeira e falsa. Deve ficar claro que sempre a ao da
condio verdadeira ser executada entre as declaraes de instruo se...seno e a ao da condio falsa ser executada entre as
declaraes de instruo seno...fim_se, nos casos de decises compostas.
Neste exerccio no necessrio fazer o aluno efetuar o clculo do valor das equaes; basta apenas apontar se a condio
verdadeira ou falsa e indicar qual equao deve ser calculada.
Tpico 4.7 - Exerccio 2 - Pgina 97 e 98

a) Falso, neste caso executa-se a equao X (A - B) / C, X = -0,20
b) Falso, neste caso executa-se a equao X (A + B) / D * (C + D), X = 7,78
c) Verdadeiro, neste executa-se a equao X (A + 2) * (B - 2), X = 4
d) Falso, neste executa-se a equao X A - B, X = 1
e) Verdadeiro, neste executa-se a equao X A + B, X = 5
f) Falso, neste executa-se a equao X D / B, X = 3
g) Verdadeiro, neste executa-se a equao X (A + D) / 2, X = 5,50
h) Verdadeiro, neste executa-se a equao X (A + D) / 2, X = 5,50
13

a) Diagrama de blocos
programa Cap04_Ex3a_Pg099_verso_1
var
A, B, DIF : inteiro
incio
leia A, B
se (A > B) ento
DIF A - B
seno
DIF B - A
fim_se
escreva DIF
fim
b) Diagrama de blocos
Este programa tambm pode ser escrito da seguinte forma:

programa Cap04_Ex3a_Pg099_verso_2
var
A, B, DIF : inteiro
incio
leia A, B
se (B > A) ento
DIF B - A
seno
DIF A - B
fim_se
escreva DIF
fim
14
programa Cap04_Ex3b_Pg099_verso_1
var
N, R : inteiro
incio
leia N
se (N < 0) ento
R N * (-1)
seno
R N
fim_se
escreva R
fim
Este programa tambm pode ser escrito da seguinte forma:

programa Cap04_Ex3b_Pg099_verso_2
var
N : inteiro
incio
leia N
se (N < 0) ento
N N * (-1)
fim_se
escreva N
fim
var
N1, N2, N3, N4, MD : real
incio
leia N1, N2, N3, N4
MD (N1 + N2 + N3 + N4) / 4
se (MD >= 5) ento
escreva "Aluno Aprovado", MD
seno
escreva "Aluno Reprovado", MD
fim_se
fim
var
N1, N2, N3, N4, MD, NOVA_MD, EX : real
incio
leia N1, N2, N3, N4
MD (N1 + N2 + N3 + N4) / 4
se (MD >= 7) ento
escreva "Aluno Aprovado", MD
seno
leia EX
NOVA_MD (MD + EX) / 2
se (NOVA_MD >= 5) ento
escreva "Aluno Aprovado em Exame", NOVA_MD
seno
escreva Aluno Reprovado, NOVA_MD
fim_se
fim_se
fim
15
Um ponto a ser observado neste exerccio a necessidade de extrair a raiz quadrada de (delta), que est sendo representado pela
varivel D. Muitos alunos esquecem-se de que para extrair uma raiz quadrada de um nmero, basta elev-lo ao inverso de seu ndice.
Ao se considerar a extrao da raiz quadrada de D, basta fazer D (1/2) ou D 0.5. Essa forma de extrao de raiz torna-se
adequada por proporcionar ao aluno a viso necessria para extrair razes de qualquer outro ndice. Assim sendo, para uma raiz
cbica, basta elevar a 1/3; para uma raiz de ndice quatro, basta elevar a 1/4 e assim por diante.
var
A, B, C, D, X, X1, X2 : real
incio
leia A, B, C
se (A = 0) .e. (B = 0) .e. (C = 0) ento
escreva "No uma equao completa de segundo grau."
seno
D B 2 - 4 * A * C
se (D = 0) ento
X -B / (2 * A)
escreva X
seno
se (D > 0) ento
X1 (-B + D (1 / 2)) / (2 * A)
X2 (-B - D (1 / 2)) / (2 * A)
escreva X1, X2
seno
escreva "No existem razes reais."
fim_se
fim_se
fim_se
fim
16
programa Cap04_Ex3f_Pg100
var
A, B, C, X : inteiro
incio
leia A, B, C
se (A > B) ento
X A
A B
B X
fim_se
se (A > C) ento
X A
A C
C X
fim_se
se (C > B) ento
X C
C B
B X
fim_se
escreva A, B, C
fim
Tpico 4.7 - Exerccio 3g

Neste exerccio enfatizado o conceito de trabalhar com valores numricos inteiros que sejam divisveis entre dois valores (seus
divisores). Para determinar se um valor divisvel por outro, basta verificar se o resto da diviso entre os valores (dividendos e divisores)
igual a zero, desde que o quociente da diviso seja um valor inteiro. por esta razo que est sendo utilizado o operador de diviso div
e no o operador / (barra). O operador / (barra) deve ser usado quando se deseja obter um quociente real. Observe que no usado o
operador mod ou % (operadores que determinam o valor do resto de uma diviso de inteiros quando usados nas linguagens de
programao PASCAL e C, C++, C#, Java, etc.), por serem exclusivos das linguagens de programao. importante que o aluno
aprenda a pensar na soluo do problema na forma algortmica e no com o operador da linguagem de programao em si.
17
var
A, B, C, D, RESTO2, RESTO3 : inteiro
incio
leia A, B, C, D
RESTO2 A - 2 * (A div 2)
se (RESTO2 = 0) .e. (RESTO3 = 0) ento
escreva "O valor ", A, " divisvel
fim_se
RESTO2 B - 2 * (B div 2)
escreva "O valor ", B, " divisvel
fim_se
RESTO2 C - 2 * (C div 2)
escreva "O valor ", C, " divisvel
fim_se
RESTO2 D - 2 * (D div 2)
escreva "O valor ", D, " divisvel
fim_se
fim
por 2 e 3"
por 2 e 3"
por 2 e 3"
por 2 e 3"
18
Tpico 4.7 - Exerccio 3h

Este exerccio tambm enfatiza o conceito de trabalhar com valores que sejam divisveis entre dois valores. Neste caso utilizado o
operador lgico .ou. nas referncias condicionais.
var
A, B, C, D, RESTO2, RESTO3 :
incio
leia A, B, C, D
se (RESTO2 = 0) .ou. (RESTO3
escreva "O valor ", A, "
fim_se
escreva "O valor ", B, "
fim_se
escreva "O valor ", C, "
fim_se
escreva "O valor ", D, "
fim_se
fim
inteiro
= 0) ento
divisvel por 2 ou 3"
= 0) ento
= 0) ento
= 0) ento
i) Diagrama de blocos
var
A, B, C, D, E, VALOR_MAIOR, VALOR_MENOR : inteiro
incio
leia A, B, C, D, E
VALOR_MAIOR A
se (VALOR_MAIOR < B) ento
VALOR_MAIOR B
fim_se
se (VALOR_MAIOR < C) ento
VALOR_MAIOR C
fim_se
se (VALOR_MAIOR < D) ento
VALOR_MAIOR D
fim_se
se (VALOR_MAIOR < E) ento
VALOR_MAIOR E
fim_se
VALOR_MENOR A
se (VALOR_MENOR > B) ento
VALOR_MENOR B
19
20
fim_se
se (VALOR_MENOR > C)
VALOR_MENOR C
fim_se
se (VALOR_MENOR > D)
VALOR_MENOR D
fim_se
se (VALOR_MENOR > E)
VALOR_MENOR E
fim_se
escreva VALOR_MAIOR,
fim
ento
ento
ento
VALOR_MENOR
var
N, RESTO : inteiro
incio
leia N
RESTO N - 2 * (N div 2)
se (RESTO = 0) ento
escreva "O valor ", N, " PAR."
seno
escreva "O valor ", N, " IMPAR."
fim_se
fim
var
N : inteiro
incio
leia N
se (N >= 1) .e. (N <= 9) ento
escreva "O valor est na faixa permitida."
seno
escreva "O valor est fora da faixa permitida."
fim_se
fim
var
N : inteiro
incio
leia N
se .no. (N > 3) ento
escreva N
fim_se
fim
21
var
NOME : cadeia
SEXO : caractere
incio
leia NOME, SEXO
se (SEXO = "M") .ou. (SEXO = "F") ento
se (SEXO = "M") ento
escreva "Ilmo. Sr. ", NOME
seno
escreva "Ilma. Sra. ", NOME
fim_se
fim_se
fim

5.1 - Lao de repetio pr-teste - controle condicional verdadeiro
var
QUADRADO, I : inteiro
incio
I 15
enquanto (I <= 200) faa
QUADRADO I 2
escreva QUADRADO
I I + 1
fim_enquanto
fim
22
var
N, I, R : inteiro
incio
leia N
I 1
R N * I
escreva N, " X ", I, " = ", R
I I + 1
fim_enquanto
fim
var
S, I : inteiro
incio
S 0
I 1
S S + I
I I + 1
fim_enquanto
escreva S
fim
23
var
S, I, RESTO : inteiro
incio
S 0
I 1
RESTO I - 2 * (I div 2)
se (RESTO = 0) ento
S S + I
fim_se
I I + 1
fim_enquanto
escreva S
fim
var
I, RESTO : inteiro
incio
I 0
se (RESTO <> 0) ento
escreva I
fim_se
I I + 1
fim_enquanto
fim
24
var
I, RESTO : inteiro
incio
I 1
enquanto (I < 200) faa
se (RESTO = 0) ento
escreva I
fim_se
I I + 1
fim_enquanto
fim
var
P, I : inteiro
incio
P 1
I 0
escreva P
P P * 3
I I + 1
fim_enquanto
fim
25
var
P, I, B, E : inteiro
incio
leia B, E
P 1
I 1
enquanto (I <= E) faa
P P * B
I I + 1
fim_enquanto
escreva P
fim
var
I, ATUAL, ANTERIOR, PRXIMO : inteiro
incio
ANTERIOR 0
ATUAL 1
I 1
escreva ATUAL
PRXIMO ATUAL + ANTERIOR
ANTERIOR ATUAL
ATUAL PRXIMO
I I + 1
fim_enquanto
fim
26
var
C, F : real
incio
C 10
enquanto (C <= 100) faa
F (9 * C + 160) / 5
escreva C, F
C C + 10
fim_enquanto
fim
var
I, GRO, QUADRO : inteiro
incio
GRO 0
QUADRO 1
I 1
GRO GRO + QUADRO
QUADRO QUADRO * 2
I I + 1
fim_enquanto
escreva GRO
fim
27
var
I, J, N, S, F : inteiro
incio
S 0
I 1
leia N
F 1
J 1
enquanto (J <= N) faa
F F * J
J J + 1
fim_enquanto
S S + F
I I + 1
fim_enquanto
escreva S
fim
var
I, N, SOMA : inteiro
MDIA : real
incio
SOMA 0
I 1
leia N
SOMA SOMA + N
I I + 1
fim_enquanto
MDIA SOMA / 10
escreva SOMA, MDIA
fim
28
var
TOTAL : inteiro
SOMA, MDIA, N : real
incio
TOTAL 0
SOMA 0
N 0
enquanto (N >= 0) faa
leia N
se (N >= 0) ento
SOMA SOMA + N
TOTAL TOTAL + 1
fim_se
fim_enquanto
se (TOTAL > 0) ento
MDIA SOMA / TOTAL
fim_se
escreva MDIA, TOTAL, SOMA
fim
29
var
FAT, R, I, J : inteiro
incio
I 1
R I - 2 * (I div 2)
se (R <> 0) ento
FAT 1
J 1
enquanto (J <= I) faa
FAT FAT * J
J J + 1
fim_enquanto
escreva FAT
fim_se
I I + 1
fim_enquanto
fim
30
var
TOTAL, SOMA, R, I : inteiro
MDIA : real
incio
TOTAL 0
SOMA 0
I 50
R I - 2 * (I div 2)
se (R = 0) ento
SOMA SOMA + I
TOTAL TOTAL + 1
fim_se
I I + 1
fim_enquanto
MDIA SOMA / TOTAL
escreva SOMA, MDIA
fim
31
var
CMODO, RESPOSTA : caractere
TOTAL, REA, LARGURA, COMPRIMENTO : real
incio
TOTAL 0
RESPOSTA "SIM"
enquanto (RESPOSTA = "SIM") faa
leia CMODO, LARGURA, COMPRIMENTO
REA LARGURA * COMPRIMENTO
TOTAL TOTAL + REA
escreva REA, "Deseja calcular novo cmodo? "
leia RESPOSTA
fim_enquanto
escreva TOTAL
fim
32
var
N, VALOR_MAIOR, VALOR_MENOR : inteiro
incio
leia N
VALOR_MAIOR N
VALOR_MENOR N
enquanto (N >= 0) faa
se (VALOR_MAIOR < N) ento
VALOR_MAIOR N
fim_se
se (VALOR_MENOR > N) ento
VALOR_MENOR N
fim_se
leia N
fim_enquanto
escreva VALOR_MAIOR, VALOR_MENOR
fim
33
var
QUOCIENTE, DIVIDENDO, DIVISOR : inteiro
incio
leia DIVIDENDO, DIVISOR
QUOCIENTE 0
enquanto (DIVISOR <= DIVIDENDO) faa
DIVIDENDO DIVIDENDO - DIVISOR
QUOCIENTE QUOCIENTE + 1
fim_enquanto
escreva QUOCIENTE
fim
5.2 - Lao de repetio pr-teste - controle condicional falso

var
incio
I 15
at_seja (I > 200) efetue
QUADRADO I 2
escreva QUADRADO
I I + 1
fim_at_seja
fim
34
var
N, I, R : inteiro
incio
leia N
I 1
R N * I
escreva N, " X ", I, " = ", R
I I + 1
fim_at_seja
fim
var
S, I : inteiro
incio
S 0
I 1
S S + I
I I + 1
fim_at_seja
escreva S
fim
35
var
incio
S 0
I 1
RESTO I 2 * (I div 2)
se (RESTO = 0) ento
S S + I
fim_se
I I + 1
fim_at_seja
escreva S
fim
var
I, RESTO : inteiro
incio
I 0
RESTO I 2 * (I div 2)
escreva I
fim_se
I I + 1
fim_at_seja
fim
36
var
I, RESTO : inteiro
incio
I 1
at_seja (I >= 199) efetue
se (RESTO = 0) ento
escreva I
fim_se
I I + 1
fim_at_seja
fim
var
P, I : inteiro
incio
P 1
I 0
escreva P
P P * 3
I I + 1
fim_at_seja
fim
37
var
incio
leia B, E
P 1
I 1
at_seja (I > E) efetue
P P * B
I I + 1
fim_at_seja
escreva P
fim
var
incio
ANTERIOR 0
ATUAL 1
I 1
escreva ATUAL
ANTERIOR ATUAL
ATUAL PRXIMO
I I + 1
fim_at_seja
fim
38
var
C, F : real
incio
C 10
at_seja (C > 100) efetue
F (9 * C + 160) / 5
escreva C, F
C C + 10
fim_at_seja
fim
var
incio
GRO 0
QUADRO 1
I 1
GRO GRO + QUADRO
QUADRO QUADRO * 2
I I + 1
fim_at_seja
escreva GRO
fim
39
var
incio
S 0
I 1
leia N
F 1
J 1
at_seja (J > N) efetue
F F * J
J J + 1
fim_at_seja
S S + F
I I + 1
fim_at_seja
escreva S
fim
var
MDIA : real
incio
SOMA 0
I 1
leia N
SOMA SOMA + N
I I + 1
fim_at_seja
MDIA SOMA / 10
escreva SOMA, MDIA
fim
40
var
TOTAL : inteiro
incio
TOTAL 0
SOMA 0
N 0
at_seja (N < 0) efetue
leia N
se (N >= 0) ento
SOMA SOMA + N
TOTAL TOTAL + 1
fim_se
fim_at_seja
se (TOTAL > 0) ento
MDIA SOMA / TOTAL
fim_se
escreva MDIA, TOTAL, SOMA
fim
41
var
incio
I 1
R I - 2 * (I div 2)
se (R <> 0) ento
FAT 1
J 1
at_seja (J > I) efetue
FAT FAT * J
J J + 1
fim_at_seja
escreva FAT
fim_se
I I + 1
fim_at_seja
fim
42
var
MDIA : real
incio
TOTAL 0
SOMA 0
I 50
R I - 2 * (I div 2)
se (R = 0) ento
SOMA SOMA + I
TOTAL TOTAL + 1
fim_se
I I + 1
fim_at_seja
MDIA SOMA / TOTAL
escreva SOMA, MDIA
fim
43
var
CMODO, RESPOSTA : cadeia
incio
TOTAL 0
RESPOSTA "SIM"
at_seja (RESPOSTA <> "SIM") efetue
TOTAL TOTAL + REA
leia RESPOSTA
fim_at_seja
escreva TOTAL
fim
44
var
incio
leia N
VALOR_MAIOR N
VALOR_MENOR N
at_seja (N < 0) efetue
VALOR_MAIOR N
fim_se
VALOR_MENOR N
fim_se
leia N
fim_at_seja
fim
var
incio
QUOCIENTE 0
at_seja (DIVISOR > DIVIDENDO) efetue
fim_at_seja
escreva QUOCIENTE
fim
45
5.3 - Lao de repetio ps-teste - controle condicional falso

var
incio
I 15
repita
QUADRADO I 2
escreva QUADRADO
I I + 1
at_que (I > 200)
fim
Portugus Estruturado
var
N, I, R : inteiro
incio
leia N
I 1
repita
R N * I
escreva N, " X ", I, " = ", R
I I + 1
at_que (I > 10)
fim
46
c) Diagrama de blocos
var
S, I : inteiro
incio
S 0
I 1
repita
S S + I
I I + 1
at_que (I > 100)
escreva S
fim
d) Diagrama de blocos
var
incio
S 0
I 1
repita
se (RESTO = 0) ento
S S + I
fim_se
I I + 1
at_que (I > 500)
escreva S
fim
47
e) Diagrama de blocos
var
I, RESTO : inteiro
incio
I 0
repita
escreva I
fim_se
I I + 1
at_que (I > 20)
fim
f) Diagrama de blocos
var
I, RESTO : inteiro
incio
I 1
repita
se (RESTO = 0) ento
escreva I
fim_se
I I + 1
at_que (I >= 200)
fim
48
g) Diagrama de blocos
var
P, I : inteiro
incio
P 1
I 0
repita
escreva P
P P * 3
I I + 1
at_que (I > 15)
fim
h) Diagrama de blocos
var
incio
leia B, E
P 1
I 1
repita
se (E = 0) ento
P 1
seno
P P * B
fim-se
I I + 1
at_que (I > E)
escreva P
fim
49
var
incio
ANTERIOR 0
ATUAL 1
I 1
repita
escreva ATUAL
ANTERIOR ATUAL
ATUAL PRXIMO
I I + 1
at_que (I > 15)
fim
j) Diagrama de blocos
var
C, F : real
incio
C 10
repita
F (9 * C + 160) / 5
escreva C, F
C C + 10
at_que (C > 100)
fim
50
k) Diagrama de blocos
var
incio
GRO 0
QUADRO 1
I 1
repita
GRO GRO QUADRO
QUADRO QUADRO 2
I I + 1
at_que (I > 64)
escreva GRO
fim
l) Diagrama de blocos
var
incio
S 0
I 1
repita
leia N
F 1
J 1
repita
F F * J
J J + 1
at_que (J > N)
S S + F
I I + 1
at_que (I > 15)
escreva S
fim
51
m) Diagrama de blocos
var
MDIA : real
incio
SOMA 0
I 1
repita
leia N
SOMA SOMA + N
I I + 1
at_que (I > 10)
MDIA SOMA / 10
escreva SOMA, MDIA
fim
n) Diagrama de blocos
var
TOTAL : inteiro
incio
TOTAL 0
SOMA 0
repita
leia N
se (N >= 0) ento
SOMA SOMA + N
TOTAL TOTAL + 1
fim_se
at_que (N < 0)
se (TOTAL > 0) ento
MDIA SOMA / TOTAL
fim_se
escreva SOMA, TOTAL, MDIA
fim
52
o) Diagrama de blocos
var
incio
I 1
repita
R I - 2 * (I div 2)
se (R <> 0) ento
FAT 1
J 1
repita
FAT FAT * J
J J + 1
at_que (J > I)
escreva FAT
fim_se
I I + 1
at_que (I > 10)
fim
53
p) Diagrama de blocos
var
MDIA : real
incio
TOTAL 0
SOMA 0
I 50
repita
R I - 2 * (I div 2)
se (R = 0) ento
SOMA SOMA + I
TOTAL TOTAL + 1
fim_se
I I + 1
at_que (I > 70)
MDIA SOMA / TOTAL
escreva SOMA, MDIA
fim
54
q) Diagrama de blocos
var
incio
TOTAL 0
RESPOSTA "SIM"
repita
TOTAL TOTAL + REA
leia RESPOSTA
at_que (RESPOSTA <> "SIM")
escreva TOTAL
fim
55
r) Diagrama de blocos
var
incio
leia N
VALOR_MAIOR N
VALOR_MENOR N
repita
VALOR_MAIOR N
fim_se
VALOR_MENOR N
fim_se
leia N
at_que (N < 0)
fim
s) Diagrama de blocos
var
incio
QUOCIENTE 0
repita
at_que (DIVISOR > DIVIDENDO)
escreva QUOCIENTE
fim
56
5.4 - Lao de repetio ps-teste - controle condicional verdadeiro

var
incio
I 15
continua
QUADRADO I 2
escreva QUADRADO
I I + 1
enquanto_for (I <= 200)
fim
var
N, I, R : inteiro
incio
leia N
I 1
continua
R N * I
escreva N, " X ", I, " = ", R
I I + 1
fim
57
var
S, I : inteiro
incio
S 0
I 1
continua
S S + I
I I + 1
escreva S
fim
var
incio
S 0
I 1
continua
se (RESTO = 0) ento
S S + I
fim_se
I I + 1
escreva S
fim
58
var
I, RESTO : inteiro
incio
I 0
continua
escreva I
fim_se
I I + 1
fim
var
I, RESTO : inteiro
incio
I 1
continua
se (RESTO = 0) ento
escreva I
fim_se
I I + 1
enquanto_for (I < 200)
fim
59
var
P, I : inteiro
incio
P 1
I 0
continua
escreva P
P P * 3
I I + 1
fim
var
incio
leia B, E
P 1
I 1
continua
se (E = 0) ento
P 1
seno
P P * B
fim-se
I I + 1
enquanto_for (I <= E)
escreva P
fim
60
var
incio
ANTERIOR 0
ATUAL 1
I 1
continua
escreva ATUAL
ANTERIOR ATUAL
ATUAL PRXIMO
I I + 1
fim
var
C, F : real
incio
C 10
continua
F (9 * C + 160) / 5
escreva C, F
C C + 10
enquanto_for (C <= 100)
fim
61
var
incio
GRO 0
QUADRO 1
I 1
continua
GRO GRO QUADRO
QUADRO QUADRO 2
I I + 1
escreva GRO
fim
62
var
incio
S 0
I 1
continua
leia N
F 1
J 1
continua
F F * J
J J + 1
enquanto_for (J <= N)
S S + F
I I + 1
escreva S
fim
63
var
MDIA : real
incio
SOMA 0
I 1
continua
leia N
SOMA SOMA + N
I I + 1
MDIA SOMA / 10
escreva SOMA, MDIA
fim
var
TOTAL : inteiro
incio
TOTAL 0
SOMA 0
continua
leia N
se (N <= 0) ento
SOMA SOMA + N
TOTAL TOTAL + 1
fim_se
enquanto_for (N >= 0)
se (TOTAL > 0) ento
MDIA SOMA / TOTAL
fim_se
fim
64
o) Digrama de blocos
var
incio
I 1
continua
R I - 2 * (I div 2)
se (R <> 0) ento
FAT 1
J 1
continua
FAT FAT * J
J J + 1
enquanto_for (J <= I)
escreva FAT
fim_se
I I + 1
fim
65
p) Digrama de blocos
var
MDIA : real
incio
TOTAL 0
SOMA 0
I 50
continua
R I - 2 * (I div 2)
se (R = 0) ento
SOMA SOMA + I
TOTAL TOTAL + 1
fim_se
I I + 1
MDIA SOMA / TOTAL
escreva SOMA, MDIA
fim
66
q) Digrama de blocos
var
incio
TOTAL 0
RESPOSTA "SIM"
continua
TOTAL TOTAL + REA
leia RESPOSTA
enquanto_for (RESPOSTA = "SIM")
escreva TOTAL
fim
67
r) Digrama de blocos
var
incio
leia N
VALOR_MAIOR N
VALOR_MENOR N
continua
VALOR_MAIOR N
fim_se
VALOR_MENOR N
fim_se
leia N
enquanto_for (N >= 0)
fim
s) Digrama de blocos
var
incio
QUOCIENTE 0
continua
enquanto_for (DIVISOR <= DIVIDENDO)
escreva QUOCIENTE
fim
68
5.5 - Lao de Repetio Condicional Seletivo

a) Digrama de blocos
var
incio
I 15
lao
QUADRADO I 2
escreva QUADRADO
saia_caso (I >= 200)
I I + 1
fim_lao
fim
var
N, I, R : inteiro
incio
leia N
I 1
lao
R N * I
escreva N, " X ", I, " = ", R
saia_caso (I >= 10)
I I + 1
fim_lao
fim
69
c) Digrama de blocos
var
S, I : inteiro
incio
S 0
I 1
lao
S S + I
I I + 1
fim_lao
escreva S
fim
var
incio
S 0
I 1
lao
se (RESTO = 0) ento
S S + I
fim_se
I I + 1
fim_lao
escreva S
fim
70
e) Digrama de blocos
var
I, RESTO : inteiro
incio
I 0
lao
escreva I
fim_se
saia_caso (I >= 20)
I I + 1
fim_lao
fim
var
I, RESTO : inteiro
incio
I 1
lao
se (RESTO = 0) ento
escreva I
fim_se
I I + 1
fim_lao
fim
71
g) Digrama de blocos
var
P, I : inteiro
incio
P 1
I 0
lao
escreva P
P P * 3
saia_caso (I >= 15)
I I + 1
fim_lao
fim
var
incio
leia B, E
P 1
I 1
lao
se (E = 0) ento
P 1
seno
P P * B
fim-se
saia_caso (I >= E)
I I + 1
fim_lao
escreva P
fim
72
i) Digrama de blocos
var
incio
ANTERIOR 0
ATUAL 1
I 1
lao
escreva ATUAL
ANTERIOR ATUAL
ATUAL PRXIMO
saia_caso (I >= 15)
I I + 1
fim_lao
fim
var
C, F : real
incio
C 10
lao
F (9 * C + 160) / 5
escreva C, F
saia_caso (C >= 100)
C C + 10
fim_lao
fim
73
k) Digrama de blocos
var
incio
GRO 0
QUADRO 1
I 1
lao
GRO GRO QUADRO
QUADRO QUADRO 2
saia_caso (I >= 64)
I I + 1
fim_lao
escreva GRO
fim
var
incio
S 0
I 1
lao
leia N
F 1
J 1
lao
F F * J
saia_caso (J >= N)
J J + 1
fim_lao
S S + F
saia_caso (I >= 15)
I I + 1
fim_lao
escreva S
fim
74
m) Digrama de blocos
var
MDIA : real
incio
SOMA 0
I 1
lao
leia N
SOMA SOMA + N
saia_caso (I >= 10)
I I + 1
fim_lao
MDIA SOMA / 10
escreva SOMA, MDIA
fim
var
TOTAL : inteiro
incio
TOTAL 0
SOMA 0
lao
leia N
se (N >= 0) ento
SOMA SOMA + N
TOTAL TOTAL + 1
fim_se
saia_caso (N < 0)
fim_lao
se (TOTAL > 0) ento
MDIA SOMA / TOTAL
fim_se
fim
75
o) Digrama de blocos
var
incio
I 1
lao
R I - 2 * (I div 2)
se (R <> 0) ento
FAT 1
J 1
lao
FAT FAT * J
saia_caso (J >= I)
J J + 1
fim_lao
escreva FAT
fim_se
saia_caso (I >= 10)
I I + 1
fim_lao
fim
76
var
MDIA : real
incio
TOTAL 0
SOMA 0
I 50
lao
R I - 2 * (I div 2)
se (R = 0) ento
SOMA SOMA + I
TOTAL TOTAL + 1
fim_se
saia_caso (I >= 70)
I I + 1
fim_lao
MDIA SOMA / TOTAL
escreva SOMA, MDIA
fim
77
q) Digrama de blocos
var
incio
TOTAL 0
RESPOSTA "SIM"
lao
TOTAL TOTAL + REA
leia RESPOSTA
saia_caso (RESPOSTA <> "SIM")
fim_lao
escreva TOTAL
fim
78
var
incio
leia N
VALOR_MAIOR N
VALOR_MENOR N
lao
VALOR_MAIOR N
fim_se
VALOR_MENOR N
fim_se
leia N
fim_lao (N >= 0)
fim
s) Digrama de blocos
var
incio
QUOCIENTE 0
lao
saia_caso (DIVISOR >= DIVIDENDO)
fim_lao
escreva QUOCIENTE
fim
79
5.6 - Lao de Repetio Incondicional

var
incio
para I de 15 at 200 passo 1 faa
QUADRADO I 2
escreva QUADRADO
fim_para
fim
var
N, I, R : inteiro
incio
leia N
R N * I
escreva N, " X ", I, " = ", R
fim_para
fim
var
S, I : inteiro
incio
S 0
S S + I
fim_para
escreva S
fim
80
var
incio
S 0
se (RESTO = 0) ento
S S + I
fim_se
fim_para
escreva S
fim
var
I, RESTO : inteiro
incio
escreva I
fim_se
fim_para
fim
var
I, RESTO : inteiro
incio
se (RESTO = 0) ento
escreva I
fim_se
fim_para
fim
81
var
P, I : inteiro
incio
P 1
escreva P
P P * 3
fim_para
fim
var
incio
leia B, E
P 1
para I de 1 at E passo 1 faa
P P * B
fim_para
escreva P
fim
var
incio
ANTERIOR 0
ATUAL 1
escreva ATUAL
ANTERIOR ATUAL
ATUAL PRXIMO
fim_para
fim
82
var
C, F : real
incio
para C de 10 at 100 passo 10 faa
F (9 * C + 160) / 5
escreva C, F
fim_para
fim
var
incio
GRO 0
QUADRO 1
GRO GRO + QUADRO
QUADRO QUADRO * 2
fim_para
escreva GRO
fim
83
var
incio
S 0
leia N
F 1
para J de 1 at N passo 1 faa
F F * J
fim_para
S S + F
fim_para
escreva S
fim
var
MDIA : real
incio
SOMA 0
leia N
SOMA SOMA + N
fim_para
MDIA SOMA / 10
escreva SOMA, MDIA
fim
n) No possvel resolver este exerccio com este tipo de lao de repetio.
84
var
incio
R I - 2 * (I div 2)
se (R <> 0) ento
FAT 1
para J de 1 at I passo 1 faa
FAT FAT * J
fim_para
escreva FAT
fim_se
fim_para
fim
var
MDIA : real
incio
TOTAL 0
SOMA 0
R I - 2 * (I div 2)
se (R = 0) ento
SOMA SOMA + I
TOTAL TOTAL + 1
fim_se
fim_para
MDIA SOMA / TOTAL
escreva SOMA, MDIA
fim
85
q) No possvel resolver este exerccio com esse tipo de lao de repetio.

r) No possvel resolver este exerccio com esse tipo de lao de repetio.
s) No possvel resolver este exerccio com esse tipo de lao de repetio.

var
A : conjunto[1..10] de cadeia
I : inteiro
incio
leia A[I]
fim_para
escreva A[I]
fim_para
fim
var
A, B : conjunto[1..8] de inteiro
I : inteiro
incio
leia A[I]
fim_para
B[I] A[I] * 3
fim_para
escreva B[I]
fim_para
fim
86
var
A, B, C : conjunto[1..20] de real
I : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
C[I] A[I] - B[I]
fim_para
escreva C[I]
fim_para
fim
var
I : inteiro
incio
leia A[I]
fim_para
B[I] A[I] 2
fim_para
escreva A[I], B[I]
fim_para
fim
87
var
I, J : inteiro
incio
leia A[I]
fim_para
B[I] 1
para J de 1 at A[I] passo 1 faa
B[I] B[I] * J
fim_para
fim_para
escreva A[I], B[I]
fim_para
fim
var
C : conjunto[1..30] de inteiro
I : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
C[I] A[I]
C[I + 15] B[I]
fim_para
escreva C[I]
fim_para
fim
88
var
B : conjunto[1..30] de cadeia
C : conjunto[1..50] de cadeia
I : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
se (I <= 20) ento
C[I] A[I]
seno
C[I] B[I - 20]
fim_se
fim_para
escreva C[I]
fim_para
fim
var
A, B : conjunto[1..20] de real
I, J : inteiro
incio
leia A[I]
fim_para
B[I] A[21 I]
fim_para
escreva A[I], B[I]
fim_para
fim
89
var
D : conjunto[1..15] de real
I : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
leia C[I]
fim_para
D[I] A[I]
D[I + 5] B[I]
D[I + 10] C[I]
fim_para
escreva D[I]
fim_para
fim
90
var
I : inteiro
incio
repita
leia A[I]
at_que (A[I] >= 0)
fim_para
B[I] A[I] * (-1)
fim_para
escreva B[I]
fim_para
fim
var
A : conjunto[1..10] de inteiro
B : conjunto[1..10] de real
I : inteiro
incio
leia A[I]
fim_para
B[I] A[I] / 2
fim_para
escreva A[I], B[I]
fim_para
fim
91
var
I, N : inteiro
incio
leia N
A[I] N * I
fim_para
escreva A[I]
fim_para
fim
var
A : conjunto[1..20] de real
SOMA, MDIA, VALOR_MAIOR, VALOR_MENOR : real
I : inteiro
incio
leia A[I]
SOMA SOMA + A[I]
fim_para
VALOR_MAIOR A[1]
VALOR_MENOR A[1]
se (VALOR_MAIOR < A[I]) ento
VALOR_MAIOR A[I]
fim_se
se (VALOR_MENOR > A[I]) ento
VALOR_MENOR A[I]
fim_se
fim_para
MDIA SOMA / 20
escreva VALOR_MAIOR, VALOR_MENOR, MDIA
fim
92
var
I : inteiro
incio
leia A[I]
fim_para
B[I] (9 * A[I] = 160) / 5
fim_para
escreva A[I], B[I]
fim_para
fim
var
I, R : inteiro
incio
leia A[I]
fim_para
R A[I] - 2 * (A[I] div 2)
se (R <> 0) ento
B[I] A[I] * 2
seno
B[I] A[I]
fim_se
fim_para
escreva B[I]
fim_para
fim
93
var
I, R : inteiro
incio
leia A[I]
fim_para
R I - 2 * (I div 2)
se (R = 0) ento
B[I] A[I] / 2
seno
B[I] A[I] * 1.5
fim_se
fim_para
escreva B[I]
fim_para
fim
94
var
A, B, C, D : conjunto[1..6] de inteiro
I, J, K, R, X, Y : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
J 1
K 2
X 1
Y 1
R I - 2 * (I div 2)
se (R <> 0) ento
C[X] A[J]
C[X + 3] B[J]
J J + 2
X X + 1
seno
D[Y] A[K]
D[Y + 3] B[K]
K K + 2
Y Y + 1
fim_se
fim_para
escreva C[I], D[I]
fim_para
fim
95
var
I, R : inteiro
incio
repita
leia A[I]
R A[I] - 2 * (A[I] div 2)
at_que (R = 0)
fim_para
repita
leia B[I]
R B[I] - 2 * (B[I] div 2)
at_que (R <> 0)
fim_para
C[I] A[I]
C[I + 6] B[I]
fim_para
escreva C[I]
fim_para
fim
96
t) Diagrama de blocos
var
I, R2, R3, R5 : inteiro
incio
repita
leia A[I]
R2 A[I] - 2 * (A[I] div 2)
R3 A[I] - 3 * (A[I] div 3)
at_que (R2 = 0) .e. (R3 = 0)
fim_para
repita
leia B[I]
R5 B[I] - 5 * (B[I] div 5)
at_que (R5 = 0)
fim_para
C[I] A[I]
C[I + 10] B[I]
fim_para
escreva C[I]
fim_para
fim
97
u) Diagrama de blocos
var
I, R2, R3, R5 : inteiro
incio
repita
leia A[I]
R2 A[I] - 2 * (A[I] div 2)
R3 A[I] - 3 * (A[I] div 3)
at_que (R2 = 0) .ou. (R3 = 0)
fim_para
repita
leia B[I]
R5 B[I] - 5 * (B[I] div 5)
at_que .no. (R5 = 0)
fim_para
C[I] A[I]
C[I + 12] B[I]
fim_para
escreva C[I]
fim_para
fim
98
v) Diagrama de blocos
var
I, R, QP, QI : inteiro
incio
leia A[I]
fim_para
QP 0
QI 0
R A[I] - 2 * (A[I] div 2)
se (R = 0) ento
QP QP + 1
seno
QI QI + 1
fim_se
fim_para
escreva QP, QI
fim
w) Diagrama de blocos
programa Cap06_Ex1w_Pg144
var
A, B, C : conjunto[1..10] de inteiro
I : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
C[I] (A[I] + B[I]) 2
fim_para
escreva C[I]
fim_para
fim
99
x) Diagrama de blocos
var
I, R : inteiro
incio
leia A[I]
fim_para
R I 2 * (I div 2)
se (R <> 0) ento
B[I] A[I + 1]
seno
B[I] A[I - 1]
fim_se
fim_para
escreva A[I], B[I]
fim_para
fim
y) Diagrama de blocos
programa Cap06_Ex1y_Pg144
var
I, TP, R : inteiro
incio
leia A[I]
fim_para
TP 0
R A[I] 2 * (A[I] div 2)
se (R = 0) ento
TP TP + 1
fim_se
fim_para
escreva TP
fim
100
z) Diagrama de blocos
programa Cap06_Ex1z_Pg144
var
I, TI, R : inteiro
PTI : real
incio
leia A[I]
fim_para
TI 0
R A[I] 2 * (A[I] div 2)
se (R <> 0) ento
TI TI + 1
fim_se
fim_para
PTI TI / 10 * 100
escreva TI, PTI
fim
101

var
I, J, X : inteiro
incio
leia A[I]
fim_para
para J de I + 1 at 12 passo 1 faa
se (A[I] < A[J]) ento
X A[I]
A[I] A[J]
A[J] X
fim_se
fim_para
fim_para
escreva A[I]
fim_para
fim
102
var
I, J, X, COMEO, FINAL, MEIO, PESQ : inteiro
RESP : cadeia
ACHA : lgico
incio
leia A[I]
fim_para
B[I] A[I] * 5
fim_para
se (B[I] > B[J]) ento
X B[I]
B[I] B[J]
B[J] X
fim_se
fim_para
fim_para
RESP "SIM"
enquanto (RESP = "SIM") faa
leia PESQ
COMEO 1
FINAL 8
ACHA .Falso.
enquanto (COMEO <= FINAL) .e. (ACHA = .Falso) faa
MEIO (COMEO + FINAL) div 2
se (PESQ = B[MEIO]) ento
ACHA .Verdadeiro.
seno
se (PESQ < B[MEIO]) ento
FINAL MEIO - 1
seno
COMEO MEIO + 1
fim_se
fim_se
fim_enquanto
se (ACHA = .Verdadeiro.) ento
escreva PESQ, " foi localizado na posio ", MEIO
seno
escreva PESQ, " no foi localizado"
fim_se
leia RESP
fim_enquanto
fim
103
104
var
I, J, X : inteiro
incio
leia A[I]
fim_para
B[I] 1
B[I] B[I] * J
fim_para
fim_para
X B[I]
B[I] B[J]
B[J] X
fim_se
fim_para
fim_para
escreva B[I]
fim_para
fim
105
106
var
I, J, X : inteiro
incio
leia A[I]
fim_para
se (A[I] > A[J]) ento
X A[I]
A[I] A[J]
A[J] X
fim_se
fim_para
fim_para
leia B[I]
fim_para
X B[I]
B[I] B[J]
B[J] X
fim_se
fim_para
fim_para
C[I] A[I] + B[I]
fim_para
se (C[I] < C[J]) ento
X C[I]
C[I] C[J]
C[J] X
fim_se
fim_para
fim_para
escreva C[I]
fim_para
fim
107
var
I, J, X : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
se (I <= 20) ento
C[I] A[I]
seno
C[I] B[I - 20]
fim_se
fim_para
X C[I]
C[I] C[J]
C[J] X
fim_se
fim_para
fim_para
escreva C[I]
fim_para
fim
108
var
I : inteiro
PESQ : real
RESP : cadeia
ACHA : lgico
incio
leia A[I]
fim_para
B[I] A[I] 3
fim_para
RESP "SIM"
leia PESQ
I 1
ACHA .Falso.
enquanto (I <= 30) .e. (ACHA = .Falso.) faa
se (PESQ = B[I]) ento
ACHA .Verdadeiro.
seno
I I + 1
fim_se
fim_enquanto
escreva PESQ, " foi localizado na posio ", I
seno
fim_se
leia RESP
fim_enquanto
fim
109
110
var
RESP : cadeia
ACHA : lgico
incio
leia A[I]
fim_para
B[I] A[I] + 2
fim_para
X B[I]
B[I] B[J]
B[J] X
fim_se
fim_para
fim_para
RESP "SIM"
leia PESQ
COMEO 1
FINAL 20
ACHA .Falso.
se (PESQ = B[MEIO]) ento
ACHA .Verdadeiro.
seno
se (PESQ < B[MEIO]) ento
FINAL MEIO - 1
seno
COMEO MEIO + 1
fim_se
fim_se
fim_enquanto
seno
fim_se
leia RESP
fim_enquanto
fim
111
var
I, J, X : inteiro
incio
repita
leia A[I]
at_que (A[I] < 0)
fim_para
B[I] A[I] * (-1)
fim_para
se (B[I] < B[J]) ento
X B[I]
B[I] B[J]
B[J] X
fim_se
fim_para
fim_para
escreva B[I]
fim_para
fim
112
var
I, J, X : inteiro
incio
leia A[I]
B[I] A[I] / 2
fim_para
se (A[I] < A[J]) ento
X A[I]
A[I] A[J]
A[J] X
fim_se
X B[I]
B[I] B[J]
B[J] X
fim_se
fim_para
fim_para
escreva A[I], B[I]
fim_para
fim
var
A, B, C, D, E : conjunto[1..15] de inteiro
I, J, X : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
C[I] 0
C[I] C[I] + J
fim_para
D[I] 1
113
114
para J de 1 at B[I] passo 1 faa
D[I] D[I] * J
fim_para
E[I] (C[I] + D[I]) - (A[I] + B[I])
fim_para
se (E[I] > E[J]) ento
X E[I]
E[I] E[J]
E[J] X
fim_se
fim_para
fim_para
escreva E[I]
fim_para
fim
var
A, B, C : conjunto[1..10] de inteiro
I, J : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
C[I] A[I] 2 + B[I] 2
fim_para
X C[I]
C[I] C[J]
C[J] X
fim_se
fim_para
fim_para
escreva C[I]
fim_para
fim
var
A, B, C, D : conjunto[1..15] de real
I, J : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
leia C[I]
fim_para
D[I] (A[I] + B[I] + C[I]) 3
fim_para
se (D[I] > D[J]) ento
X D[I]
D[I] D[J]
D[J] X
fim_se
fim_para
fim_para
escreva D[I]
fim_para
fim
115
116
var
I : inteiro
PESQ : real
RESP : cadeia
ACHA : lgico
incio
leia A[I]
fim_para
leia B[I]
fim_para
C[I] A[I] * B[I]
fim_para
RESP "SIM"
leia PESQ
I 1
ACHA .Falso.
se (PESQ = C[I]) ento
ACHA .Verdadeiro.
seno
I I + 1
fim_se
fim_enquanto
seno
fim_se
leia RESP
fim_enquanto
fim
117
118
var
RESP : cadeia
ACHA : lgico
incio
leia A[I]
fim_para
leia B[I]
fim_para
leia C[I]
fim_para
D[I] A[I] + B[I] + C[I]
fim_para
se (D[I] > D[J]) ento
X D[I]
D[I] D[J]
D[J] X
fim_se
fim_para
fim_para
RESP "SIM"
leia PESQ
COMEO 1
FINAL 15
ACHA .Falso.
enquanto (COMEO <= FINAL) .e. (ACHA = .Falso.) faa
se (PESQ = D[MEIO]) ento
ACHA .Verdadeiro.
seno
se (PESQ < D[MEIO]) ento
FINAL MEIO - 1
seno
COMEO MEIO + 1
fim_se
fim_se
fim_enquanto
seno
fim_se
leia RESP
fim_enquanto
fim
119
120
var
RESP : cadeia
ACHA : lgico
incio
leia A[I]
fim_para

X A[I]
A[I] A[J]
A[J] X
fim_se
fim_para
fim_para
RESP "SIM"
leia PESQ
COMEO 1
FINAL 15
ACHA .Falso.
se (PESQ = A[MEIO]) ento
ACHA .Verdadeiro.
seno
se (PESQ < A[MEIO]) ento
FINAL MEIO - 1
seno
COMEO MEIO + 1
fim_se
fim_se
fim_enquanto
seno
fim_se
leia RESP
fim_enquanto
fim
var
A, B : conjunto[1..10] de cadeia
I, J : inteiro
X : cadeia
incio
leia A[I]
fim_para
121
122
B[I] A[11 I]
fim_para
X B[I]
B[I] B[J]
B[J] X
fim_se
fim_para
fim_para
escreva B[I]
fim_para
fim
q) Diagramas de blocos
var
I, J, COMEO, FINAL, MEIO, PESQ : inteiro
RESP : cadeia
X : cadeia
ACHA : lgico
incio
leia A[I]
fim_para
X A[I]
A[I] A[J]
A[J] X
fim_se
fim_para
fim_para
RESP "SIM"
leia PESQ
COMEO 1
FINAL 15
ACHA .Falso.
se (PESQ = A[MEIO]) ento
ACHA .Verdadeiro.
seno
se (PESQ < A[MEIO]) ento
FINAL MEIO - 1
seno
COMEO MEIO + 1
fim_se
fim_se
fim_enquanto
seno
fim_se
leia RESP
fim_enquanto
fim
123
124
var
I, J : inteiro
X : cadeia
incio
leia A[I]
fim_para
leia B[I]
fim_para
se (I <= 10) ento
C[I] A[I]
seno
C[I] B[I - 10]
fim_se
fim_para
X C[I]
C[I] C[J]
C[J] X
fim_se
fim_para
fim_para
escreva C[I]
fim_para
fim
125
var
A : conjunto[1..10] de real
I : inteiro
PESQ : real
RESP : cadeia
ACHA : lgico
incio
leia A[I]
fim_para
RESP "SIM"
leia PESQ
I 1
ACHA .Falso.
se (PESQ = A[I]) ento
ACHA .Verdadeiro.
seno
I I + 1
fim_se
fim_enquanto
seno
fim_se
leia RESP
fim_enquanto
fim
126

Tpico 8.5 - Exerccio 1 a - Pgina 186, 187 e 188
var
A, B, C : conjunto[1..5,1..3] de inteiro
I, J : inteiro
incio
para J de 1 at 3 passo 1 faa
leia A[I,J]
fim_para
fim_para
leia B[I,J]
fim_para
fim_para
C[I,J] A[I,J] + B[I,J]
fim_para
fim_para
escreva C[I,J]
fim_para
fim_para
fim
127
var
C : conjunto[1..7,1..2] de inteiro
I, J : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
C[I,1] A[I]
C[I,2] B[I]
fim_para
escreva C[I,J]
fim_para
fim_para
fim
var
A : conjunto[1..4,1..5] de inteiro
I, J : inteiro
incio
leia A[I,J]
fim_para
fim_para
escreva A[I,J]
fim_para
fim_para
fim
128
var
C : conjunto[1..10,1..3] de inteiro
I, J : inteiro
incio
leia A[I]
fim_para
C[I,1] A[I] + 5
C[I,2] 1
C[I,2] C[I,2] * J
fim_para
C[I,3] A[I] 2
fim_para
escreva C[I,J]
fim_para
fim_para
fim
129
var
C : conjunto[1..12,1..2] de real
I, J : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
C[I,1] A[I] * 2
C[I,2] B[I] - 5
fim_para
escreva A[I]
fim_para
escreva B[I]
fim_para
escreva C[I,J]
fim_para
fim_para
fim
130
var
A, B : conjunto[1..5,1..4] de inteiro
I, J, K : inteiro
incio
leia A[I,J]
fim_para
fim_para
B[I,J] 1
para K de 1 at A[I,J] passo 1 faa
B[I,J] B[I,J] * K
fim_para
fim_para
fim_para
escreva A[I,J], B[I,J]
fim_para
fim_para
fim
131
var
A, B : conjunto[1..4,1..5] de real
I, J : inteiro
incio
leia A[I,J]
fim_para
fim_para
B[I,J] (9 * A[I,J] + 160) / 5
fim_para
fim_para
fim_para
fim_para
fim
132
var
I, J : inteiro
incio
leia A[I,J]
fim_para
fim_para
se (I = J) ento
B[I,J] A[I,J] * 3
seno
B[I,J] A[I,J] * 2
fim_se
fim_para
fim_para
escreva B[I,J]
fim_para
fim_para
fim
var
I, J, K, RI, RJ : inteiro
incio
leia A[I,J]
fim_para
fim_para
133
134
se (I = J) ento
RI I - 2 * (I div 2)
RJ J - 2 * (J div 2)
se (RI = 1) .e. (RJ = 1) ento
B[I,J] 1
B[I,J] B[I,J] * K
fim_para
seno
B[I,J] 0
B[I,J] B[I,J] + K
fim_para
fim_se
seno
B[I,J] 0
B[I,J] B[I,J] + K
fim_para
fim_se
fim_para
fim_para
escreva B[I,J]
fim_para
fim_para
fim
var
I, J, R : inteiro
incio
leia A[I,J]
fim_para
fim_para
R A[I,J] - 2 * (A[I,J] div 2)
se (R = 0) ento
B[I,J] A[I,J] + 5
seno
B[I,J] A[I,J] - 4
fim_se
fim_para
fim_para
fim_para
fim_para
fim
135
var
I, J, S : inteiro
incio
leia A[I,J]
fim_para
fim_para
S 0
se (I = J) ento
S S + A[I,J]
fim_se
fim_para
fim_para
escreva S
fim
136
var
A, B : conjunto[1..15,1..15] de
inteiro
I, J, S, R : inteiro
incio
leia A[I,J]
fim_para
fim_para
S 0
se (I = J) ento
R A[I,J] - 2 * (A[I,J] div 2)
se (R = 0) ento
S S + A[I,J]
fim_se
fim_se
fim_para
fim_para
escreva S
fim
137
var
I, J, S, RI, RJ : inteiro
incio
leia A[I,J]
fim_para
fim_para
S 0
se (I = J) ento
RI I - 2 * (I div 2)
RJ J - 2 * (J div 2)
se (RI = 1) .e. (RJ = 1) ento
S S + A[I,J]
fim_se
fim_se
fim_para
fim_para
escreva S
fim
138
var
I, J, TOT_PAR, R : inteiro
incio
leia A[I,J]
fim_para
fim_para
TOT_PAR 0
R A[I,J] - 2 * (A[I,J] div 2)
se (R = 0) ento
TOT_PAR TOT_PAR + 1
fim_se
fim_para
fim_para
escreva TOT_PAR
fim
139
var
A : conjunto[1..8,1..6] de real
B : conjunto[1..8] de real
I, J : inteiro
S : real
incio
leia A[I,J]
fim_para
fim_para
S 0
B[I] 0
B[I] B[I] + A[I,J]
fim_para
S S + B[I]
fim_para
escreva S
fim
140
var
I, J, TIMP, TPAR, R : inteiro
PIMP, PPAR : real
incio
leia A[I,J]
fim_para
fim_para
TIMP 0
TPAR 0
R A[I,J] - 2 * (A[I,J] div 2)
se (R = 0) ento
TPAR TPAR + 1
seno
TIMP TIMP + 1
fim_se
fim_para
fim_para
PPAR TPAR / 70 * 100
PIMP TIMP / 70 * 100
escreva TPAR, TIMP, PPAR, PIMP
fim
141
var
B : conjunto[1..4] de inteiro
I, J, S : inteiro
incio
leia A[I,J]
fim_para
fim_para
S 0
B[I] 0
fim_para
C[I] 0
fim_para
B[I] B[I] + A[I,J]
C[J] C[J] + A[I,J]
fim_para
fim_para
S S + B[I]
fim_para
S S + C[I]
fim_para
escreva S
fim
142
var
E : conjunto[1..4,1..4] de inteiro
I, J : inteiro
incio
leia A[I]
fim_para
leia B[I]
fim_para
leia C[I]
fim_para
leia D[I]
fim_para
E[1,I] A[I] * 2
E[2,I] B[I] * 3
E[3,I] C[I] * 4
E[4,I] 1
para J de 1 at D[I] passo 1 faa
E[4,I] E[4,I] * J
fim_para
fim_para
escreva E[I,J]
fim_para
fim_para
fim
143
var
I, J, R : inteiro
incio
repita
leia A[I,J]
R A[I,J] - 2 * (A[I,J] div 2)
at_que (R = 0)
fim_para
fim_para
repita
leia B[I,J]
R B[I,J] - 2 * (B[I,J] div 2)
at_que (R = 1)
fim_para
fim_para
fim_para
fim_para
escreva C[I,J]
fim_para
fim_para
fim
144
t) Diagrama de blocos
var
I, J, R3, R4, R5, R6 : inteiro
incio
repita
leia A[I,J]
R3 A[I,J] - 3 * (A[I,J] div 3)
R4 A[I,J] - 4 * (A[I,J] div 4)
at_que (R3 = 0) .e. (R4 = 0)
fim_para
fim_para
repita
leia B[I,J]
R5 B[I,J] - 5 * (B[I,J] div 5)
R6 B[I,J] - 6 * (B[I,J] div 6)
at_que (R5 = 0) .ou. (R6 = 0)
fim_para
fim_para
C[I,J] A[I,J] - B[I,J]
fim_para
fim_para
escreva C[I,J]
fim_para
fim_para
fim
145
u) Diagrama de blocos
var
I, J, R3, R4, R5, R6 : inteiro
incio
repita
leia A[I,J]
R3 A[I,J] - 3 * (A[I,J] div 3)
R4 A[I,J] - 4 * (A[I,J] div 4)
at_que (R3 = 0) .ou. (R4 = 0)
fim_para
fim_para
repita
leia B[I,J]
R5 B[I,J] - 5 * (B[I,J] div 5)
R6 B[I,J] - 6 * (B[I,J] div 6)
at_que (R5 = 0) .e. (R6 = 0)
fim_para
fim_para
C[I,J] A[I,J] * B[I,J]
fim_para
fim_para
escreva C[I,J]
fim_para
fim_para
fim
146
v) Diagrama de blocos
var
I, J, R : inteiro
incio
repita
leia A[I,J]
R A[I,J] - 3 * (A[I,J] div 3)
at_que .no. (R = 0)
fim_para
fim_para
repita
leia B[I,J]
R B[I,J] - 6 * (B[I,J] div 6)
at_que .no. (R = 0)
fim_para
fim_para
fim_para
fim_para
escreva C[I,J]
fim_para
fim_para
fim

Diagrama de blocos
147
148
programa Cap09_Ex1_Pg207
tipo
Dados = registro
NOME : cadeia
ENDEREO : cadeia
TELEFONE : cadeia
fim_registro
var
AGENDA : conjunto[1..10] de Dados
X : Dados
I, J, OPO : inteiro
ACHA : lgico
PESQ : cadeia
incio
OPO 0
enquanto (OPO <> 5) faa
escreva "1 - Cadastrar"
escreva "2 - Pesquisar"
escreva "3 - Classificar"
escreva "4 - Apresentar"
escreva "5 - Fim"
leia OPO
se (OPO = 1) ento
leia AGENDA[I].NOME
leia AGENDA[I].ENDEREO
leia AGENDA[I].TELEFONE
fim_para
fim_se
se (OPO = 2) ento
leia PESQ
I 1
ACHA .Falso.
se (PESQ = AGENDA[I].NOME) ento
ACHA .Verdadeiro.
seno
I I + 1
fim_se
fim_enquanto
escreva AGENDA[I].NOME
escreva AGENDA[I].ENDEREO
escreva AGENDA[I].TELEFONE
seno
escreva "Registro Inexistente"
fim_se
fim_se
se (OPO = 3) ento
para J de I+1 at 10 passo 1 faa
se (AGENDA[I].NOME > AGENDA[J].NOME) ento
X AGENDA[I]
AGENDA[I] AGENDA[J]
AGENDA[J] X
fim_se
fim_para
fim_para
fim_se
se (OPO = 4) ento
fim_para
fim_se
fim_enquanto
fim
149
150
tipo
Dados = registro
NOME : cadeia
NOTA : conjunto[1..4] de real
fim_registro
var
ALUNO : conjunto[1..20] de Dados
X : Dados
I, J, OPO, COMEO, FINAL, MEIO : inteiro
SOMAR, MDIA : real
ACHA : lgico
PESQ : cadeia
incio
OPO 0
escreva "4 - fim"
leia OPO
se (OPO = 1) ento
leia ALUNO[I].NOME
leia ALUNO[I].NOTA[J]
151
152
fim_para
fim_para
se (ALUNO[I].NOME > ALUNO[J].NOME) ento
X ALUNO[I]
ALUNO[I] ALUNO[J]
ALUNO[J] X
fim_se
fim_para
fim_para
fim_se
se (OPO = 2) ento
leia PESQ
COMEO 1
FINAL 20
ACHA .Falso.
se (PESQ = ALUNO[MEIO].NOME) ento
ACHA .Verdadeiro.
seno
se (PESQ < ALUNO[MEIO].NOME) ento
FINAL MEIO - 1
seno
COMECO MEIO + 1
fim_se
fim_se
fim_enquanto
SOMAR 0
escreva ALUNO[MEIO].NOME
escreva ALUNO[MEIO].NOTA[I]
SOMAR SOMAR + ALUNO[MEIO].NOTA[I]
fim_se
MDIA SOMAR / 4
escreva MDIA
se (MDIA >= 5) ento
escreva "Aprovado"
seno
escreva "Reprovado"
fim_se
seno
fim_se
fim_se
se (OPO = 3) ento
SOMAR 0
escreva ALUNO[I].NOME
escreva ALUNO[I].NOTA[J]
SOMAR SOMAR + ALUNO[I].NOTA[J]
fim_para
MEDIA SOMAR / 4
escreva MDIA
se (MDIA >= 5) ento
escreva "Aprovado"
seno
escreva "Reprovado"
fim_se
fim_para
fim_se
fim_enquanto
fim
Diagrama de Blocos
153
154
tipo
Dados = registro
NOME : cadeia
ALTURA : real
fim_registro
var
PESSOA : conjunto[1..15] de Dados
I, J, OPO : inteiro
SOMAR, MDIA : real
incio
OPO 0
escreva "2 - Apresentar <= 1.5"
escreva "3 - Apresentar > 1.5"
escreva "4 - Apresentar > 1.5 e < 2.0"
escreva "5 - Apresentar tudo"
escreva "6 - Fim"
leia OPO
se (OPO = 1) ento
leia PESSOA[I].NOME
leia PESSOA[I].ALTURA
fim_para
fim_se
se (OPO = 2) ento
se (PESSOA[I].ALTURA <= 1.5) ento
escreva PESSOA[I].NOME
escreva PESSOA[I].ALTURA
fim_se
fim_para
fim_se
se (OPO = 3) ento
se (PESSOA[I].ALTURA > 1.5) ento
fim_se
fim_para
fim_se
se (OPO = 4) ento
se (PESSOA[I].ALTURA > 1.5) .e. (PESSOA[I].ALTURA < 2) ento
fim_se
fim_para
fim_se
se (OPO = 5) ento
Somar 0
SOMAR SOMAR + PESSOA[I].ALTURA
fim_para
MDIA SOMAR / 15
escreva MDIA
fim_se
fim_enquanto
fim
155
156
Diagrama de Blocos
157
158
tipo
Dados = registro
NOME : cadeia
ALTURA : real
fim_registro
var
I, J, OPO : inteiro
SOMAR, MDIA : real
incio
OPO 0
escreva "6 - Fim"
leia OPO
se (OPO = 1) ento
leia PESSOA[I].NOME
fim_para
fim_se
se (OPO = 2) ento
fim_se
fim_para
fim_se
se (OPO = 3) ento
fim_se
fim_para
fim_se
se (OPO = 4) ento
fim_se
fim_para
fim_se
se (OPO = 5) ento
Somar 0
fim_para
MDIA SOMAR / 15
escreva MDIA
fim_se
fim_enquanto
fim
159
160
tipo
Dados = registro
MATRICULA : inteiro
NOME : cadeia
SALRIO : real
fim_registro
var
FUNC : conjunto[1..20] de Dados
X : Dados
I, J, OPO, COMEO, FINAL, MEIO : inteiro
ACHA : lgico
PESQ : inteiro
incio
OPO 0
escreva "4 - Apresentar salrios > 1000"
escreva "5 - Apresentar salrios < 1000"
escreva "6 - Apresentar salrios = 1000"
escreva "7 - Fim"
leia OPO
se (OPO = 1) ento
leia FUNC[I].MATRICULA
leia FUNC[I].NOME
leia FUNC[I].SALRIO
fim_para
fim_se
se (OPO = 2) ento
se (FUNC[I].MATRICULA > FUNC[J].MATRICULA) ento
X FUNC[I]
FUNC[I] FUNC[J]
FUNC[J] X
fim_se
fim_para
fim_para
fim_se
se (OPO = 3) ento
leia PESQ
COMEO 1
FINAL 20
ACHA .Falso.
se (PESQ = FUNC[MEIO].MATRICULA) ento
ACHA .Verdadeiro.
seno
se (PESQ < FUNC[MEIO].MATRICULA) ento
FINAL MEIO - 1
seno
COMECO MEIO + 1
fim_se
fim_se
fim_enquanto
escreva FUNC[MEIO].MATRICULA
escreva FUNC[MEIO].NOME
escreva FUNC[MEIO].SALRIO
seno
fim_se
fim_se
se (OPCAO = 4) ento
se (FUNC[I].SALRIO > 1000) ento
escreva FUNC[I].MATRICULA
escreva FUNC[I].NOME
escreva FUNC[I].SALRIO
fim_se
fim_para
fim_se
se (OPCAO = 5) ento
se (FUNC[I].SALRIO < 1000) ento
fim_se
fim_para
fim_se
se (OPCAO = 6) ento
se (FUNC[I].SALRIO = 1000) ento
161
162
fim_se
fim_para
fim_se
fim_enquanto
fim

a) Diagramas de Blocos
tipo
Dados = registro
NOME : cadeia
ENDEREO : cadeia
TELEFONE : cadeia
fim_registro
var
AGENDA : conjunto[1..10] de Dados
procedimento Cadastrar
var
I : inteiro
incio
leia AGENDA[I].NOME
leia AGENDA[I].ENDEREO
leia AGENDA[I].TELEFONE
163
164
fim_para
fim
procedimento Pesquisar
var
ACHA : lgico
PESQ : cadeia
I, J : inteiro
incio
leia PESQ
I 1
ACHA .Falso.
se (PESQ = AGENDA[I].NOME) ento
ACHA .Verdadeiro.
seno
I I + 1
fim_se
fim_enquanto
seno
escreva Registro Inexistente
fim_se
fim
procedimento Classificar
var
X : Dados
I, J : inteiro
incio
se (AGENDA[I].NOME > AGENDA[J].NOME) ento
X AGENDA[I]
AGENDA[I] AGENDA[J]
AGENDA[J] X
fim_se
fim_para
fim_para
fim
procedimento Apresentar
var
I : inteiro
incio
fim_para
fim
var
OPO : inteiro
incio
OPO 0
escreva "5 - Fim"
leia OPO
se (OPO <> 5) ento
caso OPO
seja 1 faa Cadastrar
seja 2 faa Pesquisar
seja 3 faa Classificar
seja 4 faa Apresentar
seno
escreva "Opo invlida - Tente novamente"
fim_caso
fim_se
fim_enquanto
fim
b) Diagramas de Blocos
165
166
tipo
Dados = registro
NOME : cadeia
NOTA : conjunto[1..4] de real
MDIA : real
fim_registro
var
ALUNO : conjunto[1..20] de Dados
var
I, J : inteiro
SOMAR : real
X : Dados
incio
SOMAR 0
leia ALUNO[I].NOME
leia ALUNO[I].NOTA[J]
SOMAR SOMAR + ALUNO[I].NOTA[J]
fim_para
ALUNO[I].MEDIA SOMAR / 4
167
168
fim_para
se (ALUNO[I].NOME > ALUNO[J].NOME) ento
X ALUNO[I]
ALUNO[I] ALUNO[J]
ALUNO[J] X
fim_se
fim_para
fim_para
fim
var
I, COMEO, FINAL, MEIO : inteiro
ACHA : lgico
PESQ: cadeia
incio
leia PESQ
COMEO 1
FINAL 20
ACHA .Falso.
se (PESQ = ALUNO[MEIO].NOME) ento
ACHA .Verdadeiro.
seno
se (PESQ < ALUNO[MEIO].NOME) ento
FINAL MEIO - 1
seno
COMEO MEIO + 1
fim_se
fim_se
fim_enquanto
escreva ALUNO[MEIO].NOME
escreva ALUNO[MEIO].NOTA[I]
fim_se
escreva ALUNO[MEIO].MDIA
se (ALUNO[MEIO].MDIA >= 5) ento
escreva "Aprovado"
seno
escreva "Reprovado"
fim_se
seno
escreva "registro Inexistente"
fim_se
fim
procedimento Todos
var
I, J : inteiro
incio
escreva ALUNO[I].NOTA[J]
fim_para
escreva ALUNO[I].MDIA
se (ALUNO[I].MDIA >= 5) ento
escreva "Aprovado"
seno
escreva "Reprovado"
fim_se
fim_para
fim
procedimento Aprovados
var
I, J : inteiro
incio
se (ALUNO[I].MDIA >= 5) ento
fim_se
fim_para
fim
procedimento Reprovados
var
I, J : inteiro
incio
se (ALUNO[I].MDIA < 5) ento
fim_se
fim_para
fim
var
OPO : inteiro
incio
OPO 0
escreva "3 - Apresentar Todos"
escreva "4 - Apresentar Aprovados"
escreva "5 - Apresentar Reprovados"
escreva "6 - Fim"
leia OPO
se (OPO <> 6) ento
caso OPO
seja 3 faa Todos
seja 4 faa Aprovados
seja 5 faa Reprovados
seno
fim_caso
fim_se
fim_enquanto
fim
169
170
c) Diagramas de Blocos
tipo
Dados = registro
NOME : cadeia
ALTURA : de real
fim_registro
var
var
I : inteiro
incio
leia PESSOA[I].NOME
fim_para
fim
procedimento Apresentar1
var
171
172
I : inteiro
incio
fim_se
fim_para
fim
var
I : inteiro
incio
fim_se
fim_para
fim
var
I : inteiro
incio
fim_se
fim_para
fim
var
I : inteiro
SOMAR, MDIA : real
incio
Somar 0
fim_para
MDIA SOMAR / 15
escreva MDIA
fim
var
OPO : inteiro
incio
OPO 0
escreva "6 - Fim"
leia OPO
se (OPO <> 6) ento
caso OPO
seja 2 faa Apresentar1
seno
fim_caso
fim_se
fim_enquanto
fim
173
174
175
176
var
tipo
Dados = registro
MATRICULA : inteiro
NOME : cadeia
SALRIO : real
fim_registro
var
FUNC : conjunto[1..20] de Dados
var
I : inteiro
incio
leia FUNC[I].MATRICULA
leia FUNC[I].NOME
leia FUNC[I].SALRIO
fim_para
fim
procedimento Classificar
var
I, J : inteiro
X : Dados
incio
se (FUNC[I].MATRICULA > FUNC[J].MATRICULA) ento
X FUNC[I]
FUNC[I] FUNC[J]
FUNC[J] X
fim_se
fim_para
fim_para
fim
var
COMEO, FINAL, MEIO, PESQ : inteiro
ACHA : lgico
incio
leia PESQ
COMEO 1
FINAL 20
ACHA .Falso.
se (PESQ = FUNC[MEIO].MATRICULA) ento
ACHA .Verdadeiro.
seno
se (PESQ < FUNC[MEIO].MATRICULA) ento
FINAL MEIO - 1
seno
COMEO MEIO + 1
fim_se
fim_se
fim_enquanto
escreva FUNC[MEIO].MATRICULA
escreva FUNC[MEIO].NOME
escreva FUNC[MEIO].SALRIO
seno
fim_se
fim
var
I : inteiro
incio
se (FUNC[I].SALRIO > 1000) ento
177
178
fim_se
fim_para
fim
var
I : inteiro
incio
se (FUNC[I].SALRIO < 1000) ento
fim_se
fim_para
fim
var
I : inteiro
incio
se (FUNC[I].SALRIO = 1000) ento
fim_se
fim_para
fim
var
OPO : inteiro
incio
OPO 0
escreva "4 - Apresentar salrios > 1000"
escreva "5 - Apresentar salrios < 1000"
escreva "6 - Apresentar salrios = 1000"
escreva "7 - Fim"
leia OPO
se (OPO <> 7) ento
caso OPO
seja 2 faa Classificar
seno
fim_caso
fim_se
fim_enquanto
fim
179

procedimento Prestao(VALOR, TAXA, TEMPO : real)
var
PREST : real
incio
PREST VALOR + (VALOR * (TAXA / 100) * TEMPO)
escreva PREST
fim
var
VAL, TAX, TMP : real
incio
leia VAL, TAX, TMP
Prestao(VAL, TAX, TMP)
fim
procedimento Somatrio(N : inteiro)
var
S, I : inteiro
incio
S 0
para I de 1 at N passo 1 faa
S S + I
fim_para
escreva S
fim
var
LIMITE : inteiro
incio
leia LIMITE
Somatrio(LIMITE)
fim
180
c) Diagramas de Blocos
procedimento Fibonacci(N : inteiro)
var
incio
ANTERIOR 0
ATUAL 1
ANTERIOR ATUAL
ATUAL PRXIMO
fim_para
escreva ANTERIOR
fim
var
NMERO : inteiro
incio
leia NMERO
Fibonacci(NMERO)
fim
d) Diagramas de Blocos
procedimento Potncia(BASE, EXPOENTE :
inteiro)
var
I, P : inteiro
incio
P 1
para I de 1 at EXPOENTE passo 1 faa
P P * BASE
fim_para
escreva P
fim
var
B, E : inteiro
incio
leia B, E
Potncia(B, E)
Fim
e) Diagramas de Blocos
procedimento TipoNumrico(N : inteiro)
var
R : inteiro
incio
R N - 2 * (N div 2)
se (R = 0) ento
escreva "Valor Par"
seno
escreva "Valor Impar"
fim_se
fim
var
NMERO : inteiro
incio
leia NMERO
TipoNumrico(NMERO)
fim
181
f) Diagramas de blocos
procedimento Somaquad(A, B, C : inteiro)
var
SOMA : inteiro
incio
SOMA (A 2) + (B 2) + (C 2)
escreva SOMA
fim
var
A, B, C : inteiro
incio
leia A, B, C
Somaquad(A, B, C)
fim
g) Diagramas de blocos
procedimento Quadsoma(A, B, C : inteiro)
var
QUADRADO : inteiro
incio
QUADRADO (A + B + C) 2
escreva QUADRADO
fim
var
A, B, C : inteiro
incio
leia A, B, C
Quadsoma(A, B, C)
fim
h) Diagramas de blocos
procedimento C2F(C : real)
var
F : real
incio
F (9 * C + 160) / 5
escreva F
fim
var
C : real
incio
leia C
C2F(C)
Fim
i) Diagramas de blocos
procedimento Cotdolar(US, COT : real)
var
QUANT_REAL : real
incio
QUANT_REAL US * COT
escreva QUANT_REAL
fim
var
DOLAR, COTAO : real
incio
leia DOLAR, COTAO
Cotdolar(DOLAR, COTAO)
Fim
182
j) Diagramas de blocos
procedimento Divisvel1(VALOR : inteiro)
var
R2, R3 : inteiro
incio
R2 VALOR - 2 * (VALOR div 2)
se (R2 = 0) .e. (R3 = 0) ento
escreva "Este valor divisvel por 2 e 3"
seno
escreva "Valor invlido"
fim_se
fim
var
N : inteiro
incio
leia N
Divisvel1(N)
fim
k) Diagramas de blocos
var
R2, R3 : inteiro
incio
se (R2 = 0) .ou. (R3 = 0) ento
escreva "Este valor divisvel por 2 ou 3"
seno
fim_se
fim
var
N : inteiro
incio
leia N
Divisvel2(N)
fim
183
l) Diagramas de blocos
var
R2, R3 : inteiro
incio
se .no. (R2 = 0) .e. .no. (R3 = 0) ento
escreva "Este valor no divisvel por 2 e 3"
seno
fim_se
fim
var
N : inteiro
incio
leia N
Divisvel3(N)
fim
m) Diagramas de blocos
procedimento Mdulo(NMERO : inteiro)
incio
se (NMERO < 0)ento
NMERO NMERO * (-1)
fim_se
escreva NMERO
fim
var
N : inteiro
incio
leia N
Mdulo(N)
fim
184
n) Diagramas de blocos
procedimento Mensagem(NOME, SEXO : cadeia)
incio
se (SEXO = "masculino") ento
escreva "Ilmo. Sr. ", NOME
seno
escreva "Ilma. Sra. ", NOME
fim_se
fim
var
NOME, SEXO : cadeia
incio
leia NOME, SEXO
Mensagem(NOME, SEXO)
fim
o) Diagramas de blocos
procedimento Fatorial(N : inteiro)
var
I, F : inteiro
incio
F 1
F F * I
fim_para
escreva F
fim
var
NMERO : inteiro
incio
leia NMERO
Fatorial(NMERO)
fim
185
p) Diagramas de blocos
procedimento Compra(QA, QB : inteiro)
var
TOT_A, TOT_B, TOTAL : inteiro
TOT_COMPRA : real
incio
se (QA <> 0) .e. (QB <> 0) ento
TOT_A QA * 10
TOT_B QB * 20
TOTAL TOT_A + TOT_B
TOT_COMPRA TOTAL - TOTAL * 0.15
seno
se (QA = 0) .e. (QB <> 0) ento
TOTAL QB * 20
seno
TOTAL QA * 10
fim_se
fim_se
escreva TOT_COMPRA
fim
var
PROD_A, PROD_B : inteiro
incio
leia PROD_A, PROD_B
Compra(PROD_A, PROD_B)
fim

a) Diagramas de blocos
procedimento Prestao(VALOR, TAXA, TEMPO : real; var PREST : real)
incio
PREST VALOR + (VALOR * (TAXA / 100) * TEMPO)
fim
var
VAL, TAX, TMP, PRE : real
incio
leia VAL, TAX, TMP
Prestao(VAL, TAX, TMP, PRE)
escreva PRE
fim
186
b) Diagramas de blocos
procedimento Somatrio(N : inteiro; var S : inteiro)
var
I : inteiro
incio
S 0
S S + I
fim_para
fim
var
LIMITE, RESULTADO : inteiro
incio
leia LIMITE
Somatrio(LIMITE, RESULTADO)
escreva RESULTADO
fim
c) Diagramas de blocos
procedimento Fibonacci(N : inteiro; var FIB : inteiro)
var
incio
ANTERIOR 0
ATUAL 1
ANTERIOR ATUAL
ATUAL PRXIMO
fim_para
FIB ANTERIOR
fim
var
NMERO, RESPOSTA : inteiro
incio
leia NMERO
Fibonacci(NMERO, RESPOSTA)
escreva RESPOSTA
fim
187
d) Diagramas de blocos
procedimento Potncia(BASE, EXPOENTE : inteiro; var P : inteiro)
var
I : inteiro
incio
P 1
P P * BASE
fim_para
fim
var
B, E, R : inteiro
incio
leia B, E
Potncia(B, E, R)
escreva R
fim
e) Diagramas de blocos
procedimento TipoNumrico(N : inteiro; var RESP : cadeia)
var
R : inteiro
incio
R N - 2 * (N div 2)
se (R = 0) ento
RESP "Valor par"
seno
RESP "Valor impar"
fim_se
fim
var
NMERO : inteiro
RESPOSTA : cadeia
188
incio
leia NMERO
TipoNumrico(NMERO, RESPOSTA)
escreva RESPOSTA
fim
f) Diagramas de blocos
procedimento Somaquad(A, B, C : inteiro; var SOMA : inteiro)
incio
SOMA (A 2) + (B 2) + (C 2)
fim
var
A, B, C, SOMA : inteiro
incio
leia A, B, C
Somaquad(A, B, C, SOMA)
escreva SOMA
fim
g) Diagramas de blocos
procedimento Quadsoma(A, B, C : inteiro; var QUADRADO : inteiro)
incio
QUADRADO (A + B + C) 2
fim
var
A, B, C, QUAD : inteiro
incio
leia A, B, C
Quadsoma(A, B, C, QUAD)
escreva QUAD
fim
189
h) Diagramas de blocos
procedimento C2F(C : real; var F : real)
incio
F (9 * C + 160) / 5
fim
var
C, F : real
incio
leia C
C2F(C, F)
escreva F
fim
i) Diagramas de blocos
procedimento Cotdolar(US, COT : real; var QUANT_REAL : real)
incio
QUANT_REAL US * COT
fim
var
DOLAR, COTAO, QUANTIA : real
incio
leia DOLAR, COTAO
Cotdolar(DOLAR, COTAO, QUANTIA)
escreva QUANTIA
fim
190
j) Diagramas de Blocos
procedimento Divisvel1(VALOR : inteiro; var RESPOSTA : cadeia)
var
R2, R3 : inteiro
incio
se (R2 = 0) .e. (R3 = 0) ento
RESPOSTA "Este valor divisvel por 2 e 3"
seno
RESPOSTA "Valor invlido"
fim_se
fim
var
N : inteiro
RESP : cadeia
incio
leia N
Divisvel1(N, RESP)
escreva RESP
fim
k) Diagramas de Blocos
procedimento Divisvel2(VALOR : inteiro; var RESPOSTA : cadeia)
var
R2, R3 : inteiro
incio
se (R2 = 0) .ou. (R3 = 0) ento
RESPOSTA "Este valor divisvel por 2 ou 3"
seno
fim_se
fim
var
N : inteiro
RESP : cadeia
incio
leia N
Divisvel2(N, RESP)
escreva RESP
fim
l) Diagramas de Blocos
191
192
procedimento Divisvel3(VALOR : inteiro, var RESPOSTA : cadeia)
var
R2, R3 : inteiro
incio
se .no. (R2 = 0) .e. .no. (R3 = 0) ento
RESPOSTA "Este valor no divisvel por 2 e 3"
seno
fim_se
fim
var
N : inteiro
RESP : cadeia
incio
leia N
Divisvel3(N, RESP)
escreva RESP
fim
m) Diagramas de Blocos
procedimento Mdulo(var NMERO : inteiro)
incio
se (NMERO < 0) ento
NMERO NMERO * (-1)
fim_se
fim
var
N : inteiro
incio
leia N
Mdulo(N)
escreva N
fim
193
n) Diagramas de Blocos
procedimento
incio
se (SEXO =
RESPOSTA
seno
RESPOSTA
fim_se
fim
Mensagem(NOME, SEXO : cadeia; var RESPOSTA : cadeia)

"masculino") ento
"Ilmo. Sr. " + NOME
"Ilma. Sra. " + NOME
var
NOME, SEXO, SAUDAO : cadeia
incio
leia NOME, SEXO
Mensagem(NOME, SEXO, SAUDAO)
escreva SAUDAO
fim
o) Diagramas de Blocos
procedimento Fatorial(N : inteiro; var F : inteiro)
var
I : inteiro
incio
F 1
F F * I
fim_para
fim
var
NMERO, FAT : inteiro
incio
leia NMERO
Fatorial(NMERO, FAT)
escreva FAT
fim
194
p) Diagramas de Blocos
procedimento Compra(QA, QB : inteiro; var TOT : real)
var
TOT_A, TOT_B, TOTAL : inteiro
TOT_COMPRA : real
incio
se (QA <> 0) .e. (QB <> 0) ento
TOT_A QA * 10
TOT_B QB * 20
TOTAL TOT_A + TOT_B
seno
se (QA = 0) .e. (QB <> 0) ento
TOTAL QB * 20
seno
TOTAL QA * 10
fim_se
fim_se
TOT TOT_COMPRA
fim
var
PROD_A, PROD_B : inteiro
TOTAL : real
incio
leia PROD_A, PROD_B
Compra(PROD_A, PROD_B, TOTAL)
escreva TOTAL
fim
195

funo Somatrio(N : inteiro) : inteiro
var
S, I : inteiro
incio
S 0
S S + I
fim_para
Somatrio S
fim
var
NMERO : inteiro
incio
leia NMERO
escreva Somatrio(NMERO)
fim
funo Fibonacci(N : inteiro) : inteiro
var
incio
ANTERIOR 0
ATUAL 1
ANTERIOR ATUAL
ATUAL PRXIMO
fim_para
Fibonacci ANTERIOR
fim
var
NMERO : inteiro
incio
leia NMERO
escreva Fibonacci(NMERO)
fim
196
c) Diagramas de Bloco
funo Prest(VALOR, TAXA, TEMPO : real) : real
incio
Prest VALOR + (VALOR * (TAXA / 100) *
TEMPO)
fim
var
VALOR, TAXA, TEMPO : real
incio
leia VALOR, TAXA, TEMPO
escreva Prest(VALOR, TAXA, TEMPO)
fim
d) Diagramas de Blocos
funo Potncia(BASE, EXPOENTE : inteiro) :
inteiro
var
I, P : inteiro
incio
P 1
P P * BASE
fim_para
Potncia P
fim
var
B, E : inteiro
incio
leia B, E
escreva Potncia(B, E)
fim
e) Diagramas de Bloco
funo Somaquad(A, B, C : inteiro) : inteiro
incio
Somaquad (A 2) + (B 2) + (C 2)
fim
var
A, B, C : inteiro
incio
leia A, B, C
escreva Somaquad(A, B, C)
fim
197
f) Diagramas de Blocos
funo Quadsoma(A, B, C : inteiro) : inteiro
incio
Quadsoma (A + B + C) 2
fim
var
A, B, C : inteiro
incio
leia A, B, C
escreva Quadsoma(A, B, C)
fim
g) Diagramas de Blocos
funo Cotdolar(US, COT : real) : real
incio
Cotdolar US * COT
fim
var
DOLAR, COTAO : real
incio
leia DOLAR, COTAO
escreva Cotdolar(DOLAR, COTAO)
fim
h) Diagramas de Bloco
funo Convdolar(VR, COT : real) : real
incio
Convdolar VR / COT
fim
var
VREAL, COTAO : real
incio
leia VREAL, COTAO
escreva Convdolar(VREAL, COTAO)
fim
i) Diagramas de Bloco
funo F2C(F : real) : real
incio
F2C (F - 32) * (5 / 9)
fim
var
F : real
incio
leia F
escreva F2C(F)
fim

Algoritmos - Lógica para Desenvolvimento de Programação de Computadores (Resposta Dos Exercícios)

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Algoritmos - Lógica para Desenvolvimento de Programação de Computadores (Resposta Dos Exercícios)

Enviado por

Direitos autorais:

Formatos disponíveis

Gabarito dos Exerccios de Fixao do livro

Gabarito dos Exerccios

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Algoritmos e Lgica de Programao;

1.2 - Competncias e Habilidades

1.3 - Contedo de Programao de Computadores Abordado na Obra

Gabarito dos Exerccios de Fixao do livro

Captulo 5. Lgica de Programao de Computadores

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

2 - Gabarito dos Exerccios

3 - Exerccios de Fixao do Captulo 3

Tpico 3.9 - Exerccio 2 - Pgina 56

(_) SOBRE NOME

Gabarito dos Exerccios de Fixao do livro

Tpico 3.9 - Exerccio 3 - Pginas 57 e 58

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

4 - Exerccios de fixao do captulo 4

Tpico 4.7 - Exerccio 2 - Pgina 97 e 98

Gabarito dos Exerccios de Fixao do livro

Tpico 4.7 - Exerccio 3 - Pgina 99 e 100

Este programa tambm pode ser escrito da seguinte forma:

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Este programa tambm pode ser escrito da seguinte forma:

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Tpico 4.7 - Exerccio 3g

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Tpico 4.7 - Exerccio 3h

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

5 - Exerccios de fixao do captulo 5

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

5.2 - Lao de repetio pr-teste - controle condicional falso

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores

Gabarito dos Exerccios de Fixao do livro

Algoritmos - Lgica para Desenvolvimento de Programao de Computadores