Lista de Exercícios para a 3ª unidade

Prévia do material em texto

�UFRN-DIMAp
DIM0320 – ALGORITMOS E PROGRAMAÇÃO DE COMPUTADORES
PROF.: AMARO DUARTE
Lista de Exercícios para a 3ª unidade
1) Assinale V (verdadeiro) ou F (falso) para as alternativas abaixo. Para as alternativas falsas, sublinhe as palavras ou frases que as tornam falsas.
Um subalgoritmo é um algoritmo subordinado a um algoritmo principal e/ou outro subalgoritmo.
Subalgoritmos podem ser usados quando se quer que um algoritmo mais complexo seja subdividido em algoritmos mais simples de serem criados.
Os parâmetros de um subalgoritmo são os meios pelos quais o algoritmo principal troca informações com o mesmo.
Parâmetros formais são parâmetros definidos no subalgoritmo.
Parâmetros reais são parâmetros utilizados no algoritmo chamador (algoritmo principal ou subalgoritmo) ao chamar um subalgoritmo.
Definir um subalgoritmo significa definir tipo e nome do subalgoritmo, seus parâmetros formais, suas variáveis locais e as instruções que este irá executar.
Um pseudocódigo completo estará dividido em: definições dos subalgoritmos (zero, um ou mais subalgoritmos) e algoritmo principal. A execução do algoritmo começa no primeiro subalgoritmo.
Quando um parâmetro formal é alterado dentro de um subalgoritmo, diz-se que este parâmetro está por referência, ou seja, o mesmo será uma referência ao parâmetro que será passado no algoritmo chamador (algoritmo principal ou subalgoritmo). Este parâmetro poderá receber, como parâmetro real, valor, variável ou expressão, de mesmo tipo do parâmetro, do algoritmo chamador.
Quando um parâmetro formal não é alterado em um subalgoritmo, diz-se que este parâmetro está por valor. Ou seja, o mesmo poderá receber como parâmetro real do algoritmo chamador, um valor, variável ou expressão do seu mesmo tipo.
Um subalgoritmo sempre será executado direta ou indiretamente dentro de um algoritmo. Portanto, não é necessária nenhuma chamada ao mesmo no algoritmo principal.
Um subalgoritmo só pode estar subordinado, apenas, a um algoritmo principal.
Um subalgoritmo só poderá ser usado se o mesmo for definido antes do algoritmo principal.
Variáveis locais são variáveis criadas dentro de um subalgoritmo. Estas variáveis podem ser usadas, também, pelo algoritmo principal.
Funções são subalgoritmos que resultam em um valor. Ou seja, uma função pode ser vista como um operador.
Uma função pode ter seu valor atribuído a uma variável, impresso com um comando escreva, fazer parte de uma expressão de tipo compatível, ser valor inicial e/ou final de um laço para-faça ou mesmo ter seu valor testado em uma expressão relacional.
Uma função pode ser definida com zero, um ou mais parâmetros formais.
É possível, dentro do algoritmo principal, criar uma expressão composta por funções, e atribuir a mesma a uma variável, desde que as funções estejam definidas antes do algoritmo principal e retornem valores de tipos compatíveis com a variável a ser atribuída.
O comando retorne é o comando responsável por fazer uma função resultar um valor. Este comando pode ser usado, também, em procedimentos e no algoritmo principal.
O tipo do valor que a função irá retornar será de mesmo tipo do valor, variável ou expressão contida no comando retorne.
A execução de uma função deve sempre terminar em um comando retorne.
Procedimentos são subalgoritmos que executam uma determinada seqüência de comandos. Um procedimento pode ser visto, portanto, como um comando.
Procedimentos podem retornar valores da mesma forma que funções e, portanto, pode ser usado em expressões.
Procedimentos só podem retornar valores através de seus parâmetros formais. Neste caso, diz-se que estes mesmos parâmetros serão por referência.
É possível criar novos comandos de leitura de variáveis a partir de procedimentos. Neste caso, não é necessário haver nenhum comando leia na seqüência de comandos do procedimento.
Se for criado um novo comando de leitura de variáveis (ou mesmo de matrizes) a partir de procedimentos, os parâmetros formais que receberão as variáveis (ou matrizes) a serem lidas serão por referência.
2) Escreva a saída para os seguintes algoritmos:
a) Os valores lidos são a=3, b=4
função quad(num)
	real: num, q
