lista de vetores e matrizes - GABARITO

Prévia do material em texto

Prepare um algoritmo para ler o nome de 50 pessoas. Em seguida você deve abrir a opção de alterar um destes nomes. Assim, você deve perguntar em que posição está o nome a ser alterado e o novo nome a ser armazenado nesta posição. Você deve fazer isto até que a posição desejada seja = 0.
Algoritmo 1;
Variáveis
	Vet_Nomes = vetor[50] de caracter;
	posição : inteiro;
	novo_nome : caracter;
Inicio
// cadastrando os nomes originais
	Para posição de 1 até 50 passo + 1 faça
		Leia(Vet_Nomes[posicao]);
	Fim_Para
	//habilitando a mudança de nomes
	Repita
		Leia(posição);
		Se posição ≠ 0
			Então
				Leia(novo_nome);
				Vet_Nomes[posição] = novo_nome;
		Fim_Se
	Até posição = 0;
Fim_Algoritmo
Prepare um algoritmo para controlar as vagas em excursões. Inicialmente seu algoritmo deverá perguntar o número de vagas em cada uma das 35 excursões. Em seguida seu algoritmo deverá perguntar o n.º da excursão (números de 1 a 35) e diminuir uma unidade das vagas disponíveis desta excursão (se houver vaga). Você deve perguntar o número da excursão até que seja digitado 0. No final seu algoritmo deverá informar o total de vagas restantes em cada excursão.
Algoritmo 2;
Variáveis
	Vet_Vagas = vetor[35] de inteiro;
	N_excursão : inteiro;
Inicio
	Para n_excursão de 1 até 35 passo + 1 faça
		Leia(Vet_Vagas[n_excursão]);
	Fim_Para
	Repita
		Leia(n_excursão);
		Se n_excursão ≠ 0
			Então
				Se Vet_Vagas[n_excursão] > 0
					Então Vet_Vagas[n_excursão] = Vet_Vagas[n_excursão] – 1;
					Senão Escreva(“Esta excursão já está lotada”);
				Fim_Se
		Fim_Se
	Até n_excursão = 0;
	Para n_excursão de 1 até 35 passo + 1 faça
		Escreva(Vet_Vagas[n_excursão]);
	Fim_Para
Fim_Algoritmo
�
Você preparar um programa para controlar informações sobre turistas em um aeroporto. Seu algoritmo deve ler, para 10000 turistas que chegaram no aeroporto, o número do país de origem (1..20). Finalmente, seu algoritmo deverá informar a quantidade de turistas oriundos de cada país. 
Algoritmo 3;
Variáveis
	Vet_Passageiros = vetor[20] de inteiro;
	n_pais : inteiro;
	n_turista: inteiro;
Inicio
	Para n_pais de 1 até 20 passo + 1 faça
		Vet_ Passageiros [n_pais] = 0;
	Fim_Para
	Para n_turista de 1 até 10000 passo + 1 faça
		Leia(n_pais);
		Vet_ Passageiros [n_pais] = Vet_ Passageiros [n_pais] + 1;
	Fim_Para
	Para n_pais de 1 até 20 passo + 1 faça
		Escreva(Vet_ Passageiros [n_pais]);
	Fim_Para
Fim_Algoritmo
Prepare um algoritmo para controlar as informações sobre uma imobiliária. Inicialmente você deve ler as informações sobre 50 imóveis que estarão a venda. As informações a serem lidas são: Endereço e Preço.
Em seguida seu algoritmo deverá fazer pesquisa de imóveis para alugar. Para isto você deve perguntar a faixa de valores desejada e listar todos os imóveis compatíveis com este preço. Após a listagem você deve perguntar se o usuário deseja fazer nova consulta ou terminar a execução. 
Exemplo de faixa de preços: 
Valor mínimo: 50.000,00
Valor máximo: 100.000,00
Listar o endereço de todos os imóveis com preço entre 50.000 e 100.000.
Algoritmo 4;
Variáveis
	Vet_Endereço = vetor[50] de caracter;
	Vet_Preço = vetor[50] de real;
	n_imovel : inteiro;
	preço_minimo : real;
	preço-maximo : real;
	resposta : caracter;
Inicio
	Para n_imovel de 1 até 50 passo + 1 faça
		Leia(Vet_Endereço[n_imovel]);
		Leia(Vet_Preço[n_imovel]);
	Fim_Para
	Repita
		Leia(preço_minimo);
		Leia(preço_maximo);
		Para n_imovel de 1 até 50 passo + 1 faça
			Se (Vet_Preço[n_imovel] > preço_minimo) e (Vet_Preço[n_imovel] < preço_maximo)
				Então
					Escreva(Vet_Endereço[n_imovel]);
					Escreva(Vet_Preço[n_imovel]);
			Fim_Se
		Fim_Para
		Leia(resposta);
Até resposta = ‘n’;
Fim_Algoritmo
Prepare um algoritmo para perguntar nome, sexo, salário e cargo a 1000 funcionários de uma empresa. Após a leitura dos dados você deve informar:
Os dados de todas as mulheres; 
Em seguida, todos os homens com salário abaixo de R$ 1.000,00
Em seguida, todos os médicos com salário maior que R$ 10.000,00
Algoritmo 5;
Variáveis
	Vet_Nomes = vetor[1000] de caracter;
	Vet_Sexos = vetor[1000] de caracter;
	Vet_Salarios = vetor[1000] de real;
	Vet_Cargos = vetor[1000] de caracter;
	n_funcionario : inteiro;
