Java - WordPress.com

Bacharelado em Ciência e Tecnologia
BC0505 – Processamento da Informação
GABARITO EXERCÍCIOS - Java
REPETIÇÃO / VALIDAÇÃO DE DADOS / TESTE DE MESA
1.
Escreva um programa que solicita ao usuário dois valores inteiros e positivos que serão a base e o expoente. O
programa deve calcular e escrever o resultado da base elevado à potência.
OBS: Não utilizar nenhuma função ou operador que faça o cálculo de potenciação. A ideia é escrever um
programa que calcule a potenciação.
Exemplo:
base = 2 expoente = 5 resultado = 2 x 2 x 2 x 2 x 2 = 32
ATENÇÃO : seu programa deve validar a entrada de dados de modo que sejam informados números positivos.
import java.util.Scanner;
public class CalculoPotencia {
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int base, expoente;
int resultado=1;
Scanner entrada = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Escreva um valor inteiro e positivo para a base: ");
base=entrada.nextInt();
System.out.println("Escreva um valor inteiro e positivo para o expoente: ");
expoente=entrada.nextInt();
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- *
for(int i=0; i<expoente; i++){
resultado=resultado*base;
}
System.out.println("Resultado= "+resultado);
}
}
2.
Escreva um programa para imprimir uma Progressão Aritmética (PA), sendo que serão fornecidos o primeiro termo,
a razão e a quantidade de termos desejada. P or exemplo, para primeiro termo = 13, razão = 5 e quantidade de
termos = 8 o programa deverá exibir: 13, 18, 23, 28, 33, 38, 43, 48
import java.util.Scanner;
public class ProgressaoAritmetica {
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int A1, r, n, An;
Scanner scan = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Digite o primeiro termo da PA: ");
A1 = scan.nextInt();
System.out.println("Digite a razão da PA: " );
r = scan.nextInt();
System.out.println("Digite a quantidade de termos da PA: ");
n = scan.nextInt();
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- *
for (int i = 1; i <= n; i++) {
An = A1 + (i -1)*r; //Fórmula geral da PA
System.out.println(An);
}
}
}
3.
A série de Fibonacci é formada pela seguinte sequência; 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ..., etc. Escreva um
algoritmo que gere a série de Fibonacci até o eNésimo termo. O valor de N (enésimo) deverá ser solici tado pelo
usuário e deverá ser maior que 10.
import java.util.Scanner;
public class SerieFibonacci {
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int n, anterior=0, fibonacci=1;
Scanner entrada = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Insira o valor de n: ");
n=entrada.nextInt();
/* ------------------- VALIDAÇÃO DE DADOS --------------------------- */
while (n<10){
System.out.println("Insira um valor maior do que 10: ");
n=entrada.nextInt();
}
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
for(int i=1; i<=n; i++){
if (i==1){
System.out.println(fibonacci);
}
else{
fibonacci+=anterior;
anterior=fibonacci-anterior;
System.out.println(fibonacci);
}
}
}
}
4.
Escreva um algoritmo para informar se um número N, é primo ou não. Faça a validação de dados de forma que
N seja positivo.
import java.util.Scanner;
public class NumeroPrimo {
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int n, soma = 0;
Scanner scan = new Scanner(System.in);
/*
------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Digite um número positivo:");
n = scan.nextInt();
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS ---------------------------
*/
if (n > 0) {
for (int i = 1; i <= n; i++) {
//Números primos são os números naturais que têm apenas dois divisores diferentes:
o 1 e ele mesmo.
//Portanto, 1 + ele mesmo = 2 (se for divisível por mais de 2 números, n não é
primo)
if (n%i == 0) {
soma = soma + 1;
}
}
if (soma <= 2) {
System.out.println("O número é primo");
}
else {
System.out.println("O número não é primo");
}
}
else { System.out.println("O
número não é positivo");
}
}
}
5.
Escreva um algoritmo que calcule N! (fatorial de N), sendo que o valor inteiro de N é fornecido pelo usuário. Faça a
validação de dados de forma que N seja positivo . Sabe-se que:
5! = 5 x 4 x 3 x 2 x 1 = 120
0! = 1, por definição
import java.util.Scanner;
public class CalculoFatorial {
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int n, fatorial=1;
Scanner entrada = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Insira um valor n para calcular seu fatorial: ");
n=entrada.nextInt();
/* ------------------- VALIDAÇÃO DE DADOS --------------------------- */
while (n<0){
System.out.println("Insira um valor positivo: ");
n=entrada.nextInt();
}
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
if (n==0 || n==1){
fatorial=1;
System.out.println("O fatorial de n é "+fatorial);
}else{
for(int i=2; i<=n; i++){
fatorial=fatorial*i;
}
System.out.println("O fatorial de n é "+fatorial);
}
}
}
6.
Escreva um programa que exiba 30 vezes na tela a mensagem “Vou ser aprovado com A em Processamento da
Informação!”.
import java.util.Scanner;
public class ImprimeMensagem {
public static void main(String[] args) {
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
for (int i = 0; i < 30; i++) {
System.out.println(i+1 + ": Vou ser aprovado com A em Processamento da
Informação!");
}
}
}
7. Escreva um programa que exiba na tela os números inteiros de 100 até 1.
import java.util.Scanner;
public class SequenciaDecrescente {
public static void main(String[] args) {
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
for(int i=100; i>0; i--){
System.out.println(i);
}
}
}
8. Escreva um programa que exiba na tela os números inteiros de 50 até 200.
import java.util.Scanner;
public class Ex8 {
public static void main(String[] args) {
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
for (int i = 50; i <= 200; i++) {
System.out.println(i);
}
}
}
9.
Escreva um programa que exiba na tela os números inteiros de A até Z, sendo que A e Z deverão ser informados
pelo usuário.
import java.util.Scanner;
public class AaZ{
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int A,Z;
Scanner entrada = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Insira o valor de A: ");
A=entrada.nextInt();
System.out.println("Insira o valor de Z: ");
Z=entrada.nextInt();
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
for(int i=A; i<=Z; i++){
System.out.println(i);
}
}
}
10. Escreva um programa que exiba na tela a soma dos números inteiros do intervalo [A, Z]. Faça a validação de
dados de modo que não seja aceito A > Z
import java.util.Scanner;
public class SomaAaZ {
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int A, Z, soma = 0;
Scanner scan = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Digite A:");
A = scan.nextInt();
System.out.println("Digite Z:");
Z = scan.nextInt();
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
if (Z > A) {
for (int i = A; i <= Z; i++) {
soma = soma + i;
}
System.out.println("A soma dos números inteiros do intervalo [A, Z] é: " + soma);
} else {
System.out.println("Z deve ser maior que A");
}
}
}
11. Dado um limite inferior e superior, calcule a soma de todos os números pares contidos nesse intervalo. Faça a
validação de dados de forma que o segundo número in formado seja maior que o primeiro
(inferior,superior)
import java.util.Scanner;
public class SomaPares{
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int inferior,superior, soma;
Scanner entrada = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Insira o valor inferior: ");
inferior=entrada.nextInt();
System.out.println("Insira o valor superior: ");
superior=entrada.nextInt();
/* ------------------- VALIDAÇÃO DE DADOS --------------------------- */
while (inferior>=superior){
System.out.println("O valor inferior deve ser menor do que o superior. Insira novos valores: ");
System.out.println("Insira o valor inferior: ");
inferior=entrada.nextInt();
System.out.println("Insira o valor superior: ");
superior=entrada.nextInt();
}
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
soma=0;
for(int i=inferior; i<=superior; i++){
if (i%2)==0{
soma=soma+i;
}
}
System.out.println("A soma dos números pares contidos no intervalo dado é "+soma);
}
}
12. Escreva um programa que solicita ao usuário uma quantidade indeterminada de números inteiros positivos (faça a
validação de dados de forma que o número informado seja positivo). O programa deve calcular e escrever a
média aritmética apenas dos números pares. A entrada de dados deve ser encerrada quando o número ZERO for
digitado.
import java.util.Scanner;
public class MediaPares {
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int n = 1, soma = 0, média=0, c = 0; //c conta quantos números positivos e pares já foram
digitados
Scanner scan = new Scanner(System.in);
/* -------------------ENTRADA / VALIDAÇÃO DE DADOS --------------------------- */
while (n != 0) {
System.out.println("Digite um número positivo:");
n = scan.nextInt();
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
if (n > 0) {
if (n % 2 == 0) {
c = c + 1;
soma = soma + n;
}
} else if (n < 0) {
System.out.println("O número é negativo, digite um número positivo");
}
}
if(c!=0){
média = soma / c;
}
System.out.println("A média dos números positivos e pares já digitados é: " +
média);
}
}
13. Imprima uma tabela de conversão de polegadas para centímetros, de 1 a 20. Considere que Polegada = Centímetro
* 2,54. Recomenda-se utilizar o comando PARA.
import java.util.Scanner;
public class TabelaConversao{
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
double resultado;
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
for(int i=1; i<=20; i++){
resultado=i*2.54;
System.out.println(i+" centímetros= "+resultado+" polegadas");
}
}
}
14. Escreva um programa que solicita a idade de 20 pessoas e exiba a quantidade de pessoas que possui idade maior
ou igual a 18 anos. Exibir também a média da idade das 20 pessoas.
import java.util.Scanner; public
class QuantMaioridade {
public static void main(String[] args) {
---------------------------------------------DECLARAÇÃODEVARIÁVEIS
/*
*/
int idade, soma = 0, média, maior = 0;
Scanner scan = new Scanner(System.in);
/* ------------------- ENTRADA / PROCESSAMENTO / SAÍDA DE DADOS ---------------------------
for (int i = 1; i <= 20; i++) {
System.out.println("Digite a idade da pessoa " + i + ":");
idade = scan.nextInt();
soma = soma + idade;
if (idade >= 18) {
maior = maior + 1;
}
}
System.out.println("Existem " + maior + " maior de idade");
média = soma / 20;
System.out.println("A média das idades é: " + média);
}
*/
}
15. A série de RICCI difere da série de FIBONACCI porque os dois primeiros termos podem ser definidos pelo usuário.
Imprima os n primeiros termos da série de RICCI.
import java.util.Scanner;
public class SerieRicci {
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int n, i1, i2, anterior, ricci;
Scanner entrada = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Insira o valor de n: ");
n=entrada.nextInt();
System.out.println("Insira o primeiro termo: ");
i1=entrada.nextInt();
System.out.println("Insira o segundo termo: ");
i2= entrada.nextInt();
/* ------------------- VALIDAÇÃO DE DADOS --------------------------- */
while (n<=2){
System.out.println("Insira um valor maior do que 2: ");
n=entrada.nextInt();
}
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
ricci=i2;
anterior=i1;
System.out.println(i1);
System.out.println(i2);
for(int i=3; i<=n; i++){
ricci+= anterior;
anterior=ricci-anterior;
System.out.println(ricci);
}
}
}
16. A série de FETUCCINE difere da série de RICCI porque o termo de posição par é resultado da subtração dos dois
anteriores. Os termos ímpares continuam sendo o resultado da soma dos dois elementos anteriores. Imprima os n
primeiros termos da série de FETUCCINE.
import java.util.Scanner;
public class Ex16 {
public static void main(String[] args) {
//A Serie de FETUCCINE é gerada da seguinte forma: os 2 primeiros termos são fornecidos
pelo usuario.
//A partir daí, os termos são gerados com a soma ou subtração dos 2 termos anteriores, ou
seja:
//- 1º caso: a posição do termo seja ímpar, obedeça a seguinte condição: Ai=Ai-1 + Ai-2, para
posição ímpar:
//- 2º caso: a posição do termo seja par, obedeça a seguinte condição: Ai=Ai-1 - Ai-2, para
posição par.
//Exemplo: termo 1 = 1; termo 2 = 2 serie da FETUCCINE: 1-2-3-1-4-3-7-4-11-7
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int n;
Scanner scan = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Digite a quantidade de termos desejada:");
n = scan.nextInt();
int fetuccine[] = new int[n + 1];
System.out.println("Digite o primeiro termo:");
fetuccine[1] = scan.nextInt();
System.out.println("Digite o segundo termo:");
fetuccine[2] = scan.nextInt();
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
for (int i = 3; i < n + 1; i++) {
if (i % 2 != 0) {
fetuccine[i] = fetuccine[i - 1] + fetuccine[i - 2];
} else if (i % 2 == 0) {
fetuccine[i] = fetuccine[i - 1] - fetuccine[i - 2];
}
}
for (int i = 1; i < n + 1; i++) {
System.out.println(fetuccine[i]);
}
}
}
OU
import java.util.Scanner;
public class Ex162 {
public static void main(String[] args) {
//A Serie de FETUCCINE é gerada da seguinte forma: os 2 primeiros termos são fornecidos
pelo usuario.
//A partir daí, os termos são gerados com a soma ou subtração dos 2 termos anteriores, ou
seja:
//- 1º caso: a posição do termo seja ímpar, obedeça a seguinte condição: Ai=Ai-1 + Ai-2, para
posição ímpar:
//- 2º caso: a posição do termo seja par, obedeça a seguinte condição: Ai=Ai-1 - Ai-2, para
posição par.
//Exemplo: termo 1 = 1; termo 2 = 2 serie da FETUCCINE: 1-2-3-1-4-3-7-4-11-7
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int a, b, n, resp;
int x=3;
Scanner scan = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Digite o primeiro termo:");
a= scan.nextInt();
System.out.println("Digite o segundo termo:");
b=scan.nextInt();
System.out.println("Digite a quantidade de termos desejada:");
n=scan.nextInt();
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
System.out.print(a+" ");
System.out.print(b+" ");
while (x<=n){
if(x%2!=0){
resp = a+b;
System.out.print(resp + " ");}
else {
resp = b-a;
System.out.print(resp + " ");}
a=b;
b=resp;
x=x+1;
}
}
}
17. Dado um limite inferior e superior, imprima todos os números primos contidos nesse intervalo. Faça a validação
de dados de forma que o segundo número informado seja maior que o primeiro (inferior,superior)
import java.util.Scanner;
public class SequenciaPrimos {
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int inferior, superior, soma;
Scanner entrada = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Insira o valor inferior: ");
inferior = entrada.nextInt();
System.out.println("Insira o valor superior: ");
superior = entrada.nextInt();
/* ------------------- VALIDAÇÃO DE DADOS --------------------------- */
while (inferior >= superior) {
System.out.println("O valor inferior deve ser menor do que o superior. Insira novos
valores: ");
System.out.println("Insira o valor inferior: ");
inferior = entrada.nextInt();
System.out.println("Insira o valor superior: ");
superior = entrada.nextInt();
}
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
for (int i = inferior; i <= superior; i++) {
soma = 0;
for (int j = 1; j <= i; j++) {
if (i % j == 0) {
soma = soma + 1;
}
}
if (soma <= 2) {
System.out.println(i);
}
}
}
}
18. Escreva um programa para ler vários números até obter o finalizador 0. Indicar quantos números quadrados
perfeitos foram lidos. Um quadrado perfeito é aquele que tem raiz quadrada inteira.
import java.util.Scanner;
public class QuadradoPerfeito {
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int n = 1, soma = 0;
Scanner scan = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
while (n != 0) {
System.out.println("Digite um número positivo:");
n = scan.nextInt();
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
if ((Math.sqrt(n) % 1 == 0) && (n != 0)) {
soma = soma + 1;
}
}
System.out.println("Existem " + soma + " quadrados perfeitos");
}
}
19. Considere que não exista o operador de divisão. Dados dois números, obter o quociente inteiro através de
subtrações sucessivas. Faça a validação de dados de forma que o DIVISOR não seja zero.
import java.util.Scanner;
public class Quociente{
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int dividendo, divisor, cont, temp;
Scanner entrada = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Insira o dividendo: ");
dividendo=entrada.nextInt();
System.out.println("Insira o divisor: ");
divisor=entrada.nextInt();
/* ------------------- VALIDAÇÃO DE DADOS --------------------------- */
while (divisor==0){
System.out.println("Insira um valor não nulo para o divisor: ");
divisor=entrada.nextInt();
}
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
temp = dividendo;
for(cont=0; divisor<=temp; cont++){
temp-=divisor;
}
System.out.println(dividendo+" dividido por "+divisor+" é igual a "+ cont);
}
}
20. Uma das maneiras de se conseguir calcular a raiz quadrada de um número é subtrair dele os números ímpares
consecutivos a partir de 1, até que o resultado seja menor ou igual a zero. O número de vezes que se conseguir
fazer as subtrações é a raiz quadrada. Faça um algoritmo que calcule a raiz quadrada de dado numero conforme
essa regra.
Exemplo: 16 – 1 = 15; 15 – 3 = 12 – 5 = 7 – 7 = 0 { foram feitas 4 subtrações}
import java.util.Scanner;
public class RaizQuadrada {
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
int x = 1, cont = 0, sub = 1;
Scanner scan = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Digite o número que deseja obter a raiz:");
int n = scan.nextInt();
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
while (n > 0) {
n = n - x;
x = x + 2;
cont = cont + 1;
}
if (n < 0) {
System.out.println("Raiz não natural");
} else {
System.out.println("A raiz do número é: " + cont);
}
}
}
21. Um vendedor de cachorro quente decidiu fazer um levantamento com seus clientes a fim de planejar as vendas.
Fez duas perguntas: Q1 – Gosta de Milho no seu hot dog? (S ou N); Q2 – qual sua idade?
Escreva um programa para processar a pesquisa. Calcule e mostre: a quantidade de clientes que preferem milho no
hot dog, a idade média dos que não gostam de milho no hot dog. Foram pesquisados 50 clientes. É necessário fazer a
validação de dados nas duas questões (S ou N na Q1 e idade não pode ser menor que 10 na Q2).
import java.util.Scanner;
public class PesquisaHotdog{
public static void main(String[] args) {
/* ------------------- DECLARAÇÃO DE VARIÁVEIS --------------------------- */
char milho;
int idade, contador=0, soma=0, resultado;
Scanner entrada = new Scanner(System.in);
/* ------------------- ENTRADA DE DADOS --------------------------- */
for(int i=1; i<=50; i++){
System.out.println("Você gosta de milho no seu hot dog? Resposta S ou N:");
milho= entrada.nextLine().charAt(0);
/* ------------------- VALIDAÇÃO DE DADOS --------------------------- */
while (milho != 'S' and milho != 'N'){
System.out.println("Responda S ou N:");
milho= entrada.nextLine().charAt(0);
}
/* ------------------- ENTRADA DE DADOS --------------------------- */
System.out.println("Qual é a sua idade?");
idade= entrada.nextInt();
/* ------------------- VALIDAÇÃO DE DADOS --------------------------- */
while (idade<10){
System.out.println("Insira uma idade maior ou igual a 10 anos");
idade= entrada.nextInt();
}
/* ------------------- PROCESSAMENTO / SAÍDA DE DADOS --------------------------- */
if (milho=='S'){
contador+=1;
}
else{
soma+=idade;
}
}
System.out.println("O número de pessoas que gostam de milho no Hotdog é"+contador);
System.out.println("A idade média das pessoas que não gostam de milho no Hotdog é"+(soma/(50contador)));
}
}
TESTE DE MESA
22. (20%) Simule a execução do algoritmo SEGREDO através de “teste de mesa” e preencha o(s) valor(es) na tabela
TESTE DE MESA” anotando os novos valores de cada variável e as linhas que as modificam. Note que as primeiras
linhas estão anotadas como exemplo, mas é obrigatório anotar todas as linhas que modifiquem um dos valores
contidos na variável a, b ou c até que o algoritmo seja encerrado. Simultaneamente, anote na
tabela SAÍDA DE DADOS todas as saídas (comando escreva) do programa e as linhas que fazem a saída.
Considere que nas linhas 8 e 10 o usuário digitará como entrada de dados, respectivamente 5 e 3.
ALGORITMO “SEGREDO”
TESTE DE MESA
LINHA
a
b
8
5
10
3
14
3
15
14
1
15
14
-1
15
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
...
LINHA
13
21
13
21
13
21
SAÍDA DE DADOS
C
A
C
A
C
A
c
0
-2
-4