início
	q <- num*num
	retorne(q)
fim
função raiz_q(num)
	real: num, rq
início
	rq <- num^(1/2)
	retorne(num)
fim
algoritmo questao2_a
	real: a, b, c
início
	repita
		escreva("Digite valores para a e b:")
		leia(a,b)
	até(a>0 .e. b>0)
	c <- raiz_q(quad(a)+quad(b))
	escreva("c = ",c)
fim
b) Os valores lidos são x1 = 9, y1 = 18, x2 = 6 e y2 = 14
função quad(num)
	real: num, q
início
	q <- num*num
	retorne(q)
fim
função raiz_q(num)
	real: num, rq
início
	rq <- num^(1/2)
	retorne(num)
fim
função inclinacao(xi, yi, xf, yf)
	real: xi, xf, yi, yf, inc
inicio
	escreva("Calculando inclinação da reta.")
	inc <- (yi-yf)/(xi-xf)
	escreva("Cálculo da inclinação concluído.")
	retorne(inc)
fim
funcao intercepta(xi, yi, xf, yf)
	real: xi, yi, xf, yf, intercep
inicio
	escreva("Iniciando cálculo da interceptação.")
	intercep <- yi+inclinacao(xi,yi,xf,yf)*xi
	escreva("Cálculo da interceptação concluído.")
	retorne(intercep)
fim
algoritmo questao2_a
	real: x1, x2, y1, y2, d, m, b
início
	escreva("Digite x1 e y1:")
	leia(x1,y1)
	escreva("Digite x2 e y2:")
	leia(x2,y2)
	d <- raiz_q(quad(x2-x1)+quad(y2-y1))
	escreva("d = ",d)
	m <- inclinacao(x1,y1,x2,y2)
	b <- intecepta(x1,y1,x2,y2)
	escreva("reta: y=",m,".x+",b)
fim
c) Os valores lidos são m = 5, p = 4
função fatorial(x)
	inteiro: x, f, i
início
	f <- 1
	para i de 2 até x faça
		f <- f*i
	fim_para
	retorne(f)
fim
função combinação(n,p)
	inteiro: n, p, comb
inicio
	comb <- fatorial(n)/(fatorial(n-p)*fatorial(p))
	retorne(comb)
fim
algoritmo questao2_c
	inteiro: m, p
início
	escreva("Digite dois números para obter as combinações: ")
	repita
		Escreva("valores não negativos: ")
		Leia(m,p)
	até(m >= 0 .e. p >= 0 .e. m >= p)
	escreva("Número de combinações = ", combinacao(m,p))
fim
d) O valor lido é a = 2
funcao f(x)
	inteiro: x
inicio
	escreva("Calculando f(",x,").")
	retorne(x^2+2*x+4)
fim
funcao g(x)
	inteiro: x
inicio
	escreva("Calculando g(",x,").")
	retorne(2*x+3)
fim
algoritmo questao2_d
	inteiro: a
início
	escreva("f(g(1))=",f(g(1)) )
	escreva("g(f(1))=",g(f(1)) )
	escreva("f(g(1)+3)=", f(g(1)+3) )
	escreva("Digite um valor inteiro para a:")
	leia(a)
	escreva("f(g(",a,"))=",f(g(a)) )
	escreva("g(f(",a,"))=",g(f(a)) )
	escreva("f(",a,"+f(",a,"+2))=", f(a+f(a+2)) )
	escreva("f(",a,"*g(",a,"))=",f(a*g(a)) )
fim
e) Os valores lidos para a e b são, respectivamente, 3 e 5.
funcao f(x)
	inteiro: x
inicio
	escreva("Calculando f(",x,").")
	retorne(x^2+2*x+4)
fim
funcao g(x)
	inteiro: x
inicio
	escreva("Calculando g(",x,").")
	retorne(2*x+3)
fim
funcao soma(x,y)
	inteiro: x,y
inicio
	escreva("Somando", x," com ", y,".")
	retorne(x+y)
fim
funcao multiplica(x,y)
	inteiro: x,y
