Gabarito respostas (3)

Gabarito dos Exercícios de Fixação do Livro

1

Gabarito dos Exercícios
de Fixação do Livro

Sumário
1 - Informações Gerais ..................................................................................................................................................................................4
1.1 - Base Tecnológica para o Ensino de Lógica de Programação ..........................................................................................................4
1.2 - Competências e Habilidades ............................................................................................................................................................4
1.3 - Conteúdo de Programação de Computadores Abordado na Obra...................................................................................................4
2 - Gabarito dos Exercícios ...........................................................................................................................................................................6
3 - Exercícios de Fixação do Capítulo 3........................................................................................................................................................6
4 - Exercícios de fixação do capítulo 4........................................................................................................................................................14
5.1 - Laço de repetição pré-teste - controle condicional verdadeiro .......................................................................................................23
5.2 - Laço de repetição pré-teste - controle condicional falso.................................................................................................................35
5.3 - Laço de repetição pós-teste - controle condicional falso ................................................................................................................47
5.4 - Laço de repetição pós-teste - controle condicional verdadeiro.......................................................................................................58
5.5 - Laço de Repetição Condicional Seletivo ........................................................................................................................................70
5.6 - Laço de Repetição Incondicional ....................................................................................................................................................81
7 - Exercícios de fixação do capítulo 7......................................................................................................................................................103
10 - Exercícios de fixação do capítulo 10..................................................................................................................................................162

2

Algoritmos - Lógica para Desenvolvimento de Programação de Computadores

1 - Informações Gerais
1.1 - Base Tecnológica para o Ensino de Lógica de Programação
Normalmente a base tecnológica da lógica de programação para computadores é ministrada em vários cursos da área de Tecnologia
da Informação (também denominada por algumas pessoas como Área de Informática), seja em nível técnico (cursos técnicos de nível
médio), nível tecnológico (cursos técnicos de nível superior), bacharelado (cursos de nível superior, tais como Sistemas de Informação,
Ciência da Computação, Engenharia da Computação, entre outros), cursos de treinamento empresarial e cursos livres, com algumas
denominações diferentes, a saber:
Algoritmos e Lógica de Programação;
Algoritmos e Pseudocódigos;
Algoritmos;
Lógica Computacional;
Lógica de Programação de Computadores;
Lógica de Programação;
Lógica;
Técnicas de Programação - Lógica;
Estudo de Algoritmos Computacionais;
Introdução à Lógica de Programação;
Introdução ao Algoritmo;
Linguagem e Técnica de Programação;
Lógica Aplicada à Programação de Computadores;
Lógica de Programação - Algoritmos;
Técnicas Básicas de Programação de Computadores;
Técnicas de Programação - Algoritmos;
Entre outras possíveis denominações.
Independentemente da nomenclatura utilizada para designá-la, fica evidente a necessidade de desenvolver as habilidades de raciocínio
lógico aplicado à programação de computadores, por meio da utilização e implementação de algoritmos computacionais. Neste sentido,
a obra à qual este gabarito pertence busca atender seu público, respeitando as estruturas definidas de programação de acordo com a
norma internacional ISO 5807:1985 no que tange à elaboração de diagramas de blocos (e não fluxogramas) e com as estruturas de
PDL (Program Design Language) propostas por Caine e Gordon na elaboração dos códigos em português estruturado.

1.2 - Competências e Habilidades
O aprendizado da lógica de programação de computadores é baseado na obtenção preliminar das seguintes competências:
Desenvolver algoritmos por meio da divisão estruturada com sub-rotinas e também com orientação a objetos;
Desenvolver algoritmos por meio da ação de refinamento sucessivo;
Interpretar pseudocódigos (algoritmos textuais) como base de documentação do raciocínio lógico para o desenvolvimento de
software;
Interpretar algoritmos gráficos baseados na norma ISO 5807:1985 (E);
Interpretar algoritmos textuais baseados na técnica PDL;
Avaliar resultados de teste dos algoritmos desenvolvidos;
Integrar módulos de programas desenvolvidos separadamente;
Desenvolver algoritmos segundo paradigma da orientação a objetos.
O aprendizado da lógica de programação de computadores é baseado na obtenção preliminar das seguintes habilidades:
Selecionar e utilizar técnicas de programação estruturada e/ou orientada a objetos na resolução de problemas computacionais;
Fazer uso de modelos, pseudocódigos, diagramas de blocos na representação da solução de problemas computacionais;
Executar procedimentos de testes de programas.

1.3 - Conteúdo de Programação de Computadores Abordado na Obra
Capítulo 1. Introdução à Computação
Capítulo 2. Mercado Computacional
Capítulo 3. Linguagens de Programação
Capítulo 4. Algoritmos Computacionais


Capítulo 5. Lógica de Programação de Computadores
Capítulo 6. Compiladores, Interpretadores e Tradutores
Capítulo 7. Programação com Estrutura Sequencial
7.1. Etapas de Ação de um Computador
7.2. Tipos de Dados Primitivos
7.3. O Uso de Variáveis
7.4. O Uso de Constantes
7.5. Os Operadores Aritméticos
7.6. Expressões Aritméticas
7.7. Instruções e Comandos
7.8. Exercício de Aprendizagem
7.9. Exercícios de Fixação
Capítulo 8. Programação com Tomada de Decisão
8.1. Decisões, Condições e Operadores Relacionais
8.2. Tomada de Decisão Simples
8.3. Desvio Condicional Composto
8.4. Outras Formas de Tomada de Decisão
8.5. Operadores Lógicos
8.6. Divisibilidade: Múltiplos e Divisores
Capítulo 9. Programação com Laços
9.1. Laços ou Malhas de Repetição (Loopings ou Loops)
9.2. Laço de Repetição Condicional Pré-Teste
9.3. Laço de Repetição Condicional Pós-Teste
9.4. Laço de Repetição Condicional Seletivo
9.5. Laço de Repetição Incondicional
9.6. Considerações entre Tipos de Laços
Capítulo 10. Estruturas de Dados Homogêneas
10.1. Matrizes de Uma Dimensão (Vetores)
10.2. Classificação de Elementos
10.3. Métodos de Pesquisa de Elementos
10.4. Matrizes com Mais de Uma Dimensão (Tabelas)
10.5. Tipo de Dado Derivado: Estrutura de Registro
10.6. Estrutura de Registro de Matriz
10.7. Estrutura de Matriz de Registros
Capítulo 11. Subprogramas
11.1. Modularidade
11.2. Métodos Top-Down e Bottom-Up
11.3. Procedimentos
11.4. Escopo de Variáveis
11.5. Passagens de Parâmetros
11.6. Funções e Recursividade
Capítulo 12. Introdução à Programação Orientada a Objetos
12.1. Origem da Programação Orientada a Objetos
12.2. Programação Estruturada versus Programação Orientada a Objetos
12.3. Classes, Objetos, Atributos, Métodos, Herança e Encapsulamento
12.4. Poliformismo (Polimorfismo)

