INSTITUTO FEDERAL DE GOIÁS – IFG

Aluno: Adriel Vitor Maciel Mendes Matrícula: 20211080080046

Curso/Período: BSI – 1º período Disciplina: Algoritmos e Técnicas de Programação

LISTA 4 – ESTRUTURA DE REPETIÇÃO

4.21)

Algoritmo
Declare numero, i, resto: Inteiro;
Escreva (“Digite um número: ”);
Leia (numero);
Para i <- 1 até numero faça;
resto <- numero mod i;
Se (resto = 0) então;
Escreval (i, “ é um número divisor de ”, numero);
Senão escreva (“Resposta inválida.”);
FimSe
FimPara
FimAlgoritmo

4.23)

Algoritmo
Declare resto, cont: Real;
Declare i: Inteiro;
i<- 1000;
Enquanto (i<=2000) faça;
Escreval (“Digite um número entre 1000 e 2000: ”);
Leia (cont);
resto<-cont mod 11;
Se (resto = 5) então;
Escreval (“O número que dividido por 11 possui resto 5 é:”, cont);
Senao escreva (“O número digitado não possui resto igual a 5.”);
FimSe
FimEnquanto
FimAlgoritmo
4.25)

Algoritmo
Declare n1, n2, c, quo, rest, quociente, resto: Inteiro;
Escreva (“Digite o valor do dividendo: ”);
Leia (n1);
Escreva (“Digite o valor do divisor: ”);
Leia (n2);
quo <- n1 div n2;
rest <- n1 mod n2;
c <- 1;
Repita;
quociente <- n1-n2;
n1 <- n1-1;
até quociente=quo;
Repita;
resto <- n1-n2;
n1 <- n1+1;
até resto=rest;
Escreva (“O quociente vale ”, quociente, “ e o resto é ”, resto, “ .”);
FimAlgoritmo

4.27)

Algoritmo
Declare n1, n2, aux: Inteiro;
Escreva ("Digite um valor inteiro positivo para N1: ");
Leia (n1);
Escreva ("Digite um valor inteiro positivo para N2: ");
Leia (n2);
Enquanto (n1>0) faça;
aux <- n1;
n1 <- n1 mod n2;
n1 <- aux;
FimEnquanto
Escreva (“O mmc dos números colocados vale: ”, aux);
FimAlgoritmo

4.29)

Algoritmo
Declare numr, denom, reducao: Inteiro;
Escreva (“Coloque o valor do numerador: ”);
Leia (num);
Escreva (“Coloque o valor do denominador: ”);
Leia (denom);
Para (num|denom) faça;
num <- num/2;
denom <- denom/2;
reducao <- num|denom;
FimPara
Escreva (“A redução da fração é: ”, reducao);
FimAlgoritmo
4.31)

Algoritmo
Declare i, j, numero, somadivisores: Inteiro;
Escreva (“Digite até onde quer verificar o resultado: ”);
Leia (numero);
Para i <- 1 ate (n - 1) faça;
Leia (numero) ;
somadivisores <- 0 ;
Para j <- 1 ate numero faça;
Se (numero mod j = 0) entao;
somadivisores <- somadivisores + j ;
FimSe
FimPara
Se (somadivisores = numero) entao;
Escreva (“O número é perfeito.”);
Senão escreva (“o número não é perfeito.”);
FimSe
FimPara
FimAlgoritmo

4.33)

Algoritmo
Declare x, y, z, f: Inteiro;
Escreva (“Aponte um valor para x de 1 a 100: ”);
Leia (x);
Escreva (“Aponte um valor para y de 6 a 30: ”);
Leia (y);
Escreva (“Aponte um valor para z de 3 a 15: ”);
Leia (z);
Para f faça;
((x^2)+(y^2)+(z^2)/(x^4)*(y^4)*(z^4));
FimPara
Escreva (“O valor da função é: ”, f);
FimAlgoritmo

4.35)