inicio
	escreva("Multiplicando", x," por ", y,".")
	retorne(x*y)
fim
algoritmo questao2_e
	inteiro: a,b
início
	escreva("Digite valores inteiros para a e b:")
	leia(a,b)
	escreva("f(a)+b = ", soma(f(a),b) )
	escreva("a*g(b) = ", multiplica(a,g(b)) )
	escreva("2*(b+f(g(a))) = ", multiplica(2, soma(b, f(g(a)))) )
fim
f) Os valores lidos são x = 15, y = 11
procedimento retangulo(lado1, lado2, perim, area)
	real: lado1, lado2, perim, area
início
	perim <- 2*(lado1 + lado2)
	area <- lado1 * lado2
fim
algoritmo questao2_f
	real: x,y,p,a
início
	repita
		escreva("Digite dois números: ")
		leia(x,y)
	até(x > 0.e. y > 0)
	retangulo(x,y,p,a)
	escreva("Perímetro = ",p)
	escreva("Área = ", a)
fim
g) Os valores lidos para n serão 30, 25 e 5, nesta ordem. Em seguida, será lido V= [2 5 8 1 10]
procedimento leia_tam_vetor(tam, tam_max)
	inteiro: tam, tam_max
inicio
	repita
		leia(tam)
		se (tam>tam_max) então
			escreva("O tamanho deve ser menor ou igual a ",tam_max,":")
		fim_se
	até(tam <= tam_max)
fim
procedimento leia_vetor_real(vet,num_elem)
	real: vet[20]
	inteiro: num_elem, i
início
	para i de 1 até num_elem faça
		escreva(i,"º elemento:")
		leia(vet[i])
	fim_para
fim
função somatorio(vet, ini, fim)
	real: vet[20], s
	inteiro: ini, fim, i
início
	escreva("Calculando somatório dos elementos do vetor...")
	s <- 0.0
	para i de ini até fim faça
		s <- s+vet[i]
	fim_para
	retorne(s)
fim
algoritmo questao2_g
	real: V[20]
	inteiro: n
início
	escreva("Quantos elementos?")
	leia_tam_vetor(n,20)
	escreva("Digite os elementos do vetor V:")
	leia_vetor_real(V,n)
	escreva(o somatório vale ", somatorio(V,1,n))
fim
h) Os valores para ini são -1, 0 e 26, nesta ordem. O valor de final é 29.
procedimento leia_num_positivo(n)
	inteiro: n
inicio
	repita
		leia(n)
		se(n<=0)
			escreva("O número deve ser positivo:")
		fim_se
	até(n>0)
fim
função soma_int(x, n)
	inteiro: x[30], n, s, i
início
	escreva("Executando a função soma_int().")
	s <- 0
	Para i de 1 até n faça
		s <- s + x[i]
	fim_para
	retorne(s)
fim
procedimento divisores(k, v, n)
	inteiro: k, v[30], n, i
início
	escreva("Obtendo divisores de ",k,":")
	n <- 0
	para i de 1 até k\2 faça
		se(k-k\i*i = 0)então
			n <- n + 1
			v[n] <- i
			escreva(v[n])
		fim_se
	fim_para
fim
algoritmo Perfeito
	inteiro: ini, final, per, V[30], q
início
	escreva("Digite um valor inicial positivo:")
	leia_num_positivo(ini)
	escreva("Digite um valor final positivo:")
	leia_num_positivo(final)
	para per de ini até final faça
		divisores(per, V, q)
		se(per = soma_int(V, q))então
			escreva(per, "é um número perfeito.")
		fim_se
	fim_para
fim
Subalgoritmos com parâmetros simples
Obs.: As questões a seguir seguem o seguinte esquema: primeiro, elas pedem os subalgoritmos, para depois pedir o algoritmo principal. Quando for resolver estas questões, leve em conta que todos os subalgoritmos, mais o algoritmo principal, são uma coisa só (um só algoritmo). Portanto, não faça algo do tipo "a) função func(...". Restrinja-se, apenas, a definir os subalgoritmos e fazer o algoritmo principal da forma que é pedida, na ordem pedida. Não esquecer que AS REGRAS DE INTERFACE DE USUÁRIO CONTINUAM VALENDO.
3) Nesta questão, faça, na ordem, o que pede os itens a seguir:
a) Defina uma função para calcular a média aritmética de 3 números reais. 
b) Faça um algoritmo principal que leia 3 números reais e utilize a função do item a para calcular a média aritmética dos mesmos.
4) Faça, em ordem, o que pede os itens a seguir:
	a) Defina a seguinte função:
		
		onde x é real e f(x) resulta valor real.
	b) Defina a seguinte função:
		
		onde x é real e g(x) resulta valor real.
	c) Crie um algoritmo principal que exiba, na ordem, os valores de:
f(-1)
f(2)
g(2)
f(g(0))
g(f(-2))
f(f(1)+g(2))
g(f(2).g(2))
ler o valor de a e exibir os valor de f(g(a)) e g(f(a)).
5) Faça, em ordem, o que pede os itens a seguir:
	a) Reaproveite a função fatorial da questão 2 item c (a função fatorial calcula x!).
	b) Crie uma função que calcule o arranjo de n elementos agrupados de p em p, que é dado pela fórmula
	 onde n e p serão parâmetros da função. 
	c) Faça um algoritmo principal que utilize a função do arranjo para calcular 
, 
 e 
.
6) Faça, em ordem, o que se pede a seguir:
a) Reaproveite a função fatorial da questão 2 item c (a função fatorial calcula x!).
b) A função seno pode ser calculada através da seguinte série:
	
Para qualquer valor real de x. Defina uma função chamada sen que receba como parâmetro um valor real para x e calcule um valor aproximado de sen(x) usando a seguinte série finita:
	Para o cálculo de 
, utilize a função fatorial.
c) A função cosseno pode ser calculada através da seguinte série:
	
Para qualquer valor real de x. Defina uma função chamada cos que receba como parâmetro um valor real para x e calcule um valor aproximado de cos(x) usando a seguinte série finita:
	
Para o cálculo de 
, utilize a função fatorial.
d) As funções sen e cos, definidas nos itens anteriores, tratam o valor de x como sendo em radianos. Defina uma função chamada converte_graus_rad, que receba como parâmetro um valor real (representando um ângulo em graus), e retorne o valor do ângulo em radianos. Para converter o valor de um ângulo de graus para radianos, usa-se a seguinte fórmula:
e) Faça um algoritmo principal que leia um valor real para a (assuma que o valor lido será em graus), converta o valor de a para radianos, usando a função converte_graus_rad, e calcule os valores de 
, 
 e 
.
7) Faça o que se pede a seguir:
a) Reaproveite todas as funções da questão 6.
b) defina uma função chamada tg que recebe como parâmetro um valor real para x e calcule a tangente de x (
). A tangente de x é definida como:
c) Faça um algoritmo principal que leia um valor de a em que 
(assuma que a esteja em graus), converta o valor de a para radianos (com a função converte_graus_rad) e calcule o valor de 
.
8) Faça o que se pede a seguir:
a) Reaproveite todas as funções da questão 6.
b) defina uma função chamada cotg que recebe como parâmetro um valor real para x e calcule a cotangente de x (
). A cotangente de x é definida como:
c) Faça um algoritmo principal que leia um valor de a em que 
e 
(assuma que a esteja em graus), converta o valor de a para radianos (com a função converte_graus_rad) e calcule o valor de 
.
9) Os dados a seguir devem ser usados dentro das funções (sem as unidades):
Faça o que se pede, em ordem:
Defina uma função chamada posicao, que recebe como parâmetro um valor real para t e retorna o valor da posição em função do tempo, a partir da fórmula 
.
Defina uma função chamada velocidade, que recebe como parâmetro um valor real para t e retorna o valor da velocidade em função do tempo, a partir da fórmula 
.
Faça um algoritmo que leia um valor maior ou igual a zero para o tempo t e calcule a posição e a velocidade nos tempos t, t+2 e t+5, usando as funções posição e velocidade.
10) Repita o algoritmo da questão 9, fazendo as seguintes mudanças:
Na função posicao, os parâmetros formais serão 
 e t.
Na função velocidade, os parâmetros formais serão 
 e t.