3

4


2 - Gabarito dos Exercícios
O material apresentado é de uso exclusivo do professor, com o objetivo de ajudar na preparação de aulas, bem como na escolha dos
exercícios a serem aplicados durante o curso ministrado, tanto para fixação como para avaliação.
São apresentadas as respostas dos exercícios de fixação do livro "Algoritmos - Lógica para o Desenvolvimento de Programação de
Computadores". Para cada exercício de programação são descritos o diagrama de bloco [de acordo com norma ISO 5807:1985 (E)] e o
código de programa correspondente escrito em PDL - Program Design Language (Português Estruturado).
As soluções fornecidas neste gabarito caracterizam-se por serem as mais genéricas possíveis, a fim de que fique fácil implementar
qualquer algoritmo em qualquer linguagem de programação de computadores. Não há intenção ou pretensão de que este gabarito
contenha a melhor resposta para um determinado exercício ou problema, mas apenas uma ideia de como conseguir determinada
resposta. Fica a critério do professor trabalhar as questões de refinamento algorítmico no sentido de buscar a melhor solução para um
determinado problema apresentado na obra.
As respostas do exercícios seguem como nomenclatura de nomes de programas a estrutura Cap03_Ex03b_Pg057, em que Cap indica
o número do capítulo, Ex o exercício em uso e Pg a página onde o exercício está posicionado no livro.

3 - Exercícios de Fixação do Capítulo 3
Tópico 3.9 - Exercício 1 - Página 56
−456

INTEIRO

0

INTEIRO

.F.

LÓGICO

1.56

REAL

.Falso.

LÓGICO

−1.56

REAL

.V.

LÓGICO

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.

LÓGICO

"V"

CARACTERE

1000

INTEIRO

(X) ENDEREÇO

(_) END*A-6

(_) 21BRASIL

(X) CIDADE3

(_) FONE$COM

(_) #CABEC

(X) NAMEUSER

(_) REAL

(X) NOME_USUÁRIO

(_) REAL$

(_) NOME*USUÁRIO

(_) SOBRE NOME

5


a) Diagrama de bloco

Português estruturado
programa Cap03_Ex3a_Pg057
var
C, F : real
início
leia C
F ← (9 * C + 160) / 5
escreva F
fim

b) Diagrama de bloco

programa Cap03_Ex3b_Pg057
var
C, F : real
início
leia F
C ← (F - 32) * (5 / 9)
escreva C
fim

c) Diagrama de bloco

programa Cap03_Ex3c_Pg057
var
VOLUME, R, ALTURA : real
início
leia R, ALTURA
VOLUME ← 3.14159 * R ↑ 2 * ALTURA
escreva VOLUME
fim

d) Diagrama de bloco

programa Cap03_Ex3d_Pg057
var
DISTÂNCIA, TEMPO, VELOCIDADE, LITROS_USADOS : real
início
leia TEMPO, VELOCIDADE
DISTÂNCIA ← TEMPO * VELOCIDADE
LITROS_USADOS ← DISTÂNCIA / 12
escreva VELOCIDADE, TEMPO, DISTÂNCIA, LITROS_USADOS
fim

6

e) Diagrama de bloco


programa Cap03_Ex3e_Pg057
var
PRESTAÇÃO, VALOR, TAXA, TEMPO : real
início
leia VALOR, TAXA, TEMPO
PRESTAÇÃO ← VALOR + (VALOR * (TAXA / 100) * TEMPO)
escreva PRESTAÇÃO
fim

f) Diagrama de bloco

programa
Cap03_Ex3f_Pg057_versão_1
var
A, B, X : inteiro
início
leia A, B
X ← A
A ← B
B ← X
escreva A, B
fim

Este programa também pode ser escrito da Este programa também pode ser escrito da
seguinte forma:
seguinte forma:
programa
var
A, B, X : real
início
leia A, B
X ← A
A ← B
B ← X
escreva A, B
fim

programa
var
A, B, X : cadeia
início
leia A, B
X ← A
A ← B
B ← X
escreva A, B
fim

7


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
início
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
início
leia COMPRIMENTO, LARGURA, ALTURA
VOLUME ← COMPRIMENTO * LARGURA * ALTURA
escreva VOLUME
fim

i) Diagrama de bloco

programa Cap03_Ex3i_Pg057
var
N, R : inteiro
início
leia N
R ← N * N (ou R ← N ↑ 2)
escreva R
fim

8


Tópico 3.9 - Exercício - Página 58
j) Diagrama de bloco

programa Cap03_Ex3j_Pg058
var
A, B, R : inteiro
início
leia A, B
R ← (A − B) ↑ 2
escreva R
fim

k) Diagrama de bloco

programa Cap03_Ex3k_Pg058
var
R, US, COTAÇÃO : real
início
leia US, COTAÇÃO
R ← US * COTAÇÃO
escreva R
fim

l) Diagrama de bloco

programa Cap03_Ex3l_Pg058
var
R, US, COTAÇÃO : real
início
leia R, COTAÇÃO
US ← R / COTAÇÃO
escreva US
fim

m) Diagrama de bloco

programa Cap03_Ex3m_Pg058
var
R, A, B, C : inteiro
início
leia A, B, C
R ← (A ↑ 2) + (B ↑ 2) + (C ↑ 2)
escreva R
fim

9


n) Diagrama de bloco

programa Cap03_Ex3n_Pg058
var
R, A, B, C : inteiro
início
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
início
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
início
leia SM, PR
NS ← SM + SM * PR / 100
escreva NS
fim

q) Diagrama de bloco

programa Cap03_Ex3q_Pg058
var
A, R : real
início
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
início
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
início
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, DISTÂNCIA, TEMPO : real
início
leia DISTÂNCIA, TEMPO
VELOCIDADE ← (DISTÂNCIA * 1000) / (TEMPO * 60)
escreva VELOCIDADE
fim

11


u) Diagrama de bloco

programa Cap03_Ex3u_Pg058
var
VOLUME, RAIO : real
início
leia RAIO
VOLUME ← (4 / 3) * 3.14159 * (RAIO ↑ 3)
escreva VOLUME
fim

v) Diagrama de bloco

programa Cap03_Ex3v_Pg058
var
BASE, EXPOENTE, POTÊNCIA : inteiro
início
leia BASE, EXPOENTE
POTÊNCIA ← BASE ↑ EXPOENTE
escreva POTÊNCIA
fim

w) Diagrama de bloco

programa Cap03_Ex3x_Pg058
var
PÉS, METROS : real
início
leia PÉS
METROS ← PÉS * 0,3048
escreva METROS
fim

x) Diagrama de bloco

var
RAIZ, BASE, ÍNDICE : REAL
início
leia BASE, ÍNDICE
RAIZ ← BASE ↑ (1 / ÍNDICE)
escreva RAIZ
fim