Inicio
	Para n_funcionario de 1 até 1000 passo + 1 faça
		Leia(Vet_Nomes[n_funcionario]);
		Leia(Vet_Sexos[n_funcionario]);
		Leia(Vet_Salarios[n_funcionario]);
		Leia(Vet_Cargos[n_funcionario]);
	Fim_Para
	Para n_funcionario de 1 até 1000 passo + 1 faça
		Se Vet_Sexos[n_funcionario] = ‘F”
 			Então
				Escreva(Vet_Nomes[n_funcionario]);
				Escreva(Vet_Sexos[n_funcionario]);
				Escreva (Vet_Salarios[n_funcionario]);
				Escreva (Vet_Cargos[n_funcionario]);
		Fim_Se
	Fim_Para
	Para n_funcionario de 1 até 1000 passo + 1 faça
		Se Vet_Sexos[n_funcionario] = ‘M” e Vet_Salarios[n_funcionario] < 1000
 			Então
				Escreva(Vet_Nomes[n_funcionario]);
				Escreva(Vet_Sexos[n_funcionario]);
				Escreva (Vet_Salarios[n_funcionario]);
				Escreva (Vet_Cargos[n_funcionario]);
		Fim_Se
	Fim_Para
	Para n_funcionario de 1 até 1000 passo + 1 faça
		Se Vet_Cargos[n_funcionario] = ‘Medico” e Vet_Salarios[n_funcionario] > 10000
 			Então
				Escreva(Vet_Nomes[n_funcionario]);
				Escreva(Vet_Sexos[n_funcionario]);
				Escreva (Vet_Salarios[n_funcionario]);
				Escreva (Vet_Cargos[n_funcionario]);
		Fim_Se
	Fim_Para
Fim_Algoritmo
Você deve gerenciar informações sobre utilização de cartões de vale-transporte. Foram distribuídos 10 cartões, identificados de com os números de 1 a 10. 
	1
	2
	3
	4
	5
	6
	7
	8
	9
	10
	
	
	
	
	
	
	
	
	
	
Inicialmente você deve ler o valor inicial inserido em cada cartão. 
Exemplo:
	1
	2
	3
	4
	5
	6
	7
	8
	9
	10
	10,00
	50,00
	20,00
	15,00
	27,00
	48,00
	95,00
	70,00
	23,00
	81,00
Em seguida, você deve perguntar o tipo de operação desejada:
1 – para “Debitar valor”
2 – para “Creditar valor”
3 – para “Listagem geral”
4 – para terminar
Debitar valor. Perguntar o n.º do cartão e o valor a ser debitado.
Exemplo: Nº do cartão: 3, Valor: 3,00
	1
	2
	3
	4
	5
	6
	7
	8
	9
	10
	10,00
	50,00
	17,00
	15,00
	27,00
	48,00
	95,00
	70,00
	23,00
	81,00
Creditar Valor. Perguntar o n.º do cartão e o valor a ser creditado.
Exemplo: Nº do cartão: 5, Valor: 5,00
	1
	2
	3
	4
	5
	6
	7
	8
	9
	10
	10,00
	50,00
	17,00
	15,00
	32,00
	48,00
	95,00
	70,00
	23,00
	81,00
Listagem geral. Listar o valor atual em cada um dos 10 cartões.
Algoritmo 6;
Variáveis
	Vet_Cartões = vetor[10] de real;
	n_cartão : inteiro;
	opção : inteiro;
	valor: real;
Inicio
	Para n_cartão de 1 até 10 passo + 1 faça
		Leia(Vet_Cartões[n_cartão]);
	Fim_Para
	Repita
 		Leia(opção);
Caso opção 
1: 	leia(n_cartão);
	leia(valor);
 	Vet_cartões[n_cartão] = Vet_cartões[n_cartão] - valor;
2: 	leia(n_cartão);
	leia(valor);
 	Vet_cartões[n_cartão] = Vet_cartões[n_cartão] + valor;
3	Para n_cartão de 1 até 10 passo + 1 faça
					Escreva(n_cartão, Vet_cartões[n_cartão]);
				Fim_Para
		Fim_Caso
	Até opção = 4;
Fim_Algoritmo
�
Você deve controlar os dados de 50 carros de corrida. Estes carros fazem testes e você deve cadastrar informações sobre as voltas: N.º da carro e tempo da volta (em segundos). Você deve ler estes dados até que seja digitado zero no n.º do carro. Informe:
O Total de voltas de cada carro
A volta mais rápida de cada carro
O n.º do carro que fez a volta mais rápida.
Algoritmo 7;
Variáveis
	Vet_Voltas = vetor[50] de inteiro;
	Vet_Melhor_Volta = vetor[50] de real;
	n_carro : inteiro;
	melhor_volta_geral : real;
n_melhor_carro : inteiro;
Inicio
	Para n_carro de 1 até 50 passo + 1 faça
		Vet_Voltas[n_carro] = 0;
		Vet_Melhor_Volta[n_carro] = 999999;
	Fim_Para
	melhor_volta = 999999;
	Repita
 		Leia(n_carro);