No algoritmo principal, ler um valor maior ou igual a zero para o tempo t e exiba a posição e a velocidade nos tempos t, t+2 e t+5, usando as funções definidas, só que desta vez, os valores dados na questão 8 para 
 devem ser passados como parâmetros reais nas chamadas das funções posicao e velocidade.
11) Para o algoritmo desta questão, faça o que se pede:
Defina um procedimento chamado ler_nota, para ler um valor real maior ou igual a zero e menor ou igual a 10.
Defina uma função para calcular a média parcial da UFRN. A função deve ter 3 parâmetros formais.
Defina uma função para calcular a média final da UFRN. A função deve ter 2 parâmetros formais.
Faça um algoritmo principal para ler as 3 primeiras notas, usando o procedimento ler_nota, e exibir o valor da média usando a função para calcular a média parcial. Em seguida, diga se o aluno foi aprovado, está em 4ª prova ou foi reprovado. Se estiver em 4ª prova, faça o algoritmo ler a 4ª nota usando o procedimento ler_nota, calcular e exibir a média final e dizer se o alunofoi aprovado ou reprovado em 4ª prova.
12) Faça o que se pede a seguir:
Defina um procedimento chamado ler_real, para ler um número real maior ou igual a zero.
Defina uma função chamada area_retangulo, que recebe como parâmetros 2 reais representando os lados do retângulo e retorna o valor da área do retângulo.
Defina uma função chamada perimetro_ret, que recebe como parâmetros 2 reais representando os lados do retângulo e retorna o perímetro do mesmo.
Faça um algoritmo principal que leia os lados do retângulo com o procedimento ler_real, calcule a área do retângulo com a função area_retangulo, e o perímetro, com a função perimetro_ret.
13) Faça o que se pede a seguir:
Reaproveite o procedimento ler_real definido na questão 12.
Defina uma função chamada area_circulo, que recebe como parâmetro um valor real para o raio r do círculo e retorna a área do círculo (
).
Defina uma função chamada perimetro_circulo, que recebe que recebe como parâmetro um valor real r para o raio do círculo e retorna o perímetro do círculo (
).
Faça um algoritmo principal que leia o raio do círculo com o procedimento ler_real, calcule a área do círculo com a função area_circulo, e o perímetro, com a função perimetro_circulo.
14) Faça o que se pede a seguir:
Reaproveite o procedimento ler_real definido na questão 12.
Defina uma função chamada triangulo_valido, que recebe como parâmetros 3 valores reais e retorna o valor lógico .V., se os valores dos parâmetros formarem um triangulo válido, ou .F. , caso contrário. Os três valores só formam um triângulo válido se os mesmos seguirem a seguinte regra: a soma de 2 dos valores deve ser maior que o terceiro (a+b > c, b+c > a e a+c > b).
Defina uma função chamada triangulo_ret, que recebe como parâmetros os 3 lados do triângulo e retorna .V., se os lados formam um triângulo retângulo, ou .F., caso contrário. Um triângulo é retângulo se os lados obedecem ao teorema de Pitágoras (
, 
 ou 
).
Defina uma função chamada triangulo_equi, que recebe como parâmetros os 3 lados do triângulo, e retorna .V. se o triângulo for equilátero, ou .F., caso contrário. Um triângulo é equilátero se os 3 lados forem iguais.
Defina uma função chamada triangulo_iso, que recebe como parâmetros os 3 lados do triângulo, e retorna .V. se o triângulo for isósceles, ou .F., caso contrário. Um triângulo será isósceles se ele não for equilátero e apenas 2 dos lados do triângulo forem iguais.
Defina uma função chamada triangulo_esc, que recebe como parâmetros os 3 lados do triângulo, e retorna .V. se o triângulo for escaleno, ou .F., caso contrário. Um triângulo será escaleno se ele não for equilátero e nem isósceles. (dica: utilize as funções triangulo_equi e triangulo_iso no teste)
Defina uma função chamada perimetro_tri que recebe 3 parâmetros reais e retorna o perímetro de um triângulo.
Defina uma função chamada area_tri que receba os lados do triângulo como parâmetro e calcule a área do triângulo, dada pela fórmula:
,
Onde p é o semi-perímetro do triângulo, dado por:
 neste caso, use a função perímetro_tri para calcular o valor de p.