12

y) Diagrama de bloco


programa Cap03_Ex3y_Pg058
var
VALOR, SUCESSOR, ANTECESSOR : INTEIRO
início
leia VALOR
SUCESSOR ← VALOR + 1
ANTECESSOR ← VALOR - 1
escreva SUCESSOR, ANTECESSOR
fim

4 - Exercícios de fixação do capítulo 4
Tópico 4.7 - Exercício 1 - Páginas 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 exercícios o aluno perceba a posição das condições verdadeira e falsa. Deve ficar claro que sempre a ação da
condição verdadeira será executada entre as declarações de instrução se...senão e a ação da condição falsa será executada entre as
declarações de instrução senão...fim_se, nos casos de decisões compostas.
Neste exercício não é necessário fazer o aluno efetuar o cálculo do valor das equações; basta apenas apontar se a condição é
verdadeira ou falsa e indicar qual equação deve ser calculada.

Tópico 4.7 - Exercício 2 - Página 98 e 99
a) Falso, neste caso executa-se a equação X ← (A - B) / C, X = -0,20
b) Falso, neste caso executa-se a equação X ← (A + B) / D * (C + D), X = 7,78
c) Verdadeiro, neste executa-se a equação X ← (A + 2) * (B - 2), X = 4
d) Falso, neste executa-se a equação X ← A - B, X = − 1
e) Verdadeiro, neste executa-se a equação X ← A + B, X = 5
f) Falso, neste executa-se a equação X ← D / B, X = 3
g) Verdadeiro, neste executa-se a equação X ← (A + D) / 2, X = 5,50
h) Verdadeiro, neste executa-se a equação X ← (A + D) / 2, X = 5,50

13


a) Diagrama de blocos

programa Cap04_Ex3a_Pg099_versão_1
var
A, B, DIF : inteiro
início
leia A, B
se (A > B) então
DIF ← A - B
senão
DIF ← B - A
fim_se
escreva DIF
fim

b) Diagrama de blocos

Este programa também pode ser escrito da seguinte forma:
programa Cap04_Ex3a_Pg099_versão_2
var
A, B, DIF : inteiro
início
leia A, B
se (B > A) então
DIF ← B - A
senão
DIF ← A - B
fim_se
escreva DIF
fim

14

programa Cap04_Ex3b_Pg099_versão_1
var
N, R : inteiro
início
leia N
se (N < 0) então
R ← N * (-1)
senão
R ← N
fim_se
escreva R
fim



Este programa também pode ser escrito da seguinte forma:
programa Cap04_Ex3b_Pg099_versão_2
var
N : inteiro
início
leia N
se (N < 0) então
N ← N * (-1)
fim_se
escreva N
fim

var
N1, N2, N3, N4, MD : real
início
leia N1, N2, N3, N4
MD ← (N1 + N2 + N3 + N4) / 4
se (MD >= 5) então
escreva "Aluno Aprovado", MD
senão
escreva "Aluno Reprovado", MD
fim_se
fim


var
N1, N2, N3, N4, MD, NOVA_MD, EX : real
início
leia N1, N2, N3, N4
MD ← (N1 + N2 + N3 + N4) / 4
se (MD >= 7) então
escreva "Aluno Aprovado", MD
senão
leia EX
NOVA_MD ← (MD + EX) / 2
se (NOVA_MD >= 5) então
escreva "Aluno Aprovado em Exame", NOVA_MD
senão
escreva “Aluno Reprovado”, NOVA_MD
fim_se
fim_se
fim


15

Um ponto a ser observado neste exercício é a necessidade de extrair a raiz quadrada de Δ (delta), que está sendo representado pela
variável D. Muitos alunos esquecem-se de que para extrair uma raiz quadrada de um número, basta elevá-lo ao inverso de seu índice.
Ao se considerar a extração da raiz quadrada de D, basta fazer D ↑ (1/2) ou D ↑ 0.5. Essa forma de extração de raiz torna-se
adequada por proporcionar ao aluno a visão necessária para extrair raízes de qualquer outro índice. Assim sendo, para uma raiz
cúbica, 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
início
leia A, B, C
se (A = 0) .e. (B = 0) .e. (C = 0) então
escreva "Não é uma equação completa de segundo grau."
senão
D ← B ↑ 2 - 4 * A * C
se (D = 0) então
X ← -B / (2 * A)
escreva X
senão
se (D > 0) então
X1 ← (-B + D ↑ (1 / 2)) / (2 * A)
X2 ← (-B - D ↑ (1 / 2)) / (2 * A)
escreva X1, X2
senão
escreva "Não existem raízes reais."
fim_se
fim_se
fim_se
fim

16



programa Cap04_Ex3f_Pg100
var
A, B, C, X : inteiro
início
leia A, B, C
se (A > B) então
X ← A
A ← B
B ← X
fim_se
se (A > C) então
X ← A
A ← C
C ← X
fim_se
se (C > B) então
X ← C
C ← B
B ← X
fim_se
escreva A, B, C
fim

Tópico 4.7 - Exercício 3g - Página 100
Neste exercício é enfatizado o conceito de trabalhar com valores numéricos inteiros que sejam divisíveis entre dois valores (seus
divisores). Para determinar se um valor é divisível por outro, basta verificar se o resto da divisão entre os valores (dividendos e divisores)
é igual a zero, desde que o quociente da divisão seja um valor inteiro. É por esta razão que está sendo utilizado o operador de divisão div
e não o operador / (barra). O operador / (barra) deve ser usado quando se deseja obter um quociente real. Observe que não é usado o
operador mod ou % (operadores que determinam o valor do resto de uma divisão de inteiros quando usados nas linguagens de
programação PASCAL e C, C++, C#, Java, etc.), por serem exclusivos das linguagens de programação. É importante que o aluno
aprenda a pensar na solução do problema na forma algorítmica e não com o operador da linguagem de programação em si.

17



var
A, B, C, D, RESTO2, RESTO3 : inteiro
início
leia A, B, C, D
RESTO2 ← A - 2 * (A div 2)
RESTO3 ← A - 3 * (A div 3)
se (RESTO2 = 0) .e. (RESTO3 = 0) então
escreva "O valor ", A, " é divisível
fim_se
RESTO2 ← B - 2 * (B div 2)
RESTO3 ← B - 3 * (B div 3)
escreva "O valor ", B, " é divisível
fim_se
RESTO2 ← C - 2 * (C div 2)
RESTO3 ← C - 3 * (C div 3)
escreva "O valor ", C, " é divisível
fim_se
RESTO2 ← D - 2 * (D div 2)
RESTO3 ← D - 3 * (D div 3)
escreva "O valor ", D, " é divisível
fim_se
fim

por 2 e 3"

por 2 e 3"

por 2 e 3"

por 2 e 3"

18


Este exercício também enfatiza o conceito de trabalhar com valores que sejam divisíveis entre dois valores. Neste caso é utilizado o
operador lógico .ou. nas referências condicionais.


var
A, B, C, D, RESTO2, RESTO3 :
início
leia A, B, C, D
RESTO2 ← A - 2 * (A div 2)
RESTO3 ← A - 3 * (A div 3)
se (RESTO2 = 0) .ou. (RESTO3
escreva "O valor ", A, " é
fim_se
RESTO2 ← B - 2 * (B div 2)
RESTO3 ← B - 3 * (B div 3)
escreva "O valor ", B, " é
fim_se
RESTO2 ← C - 2 * (C div 2)
RESTO3 ← C - 3 * (C div 3)
escreva "O valor ", C, " é
fim_se
RESTO2 ← D - 2 * (D div 2)
RESTO3 ← D - 3 * (D div 3)
escreva "O valor ", D, " é
fim_se
fim

inteiro

= 0) então
divisível por 2 ou 3"

= 0) então