Se n_carro ≠ 0
Então
Leia(tempo_volta_atual);
Vet_Voltas[n_carro] = Vet_Voltas[n_carro] + 1;
Se tempo_volta_atual < Vet_Melhor_Volta[n_carro]
	Então
Vet_Melhor_Volta[n_carro] = tempo_volta_atual;Fim_Se
Se tempo_volta_atual < melhor_volta_geral
	Então
	 	melhor_volta_geral = tempo_volta_atual;
		n_melhor_carro = n_carro;
				Fim_Se
		Fim_Se
	Até n_carro = 0;
Para n_carro de 1 até 50 passo + 1 faça
		Escreva(n_carro, Vet_Voltas[n_carro],Vet_Melhor_Volta[n_carro]);
	Fim_Para
	Escreva(n_melhor_carro, melhor_volta_geral);
Fim_Algoritmo
�
Prepare um algoritmo para controlar as vendas de uma loja. Sua loja vende 10 produtos e existem 6 vendedores. Inicialmente, para cada produto, você deve ler e armazenar a quantidade em estoque. Em seguida você ler os dados de 5000 vendas que são n.º do produto, n.º do vendedor e quantidade vendida. Você deve ler estes dados até que o numero do produto seja = 0 e em seguida informar: (está errado ou e 5000 vezes ou ate que o numero do produto seja = 0. Gabarito feito para os 2 modos)
Quantidade vendida por cada vendedor, independente de produto.
Estoque final de cada produto.
Algoritmo 8;
Variáveis
	Vet_Produtos = vetor[10] de real;
	Vet_Vendedores = vetor[6] de real;
	n_produto : inteiro;
	n_vendedor : real;
quantidade_vendida: real;
n_venda : inteiro;
Inicio
	Para n_produto de 1 até 10 passo + 1 faça
		Leia(Vet_Produtos[n_produto]);
	Fim_Para
	Para n_vendedor de 1 até 6 passo + 1 faça
		Vet_Vendedores[n_vendedor] = 0;
	Fim_Para
	Para n_venda de 1 até 5000 passo + 1 faça
		Leia(n_produto);
		Leia(n_vendedor);
		Leia(quantidade_vendida);
		Vet_Vendedores[n_vendedor] = Vet_Vendedores[n_vendedor] + quantidade_vendida;
		Vet_Produtos[n_produto] = Vet_Produtos[n_produto] - quantidade_vendida;
	Fim_Para
	Para n_produto de 1 até 10 passo + 1 faça
		Escreva(n_produto, Vet_Produtos[n_produto]);
	Fim_Para
	Para n_vendedor de 1 até 6 passo + 1 faça
		Escreva(n_vendedor, Vet_Vendedores[n_vendedor]);
	Fim_Para
Fim_Algoritmo
2º modo
	Repita
		Leia(n_produto);
		Se n_produto ≠ 0
			Então
Leia(n_vendedor);
				Leia(quantidade_vendida);
Vet_Vendedores[n_vendedor] = 	Vet_Vendedores[n_vendedor] +
 					quantidade_vendida;
				Vet_Produtos[n_produto] = Vet_Produtos[n_produto] – 
quantidade_vendida;
		Fim_Se
	Até n_produto = 0;
	
Faça as seguintes declarações.
Declare uma matriz 100x50 de números inteiros.
Mat = matriz[100][50] de inteiro;
Declare uma matriz 30x20x80 de números reais.
Mat = matriz[30][20][80] de real;
Declare uma matriz 200x100, onde cada posição contém os campos nome (string), idade (inteiro) e salário (real)
Sem o uso de registro devem ser declaradas 3 matrizes:
Mat_Nomes 	= matriz [200][100] de caracter;
Mat_Idades 	= matriz [200][100] de inteiro;
Mat_Salários	= matriz [200][100] de real;
Faça os procedimentos para o seguinte algoritmo:
Declarar uma matriz de números reais, contendo 1000 linhas e 500 colunas.
Ler o valor de cada posição desta matriz.
Calcular e informar a soma total de todas as linhas pares. 
Calcular e informar quantas vezes um determinado número aparece na matriz. Você deve perguntar o número desejado
Algoritmo 10;
Variáveis
	Mat = matriz[1000][500] de real;
linha : inteiro;
coluna : inteiro;
soma_linhas_pares : real;
numero_escolhido : real;
quantidade : inteiro;
Inicio
	Para linha de 1 até 1000 passo + 1 faça
		Para coluna de 1 até 500 passo + 1 faça
			Leia(Mat[linha][coluna]);
		Fim_Para
	Fim_Para
	soma_linhas_pares = 0;
	Para linha de 2 até 1000 passo + 2 faça
		Para coluna de 1 até 500 passo + 1 faça
			soma_linhas_pares = soma_linhas_pares + Mat[linha][coluna];
		Fim_Para
	Fim_Para
	Escreva(soma_linhas_pares);
	Leia(numero_escolhido);
	quantidade = 0;
	Para linha de 1 até 1000 passo + 1 faça
		Para coluna de 1 até 500 passo + 1 faça
			Se numero_escolhido = Mat[linha][coluna]
				Então quantidade = quantidade + 1;
			Fim_Se
		Fim_Para
	Fim_Para
	Escreva(quantidade);