Faça um algoritmo principal que leia os lados do triângulo com o procedimento ler_real, e, utilizando a função triangulo_valido, testar se os lados lidos formam um triângulo válido. Se sim, utilizar as funções triangulo_ret, triangulo_equi, triangulo_iso e triangulo_esc, para dizer o tipo do triângulo (retângulo ou não, equilátero, isósceles ou escaleno), e as funções area_tri e perimetro_tri para calcular área e perímetro do triângulo. Caso a função triangulo_valido dê .F. , diga que os lados não formam um triângulo válido.
15) Utilizando apenas os subalgoritmos definidos nas questões 12 a 14, faça algoritmos para ler os dados pedidos com o procedimento ler_real e calcular as áreas totais e os perímetros totais das figuras a seguir:
a) Ler c e r. d) Ler c e h.
 
b) Ler c e r.
 e) Ler c, h.
c) ler r.
Subalgoritmos com vetores e matrizes
Obs.: Ao declarar vetores, certifique-se que os vetores tanto dos subalgoritmos como do algoritmo principal possuam os mesmos tamanhos.
16) Reaproveite todos os subalgoritmos da questão 2 item g e utilize-os no algoritmo principal para ler um valor para n, e n elementos para um vetor V, e calcular a média aritmética dos elementos de V.
17) Faça um algoritmo com os seguintes subalgoritmos:
Procedimento leia_tam_vetor da questão 2 item g.
Procedimento leia_vetor_real da questão 2 item g.
Um procedimento chamado ordem_crescente, que ordena (e não imprime) um vetor de números reais em ordem crescente.
Um procedimento chamado ordem_decrescente, que ordena (e não imprime) um vetor de números reais em ordem decrescente.
Um procedimento imprime_vetor_real, que recebe como parâmetros um vetor real, índice do primeiro elemento a ser impresso (ini), o índice do último elemento (final), e imprime elementos do vetor do índice ini ao índice final. Se ini for maior que final, faça com que os índices do vetor variem em ordem decrescente.
O algoritmo principal deve ler o valor de n com o procedimento leia_tam_vetor, e ler n elementos reais para um vetor V, usando o procedimento leia_vetor_real. O algoritmo deverá exibir os elementos do vetor na ordem direta (na mesma ordem em que foram lidos), na ordem inversa, em ordem crescente e em ordem decrescente. Utilize, apenas, os procedimentos indicados nesta questão no algoritmo principal, e comandos escreva, para indicar o que está sendo lido ou impresso.
18) O algoritmo desta questão deverá simular a construção de conjuntos de elementos não repetidos. Para isso, faça o que se pede:
Defina um procedimento chamado leia_tam_conjunto, que leia um valor maior ou igual a zero para o tamanho de um conjunto. Obs.: o tamanho lido por este procedimento será, na verdade, a quantidade de elementos a serem lidos para um vetor.
Defina uma função chamada existe_elemento, que receberá como parâmetros um valor real, um vetor de reais e a quantidade de elementos que o vetor possui. A função retorna .V., se o valor real está contido no vetor, ou .F., caso contrário. Observe que, se o vetor estiver vazio, o parâmetro que conterá a quantidade de elementos do vetor será zero. Neste caso, a função deve, também retornar .F. .
Defina um procedimento chamado leia_conjunto, que recebe como parâmetros um vetor de números reais, e a quantidade de elementos a serem lidos. Se a quantidade de elementos a serem lidos for maior que zero, este procedimento, por sua vez, irá ler um valor real, verificar se o valor lido está contido no vetor, usando a função existe_elemento, e se ela der .F., o elemento será inserido no vetor. Caso contrário, avisar que o valor já existe no vetor.
Reaproveite o procedimento ordem_crescente da questão 17 item d.
Reaproveite o procedimento imprime_vetor_real da questão 17 item e.
Faça um algoritmo principal que leia o valor de n com o procedimento leia_tam_vetor, e ler n elementos reais para um vetor V, usando o procedimento leia_conjunto. O algoritmo deverá, então, exibir os elementos do vetor em ordem crescente.
19) Reutilize todos os subalgoritmos da questão 16 e defina procedimentos para implementar as seguintes operações com conjuntos:
 (união de A com B, ou seja, elementos (não repetidos) que estão contidos em A ou em B.)
 (interseção de A com B, ou seja, elementos comuns que estão contidos, ao mesmo tempo, em A e em B).
 (elementos de A que não estão contidos em B)