= 0) então

= 0) então


i) Diagrama de blocos

var
A, B, C, D, E, VALOR_MAIOR, VALOR_MENOR : inteiro
início
leia A, B, C, D, E
VALOR_MAIOR ← A
se (VALOR_MAIOR < B) então
VALOR_MAIOR ← B
fim_se
se (VALOR_MAIOR < C) então
VALOR_MAIOR ← C
fim_se
se (VALOR_MAIOR < D) então
VALOR_MAIOR ← D
fim_se
se (VALOR_MAIOR < E) então
VALOR_MAIOR ← E
fim_se
VALOR_MENOR ← A
se (VALOR_MENOR > B) então
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



então

então

então

VALOR_MENOR

var
N, RESTO : inteiro
início
leia N
RESTO ← N - 2 * (N div 2)
se (RESTO = 0) então
escreva "O valor ", N, " é PAR."
senão
escreva "O valor ", N, " é IMPAR."
fim_se
fim


var
N : inteiro
início
leia N
se (N >= 1) .e. (N <= 9) então
escreva "O valor está na faixa permitida."
senão
escreva "O valor está fora da faixa permitida."
fim_se
fim


var
N : inteiro
início
leia N
se .não. (N > 3) então
escreva N
fim_se
fim

21



var
NOME : cadeia
SEXO : caractere
início
leia NOME, SEXO
se (SEXO = "M") .ou. (SEXO = "F") então
se (SEXO = "M") então
escreva "Ilmo. Sr. ", NOME
senão
escreva "Ilma. Sra. ", NOME
fim_se
fim_se
fim

5.1 - Laço de repetição pré-teste - controle condicional verdadeiro

var
QUADRADO, I : inteiro
início
I ← 15
enquanto (I <= 200) faça
QUADRADO ← I ↑ 2
escreva QUADRADO
I ← I + 1
fim_enquanto
fim

22



var
N, I, R : inteiro
início
leia N
I ← 1
R ← N * I
escreva N, " X ", I, " = ", R
I ← I + 1
fim_enquanto
fim


var
S, I : inteiro
início
S ← 0
I ← 1
S ← S + I
I ← I + 1
fim_enquanto
escreva S
fim

23



var
S, I, RESTO : inteiro
início
S ← 0
I ← 1
RESTO ← I - 2 * (I div 2)
S ← S + I
fim_se
I ← I + 1
fim_enquanto
escreva S
fim


var
I, RESTO : inteiro
início
I ← 0
se (RESTO <> 0) então
escreva I
fim_se
I ← I + 1
fim_enquanto
fim

24



var
I, RESTO : inteiro
início
I ← 1
enquanto (I < 200) faça
escreva I
fim_se
I ← I + 1
fim_enquanto
fim


var
P, I : inteiro
início
P ← 1
I ← 0
escreva P
P ← P * 3
I ← I + 1
fim_enquanto
fim

25



var
P, I, B, E : inteiro
início
leia B, E
P ← 1
I ← 1
enquanto (I <= E) faça
P ← P * B
I ← I + 1
fim_enquanto
escreva P
fim


var
I, ATUAL, ANTERIOR, PRÓXIMO : inteiro
início
ANTERIOR ← 0
ATUAL ← 1
I ← 1
escreva ATUAL
PRÓXIMO ← ATUAL + ANTERIOR
ANTERIOR ← ATUAL
ATUAL ← PRÓXIMO
I ← I + 1
fim_enquanto
fim

26



var
C, F : real
início
C ← 10
enquanto (C <= 100) faça
F ← (9 * C + 160) / 5
escreva C, F
C ← C + 10
fim_enquanto
fim


var
I, GRÃO, QUADRO : inteiro
início
GRÃO ← 0
QUADRO ← 1
I ← 1
GRÃO ← GRÃO + QUADRO
QUADRO ← QUADRO * 2
I ← I + 1
fim_enquanto
escreva GRÃO
fim

27



var
I, J, N, S, F : inteiro
início
S ← 0
I ← 1
leia N
F ← 1
J ← 1
enquanto (J <= N) faça
F ← F * J
J ← J + 1
fim_enquanto
S ← S + F
I ← I + 1
fim_enquanto
escreva S
fim


var
I, N, SOMA : inteiro
MÉDIA : real
início
SOMA ← 0
I ← 1
leia N
SOMA ← SOMA + N
I ← I + 1
fim_enquanto
MÉDIA ← SOMA / 10
escreva SOMA, MÉDIA
fim

28



var
TOTAL : inteiro
SOMA, MÉDIA, N : real
início
TOTAL ← 0
SOMA ← 0
N ← 0
enquanto (N >= 0) faça
leia N
se (N >= 0) então
SOMA ← SOMA + N
TOTAL ← TOTAL + 1
fim_se
fim_enquanto
se (TOTAL > 0) então
MÉDIA ← SOMA / TOTAL
fim_se
escreva MÉDIA, TOTAL, SOMA
fim

29



var
FAT, R, I, J : inteiro
início
I ← 1
R ← I - 2 * (I div 2)
se (R <> 0) então
FAT ← 1
J ← 1
enquanto (J <= I) faça
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
MÉDIA : real
início
TOTAL ← 0
SOMA ← 0
I ← 50
R ← I - 2 * (I div 2)
se (R = 0) então
SOMA ← SOMA + I
TOTAL ← TOTAL + 1
fim_se
I ← I + 1
fim_enquanto
fim

31



var
CÔMODO, RESPOSTA : caractere
TOTAL, ÁREA, LARGURA, COMPRIMENTO : real
início
TOTAL ← 0
RESPOSTA ← "SIM"
enquanto (RESPOSTA = "SIM") faça
leia CÔMODO, LARGURA, COMPRIMENTO
ÁREA ← LARGURA * COMPRIMENTO
TOTAL ← TOTAL + ÁREA
escreva ÁREA, "Deseja calcular novo cômodo? "
leia RESPOSTA
fim_enquanto
escreva TOTAL
fim