Fim_Algoritmo
Faça um algoritmo para ler uma matriz de tamanho 20x20 e informar se ela é um quadrado perfeito. Uma matriz é um quadrado perfeito se a soma de cada linha e de cada coluna é sempre igual ao mesmo valor.
Algoritmo 11;
Variáveis
	Mat = matriz[20][20] de real;
linha : inteiro;
coluna : inteiro;
soma_linha : real;
soma_coluna : real;
valor_base : real;
quadrado_perfeito : caracter;
Inicio
	Para linha de 1 até 20 passo + 1 faça
		Para coluna de 1 até 20 passo + 1 faça
			Leia(Mat[linha][coluna]);
		Fim_Para
	Fim_Para
	Quadrado_perfeito = “Sim”;
	Para linha de 1 até 20 passo + 1 faça
		soma_linha = 0;
		Para coluna de 1 até 20 passo + 1 faça
			soma_linha = soma_linha + Mat[linha][coluna];
		Fim_Para
		Se linha = 1
			Então 
valor_base = soma_linha;
			Senão
				Se soma_linha ≠ valor_base
					Então quadrado_perfeito = “não”;
				Fim_Se
		Fim_Se
 	Fim_Para
	Se quadrado_perfeito = “Sim”
		Então
			Para coluna de 1 até 20 passo + 1 faça
				soma_coluna = 0;
				Para linha de 1 até 20 passo + 1 faça
					soma_coluna = soma_coluna + Mat[linha][coluna];
				Fim_Para		
				Se soma_coluna ≠ valor_base
					Então quadrado_perfeito = “não”;
				Fim_Se
 			Fim_Para
	Fim_Se
	
	Escreva(quadrado_perfeito);
