Gabarito Respostas

Gabarito dos Exerccios de Fixao do Livro 1
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
Gabarito dos Exerccios
de Fixao do Livro

2 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
.F. LGICO
.Falso. LGICO
.V. LGICO
"0.87" CADEIA
"0" CARACTERE
"9.12" CADEIA
"900" CADEIA
"Casa 8" CADEIA
"Cinco" CADEIA
"V" CARACTERE
0 INTEIRO
1.56 REAL
1.56 REAL
34 INTEIRO
45.8976 REAL
465 INTEIRO
678 INTEIRO
678 INTEIRO
99.8 REAL
.V. LGICO
1000 INTEIRO
(X) ENDEREO
(_) 21BRASIL
(_) FONE$COM
(X) NAMEUSER
(X) NOME_USURIO
(_) NOME*USURIO
(_) END*A-6
(X) CIDADE3
(_) #CABEC
(_) REAL
(_) REAL$
(_) SOBRE NOME

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
seguinte forma:

programa
var
A, B, X : real
incio
leia A, B
X A
A B
B X
escreva A, B
fim

Este programa tambm pode ser escrito da
seguinte forma:

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

Tpico 3.9 - Exerccio - Pgina 58
j) Diagrama de bloco


programa Cap03_Ex3j_Pg058
var
A, B, R : inteiro
incio
leia A, B
R (A B) 2
escreva R
fim

k) Diagrama de bloco


programa Cap03_Ex3k_Pg058
var
R, US, COTAO : real
incio
leia US, COTAO
R US * COTAO
escreva R
fim
l) Diagrama de bloco


programa Cap03_Ex3l_Pg058
var
R, US, COTAO : real
incio
leia R, COTAO
US R / COTAO
escreva US
fim
m) Diagrama de bloco


programa Cap03_Ex3m_Pg058
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

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

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
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 98 e 99
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
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

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
b) Diagrama de blocos


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
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



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 - Pgina 100
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.




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 por 2 e 3"
fim_se
RESTO2 B - 2 * (B div 2)
escreva "O valor ", B, " divisvel por 2 e 3"
fim_se
RESTO2 C - 2 * (C div 2)
escreva "O valor ", C, " divisvel por 2 e 3"
fim_se
RESTO2 D - 2 * (D div 2)
escreva "O valor ", D, " divisvel por 2 e 3"
fim_se
fim

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 : inteiro
incio
leia A, B, C, D
se (RESTO2 = 0) .ou. (RESTO3 = 0) ento
escreva "O valor ", A, " divisvel por 2 ou 3"
fim_se
escreva "O valor ", B, " divisvel por 2 ou 3"
fim_se
escreva "O valor ", C, " divisvel por 2 ou 3"
fim_se
escreva "O valor ", D, " divisvel por 2 ou 3"
fim_se
fim

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
fim_se
se (VALOR_MENOR > C) ento
VALOR_MENOR C
fim_se
se (VALOR_MENOR > D) ento
VALOR_MENOR D
fim_se
se (VALOR_MENOR > E) ento
VALOR_MENOR E
fim_se
escreva VALOR_MAIOR, VALOR_MENOR
fim


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



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



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



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



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



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



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



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



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



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



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



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



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
fim



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



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



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



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




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



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



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



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



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



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



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



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

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

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

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

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



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

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

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

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

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

q) Diagrama de blocos


var
incio
TOTAL 0
RESPOSTA "SIM"
repita
TOTAL TOTAL + REA
leia RESPOSTA
at_que (RESPOSTA <> "SIM")
escreva TOTAL
fim

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
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



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



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



var
P, I : inteiro
incio
P 1
I 0
continua
escreva P
P P * 3
I I + 1
fim

h) Diagrama de blocos Portugus estruturado

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



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



var
incio
GRO 0
QUADRO 1
I 1
continua
GRO GRO + QUADRO
QUADRO QUADRO 2
I I + 1
escreva GRO
fim



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



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

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

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

q) Digrama de blocos


var
incio
TOTAL 0
RESPOSTA "SIM"
continua
TOTAL TOTAL + REA
leia RESPOSTA
enquanto_for (RESPOSTA = "SIM")
escreva TOTAL
fim

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

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

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

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

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

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

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

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
o) Digrama de blocos Portugus estruturado

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



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

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



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
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



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



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


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



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.



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

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



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



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



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



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



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



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



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



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



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



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

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

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

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

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

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



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



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



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



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



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



var
I, PESQ : inteiro
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



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



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



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
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


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



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



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
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



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

s) Diagrama de blocos Portugus estruturado

var
A : conjunto[1..10] de real
I, PESQ : inteiro
RESP : cadeia
ACHA : lgico
incio
leia A[I]
fim_para
RESP "SIM"
leia PESQ
I 1
ACHA .Falso.
se (PESQ = B[I]) ento
ACHA .Verdadeiro.
seno
I I + 1
fim_se
fim_enquanto
seno
fim_se
leia RESP
fim_enquanto
fim

Tpico 8.5 - Exerccio 1 a - Pgina 185


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

b) Diagrama de blocos Portugus estruturado


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



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



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



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



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



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
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



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



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



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



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



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



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



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



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



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
C[I,J] A[I,J] + B[I,J]
fim_para
fim_para
escreva C[I,J]
fim_para
fim_para
fim

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

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

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
C[I,J] A[I,J] + B[I,J]
fim_para
fim_para
escreva C[I,J]
fim_para
fim_para
fim

Diagrama de blocos


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





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]
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



programa Ex3_Pg166
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

Diagrama de Blocos




programa Ex3_Pg166
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


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
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
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



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
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

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
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






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
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



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
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
Tpico 10.9 - Exerccio 2 d - Pgina 261
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

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

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

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

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

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

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

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
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

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

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



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



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

n) Diagramas de Blocos


procedimento Mensagem(NOME, SEXO : cadeia, var RESPOSTA : cadeia)
incio
se (SEXO = "masculino") ento
RESPOSTA "Ilmo. Sr. " + NOME
seno
RESPOSTA "Ilma. Sra. " + NOME
fim_se
fim

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

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




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

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 Portugus Estruturado


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

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 Portugus Estruturado


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

Gabarito Respostas

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

Gabarito Respostas

Enviado por

Direitos autorais:

Formatos disponíveis

Gabarito dos Exerccios de Fixao do Livro 1

Você também pode gostar