32



var
N, VALOR_MAIOR, VALOR_MENOR : inteiro
início
leia N
VALOR_MAIOR ← N
VALOR_MENOR ← N
enquanto (N >= 0) faça
se (VALOR_MAIOR < N) então
VALOR_MAIOR ← N
fim_se
se (VALOR_MENOR > N) então
VALOR_MENOR ← N
fim_se
leia N
fim_enquanto
escreva VALOR_MAIOR, VALOR_MENOR
fim

33



var
QUOCIENTE, DIVIDENDO, DIVISOR : inteiro
início
leia DIVIDENDO, DIVISOR
QUOCIENTE ← 0
enquanto (DIVISOR <= DIVIDENDO) faça
DIVIDENDO ← DIVIDENDO - DIVISOR
QUOCIENTE ← QUOCIENTE + 1
fim_enquanto
escreva QUOCIENTE
fim

5.2 - Laço de repetição pré-teste - controle condicional falso

var
início
I ← 15
até_seja (I > 200) efetue
escreva QUADRADO
I ← I + 1
fim_até_seja
fim

34



var
N, I, R : inteiro
início
leia N
I ← 1
R ← N * I
escreva N, " X ", I, " = ", R
I ← I + 1
fim_até_seja
fim


var
S, I : inteiro
início
S ← 0
I ← 1
S ← S + I
I ← I + 1
fim_até_seja
escreva S
fim

35



var
início
S ← 0
I ← 1
RESTO ← I – 2 * (I div 2)
S ← S + I
fim_se
I ← I + 1
fim_até_seja
escreva S
fim


var
I, RESTO : inteiro
início
I ← 0
RESTO ← I – 2 * (I div 2)
escreva I
fim_se
I ← I + 1
fim_até_seja
fim

36



var
I, RESTO : inteiro
início
I ← 1
até_seja (I >= 199) efetue
escreva I
fim_se
I ← I + 1
fim_até_seja
fim


var
P, I : inteiro
início
P ← 1
I ← 0
escreva P
P ← P * 3
I ← I + 1
fim_até_seja
fim

37



var
início
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
início
ANTERIOR ← 0
ATUAL ← 1
I ← 1
escreva ATUAL
ANTERIOR ← ATUAL
ATUAL ← PRÓXIMO
I ← I + 1
fim_até_seja
fim

38



var
C, F : real
início
C ← 10
até_seja (C > 100) efetue
F ← (9 * C + 160) / 5
escreva C, F
C ← C + 10
fim_até_seja
fim


var
início
GRÃO ← 0
QUADRO ← 1
I ← 1
I ← I + 1
fim_até_seja
escreva GRÃO
fim

39



var
início
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
MÉDIA : real
início
SOMA ← 0
I ← 1
leia N
SOMA ← SOMA + N
I ← I + 1
fim_até_seja
fim

40



var
TOTAL : inteiro
início
TOTAL ← 0
SOMA ← 0
N ← 0
até_seja (N < 0) efetue
leia N
se (N >= 0) então
SOMA ← SOMA + N
TOTAL ← TOTAL + 1
fim_se
fim_até_seja
fim_se
escreva MÉDIA, TOTAL, SOMA
fim

41



var
início
I ← 1
R ← I - 2 * (I div 2)
se (R <> 0) então
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
MÉDIA : real
início
TOTAL ← 0
SOMA ← 0
I ← 50
R ← I - 2 * (I div 2)
se (R = 0) então
SOMA ← SOMA + I
TOTAL ← TOTAL + 1
fim_se
I ← I + 1
fim_até_seja
fim

43



var
CÔMODO, RESPOSTA : cadeia
início
TOTAL ← 0
RESPOSTA ← "SIM"
até_seja (RESPOSTA <> "SIM") efetue
leia RESPOSTA
fim_até_seja
escreva TOTAL
fim

44



var
início
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
início
QUOCIENTE ← 0
até_seja (DIVISOR > DIVIDENDO) efetue
fim_até_seja
escreva QUOCIENTE
fim

45


5.3 - Laço de repetição pós-teste - controle condicional falso

var
início
I ← 15
repita
escreva QUADRADO
I ← I + 1
até_que (I > 200)
fim


Português Estruturado
var
N, I, R : inteiro
início
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
início
S ← 0
I ← 1
repita
S ← S + I
I ← I + 1
até_que (I > 100)
escreva S
fim

d) Diagrama de blocos

var
início
S ← 0
I ← 1
repita
S ← S + I
fim_se
I ← I + 1
até_que (I > 500)
escreva S
fim

47


e) Diagrama de blocos

var
I, RESTO : inteiro
início
I ← 0
repita
escreva I
fim_se
I ← I + 1
até_que (I > 20)
fim

f) Diagrama de blocos

var
I, RESTO : inteiro
início
I ← 1
repita
escreva I
fim_se
I ← I + 1
até_que (I >= 200)
fim

48

g) Diagrama de blocos


var
P, I : inteiro
início
P ← 1
I ← 0
repita
escreva P
P ← P * 3
I ← I + 1
até_que (I > 15)
fim

h) Diagrama de blocos

var
início
leia B, E
P ← 1
I ← 1
repita
se (E = 0) então
P ← 1
senão
P ← P * B
fim-se
I ← I + 1
até_que (I > E)
escreva P
fim

49



var
início
ANTERIOR ← 0
ATUAL ← 1
I ← 1
repita
escreva ATUAL
ANTERIOR ← ATUAL
ATUAL ← PRÓXIMO
I ← I + 1
até_que (I > 15)
fim

j) Diagrama de blocos

var
C, F : real
início
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
início
GRÃO ← 0
QUADRO ← 1
I ← 1
repita
QUADRO ← QUADRO ∗ 2
I ← I + 1
até_que (I > 64)
escreva GRÃO
fim

l) Diagrama de blocos

var
início
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
MÉDIA : real
início
SOMA ← 0
I ← 1
repita
leia N
SOMA ← SOMA + N
I ← I + 1
até_que (I > 10)
fim

n) Diagrama de blocos

var
TOTAL : inteiro
início
TOTAL ← 0
SOMA ← 0
repita
leia N
se (N >= 0) então
SOMA ← SOMA + N
TOTAL ← TOTAL + 1
fim_se
até_que (N < 0)
fim_se
escreva SOMA, TOTAL, MÉDIA
fim

52

o) Diagrama de blocos


var
início
I ← 1
repita
R ← I - 2 * (I div 2)
se (R <> 0) então
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
MÉDIA : real
início
TOTAL ← 0
SOMA ← 0
I ← 50
repita
R ← I - 2 * (I div 2)
se (R = 0) então
SOMA ← SOMA + I
TOTAL ← TOTAL + 1
fim_se
I ← I + 1
até_que (I > 70)
fim

54