Algoritmo
Declare n1, n2, n3, aux: Inteiro;
Escreva (“Digite o primeiro número de 3 dígitos: ”);
Leia (n1);
Escreva (“Digite o segundo número de 3 dígitos: ”);
Leia (n2);
Escreva (“Digite o terceiro número de 3 dígitos: ”);
Leia (n3);
Enquanto (n1>0) faça;
aux <- n1;
n1 <- n1 mod n2;
n1 <- n2 mod n3;
n1 <- aux;
FimEnquanto
Escreva (“O mmc dos números colocados vale: ”, aux);
FimAlgoritmo
4.37)

Algoritmo
Declare num, resultado: Inteiro;
Escreva (“Digite um número inteiro: ”);
Leia (num);
resultado <- num^2;
Para num até (num-1) faça;
2*num+1;
FimPara
lista <- num;
Escreva (“O número digitado foi ”, num, “ , os números ímpares usados foram ”,
lista, “ e o seu resultado é ”, resultado, “.”);
FimAlgoritmo

4.39)

Algoritmo
Declare i, num, num2, resto: Inteiro;
Escreva (“Coloque o número que deseja saber sua raiz: ”);
Leia (num);
num2 <- num;
i <- 1;
Enquanto (num>0) faça;
resto = num - 1;
Escreva (“O resto vale: ”, resto);
num = resto;
i += 2;
FimEnquanto
Se (resto=0) então;
Escreva (“A raiz exata do número é: ”, num2);
Senão escreva (“A raiz aproximada do número é: ”, num2);
FimSe
FimAlgoritmo

4.41)

Algoritmo
Declare y, i: Inteiro;
Escreva (“Digite um número inteiro positivo: ”);
Leia (y);
i <- 20;
Para (i>0) faça;
i <- y/2;
i <- ((i+y)/(2*i));
FimPara
Escreval (“O resultado da operação é: ”, i);
FimAlgoritmo
 LISTA 4 – VETOR E MATRIZES

1)

Algoritmo
Declare a, v, x: Inteiro;
Declare achou: Lógico;
achou<-falso;
Para i de 1 até 10 faca;
Leia (v[i]);
FimPara
Escreva (“Digite o valor de x: ”);
Leia(x);
Para i de 1 até 10 faca;
Se (x=v[i]) entao;
Escreval (“O valor ”, x, “ está no vetor na posição ”, i, “.”);
achou <- verdadeiro;
FimSe
FimPara
Se (achou=falso) entao;
Escreval ("O valor ", x, " não está no vetor.");
FimSe
FimAlgoritmo

2)

Algoritmo
Declare v1, v2, v3, i: Inteiro;
Para i de 1 até 10 faça;
Leia(v1[i]);
FimPara
Para i de 1 até 10 faça;
Leia(v2[i]);
FimPara
Para i de 1 até 10 faça;
v3[i] <- v1[i]*v2[i];
FimPara
Para i de 1 até 10 faça;
Escreval (v3[i]);
FimPara
FimAlgoritmo

3)

Algoritmo
Declare v, i, qtde: Inteiro;
qtde <- 0;
Para i de 1 até 10 faça;
Leia(v[i]);
FimPara
Para i de 1 até 10 faça;
Se (v[i] mod 2=0) então;
qtde <- qtde+1;
FimSe
FimPara
Escreval (“A quantidade de números pares é: ”, qtde, “.”);
FimAlgoritmo
4)
Algoritmo
Declare vet: Inteiro;
Declare vetpospar, vetposimpar: Inteiro;
j, i: Inteiro;
Escreval (“Entre com 10 números inteiros: ”);
Para i de 1 até 10 faça;
Escreva (“Entre com o ”, i, “º número: ”);
leia(vet[i]);
FimPara
j <- 0;
Para i de 1 até 10 faça;
Se i mod 2 <> 0 entao;
j <- j+1;
vetposimpar[j] <- vet[i];
Senao;
vetpospar[j] <- vet[i];
FimSe
FimPara
Escreval (“Os números na posição par são: ”, vetpospar[i]);
Para i de 1 até 5 faça;
Escreva(vetpospar[i]);
FimPara
Escreval (“Os números na posição ímpar são:”, vetposimpar[i]);
Para i de 1 até 5 faça;
Escreva(vetposimpar[i]);
FimPara
FimAlgoritmo