Fim_Algoritmo
�
Você deve preencher uma matriz de 100 x 100 usando o seguinte critério:
Se a soma dos índices for menor que 30, a posição deve receber o valor do 1º índice.
	Exemplo( Posição [2,20] = 2; pois a soma 2 + 20 = 22 < 30.
Se a soma dos índices for maior que 100, a posição deve receber o valor do 2º índice.
	Exemplo( Posição [30,82] = 82; pois a soma 30 + 82 = 112 > 100.
Se a soma dos índices for entre 30 e 100, inclusive, a posição deve receber o valor do 1º índice somado com o segundo índice. Exemplo( Posição [30,20] = 50; pois a soma 30 + 20 = 50, está entre 30 e 100.
Algoritmo 12;
Variáveis
	Mat = matriz[100][100] de real;
linha : inteiro;
coluna : inteiro;
Inicio
	Para linha de 1 até 20 passo + 1 faça
		Para coluna de 1 até 20 passo + 1 faça
			Se (linha + coluna) < 30
Então
Mat[linha][coluna] = linha;
			Fim_Se
			Se (linha + coluna) > 100
Então
Mat[linha][coluna] = coluna;
			Fim_Se
			Se ((linha + coluna) >= 30) e ((linha + coluna) <= 100) 
Então
Mat[linha][coluna] = linha + coluna;
			Fim_Se
		Fim_Para
	Fim_Para
	Para linha de 1 até 20 passo + 1 faça
		Para coluna de 1 até 20 passo + 1 faça
			Escreva(Mat[linha][coluna]);
		Fim_Para
	Fim_Para
Fim_Algoritmo
�
Você deve controlar informações sobre um presídio. Existem 5 alas, cada um com 50 celas. Inicialmente você inicializar ler a quantidade de presos em cada cela de cada ala. Em seguida você deve perguntar o número da ala e o número da cela onde será detido mais um preso. Você deve ler estes dados até que o numero da ala seja = -1. Informe a quantidade final de presos em cada cela de cada ala.
Algoritmo 13;
Variáveis
	Mat_Presidio = matriz[5][50] de real;
n_ala : inteiro;
n_cela : inteiro;
Inicio
	Para n_ala de 1 até 5 passo + 1 faça
		Para n_cela de 1 até 50 passo + 1 faça
			Leia(Mat_Presidio[n_ala][n_cela]);
		Fim_Para
	Fim_Para
	Repita
		Leia(n_ala);
		Se n_ala ≠ -1
			Então
Leia(n_cela);
Mat_Presidio[n_ala][n_cela] = Mat_Presidio[n_ala][n_cela] + 1;
		Fim_Se
	Até n_ala = -1;
	Para n_ala de 1 até 5 passo + 1 faça
		Para n_cela de 1 até 50 passo + 1 faça
			Escreva(Mat_Presidio[n_ala][n_cela]);
		Fim_Para
	Fim_Para
Fim_Algoritmo
�
Prepare um algoritmo para os dados sobre produção em uma fábrica. Existem 8 setores, cada um com 10 máquinas. Seu algoritmo deverá perguntar n.º do setor, n.º da máquina e quantidade produzida até que o n.º do setor seja = 0. Informe: 
A quantidade produzida em cada máquina de cada setor
A quantidade produzida em cada setor
A quantidade total produzida
Algoritmo 14;
Variáveis
	Mat_Fábrica = matriz[8][10] de real;
n_setor : inteiro;
n_maquina : inteiro;
quantidade_produzida : real;
total_setor : real;
total_fabrica : real;
Inicio
	Para n_setor de 1 até 8 passo + 1 faça
		Para n_maquina de 1 até 10 passo + 1 faça
			Mat_Fabrica[n_setor][n_maquina] = 0;
		Fim_Para
	Fim_Para
	Repita
		Leia(n_setor);Se n_setor ≠ 0
			Então
Leia(n_maquina);
Leia(quantidade_produzida);
Mat_Fabrica[n_setor][n_maquina] = Mat_Fabrica[n_setor][n_maquina] + 
					quantidade_produzida;
		Fim_Se
	Até n_setor = 0;
	total_fabrica = 0;
	Para n_setor de 1 até 8 passo + 1 faça
		total_setor = 0;
		Para n_maquina de 1 até 10 passo + 1 faça
			Escreva(Mat_Fabrica[n_setor][n_maquina]);
			total_setor = total_setor + Mat_Fabrica[n_setor][n_maquina];
		Fim_Para
		Escreva(total_setor);
		total_fabrica = total_fabrica + total_setor;
	Fim_Para
	Escreva(total_fabrica);
Fim_Algoritmo
�
Prepare um algoritmo para controlar as informações sobre processos em uma firma de advocacia. Existem 50 advogados e cada um cuida de 100 processos. Inicialmente seu algoritmo deverá cadastrar para cada processo de cada advogado o nome do cliente e os custos, que inicialmente será 0.
Em seguida seu algoritmo deverá perguntar o n.º do advogado(1..50), o n.º do processo(1..100) e o valor de despesa. Você deve acumular estes valores para o processo. Você deve implementar algum mecanismo para interromper a leitura dos dados.
Finalmente seu algoritmo deverá informar para cada processo de cada advogado:
Nome do cliente
Custo total
Algoritmo 15;
Variáveis
	Mat_Clientes = matriz[50][100] de caracter;
Mat_Custos = matriz[50][100] de real;
n_advogado : inteiro;
n_processo : inteiro;
valor_despesa : real;
Inicio
	Para n_advogado de 1 até 50 passo + 1 faça
		Para n_processo de 1 até 100 passo + 1 faça
			Leia(Mat_Clientes[n_advogado][n_processo]);
 			Mat_Custos[n_advogado][n_processo]= 0;
		Fim_Para
	Fim_Para
	Repita
		Leia(n_advogado);
		Se n_advogado ≠ 0
			Então
Leia(n_processo);
Leia(valor_despesa);
Mat_Custos[n_advogado][n_processo] = Mat_Custos[n_advogado][n_processo] + 
						Valor_despesa;
		Fim_Se
	Até n_advogado = 0;
	Para n_advogado de 1 até 50 passo + 1 faça
		Para n_processo de 1 até 100 passo + 1 faça
			Escreva(Mat_Clientes[n_advogado][n_processo]);
 			Escreva(Mat_Custos[n_advogado][n_processo]);
		Fim_Para
	Fim_Para
Fim_Algoritmo
	Repita
		Leia(n_advogado);
Leia(n_processo);
Leia(valor_despesa);
Mat_Custos[n_advogado][n_processo] = Mat_Custos[n_advogado][n_processo] + 
				Valor_despesa;
		Leia(resposta_continuar);
	Até resposta_continuar = “não”;
�
Você deve controlar os dados sobre uso de computadores. Existem 10 laboratórios com 30 máquinas cada. Existem 100 usuários e você deve perguntar o nome de cada um deles. Sempre que um dos 100 usuários usa um computador é registrado: Numero do usuário, tempo de uso (em minutos). Você deve ler estes dados até que seja digitado –1 no n.º do usuário. Informe:
O total de vezes que cada computador de cada laboratório foi usado
O tempo total de uso de cada computador de cada laboratório
O tempo total de uso por cada usuário
O total de utilizações de cada usuário
Algoritmo 16;
Variáveis
	Mat_Vezes = matriz[10][300] de inteiro;
Mat_Custos = matriz[50][100] de real;
n_advogado : inteiro;
n_processo : inteiro;
valor_despesa : real;
Inicio
	Para n_advogado de 1 até 50 passo + 1 faça
		Para n_processo de 1 até 100 passo + 1 faça
			Leia(Mat_Clientes[n_advogado][n_processo]);
 			Mat_Custos[n_advogado][n_processo]= 0;
		Fim_Para
	Fim_Para
	Repita
		Leia(n_advogado);
		Se n_advogado ≠ 0
			Então
Leia(n_processo);
Leia(valor_despesa);
Mat_Custos[n_advogado][n_processo] = Mat_Custos[n_advogado][n_processo] + 
						Valor_despesa;
		Fim_Se
	Até n_advogado = 0;
	Para n_advogado de 1 até 50 passo + 1 faça
		Para n_processo de 1 até 100 passo + 1 faça
			Escreva(Mat_Clientes[n_advogado][n_processo]);
 			Escreva(Mat_Custos[n_advogado][n_processo]);
		Fim_Para
	Fim_Para
Fim_Algoritmo
	Repita
		Leia(n_advogado);
Leia(n_processo);
Leia(valor_despesa);
Mat_Custos[n_advogado][n_processo] = Mat_Custos[n_advogado][n_processo] + 
				Valor_despesa;
		Leia(resposta_continuar);
	Até resposta_continuar = “não”;
�
Prova de 08-11-2008
Você deve controlar os dados sobre 500 engenheiros cadastrados no CREA. Para cada engenheiro você deve guardar os seguintes dados:
CREA
Nome
Quantidade de obras
Valor Arrecadado
Inicialmente seu algoritmo deverá ler o CREA e Nome de cada engenheiro. Ainda, a quantidade de obras e o valor arrecadado de cada engenheiro também deverão ser zerados.
Em seguida você deve ler os dados de 3500 obras realizadas. Em cada uma foi solicitado:
Nº do Engenheiro (numero entre 1 e 500)
Valor da Obra
		Finalmente você deve listar todos os dados de todos os Engenheiros.
Algoritmo 17;
Variáveis
	Vet_CREA 	= vetor[500] de inteiro;
	Vet_Nomes 	= vetor[500] de caracter;
	Vet_Obras 	= vetor[500] de inteiro;
	Vet_Valores 	= vetor[500] de real;
	n_engenheiro : inteiro;
valor_obra : real;
n_obra : inteiro;
Inicio
	Para n_engenheiro de 1 até 500 passo + 1 faça
		Leia(Vet_CREA[n_engenheiro]);
		Leia(Vet_Nomes[n_engenheiro]);
		Vet_Obras[n_engenheiro] = 0;
		Vet_Valores[n_engenheiro] = 0;
	Fim_Para
	Para n_obra de 1 até 3500 passo + 1 faça
		Leia(n_engenheiro);
		Leia(valor_obra);
		Vet_Obras[n_engenheiro] =Vet_Obras[n_engenheiro] + 1;
		Vet_Valores[n_engenheiro] = Vet_Valores[n_engenheiro] + valor_obra;	
	Fim_Para
	Para n_engenheiro de 1 até 500 passo + 1 faça
		Escreva(Vet_CREA[n_engenheiro]);
		Escreva(Vet_Nomes[n_engenheiro]);
		Escreva(Vet_Obras[n_engenheiro]);
		Escreva(Vet_Valores[n_engenheiro]);
	Fim_Para
Fim_Algoritmo
�
Prepare um algoritmo para manipulação de matrizes. Seu algoritmo deverá declarar 3 matrizes de 300 x 200 do tipo inteiro.
Inicialmente seu algoritmo deverá ler os dados da 1ª matriz.
Em seguida seu algoritmo devera ler os dados da 2ª matriz
Em seguida você deve calcular a 3ª matriz:
	MAT3[linha][coluna] = MAT1[linha][coluna] + 2* MAT2[linha][coluna], para todas as linhas e colunas da matriz.
Finalmente você deve escrever a 3ª matriz.
Algoritmo 18;
Variáveis
	Mat1 = matriz[300][200] de inteiro;
	Mat2 = matriz[300][200] de inteiro;
	Mat3 = matriz[300][200] de inteiro;
Linha,
Coluna : inteiro;
Inicio
	Para linha de 1 até 300 passo + 1 faça
		Para coluna de 1 até 200 passo + 1 faça
			Leia(Mat1[linha][coluna]);
		Fim_Para
	Fim_Para
	Para linha de 1 até 300 passo + 1 faça
		Para coluna de 1 até 200 passo + 1 faça
			Leia(Mat2[linha][coluna]);
		Fim_Para
	Fim_Para
	Para linha de 1 até 300 passo + 1 faça
		Para coluna de 1 até 200 passo + 1 faça
			Mat3[linha][coluna] = Mat1[linha][coluna] + (2 * Mat2[linha][coluna]);
		Fim_Para
	Fim_Para
	Para linha de 1 até 300 passo + 1 faça
		Para coluna de 1 até 200 passo + 1 faça
			Escreva(Mat3[linha][coluna]);
		Fim_Para
	Fim_Para
Fim_Algoritmo
�
Prepare um algoritmo para controlar os dados sobre 700 clinicas odontológicas registradas no CRO. Para cada clinica você deve armazenar os seguintes dados:
Nome
Endereço
Quantidade de atendimentos
Valor Arrecadado
Inicialmente seu algoritmo deverá ler o Nome e o endereço de cada clínica. Ainda, a quantidade de atendimentos e o valor arrecadado de cada clínica também deverão ser zerados.
Em seguida você deve ler os dados de atendimentos realizados nas clinicas. Em cada atendimento foi solicitado:
Nº da clínica (número entre 1 e 700)
Valor do Atendimento
		Após cada atendimento você deve perguntar se o usuário deseja continuar cadastrando novos atendimentos.
		Finalmente você deve listar todos os dados de todas as Clínicas.
Algoritmo 19;
Variáveis
	Vet_Nomes 		= vetor[700] de caracter;
	Vet_Endereços 	= vetor[700] de caracter;
	Vet_Atendimentos 	= vetor[700] de inteiro;
	Vet_Valores 		= vetor[700] de real;
	n_clinica : inteiro;
valor_atendimento : real;
resposta : caracter;
Inicio
	Para n_clinica de 1 até 700 passo + 1 faça
		Leia(Vet_Nomes[n_clinica]);
		Leia(Vet_Endereços[n_clinica]);
		Vet_Atendimentos[n_clinica] = 0;
		Vet_Valores[n_clinica] = 0;
	Fim_Para
	Repita
		Leia(n_clinica);
		Leia(valor_atendimento);
		Vet_Atendimentos[n_clinica] = Vet_Atendimentos[n_clinica]+ 1;
		Vet_Valores[n_clinica] = Vet_Valores[n_clinica] + valor_atendimento;	
	Fim_Para
	Para n_clinica de 1 até 700 passo + 1 faça
		Escreva (Vet_Nomes[n_clinica]);
		Escreva (Vet_Endereços[n_clinica]);
		Escreva (Vet_Atendimentos[n_clinica]);
		Escreva (Vet_Valores[n_clinica]);
	Fim_Para
Fim_Algoritmo
�
Prepare um algoritmo para manipulação de matrizes. Seu algoritmo deverá declarar 3 matrizes de 800 x 500 do tipo real.
Inicialmente seu algoritmo deverá ler os dados da 1ª matriz.
Em seguida seu algoritmo devera ler os dados da 2ª matriz
Em seguida você deve calcular a 3ª matriz:
	MAT3[linha][coluna] = (3 * MAT1[linha][coluna]) - MAT2[linha][coluna], para todas as linhas e colunas da matriz.
Finalmente você deve escrever a 3ª matriz.
Algoritmo 20;
Variáveis
	Mat1 = matriz[800][500] de inteiro;
	Mat2 = matriz[800][500] de inteiro;
	Mat3 = matriz[800][500] de inteiro;
Linha,
Coluna : inteiro;
Inicio
	Para linha de 1 até 800 passo + 1 faça
		Para coluna de 1 até 500 passo + 1 faça
			Leia(Mat1[linha][coluna]);
		Fim_Para
	Fim_Para
	Para linha de 1 até 800 passo + 1 faça
		Para coluna de 1 até 500 passo + 1 faça
			Leia(Mat2[linha][coluna]);
		Fim_Para
	Fim_Para
	Para linha de 1 até 800 passo + 1 faça
		Para coluna de 1 até 500 passo + 1 faça
			Mat3[linha][coluna] = (3 * Mat1[linha][coluna]) + Mat2[linha][coluna];
		Fim_Para
	Fim_Para
	Para linha de 1 até 800 passo + 1 faça
		Para coluna de 1 até 500 passo + 1 faça
			Escreva(Mat3[linha][coluna]);
		Fim_Para
	Fim_Para
Fim_Algoritmo
�
Prepare um algoritmo para controlar os dados sobre 900 hospitais. Para cada hospital você deve armazenar os seguintes dados:
Nome
Endereço
Diretor
Quantidade de atendimentos
Valor Arrecadado
Inicialmente seu algoritmo deverá ler o nome, endereço e diretor de cada hospital. Ainda, a quantidade de atendimentos e o valor arrecadado de cada hospital também deverão ser zerados.
Em seguida você deve ler os dados de atendimentos realizados nos hospitais. Em cada atendimento foi solicitado:
Nº do hospital (número entre 1 e 900, ou 0 para sair)
Valor do Atendimento
Você deve ler estes dados até que o número do hospital seja = 0.
Finalmente você deve listar todos os dados de todos os hospitais.
Algoritmo 21;
Variáveis
	Vet_Nomes 		= vetor[900] de caracter;
	Vet_Endereços 	= vetor[900] de caracter;
	Vet_Diretores 	= vetor[900] de caracter;
	Vet_Atendimentos 	= vetor[900] de inteiro;
	Vet_Valores 		= vetor[900] de real;
	n_hospital : inteiro;
valor_atendimento : real;
Inicio
	Para n_hospital de 1 até 900 passo + 1 faça
		Leia(Vet_Nomes[n_hospital]);
		Leia(Vet_Endereços[n_hospital]);
		Leia(Vet_Diretores[n_hospital]);
		Vet_Atendimentos[n_hospital] = 0;
		Vet_Valores[n_hospital] = 0;
	Fim_Para
	Repita
		Leia(n_hospital);
		Se n_hospital ≠0
			Então
				Leia(valor_atendimento);
				Vet_Atendimentos[n_hospital] = Vet_Atendimentos[n_hospital] + 1;
				Vet_Valores[n_hospital] = Vet_Valores[n_hospital] + valor_atendimento;
		Fim_Se	
	Até n_hospital = 0;
	Para n_hospital de 1 até 900 passo + 1 faça
		Escreva(Vet_Nomes[n_hospital]);
		Escreva(Vet_Endereços[n_hospital]);
		Escreva(Vet_Diretores[n_hospital]);
		Escreva(Vet_Atendimentos[n_hospital]);
		Escreva(Vet_Valores[n_hospital]);
	Fim_Para
Fim_Algoritmo
�
Prepare um algoritmo para manipulação de matrizes. Seu algoritmo deverá declarar 3 matrizes de 600 x 400 do tipo real.
Inicialmente seu algoritmo deverá ler os dados da 1ª matriz.
Em seguida seu algoritmo devera ler os dados da 2ª matriz.
Em seguida você deve calcular a 3ª matriz:
	MAT3[linha][coluna] = (5 * MAT1[linha][coluna]) + (2* MAT2[linha][coluna]), 
para todas as linhas e colunas da matriz.
Finalmente você deve escrever a 3ª matriz.
Algoritmo 22;
Variáveis
	Mat1 = matriz[600][400] de inteiro;
	Mat2 = matriz[600][400] de inteiro;
	Mat3 = matriz[600][400] de inteiro;
Linha,
Coluna : inteiro;
Inicio
	Para linha de 1 até 600 passo + 1 faça
		Para coluna de 1 até 400 passo + 1 faça
			Leia(Mat1[linha][coluna]);
		Fim_Para
	Fim_Para
	Para linha de 1 até 600 passo + 1 faça
		Para coluna de 1 até 400 passo + 1 faça
			Leia(Mat2[linha][coluna]);
		Fim_Para
	Fim_Para
	Para linha de 1 até 600 passo + 1 faça
		Para coluna de 1 até 400 passo + 1 faça
			Mat3[linha][coluna] = (5 * Mat1[linha][coluna]) + (2 * Mat2[linha][coluna]);
		Fim_Para
	Fim_Para
	Para linha de 1 até 600 passo + 1 faça
		Para coluna de 1 até 400 passo + 1 faça
			Escreva(Mat3[linha][coluna]);
		Fim_Para
	Fim_Para
Fim_Algoritmo
�
Algoritmo Pedágio;
Variáveis
	Vet_Cabines: Vetor[1..20] de Real;
	N_Cabine : Inteiro;
	Tipo 	: Caracter;
	Maior_Arrecadacao	: Real;
	Menor_Arrecadacao	: Real;
	Melhor_Cabine 		: Inteiro;
	Pior_Cabine		: Inteiro;
Início
	Para N_Cabine de 1 até 20 passo + 1 faça
		Vet_Cabines[N_Cabine] ( 0;
	Fim_Para
	Repita
		Leia(N_Cabine);
		Se N_Cabine <> 0 
			Então
				Escreva(“Digite o tipo de veículo: “);
				Leia(Tipo);
				Se Tipo = “CARRO”
					Então Vet_Cabines[N_Cabine] ( Vet_Cabines[N_Cabine] + 5
					Senão Se Tipo = “ONIBUS”
							Então Vet_Cabines[N_Cabine] ( Vet_Cabines[N_Cabine] + 8
							Senão Vet_Cabines[N_Cabine] ( Vet_Cabines[N_Cabine] + 15
						Fim_Se
				Fim_Se
		Fim_Se
	Até N_Cabine = 0;
	Para N_Cabine de 1 até 20 passo + 1 faça
		Escreva(“O valor arrecadado na cabine: “,N_Cabine,”foi R$: “,Vet_Cabines[N_Cabine]);
	Fim_Para
Fim_Algoritmo
�
Algoritmo Pedágio;
Variáveis
	Vet_Cabines: Vetor[1..20] de Real;
	N_Cabine : Inteiro;
	Tipo 	: Caracter;
	Maior_Arrecadacao	: Real;
	Menor_Arrecadacao	: Real;
	Melhor_Cabine 		: Inteiro;
	Pior_Cabine		: Inteiro;
Início
	Para N_Cabine de 1 até 20 passo + 1 faça
		Vet_Cabines[N_Cabine] ( 0;
	Fim_Para
	Repita
		Escreva(“Digite o número da cabine: “);
		Leia(N_Cabine);
		Se N_Cabine <> 0 
			Então
				Escreva(“Digite o tipo de veículo: “);
				Leia(Tipo);
				Se Tipo = “CARRO”
					Então Vet_Cabines[N_Cabine] ( Vet_Cabines[N_Cabine] + 5
					Senão Se Tipo = “ONIBUS”
							Então Vet_Cabines[N_Cabine] ( Vet_Cabines[N_Cabine] + 8
							Senão Vet_Cabines[N_Cabine] ( Vet_Cabines[N_Cabine] + 15
						Fim_Se
				Fim_Se
		Fim_Se
	Até N_Cabine = 0;
	Maior_Arrecadacao ( Vet_Cabines[1];
	Menor_Arrecadacao( Vet_Cabines[1];
	Melhor_Cabine ( 1;
	Pior_Cabine ( 1;
	Para N_Cabine de 1 até 20 passo + 1 faça
		Escreva(“O valor arrecadado na cabine: “,N_Cabine,”foi R$: “,Vet_Cabines[N_Cabine]);
		Se Vet_Cabines[N_Cabine] > Maior_Arrecadacao
			Então Maior_Arrecadacao ( Vet_Cabines[N_Cabine];
				 Melhor_Cabine (N_Cabine;
		Fim_Se
		Se Vet_Cabines[N_Cabine] < Menor_Arrecadacao
			Então Menor_Arrecadacao ( Vet_Cabines[N_Cabine];
				 Pior_Cabine (N_Cabine;
		Fim_Se
	Fim_Para
	Escreva(“A cabine que mais arrecadou foi “,Melhor_Cabine,”Com R$ “,Maior_Arecadacao);
	Escreva(“A cabine que menos arrecadou foi “,Pior_Cabine,”Com R$ “,Menor_Arecadacao);
Fim_Algoritmo