q) Diagrama de blocos


var
início
TOTAL ← 0
RESPOSTA ← "SIM"
repita
leia RESPOSTA
até_que (RESPOSTA <> "SIM")
escreva TOTAL
fim

55


r) Diagrama de blocos

var
início
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
início
QUOCIENTE ← 0
repita
até_que (DIVISOR > DIVIDENDO)
escreva QUOCIENTE
fim

56


5.4 - Laço de repetição pós-teste - controle condicional verdadeiro

var
início
I ← 15
continua
escreva QUADRADO
I ← I + 1
enquanto_for (I <= 200)
fim


var
N, I, R : inteiro
início
leia N
I ← 1
continua
R ← N * I
escreva N, " X ", I, " = ", R
I ← I + 1
fim

57



var
S, I : inteiro
início
S ← 0
I ← 1
continua
S ← S + I
I ← I + 1
escreva S
fim


var
início
S ← 0
I ← 1
continua
S ← S + I
fim_se
I ← I + 1
escreva S
fim

58



var
I, RESTO : inteiro
início
I ← 0
continua
escreva I
fim_se
I ← I + 1
fim


var
I, RESTO : inteiro
início
I ← 1
continua
escreva I
fim_se
I ← I + 1
enquanto_for (I < 200)
fim

59



var
P, I : inteiro
início
P ← 1
I ← 0
continua
escreva P
P ← P * 3
I ← I + 1
fim


var
início
leia B, E
P ← 1
I ← 1
continua
se (E = 0) então
P ← 1
senão
P ← P * B
fim-se
I ← I + 1
enquanto_for (I <= E)
escreva P
fim

60



var
início
ANTERIOR ← 0
ATUAL ← 1
I ← 1
continua
escreva ATUAL
ANTERIOR ← ATUAL
ATUAL ← PRÓXIMO
I ← I + 1
fim


var
C, F : real
início
C ← 10
continua
F ← (9 * C + 160) / 5
escreva C, F
C ← C + 10
enquanto_for (C <= 100)
fim

61



var
início
GRÃO ← 0
QUADRO ← 1
I ← 1
continua
I ← I + 1
escreva GRÃO
fim

62



var
início
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
MÉDIA : real
início
SOMA ← 0
I ← 1
continua
leia N
SOMA ← SOMA + N
I ← I + 1
fim


var
TOTAL : inteiro
início
TOTAL ← 0
SOMA ← 0
continua
leia N
se (N <= 0) então
SOMA ← SOMA + N
TOTAL ← TOTAL + 1
fim_se
enquanto_for (N >= 0)
fim_se
fim

64

o) Digrama de blocos


var
início
I ← 1
continua
R ← I - 2 * (I div 2)
se (R <> 0) então
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
MÉDIA : real
início
TOTAL ← 0
SOMA ← 0
I ← 50
continua
R ← I - 2 * (I div 2)
se (R = 0) então
SOMA ← SOMA + I
TOTAL ← TOTAL + 1
fim_se
I ← I + 1
fim

66

q) Digrama de blocos


var
início
TOTAL ← 0
RESPOSTA ← "SIM"
continua
leia RESPOSTA
enquanto_for (RESPOSTA = "SIM")
escreva TOTAL
fim

67


r) Digrama de blocos

var
início
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
início
QUOCIENTE ← 0
continua
enquanto_for (DIVISOR <= DIVIDENDO)
escreva QUOCIENTE
fim

68


5.5 - Laço de Repetição Condicional Seletivo
a) Digrama de blocos

var
início
I ← 15
laço
escreva QUADRADO
saia_caso (I >= 200)
I ← I + 1
fim_laço
fim


var
N, I, R : inteiro
início
leia N
I ← 1
laço
R ← N * I
escreva N, " X ", I, " = ", R
saia_caso (I >= 10)
I ← I + 1
fim_laço
fim

69


c) Digrama de blocos

var
S, I : inteiro
início
S ← 0
I ← 1
laço
S ← S + I
I ← I + 1
fim_laço
escreva S
fim


var
início
S ← 0
I ← 1
laço
S ← S + I
fim_se
I ← I + 1
fim_laço
escreva S
fim

70

e) Digrama de blocos


var
I, RESTO : inteiro
início
I ← 0
laço
escreva I
fim_se
saia_caso (I >= 20)
I ← I + 1
fim_laço
fim


var
I, RESTO : inteiro
início
I ← 1
laço
escreva I
fim_se
I ← I + 1
fim_laço
fim

71


g) Digrama de blocos

var
P, I : inteiro
início
P ← 1
I ← 0
laço
escreva P
P ← P * 3
saia_caso (I >= 15)
I ← I + 1
fim_laço
fim


var
início
leia B, E
P ← 1
I ← 1
laço
se (E = 0) então
P ← 1
senão
P ← P * B
fim-se
saia_caso (I >= E)
I ← I + 1
fim_laço
escreva P
fim

72

i) Digrama de blocos


var
início
ANTERIOR ← 0
ATUAL ← 1
I ← 1
laço
escreva ATUAL
ANTERIOR ← ATUAL
ATUAL ← PRÓXIMO
saia_caso (I >= 15)
I ← I + 1
fim_laço
fim


var
C, F : real
início
C ← 10
laço
F ← (9 * C + 160) / 5
escreva C, F
saia_caso (C >= 100)
C ← C + 10
fim_laço
fim

73


k) Digrama de blocos

var
início
GRÃO ← 0
QUADRO ← 1
I ← 1
laço
saia_caso (I >= 64)
I ← I + 1
fim_laço
escreva GRÃO
fim


var
início
S ← 0
I ← 1
laço
leia N
F ← 1
J ← 1
laço
F ← F * J
saia_caso (J >= N)
J ← J + 1
fim_laço
S ← S + F
saia_caso (I >= 15)
I ← I + 1
fim_laço
escreva S
fim

74

m) Digrama de blocos


var
MÉDIA : real
início
SOMA ← 0
I ← 1
laço
leia N
SOMA ← SOMA + N
saia_caso (I >= 10)
I ← I + 1
fim_laço
fim


var
TOTAL : inteiro
início
TOTAL ← 0
SOMA ← 0
laço
leia N
se (N >= 0) então
SOMA ← SOMA + N
TOTAL ← TOTAL + 1
fim_se
saia_caso (N < 0)
fim_laço
fim_se
fim

75


o) Digrama de blocos

var
início
I ← 1
laço
R ← I - 2 * (I div 2)
se (R <> 0) então
FAT ← 1
J ← 1
laço
FAT ← FAT * J
saia_caso (J >= I)
J ← J + 1
fim_laço
escreva FAT
fim_se
saia_caso (I >= 10)
I ← I + 1
fim_laço
fim

76