5)
Algoritmo
Declare vet: Inteiro;
Declare vetpospar, vetposimpar, total: Inteiro;
j, i: Inteiro;
Escreval (“Entre com 10 números inteiros: ”);
Para i de 1 até 10 faça;
Escreva (“Entre com o ”, i, “º número: ”);
leia(vet[i]);
FimPara
j <- 0;
Para i de 1 até 10 faça;
Se i mod 2 <> 0 entao;
j <- j+1;
vetposimpar[j] <- vet[i];
Senao;
vetpospar[j] <- vet[i];
FimSe
FimPara
total <- j+vetpospar[i];
Escreva (“A soma dos valores pares é: ”, total);
Escreval (“Os números na posição par são: ”, vetpospar[i]);
Para i de 1 até 10 faça;
Escreva(vetpospar[i]);
FimPara
total <- j+vetposimpar[i];
Escreva (“A soma dos valores ímpares é: ”, total);
Escreval (“Os números na posição ímpar são:”, vetposimpar[i]);
Para i de 1 até 10 faça;
Escreva(vetposimpar[i]);
FimPara
FimAlgoritmo
6)

Algoritmo
Declare A: Inteiro;
Declare i, aux: Inteiro;
Para i de 1 até 20 faça;
leia (A[i]);
FimPara
Para i de 1 até 20 faça;
Escreva(A[i], “ “);
FimPara
Para i de 1 até 10 faça;
aux <- A[i];
A[i] <- A[21-i];
A[21-i] <- aux;
FimPara
Escreval (" ");
Para i de 1 até 20 faça;
Escreva(A[i], " ");
FimPara
FimAlgoritmo

7)

Algoritmo
Declare v: Inteiro;
Declare menor, i: Inteiro;
Para i de 1 até 10 passo 1 faça;
Leia(v[i]);
FimPara
menor <- v[1];
Para i de 2 ate 10 passo 1 faça;
Se (v[i] < menor) entao;
menor <- v[i];
FimSe
FimPara
Para i de 1 ate 80 passo 1 faça;
Se (v[i] = menor) entao;
Escreval (“O menor elemento é ”, menor, “ e está na posição ”, i);
FimSe
FimPara
FimAlgoritmo
8)

Algoritmo
Declare v: Inteiro;
Declare ampli, menor, maior, media, i: Real;
Escreva (“Digite o(s) número(s): ”);
Leia (i);
i <- 0;
Para i de 1 até 100 passo 1 faça;
Leia(v[i]);
FimPara
menor <- v[1];
Para i de 1 até 100 passo 2 faça;
Se (v[i] < menor) entao;
menor <- v[i];
FimSe
FimPara
Para i de 1 até 100 passo 3 faça;
Se (v[i] > menor) entao;
maior <- v[i];
FimSe
FimPara
ampli <- maior-menor;
media <- i/2;
media <- 0;
Escreval (“A amplitude dos números vale ”, ampli, “ e a média é ”, media, “.”);
FimAlgoritmo

9)

Algoritmo
Declare v: Inteiro;
Declare ampli, menor, maior, media, baixomedia, i: Real;
Escreva (“Digite o(s) número(s): ”);
Leia (i);
i <- 0;
Para i de 1 até 100 passo 1 faça;
Leia(v[i]);
FimPara
menor <- v[1];
Para i de 1 até 100 passo 2 faça;
Se (v[i] < menor) entao;
menor <- v[i];
FimSe
FimPara
Para i de 1 até 100 passo 3 faça;
Se (v[i] > menor) entao;
maior <- v[i];
FimSe
FimPara
ampli <- maior-menor;
media <- i/2;
media <- 0;
Se (i<>media) então;
baixomedia <- i
Escreva (“Os números que estão abaixo da média são: ”, baixomedia);
FimAlgoritmo
10)

Algoritmo
Declare vet[50], i, qtde, vezes, j, num: Real;
Repita;
Escreva (“Quantos elementos serão digitados?”);
Leia (qtde);
até ((qtde <= 50) e (qtde >0));
Para i de 1 até qtde faça;
Repita;
Escreva (“Digite um número entre 0 e 10: ”);
Leia (num);
até ((num>=0) e (num<=10));
vet[i] <-- num;
FimPara
Para i de 1 até qtde faça;
Para j de 1 até qtde faça;
Se(vet[i] = vet[j]);
Então vezes <-- vezes +1;
FimSe
FimPara
Escreva (”Número ”, vet[i], ": ", vezes, “vezes”);
vezes <-- 0;
FimPara
FimAlgoritmo