Em seguida, faça com que o algoritmo principal leia valores para m e n, usando o procedimento leia_tam_vetor, m elementos para um vetorX e n elementos para um vetor Y, usando o procedimento leia_conjunto. Em seguida, exiba, em ordem crescente, os vetores X e Y, a união de X com Y, a interseção de X com Y, os elementos de X que não estão em Y e os elementos de Y que não estão em X. Se algum conjunto a ser exibido for vazio, faça o algoritmo avisar tal fato no momento da exibição.
Subalgoritmos com matrizes
Obs.: Ao declarar matrizes, certifique-se que as matrizes tanto dos subalgoritmos como do algoritmo principal sejam quadradas e possuam os mesmos tamanhos para linhas e colunas.
20) Crie os seguintes subalgoritmos:
Um procedimento chamado leia2tamanhos para ler 2 valores inteiros positivos, onde esses valores serão quantidade de linha e coluna de uma matriz.
Um procedimento chamado leia_matriz, para ler uma matriz qualquer. Os parâmetros serão uma matriz, a quantidade de linhas e a quantidade de colunas da mesma.
Um procedimento chamado coluna_matriz, que recebe como parâmetros uma matriz, a quantidade de linhas e de colunas da mesma, um vetor e um índice de coluna para a matriz passada como parâmetro. O procedimento deve, então, atribuir, aos elementos do vetor, os elementos da coluna escolhida da matriz.
Um procedimento imprime_vetor, que recebe como parâmetros um vetor e o tamanho do mesmo, e imprime os elementos do mesmo vetor.
Em seguida, faça um algoritmo que leia valores para m e n, usando o procedimento leia2tamanhos, uma matriz Am x n, usando o procedimento leia_matriz, um valor c (maior ou igual a 1 e menor ou igual a n) que indique uma coluna da matriz A. Em seguida, gere um vetor V que contenha o mesmo conteúdo da coluna c da matriz A, utilizando o procedimento coluna_matriz, e imprima o vetor V, com o procedimento imprime_vetor.
21) Para o algoritmo desta questão, proceda da seguinte forma:
Reaproveite os procedimentos dos itens a, b e d da questão 20.
Defina um procedimento chamado linha_matriz, que recebe como parâmetros uma matriz, a quantidade de linhas e de colunas da mesma, um vetor e um índice de linha para a matriz passada como parâmetro. O procedimento deve, então, atribuir, aos elementos do vetor, os elementos da linha escolhida da matriz.
Faça um algoritmo principal que leia valores para m e n, usando o procedimento leia2tamanhos, uma matriz Am x n, usando o procedimento leia_matriz, um valor lin (maior ou igual a um e menor ou igual a m) que indique uma linha da matriz A. Em seguida, gere um vetor V que contenha o mesmo conteúdo da linha lin da matriz A, utilizando o procedimento linha_matriz, e imprima o vetor V, com o procedimento imprime_vetor.
22) Para o algoritmo desta questão, faça o que se pede:
Crie um procedimento chamado leia3tamanhos, que lê 3 valores para os tamanhos de uma matriz. Leve em conta que, neste procedimento, estaremos lendo os tamanhos para 2 matrizes envolvidas em uma multiplicação.
Reaproveite o procedimento leia_matriz da questão 18.
Faça um procedimento chamado imprima_matriz, que receba uma matriz e a quantidade de linhas de de colunas para ela, e imprima seus elementos. Procure fazer com que o procedimento, ao exibir um elemento, diga a linha e a coluna a que ele pertence.
Faça um procedimento chamado mult_escalar_matriz, que receba como parâmetros 2 matrizes de mesmo tamanho (uma será o resultado da operação e outra, a matriz a ser operada), a quantidade de linhas e de colunas para elas (2 parâmetros bastam, já que serão 2 matrizes de mesmo tamanho), e um escalar real. O procedimento, então, deve multiplicar o escalar pelos elementos da matriz. Ou seja, o procedimento deve realizar a seguinte operação:
Faça um procedimento chamado matriz_transposta, que recebe como parâmetros 2 matrizes (uma será o resultado da operação e outra, a matriz a ser operada), e a quantidade de linhas e de colunas da matriz a ser operada. O procedimento deve, então, gerar a transposta de uma matriz, ou seja:
	onde as colunas de A serão as linhas da transposta e vice-versa.