var
MÉDIA : real
início
TOTAL ← 0
SOMA ← 0
I ← 50
laço
R ← I - 2 * (I div 2)
se (R = 0) então
SOMA ← SOMA + I
TOTAL ← TOTAL + 1
fim_se
saia_caso (I >= 70)
I ← I + 1
fim_laço
fim

77


q) Digrama de blocos

var
início
TOTAL ← 0
RESPOSTA ← "SIM"
laço
leia RESPOSTA
saia_caso (RESPOSTA <> "SIM")
fim_laço
escreva TOTAL
fim

78



var
início
leia N
VALOR_MAIOR ← N
VALOR_MENOR ← N
laço
VALOR_MAIOR ← N
fim_se
VALOR_MENOR ← N
fim_se
leia N
fim_laço (N >= 0)
fim

s) Digrama de blocos

var
início
QUOCIENTE ← 0
laço
saia_caso (DIVISOR >= DIVIDENDO)
fim_laço
escreva QUOCIENTE
fim

79


5.6 - Laço de Repetição Incondicional

var
início
para I de 15 até 200 passo 1 faça
escreva QUADRADO
fim_para
fim


var
N, I, R : inteiro
início
leia N
R ← N * I
escreva N, " X ", I, " = ", R
fim_para
fim


var
S, I : inteiro
início
S ← 0
S ← S + I
fim_para
escreva S
fim

80



var
início
S ← 0
S ← S + I
fim_se
fim_para
escreva S
fim


var
I, RESTO : inteiro
início
escreva I
fim_se
fim_para
fim


var
I, RESTO : inteiro
início
escreva I
fim_se
fim_para
fim

81



var
P, I : inteiro
início
P ← 1
escreva P
P ← P * 3
fim_para
fim


var
início
leia B, E
P ← 1
para I de 1 até E passo 1 faça
P ← P * B
fim_para
escreva P
fim


var
início
ANTERIOR ← 0
ATUAL ← 1
escreva ATUAL
ANTERIOR ← ATUAL
ATUAL ← PRÓXIMO
fim_para
fim

82



var
C, F : real
início
para C de 10 até 100 passo 10 faça
F ← (9 * C + 160) / 5
escreva C, F
fim_para
fim


var
início
GRÃO ← 0
QUADRO ← 1
fim_para
escreva GRÃO
fim

83



var
início
S ← 0
leia N
F ← 1
para J de 1 até N passo 1 faça
F ← F * J
fim_para
S ← S + F
fim_para
escreva S
fim


var
MÉDIA : real
início
SOMA ← 0
leia N
SOMA ← SOMA + N
fim_para
fim

n) Não é possível resolver este exercício com este tipo de laço de repetição.

84



var
início
R ← I - 2 * (I div 2)
se (R <> 0) então
FAT ← 1
para J de 1 até I passo 1 faça
FAT ← FAT * J
fim_para
escreva FAT
fim_se
fim_para
fim


var
MÉDIA : real
início
TOTAL ← 0
SOMA ← 0
R ← I - 2 * (I div 2)
se (R = 0) então
SOMA ← SOMA + I
TOTAL ← TOTAL + 1
fim_se
fim_para
fim

85


q) Não é possível resolver este exercício com esse tipo de laço de repetição.
r) Não é possível resolver este exercício com esse tipo de laço de repetição.
s) Não é possível resolver este exercício com esse tipo de laço de repetição.


var
A : conjunto[1..10] de cadeia
I : inteiro
início
leia A[I]
fim_para
escreva A[I]
fim_para
fim


var
A, B : conjunto[1..8] de inteiro
I : inteiro
início
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
início
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
início
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
início
leia A[I]
fim_para
B[I] ← 1
para J de 1 até A[I] passo 1 faça
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
início
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
início
leia A[I]
fim_para
leia B[I]
fim_para
se (I <= 20) então
C[I] ← A[I]
senão
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
início
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
início
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
início
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
início
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
início
leia N
A[I] ← N * I
fim_para
escreva A[I]
fim_para
fim


var
A : conjunto[1..20] de real
SOMA, MÉDIA, VALOR_MAIOR, VALOR_MENOR : real
I : inteiro
início
leia A[I]
SOMA ← SOMA + A[I]
fim_para
VALOR_MAIOR ← A[1]
VALOR_MENOR ← A[1]
se (VALOR_MAIOR < A[I]) então
VALOR_MAIOR ← A[I]
fim_se
se (VALOR_MENOR > A[I]) então
VALOR_MENOR ← A[I]
fim_se
fim_para
escreva VALOR_MAIOR, VALOR_MENOR, MÉDIA
fim

92



var
I : inteiro
início
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
início
leia A[I]
fim_para
R ← A[I] - 2 * (A[I] div 2)
se (R <> 0) então
B[I] ← A[I] * 2
senão
B[I] ← A[I]
fim_se
fim_para
escreva B[I]
fim_para
fim

93



var
I, R : inteiro
início
leia A[I]
fim_para
R ← I - 2 * (I div 2)
se (R = 0) então
B[I] ← A[I] / 2
senão
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
início
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) então
C[X] ← A[J]
C[X + 3] ← B[J]
J ← J + 2
X ← X + 1
senão
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
início
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


programa Cap06_Ex1t_Pg143
var
I, R2, R3, R5 : inteiro
início
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

programa Cap06_Ex1u_Pg143
var
I, R2, R3, R5 : inteiro
início
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 .não. (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


programa Cap06_Ex1v_Pg144
var
I, R, QP, QI : inteiro
início
leia A[I]
fim_para
QP ← 0
QI ← 0
R ← A[I] - 2 * (A[I] div 2)
se (R = 0) então
QP ← QP + 1
senão
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
início
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
início
leia A[I]
fim_para
R ← I – 2 * (I div 2)
se (R <> 0) então
B[I] ← A[I + 1]
senão
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
início
leia A[I]
fim_para
TP ← 0
R ← A[I] – 2 * (A[I] div 2)
se (R = 0) então
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
início
leia A[I]
fim_para
TI ← 0
R ← A[I] – 2 * (A[I] div 2)
se (R <> 0) então
TI ← TI + 1
fim_se
fim_para
PTI ← TI / 10 * 100
escreva TI, PTI
fim

101



var
I, J, X : inteiro
início
leia A[I]
fim_para
para J de I + 1 até 12 passo 1 faça
se (A[I] < A[J]) então
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, COMEÇO, FINAL, MEIO, PESQ : inteiro
RESP : cadeia
ACHA : lógico
início
leia A[I]
fim_para
B[I] ← A[I] * 5
fim_para
se (B[I] > B[J]) então
X ← B[I]
B[I] ← B[J]
B[J] ← X
fim_se
fim_para
fim_para
RESP ← "SIM"
enquanto (RESP = "SIM") faça
leia PESQ
COMEÇO ← 1
FINAL ← 8
ACHA ← .Falso.
enquanto (COMEÇO <= FINAL) .e. (ACHA = .Falso) faça
MEIO ← (COMEÇO + FINAL) div 2
se (PESQ = B[MEIO]) então
ACHA ← .Verdadeiro.
senão
se (PESQ < B[MEIO]) então
FINAL ← MEIO - 1
senão
COMEÇO ← MEIO + 1
fim_se
fim_se
fim_enquanto
se (ACHA = .Verdadeiro.) então
escreva PESQ, " foi localizado na posição ", MEIO
senão
escreva PESQ, " não foi localizado"
fim_se
leia RESP
fim_enquanto
fim

103

104



var
I, J, X : inteiro
início
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
início
leia A[I]
fim_para
se (A[I] > A[J]) então
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]) então
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
início
leia A[I]
fim_para
leia B[I]
fim_para
se (I <= 20) então
C[I] ← A[I]
senão
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, PESQ : inteiro
RESP : cadeia
ACHA : lógico
início
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.) faça
se (PESQ = B[I]) então
senão
I ← I + 1
fim_se
fim_enquanto
escreva PESQ, " foi localizado na posição ", I
senão
fim_se
leia RESP
fim_enquanto
fim