11)

Algoritmo
Declare Mat[10][10], i, j, soma_dp, soma_ds: Real;
Para i de 1 até 10 faça;
Para j de 1 até 10 faça;
Escreva (“Coloque o valor de Mat[“,i,”][“,j,”]”);
Leia (Mat[i][j]);
FimPara
FimPara
soma_dp <-- 0;
soma_ds <-- 0;
Para i de 1 até 10 faça;
Para j de 1 até 10 faça;
Se (i = j);
Então soma_dp <-- soma_dp + Mat[i][j];
Senão se ((i+j) = 11);
Então soma_ds <-- soma_ds + Mat[i][j];
FimSe
FimSe
FimPara
FimPara
Escreva (“O somatório dos elementos da diagonal principal vale: ”, soma_dp);
Escreva (“O somatório dos elementos da diagonal secundária vale: ”, soma_ds);
FImAlgoritmo
12)

Algoritmo
Declare Mat[10][10], i, j, soma_dp, soma_ds, determ: Real;
Para i de 1 até 10 faça;
Para j de 1 até 10 faça;
Escreva (“Coloque o valor de Mat[“,i,”][“,j,”]”);
Leia (Mat[i][j]);
FimPara
FimPara
soma_dp <-- 0;
soma_ds <-- 0;
Para i de 1 até 10 faça;
Para j de 1 até 10 faça;
Se (i = j);
Então soma_dp <-- soma_dp + Mat[i][j];
Senão se ((i+j) = 11);
Então soma_ds <-- soma_ds + Mat[i][j];
FimSe
FimSe
FimPara
FimPara
Determin <- ((2*i)-j);
Escreva (“O somatório dos elementos da diagonal principal vale: ”, soma_dp);
Escreva (“O somatório dos elementos da diagonal secundária vale: ”, soma_ds);
Escreva (“O valor da determinante é: ”, determ);
FImAlgoritmo

13)

Algoritmo
Declare Mat[5][5], c, i, j, soma_dp, soma_ds: Real;
Para i de 1 até 5 faça;
Para j de 1 até 5 faça;
Escreva (“Coloque o valor de Mat[“,i,”][“,j,”]”);
Leia (Mat[i][j]);
FimPara
FimPara
soma_dp <-- 0;
soma_ds <-- 0;
Para i de 1 até 5 faça;
Para j de 1 até 5 faça;
Se (i = j);
Então soma_dp <-- soma_dp + Mat[i][j];
Senão se ((i+j) = 11);
Então soma_ds <-- soma_ds + Mat[i][j];
FimSe
FimSe
FimPara
FimPara
C <- soma_dp+soma_ds;
Escreva (“O somatório dos elementos da diagonal principal vale: ”, soma_dp);
Escreva (“O somatório dos elementos da diagonal secundária vale: ”, soma_ds);
Escreva (“O valor da matriz resultante C vale: ”, c);
FImAlgoritmo
14)

Algoritmo
Declare Mat[5][5], c, i, j, soma_dp, soma_ds: Real;
Para i de 1 até 5 faça;
Para j de 1 até 5 faça;
Escreva (“Coloque o valor de Mat[“,i,”][“,j,”]”);
Leia (Mat[i][j]);
FimPara
FimPara
soma_dp <-- 0;
soma_ds <-- 0;
Para i de 1 até 5 faça;
Para j de 1 até 5 faça;
Se (i = j);
Então soma_dp <-- soma_dp + Mat[i][j];
Senão se ((i+j) = 11);
Então soma_ds <-- soma_ds + Mat[i][j];
FimSe
FimSe
FimPara
FimPara
C <- soma_dp*soma_ds;
Escreva (“O somatório dos elementos da diagonal principal vale: ”, soma_dp);
Escreva (“O somatório dos elementos da diagonal secundária vale: ”, soma_ds);
Escreva (“O valor da matriz resultante C vale: ”, c);
FImAlgoritmo