Faça um procedimento chamado soma_matrizes, que receba 3 matrizes de mesmo tamanho (uma para o resultado e 2 como operandos), os tamanhos para as mesmas (2 parâmetros apenas) e calcule a soma de 2 matrizes, ou seja:
	
Faça um procedimento chamado mult_matrizes, que receba 3 matrizes de mesmo tamanho (uma para o resultado e 2 como operandos), os tamanhos para as mesmas (3 parâmetros) e calcule o produto de 2 matrizes.
		A fórmula de recorrência para os elementos de R é
Utilizando todos os procedimentos acima definidos, faça um algoritmo principal que leia os tamanhos m,n e p, as matrizes A, B e C, e os coeficientes reais t e u, e calcule a seguinte expressão:
23) Reaproveite os procedimentos da questão 22 (apenas os procedimentos que forem necessários) e faça algoritmos para ler os valores m, n e p, as matrizes A, B, C e D (com as dimensões dadas nas expressões de cada item) e calcular as seguintes matrizes:�
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
 onde t e u são valores reais, a serem lidos pelo algoritmo.
 onde 
 e 
 são matrizes transpostas de A, B e D, e D é uma matriz m por n.
, onde 
 e 
 são matrizes transpostas de A, B e C, e C é uma matriz m por n.
, onde D será uma matriz n linhas por m colunas
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
, onde t e u são valores reais, a serem lidos pelo algoritmo.
 onde t e u são valores reais, a serem lidos pelo algoritmo.
c
c
r
c
c
r
r
r
r
r
r
 c
 c
 c
 h
 c
 c
 c
 h
_284583940.unknown
_360032804.unknown
_559622700.unknown
_559683184.unknown
_559683824.unknown
_559684144.unknown
_559683504.unknown
_559682544.unknown
_559682864.unknown
_559623020.unknown
_559621100.unknown
_559622060.unknown
_559622380.unknown
_559621420.unknown
_559621740.unknown
_360033444.unknown
_559620460.unknown
_559620780.unknown
_360033124.unknown
_290618280.unknown
_297684072.unknown
_360031524.unknown
_360032164.unknown
_360032484.unknown
_360031844.unknown
_360030244.unknown
_360030884.unknown
_360031204.unknown
_360030564.unknown
_326364320.unknown
_326364640.unknown
_326364000.unknown
_326361760.unknown
_290625196.unknown
_290626476.unknown_290656736.unknown
_290626156.unknown
_290623916.unknown
_290624556.unknown
_290624236.unknown
_290618920.unknown
_284585220.unknown
_284636232.unknown
_284637512.unknown
_290616040.unknown
_290617960.unknown
_284637832.unknown
_284636872.unknown
_284637192.unknown
_284636552.unknown
_284635592.unknown
_284635912.unknown
_284585540.unknown
_284584580.unknown
_284584900.unknown
_284584260.unknown
_284529408.unknown
_284531968.unknown
_284582660.unknown
_284583300.unknown
_284583620.unknown
_284582980.unknown
_284582020.unknown
_284582340.unknown
_284532288.unknown
_284530688.unknown
_284531328.unknown
_284531648.unknown
_284531008.unknown
_284530048.unknown
_284530368.unknown
_284529728.unknown
_235471004.unknown
_275872532.unknown
_284345396.unknown
_284427320.unknown
_284427960.unknown
_284428280.unknown
_284428600.unknown
_284427640.unknown
_284426680.unknown
_284427000.unknown
_284345716.unknown
_284426360.unknown
_275873300.unknown
_284345076.unknown
_275872916.unknown
_275871380.unknown
_275871764.unknown
_275872148.unknown
_275869844.unknown
_275870228.unknown
_268158932.unknown
_235471388.unknown
_224811032.unknown
_224812568.unknown
_234327528.unknown
_234327208.unknown
_224811416.unknown
_224810264.unknown
_224810648.unknown
_224809112.unknown
_224809880.unknown
_196518920.unknown