109

110


var
RESP : cadeia
ACHA : lógico
início
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
COMEÇO ← 1
FINAL ← 20
ACHA ← .Falso.
se (PESQ = B[MEIO]) então
senão
se (PESQ < B[MEIO]) então
FINAL ← MEIO - 1
senão
fim_se
fim_se
fim_enquanto
senão
fim_se
leia RESP
fim_enquanto
fim

111



var
I, J, X : inteiro
início
repita
leia A[I]
até_que (A[I] < 0)
fim_para
B[I] ← A[I] * (-1)
fim_para
se (B[I] < B[J]) então
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
início
leia A[I]
B[I] ← A[I] / 2
fim_para
se (A[I] < A[J]) então
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
início
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 faça
D[I] ← D[I] * J
fim_para
E[I] ← (C[I] + D[I]) - (A[I] + B[I])
fim_para
se (E[I] > E[J]) então
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
início
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
início
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]) então
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 : lógico
início
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]) então
senão
I ← I + 1
fim_se
fim_enquanto
senão
fim_se
leia RESP
fim_enquanto
fim


117

118



var
A, B, C, D : conjunto[1..15] de inteiro
RESP : cadeia
ACHA : lógico
início
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]) então
X ← D[I]
D[I] ← D[J]
D[J] ← X
fim_se
fim_para
fim_para
RESP ← "SIM"
leia PESQ
COMEÇO ← 1
FINAL ← 15
ACHA ← .Falso.
enquanto (COMEÇO <= FINAL) .e. (ACHA = .Falso.) faça
se (PESQ = D[MEIO]) então
senão
se (PESQ < D[MEIO]) então
FINAL ← MEIO - 1
senão
fim_se
fim_se
fim_enquanto
senão
fim_se
leia RESP
fim_enquanto
fim

119

120


var
RESP : cadeia
ACHA : lógico
início
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
COMEÇO ← 1
FINAL ← 15
ACHA ← .Falso.
se (PESQ = A[MEIO]) então
senão
se (PESQ < A[MEIO]) então
FINAL ← MEIO - 1
senão
fim_se
fim_se
fim_enquanto
senão
fim_se
leia RESP
fim_enquanto
fim


var
A, B : conjunto[1..10] de cadeia
I, J : inteiro
X : cadeia
início
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, COMEÇO, FINAL, MEIO, PESQ : inteiro
RESP : cadeia
X : cadeia
ACHA : lógico
início
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
COMEÇO ← 1
FINAL ← 15
ACHA ← .Falso.
se (PESQ = A[MEIO]) então
senão
se (PESQ < A[MEIO]) então
FINAL ← MEIO - 1
senão
fim_se
fim_se
fim_enquanto
senão
fim_’se
leia RESP
fim_enquanto
fim

123

124



var
I, J : inteiro
X : cadeia
início
leia A[I]
fim_para
leia B[I]
fim_para
se (I <= 10) então
C[I] ← A[I]
senão
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, PESQ : inteiro
RESP : cadeia
ACHA : lógico
início
leia A[I]
fim_para
RESP ← "SIM"
leia PESQ
I ← 1
ACHA ← .Falso.
se (PESQ = B[I]) então
senão
I ← I + 1
fim_se
fim_enquanto
senão
fim_se
leia RESP
fim_enquanto
fim

126


Tópico 8.5 - Exercício 1 a - Página 185

var
A, B, C : conjunto[1..5,1..3] de inteiro
I, J : inteiro
início
para J de 1 até 3 passo 1 faça
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
início
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
início
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
início
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
início
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
início
leia A[I,J]
fim_para
fim_para
B[I,J] ← 1
para K de 1 até A[I,J] passo 1 faça
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
início
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
início
leia A[I,J]
fim_para
fim_para
se (I = J) então
B[I,J] ← A[I,J] * 3
senão
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
início
leia A[I,J]
fim_para
fim_para

133

134


se (I = J) então
RI ← I - 2 * (I div 2)
RJ ← J - 2 * (J div 2)
se (RI = 1) .e. (RJ = 1) então
B[I,J] ← 1
B[I,J] ← B[I,J] * K
fim_para
senão
B[I,J] ← 0
B[I,J] ← B[I,J] + K
fim_para
fim_se
senão
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
início
leia A[I,J]
fim_para
fim_para
R ← A[I,J] - 2 * (A[I,J] div 2)
se (R = 0) então
B[I,J] ← A[I,J] + 5
senão
B[I,J] ← A[I,J] - 4
fim_se
fim_para
fim_para
fim_para
fim_para
fim

135



var
I, J, S : inteiro
início
leia A[I,J]
fim_para
fim_para
S ← 0
se (I = J) então
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
início
leia A[I,J]
fim_para
fim_para
S ← 0
se (I = J) então
R ← A[I,J] - 2 * (A[I,J] div 2)
se (R = 0) então
S ← S + A[I,J]
fim_se
fim_se
fim_para
fim_para
escreva S
fim

137



var
I, J, S, RI, RJ : inteiro
início
leia A[I,J]
fim_para
fim_para
S ← 0
se (I = J) então
RI ← I - 2 * (I div 2)
RJ ← J - 2 * (J div 2)
se (RI = 1 .e. (RJ = 1) então
S ← S + A[I,J]
fim_se
fim_se
fim_para
fim_para
escreva S
fim

138



var
I, J, TOT_PAR, R : inteiro
início
leia A[I,J]
fim_para
fim_para
TOT_PAR ← 0
R ← A[I,J] - 2 * (A[I,J] div 2)
se (R = 0) então
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
início
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
início
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) então
TPAR ← TPAR + 1
senão
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
início
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

Gabarito respostas (3)

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (14)

Similaire à Gabarito respostas (3)

Similaire à Gabarito respostas (3) (20)

Gabarito respostas (3)