Algoritmos 2o Bim

ÍNDICE 2º bimestre

CAPÍTULO 9 – MODULARIZAÇÃO......................................................................................109

9.1 NECESSIDADE DA MODULARIZAÇÃO EM PROGRAMAS.......................................................1099.2 CONSTRUÇÃO DE MÓDULOS...........................................................................................1099.3 ESCOPO DE VARIÁVEIS...................................................................................................1109.4 MÓDULOS PROCEDIMENTO.............................................................................................110

Pseudocódigo.................................................................................................................110Java................................................................................................................................111

9.5 MÓDULOS FUNÇÃO........................................................................................................112Pseudocódigo.................................................................................................................112Java................................................................................................................................113

9.6 PARAMETRIZAÇÃO DE MÓDULOS.....................................................................................113Pseudocódigo.................................................................................................................114Java................................................................................................................................115

9.7 CHAMADA DOS MÓDULOS...............................................................................................115Pseudocódigo – módulo procedimento sem parametrização........................................116Java – módulo procedimento sem parametrização.......................................................116Pseudocódigo – módulo função sem parametrização...................................................116Java – módulo função sem parametrização...................................................................117Pseudocódigo – módulo procedimento com parametrização........................................117Java – módulo função com parametrização...................................................................117

9.8 EXEMPLO DE MODULARIZAÇÃO EM PSEUDOCÓDIGO.........................................................1189.9 EXEMPLO DE MODULARIZAÇÃO EM JAVA.........................................................................1249.10 EXERCÍCIOS DE MODULARIZAÇÃO.................................................................................131

CAPÍTULO 10 – ESTRUTURA DE DADOS HOMOGÊNEA – VETORES..........................137

10.1 DEFINIÇÃO DE VETOR...................................................................................................13710.2 DECLARAÇÃO DE VETOR..............................................................................................137


10.3 EXEMPLO DE VETOR....................................................................................................13810.4 ATRIBUINDO VALORES AO VETOR..................................................................................139


10.5 MOSTRANDO OS ELEMENTOS DE UM VETOR..................................................................140Pseudocódigo.................................................................................................................140Java................................................................................................................................140

10.6 EXEMPLOS DE VETORES EM PSEUDOCÓDIGO................................................................14110.7 EXEMPLOS DE VETORES EM JAVA.................................................................................14310.8 EXERCÍCIOS DE VETORES.............................................................................................145

CAPÍTULO 11 – ESTRUTURA DE DADOS HOMOGÊNEA – MATRIZES.........................149

11.1 DEFINIÇÃO DE MATRIZ..................................................................................................14911.2 DECLARAÇÃO DE MATRIZ..............................................................................................150


11.3 EXEMPLO DE MATRIZ....................................................................................................15111.4 ATRIBUINDO VALORES À MATRIZ...................................................................................152


11.5 MOSTRANDO OS ELEMENTOS DE UMA MATRIZ...............................................................154Pseudocódigo.................................................................................................................154Java................................................................................................................................154

11.6 EXEMPLOS DE MATRIZES EM PSEUDOCÓDIGO................................................................15511.7 EXEMPLOS DE MATRIZES EM JAVA................................................................................15711.8 Exercícios de matrizes..............................................................................................159

Copyright – IBTA – Instituto Brasileiro de Tecnologia Avançada 109

IBTA 00BD/Redes/ WebLógica de ProgramaçãoMódulo II

Capítulo 9 – Modularização

Muitas vezes, fica complicado desenvolvermos um algoritmo extenso de um único problema. Para isso, utilizaremos a modularização desse algoritmo, isto é, a divisão do algoritmo em módulos ou sub-rotinas, para que o problema dividido em subproblemas possa ser facilmente interpretado e desenvolvido.

Nesse sentido, veremos a necessidade da modularização, aprenderemos como construir módulos de um algoritmo, módulos esses que são conjuntos de comandos que têm como finalidade executar determinada função.

Temos dois tipos de módulos: procedimentos e funções. Os procedimentos são aqueles módulos que executam um conjunto de comandos sem retorno para o módulo que o chamou. As funções são aqueles módulos que executam um conjunto de comando e retornam algum dado para o módulo que o chamou. A seguir vamos ver como e quando trabalhar com cada um deles.

9.1 Necessidade da modularização em programas

Um dos pontos principais para o uso da modularização é a divisão do algoritmo em módulos para que ele seja melhor interpretado e desenvolvido. Esses módulos acabam sendo mais simples e menos complexos. A divisão em módulos facilita o entendimento parcial do problema e entendendo todos os problemas parciais, no final, teremos entendido o problema maior.

A maioria dos módulos pode ser vista como um mini-algoritmo, ou seja, com entrada de dados, processamento desses dados e saída de resultados.

Outro ponto principal para o uso de modularização é a reutilização de código. Muitas vezes, precisamos repetir um mesmo pedaço do algoritmo, por exemplo, um menu de opções, várias vezes, dentro de um mesmo algoritmo. Nesse caso, basta desenvolver um módulo com esse pedaço do algoritmo e sempre que precisarmos dele no algoritmo, basta fazer a chamada do módulo, evitando reescrever o mesmo código.

9.2 Construção de módulos

Para focalizarmos o problema e dividi-lo em subproblemas, precisamos adotar uma regra. Essa regra serve para nos orientar na divisão e construção de módulos.

Para construir os módulos, primeiro precisamos analisar o problema e dividi-lo em partes principais, que são os módulos; depois precisamos analisar os módulos obtidos para verificar se a divisão está coerente. Se algum módulo ainda estiver complexo, devemos dividi-lo também em outros submódulos. Por fim, precisamos analisar todos os módulos e o problema geral para garantir que o algoritmo mais os módulos resolvam o problema de forma simples.

Esse processo é chamado de Método de Refinamento Sucessivo, pois o problema complexo é dividido em problemas menores e, a partir do resultado dos problemas menores, teremos o resultado do problema complexo.



Por exemplo, suponha que queremos desenvolver um algoritmo que receba dois valores numéricos e uma opção do usuário que decida qual entre as quatro operações básicas da matemática (soma, subtração, divisão e multiplicação) ele quer resolver.

Analisando esse problema, vamos dividi-lo em subproblemas, por exemplo, um menu de opções para que o usuário possa escolher uma operação matemática, o cálculo da soma, o cálculo da subtração, o cálculo da divisão e o cálculo da multiplicação. Temos assim cinco módulos para resolver o nosso problema. São módulos coerentes que ajudam a resolver o nosso problema de forma simples. Mas, analisando bem os módulos, verificamos que falta mais um módulo, o módulo principal que se encarrega de fazer a chamada dos módulos, enviar e receber dados para esses módulos. Agora sim temos o nosso problema dividido e analisado, basta agora começar a desenvolvê-los. Mas para isso, precisamos assimilar outros conceitos como escopo de variáveis, módulo procedimento, módulo função e chamada de módulo que veremos a seguir, completando com um exemplo.

9.3 Escopo de variáveis

O escopo de uma variável é onde, dentro do algoritmo, uma variável é válida ou pode ser reconhecida. Uma variável pode ter o escopo dividido em dois tipos: variável global ou variável local.

Uma variável global é aquela declarada no início do algoritmo e pode ser utilizada por qualquer parte desse algoritmo, seja nos comandos do próprio algoritmo, bem como, dentro de qualquer módulo que pertença ao algoritmo. Nesse caso, sua declaração é feita apenas uma única vez, não sendo permitido que o mesmo nome de variável seja declarado dentro de qualquer outra parte do algoritmo, por exemplo, dentro de qualquer outro módulo.

Uma variável local é aquela declarada dentro de algum bloco, por exemplo, dentro de um módulo. Nesse caso, essa variável é válida e reconhecida somente dentro do bloco em que foi declarada. Assim, o mesmo nome de variável pode ser declarado dentro de diferentes blocos, pois serão reconhecidas como uma nova variável.

Por exemplo, se declararmos uma variável x no início de um algoritmo, essa variável x pode ser usada e alterada em qualquer parte desse algoritmo e em nenhum momento declarada novamente, ou seja, ela é única no algoritmo inteiro. Mas é muito importante ter o controle dessas variáveis globais, justamente porque elas podem ser alteradas a qualquer momento. No entanto, se declararmos, usarmos e alterarmos uma variável y dentro do módulo soma, poderemos também declará-la, utilizá-la e alterá-la dentro do módulo subtração, do módulo divisão e do módulo multiplicação, se assim o desejarmos. Nesse caso, não precisando tomar os cuidados necessários que uma variável global precisa.

9.4 Módulos Procedimento

Os módulos procedimento são os módulos que não retornam valor para o módulo ou algoritmo que os tenham chamado. Nesse sentido, esse tipo de módulo é utilizado quando o algoritmo principal ou módulo que chama o módulo procedimento não necessita de retorno de qualquer dado do módulo.

Pseudocódigo

Nos módulos procedimento, utilizaremos as palavras início_módulo e fimmódulo; que representam as palavras principais deste módulo, ou seja, o início e o fim do módulo,



respectivamente. Os módulos procedimento em pseudocódigo seguem a seguinte regra sintática:

<nome do módulo> ( ) início_módulo <comandos>; fimmódulo;

Note que os comandos dentro do módulo são comuns àqueles de qualquer algoritmo, ou seja, com entrada de dados, processamento desses dados e saída de resultados.

Por exemplo, suponha que queremos desenvolver um módulo que imprima o nome da disciplina e o nome da instituição de ensino:

Dados ( ) início_módulo Declarar disc, fac alfanumérico; disc ← "Lógica de Programação"; fac ← "IBTA"; escrever ("nome da disciplina => " , disc); escrever ("nome da instituição de ensino =>" , fac); fimmódulo;

Neste exemplo, Dados é o nome do módulo procedimento. O módulo parece um mini-algoritmo com declaração de variáveis, entrada de dados para essas variáveis e a saída de resultados. O que difere um algoritmo de um módulo é justamente sua simplicidade.

Java

Nos módulos procedimento em Java, utilizaremos a palavra void que representa a palavra principal dessa estrutura e a chave aberta, {, e chave fechada, }, para representar o conjunto de comandos que fazem parte desse módulo. Os módulos procedimento em Java seguem a seguinte regra sintática:

void <nome do módulo> ( ) { <comandos>; }

Note que os comandos dentro do módulo são comuns àqueles de qualquer programa, ou seja, com entrada de dados, processamento desses dados e saída de resultados.

Por exemplo, suponha que queremos desenvolver um módulo que imprima o nome da disciplina e o nome da instituição de ensino:

void Dados ( ) { String disc, fac; disc = "Lógica de Programação"; fac = "IBTA"; System.out.println ("nome da disciplina => " + disc); System.out.println ("nome da instituição de ensino =>" + fac);



}

Neste exemplo, Dados é o nome do módulo procedimento. O módulo parece um miniprograma com declaração de variáveis, entrada de dados para essas variáveis e a saída de resultados. O que difere um programa de um módulo é justamente sua simplicidade.

Perceba o uso da palavra void, ela é utilizada no Java para identificar um módulo procedimento.

9.5 Módulos Função

Os módulos função são os módulos que retornam algum valor para o módulo ou algoritmo que os tenha chamado. Nesse sentido, esse tipo de módulo é utilizado quando o algoritmo principal ou módulo que chama o módulo função necessita de retorno de qualquer dado do módulo.

Pseudocódigo

Nos módulos função, utilizaremos as palavras início_módulo e fimmódulo; que representam as palavras principais desse módulo, ou seja, o início e o fim do módulo, respectivamente. Além dessas palavras, utilizaremos a palavra retornar que é a principal palavra do módulo função, pois é a partir desse comando que um valor é retornado para o algoritmo ou módulo que o chamou. Os módulos função em pseudocódigo seguem a seguinte regra sintática:

<tipo de retorno> <nome do módulo> ( ) início_módulo <comandos>; retornar <valor de retorno>; fimmódulo;

Note que os comandos dentro do módulo são comuns àqueles de qualquer algoritmo, ou seja, com entrada de dados, processamento desses dados e saída de resultados. Note ainda que o valor de retorno enviado pelo comando retornar precisa ser do mesmo tipo de dado declarado para o módulo função.

Por exemplo, suponha que queremos desenvolver um módulo que retorne o nome da disciplina e o nome da instituição de ensino:

alfanumérico Dados ( ) início_módulo Declarar disc, fac, mens alfanumérico; disc ← "Lógica de Programação"; fac ← "IBTA"; mens ← "nome da disciplina => " + disc + "\nnome da instituição de ensino => " + fac; retornar mens; fimmódulo;

Neste exemplo, Dados é o nome do módulo função. O módulo parece um mini-algoritmo com declaração de variáveis, entrada de dados para essas variáveis, processamento de dados e retorno dos resultados. O que difere um algoritmo de um módulo é justamente sua simplicidade.



Note que o tipo de retorno do módulo função Dados é alfanumérico e o retorno do módulo é o conteúdo da variável mens do tipo alfanumérico, ou seja, do mesmo tipo de dados, isso é obrigatório.

Java

Nos módulos função em Java, utilizaremos a palavra return que representa a palavra principal dessa estrutura e a chave aberta, {, e chave fechada, }, para representar o conjunto de comandos que fazem parte desse módulo. É a partir do comando return que um valor é retornado para o programa ou método que o chamou. Os módulos função em Java seguem a seguinte regra sintática:

<tipo de retorno> <nome do módulo> ( ) { <comandos>; return <valor de retorno>; }

Note que os comandos dentro do módulo são comuns àqueles de qualquer programa, ou seja, com entrada de dados, processamento desses dados e saída de resultados. Note ainda que o valor de retorno enviado pelo comando return precisa ser do mesmo tipo de dado declarado para o módulo função.

Por exemplo, suponha que queremos desenvolver um módulo que retorne o nome da disciplina e o nome da instituição de ensino:

String Dados ( ) { String disc, fac, mens; disc = "Lógica de Programação"; fac = "IBTA"; mens = "nome da disciplina => " + disc + "\nnome da instituição de ensino => " + fac; return mens; }

Neste exemplo, Dados é o nome do módulo função. O módulo parece um miniprograma com declaração de variáveis, entrada de dados para essas variáveis, processamento de dados e o retorno dos resultados. O que difere um programa de um módulo é justamente sua simplicidade.

Note que o tipo de retorno do módulo função Dados é String e o retorno do módulo é o conteúdo da variável mens que é do tipo String, ou seja, do mesmo tipo de dados. Isso é obrigatório.

9.6 Parametrização de módulos

Aprendemos a dividir um problema usando o método de refinamentos sucessivos e também a identificar cada subdivisão do problema como um módulo do algoritmo que desejamos desenvolver. Aprendemos também que temos dois tipos de módulos, o módulo função e o módulo procedimento, para desenvolver cada um dos módulos detectados. No entanto, cada módulo interage com o módulo principal ou mesmo com outros módulos e, muitas



vezes, quando os módulos são chamados há a necessidade de enviar dados para que esses módulos possam resolver o seu subproblema. Esses dados, que são enviados para os módulos, são chamados de argumentos que são passados como parâmetros aos módulos.

O uso de argumentos passados como parâmetros em módulos, sejam eles funções ou procedimentos é muito comum. Os exemplos vistos anteriormente para funções e procedimentos estão sem o uso de parametrização de módulos, por isso, após o nome dos módulos, os parênteses estão vazios. É dentro dos parênteses que os argumentos são passados como parâmetros aos módulos.

Quando passamos argumentos como parâmetros, precisamos identificar qual o tipo de dado será passado como parâmetro. Nesse caso, cada argumento deverá ser declarado no momento em que o módulo for desenvolvido.

Note que, o uso de parametrização em módulos depende do subproblema que o módulo precisa resolver. Nesse caso, o desenvolvedor do algoritmo ou módulos é quem deve decidir se o uso ou não da parametrização é necessário para um determinado módulo. Muitas vezes, é possível desenvolver o mesmo problema com ou sem o uso de parametrização, como vimos nos exemplos anteriores, por isso, essa decisão cabe ao desenvolvedor.

Vamos rever os mesmos exemplos do módulo procedimento em pseudocódigo e do módulo função em Java, agora passando argumentos como parâmetro. Note que o uso de parametrização em módulos pode ser tanto para o módulo função como para o módulo procedimento, não havendo diferenças no seu desenvolvimento, apenas o retorno ou não de um valor.

Pseudocódigo

Nos módulos procedimento, utilizaremos as palavras início_módulo e fimmódulo; que representam as palavras principais deste módulo, ou seja, o início e o fim do módulo, respectivamente. Os módulos procedimento em pseudocódigo com parametrização seguem a seguinte regra sintática:

<nome do módulo> (<nome da var> <tipo da var>, ... , <nome da var> <tipo da var>) início_módulo <comandos>; fimmódulo;

Note que a quantidade de argumentos que pode ser passada como parâmetro não é determinada, pode ser um único argumento ou uma quantidade finita de argumentos.

Por exemplo, suponha que queremos desenvolver um módulo que receba dois argumentos do tipo alfanumérico como parâmetro e imprima o nome da disciplina e o nome da instituição de ensino:

Dados (disc alfanumérico, fac alfanumérico) início_módulo escrever ("nome da disciplina => " , disc); escrever ("nome da instituição de ensino => " , fac); fimmódulo;

Neste exemplo, não é mais necessária a declaração das variáveis disc e fac dentro do módulo Dados, pois esses dados estão declarados no cabeçalho do módulo como



argumentos que receberão dados que serão passados como parâmetros na chamada desse módulo.

Java

Nos módulos função em Java, utilizaremos a palavra return que representa a palavra principal dessa estrutura e a chave aberta, {, e a chave fechada, }, para representar o conjunto de comandos que fazem parte desse módulo. É a partir do comando return que um valor é retornado para o programa ou método que o chamou. Os módulos função em Java com parametrização seguem a seguinte regra sintática:

<tipo de retorno> <nome módulo> (<tipo var> <nome var> , ... , <tipo var> <nome var>) { <comandos>; return <valor de retorno>; }

Note que a quantidade de argumentos que pode ser passada como parâmetro não é determinada, pode ser um único argumento ou uma quantidade finita de argumentos.

Por exemplo, suponha que queremos desenvolver um módulo que receba dois argumentos do tipo String como parâmetro e imprima o nome da disciplina e o nome da instituição de ensino:

String Dados (String disc , String fac) { String mens; mens = "nome da disciplina => " + disc + "\nnome da instituição de ensino => " + fac; return mens; }

Neste exemplo, não é mais necessária a declaração das variáveis disc e fac dentro do módulo Dados, pois esses dados estão declarados no cabeçalho do módulo como argumentos que receberão dados que serão passados como parâmetros na chamada deste módulo.

9.7 Chamada dos módulos

Aprendemos como desenvolver um módulo e como passar argumentos como parâmetros para um módulo. No entanto, quando usamos modularização, o algoritmo principal ou outros módulos precisam chamar os módulos para que eles sejam executados. A chamada de módulos depende do tipo de módulo.

Para o módulo procedimento, basta fazer a chamada desse módulo pelo nome do módulo, passando os respectivos dados como argumento se for necessário.

Para o módulo função, a chamada desse módulo precisa estar vinculada a uma variável, ou seja, o retorno de dado da chamada do módulo função deve ser atribuído a uma variável cujo tipo de dado deve ser o mesmo que o dado que está sendo retornado. Nesse caso, a passagem de dados como argumentos, se for necessária, não se difere do módulo procedimento.



Por exemplo, vamos fazer a chamada dos módulos função e procedimento dos exemplos vistos anteriormente.

Pseudocódigo – módulo procedimento sem parametrização

A chamada dos módulos procedimento sem parametrização em pseudocódigo segue a seguinte regra sintática:

<nome do módulo> ( );

Por exemplo, vamos chamar o módulo que imprime o nome da disciplina e o nome da instituição de ensino desenvolvido anteriormente em pseudocódigo:

Dados ( );

Neste exemplo, Dados é o nome do módulo procedimento, como ele é um módulo sem parametrização, seus parênteses ficam vazios.

Java – módulo procedimento sem parametrização

A chamada dos módulos procedimento sem parametrização em Java segue a seguinte regra sintática:

<nome do módulo> ( );

Por exemplo, vamos chamar o módulo que imprime o nome da disciplina e o nome da instituição de ensino desenvolvido anteriormente em Java:

Dados ();

Neste exemplo, Dados é o nome do módulo procedimento; como ele é um módulo sem parametrização, seus parênteses ficam vazios.

Pseudocódigo – módulo função sem parametrização

A chamada dos módulos função sem parametrização em pseudocódigo segue a seguinte regra sintática:

<variável> ← <nome do módulo> ( );

Por exemplo, vamos chamar o módulo que imprime o nome da disciplina e o nome da instituição de ensino desenvolvido anteriormente em pseudocódigo:

alfanumérico m;m ← Dados ( );

Neste exemplo, Dados é o nome do módulo função; como ele é um módulo sem parametrização, seus parênteses ficam vazios. No entanto, como ele deve retornar um valor, esse valor é atribuído à variável m.

Note que o tipo de retorno do módulo função Dados é alfanumérico e a variável m que recebe o valor de retorno da função também é do tipo alfanumérico, ou seja, do mesmo tipo de dados. Isso é obrigatório!



Java – módulo função sem parametrização

A chamada dos módulos função sem parametrização em Java segue a seguinte regra sintática:

<variável> = <nome do módulo> ( );


String m;m = Dados ( );

Neste exemplo, Dados é o nome do módulo função; como ele é um módulo sem parametrização, seus parênteses ficam vazios. No entanto, como ele deve retornar um valor, esse valor é atribuído à variável m.

Note que o tipo de retorno do módulo função Dados é String e a variável m que recebe o valor de retorno da função também é do tipo String, ou seja, do mesmo tipo de dados. Isso é obrigatório.

Pseudocódigo – módulo procedimento com parametrização

A chamada dos módulos procedimentos com parametrização em pseudocódigo segue a seguinte regra sintática:

<nome do módulo> (<valor ou variável > , ... , <valor ou variável >);

Por exemplo, vamos chamar o módulo que imprime o nome da disciplina e o nome da instituição de ensino desenvolvido anteriormente em psedocódigo:

Dados ("Lógica de Programação" , "IBTA");

Neste exemplo, Dados é o nome do módulo procedimento; como ele é um módulo com parametrização, dentro de seus parênteses são passados os argumentos como parâmetros para o módulo Dados.

Note que a quantidade de argumentos que foi passada como parâmetro é a mesma do módulo quando ele foi declarado. No nosso exemplo, a quantidade de argumentos é dois: "Lógica de Programação" e "IBTA".

Java – módulo função com parametrização

A chamada dos módulos função com parametrização em Java segue a seguinte regra sintática:

<variável> = <nome do módulo> (<valor ou variável > , ... , <valor ou variável>);


String m;m = Dados ("Lógica de Programação" , "IBTA");



Neste exemplo, Dados é o nome do módulo função; como ele é um módulo com parametrização, dentro de seus parênteses são passados os argumentos como parâmetros para o módulo Dados.

Note que a quantidade de argumentos que foi passada como parâmetro é a mesma do módulo quando ele foi declarado. No nosso exemplo, a quantidade de argumentos é dois: "Lógica de Programação" e "IBTA".

9.8 Exemplo de modularização em pseudocódigo

1. Desenvolva um algoritmo que receba dois valores numéricos inteiros e o símbolo da operação conforme tabela abaixo, calcule e mostre a operação efetuada:

Símbolo da operação Nome da operação+ adição- subtração* multiplicação/ divisão

// módulo função Mais que recebe dois valores inteiros e retorna um valor inteironumérico_inteiro Mais (n1 numérico_inteiro , n2 numérico_inteiro) início_módulo // declaração de variáveis que só podem ser usadas dentro deste módulo Declarar res numérico_inteiro;

// processamento de dados res ← n1 + n2; // retorno do módulo retornar res; fimmódulo; // Mais

// módulo procedimento Menos que recebe dois valores inteiros Menos (n1 numérico_inteiro, n2 numérico_inteiro) início_módulo // declaração de variáveis que só podem ser usadas dentro deste módulo Declarar res numérico_inteiro;

// processamento de dados res ← n1 - n2; // saída de resultados escrever ("A diferença de " , n1 , " com " , n2 , " é " , res); fimmódulo; // Menos

// módulo procedimento Vezes que recebe dois valores inteirosVezes (n1 numérico_inteiro, n2 numérico_inteiro) início_módulo // declaração de variáveis que só podem ser usadas dentro deste módulo Declarar res numérico_inteiro;

// processamento de dados res ← n1 * n2;



// saída de resultados escrever ("O produto de " , n1 , " com " , n2 , " é " , res); fimmódulo; // Vezes

// módulo função Dividido que recebe dois valores inteiros e retorna um valor realnumérico_real Dividido (n1 numérico_inteiro, n2 numérico_inteiro) início_módulo // declaração de variáveis que só podem ser usadas dentro deste módulo Declarar res numérico_real;

// processamento de dados res ← n1 / n2; // retorno do módulo retornar res; fimmódulo; // Dividido

// módulo principalAlgoritmo Calculo início_algoritmo // declaração de variáveis e/ou constantes que podem ser usadas no algoritmo Calculo Declarar d numérico_real; soma, num1, num2 numérico_inteiro; oper alfanumérico;

// mensagem ao usuário escrever ("Digite dois inteiros e a operação"); // entrada de dados ler (num1, num2, oper); // processamento de dados escolha (oper) caso '+' : // chamada do módulo função Mais, passando num1 e num2 como // parâmetro e atribuindo o retorno do módulo na variável soma soma ← Mais(num1 , num2); // saída de resultados escrever ("A soma de " , num1 , " com " , num2 , " é " , soma); caso '-' : // chamada domódulo procedimento Menos, passando num1 e num2 como // parâmetro Menos (num1 , num2); caso '*' : // chamada do módulo procedimento vezes, passando num1 e num2 como // parâmetro Vezes (num1 , num2); caso '/' : // chamada do módulo função Dividido, passando num1 e num2 como // parâmetro e atribuindo o retorno do módulo na variável d d ← Dividido (num1 , num2); // saída de resultados escrever ("A divisão de " , num1 , " com " , num2 , " é " , d); caso contrário : // saída de resultados escrever ("operação inválida"); fimescolha; fim_algoritmo.



2. Desenvolva um algoritmo que mostre um menu de opções para: calcular a soma de três números fornecidos pelo usuário; verificar se um número fornecido pelo usuário é par; e verificar se um número fornecido pelo usuário é divisível por 3.

// módulo procedimento Menu Menu() início_módulo // mensagens ao usuário escrever ("Digite 1 para somar três números\n"); escrever ("Digite 2 para verificar se um número é par\n"); escrever ("Digite 3 para verificar se um número é divisível por 3\n"); escrever ("Digite 0 para sair do programa\n"); fimmódulo; // Menu

// módulo função SomaTudo que retorna um valor inteironumérico_inteiro SomaTudo () início_módulo // declaração de variáveis que só podem ser usadas dentro deste módulo Declarar s←0, i numérico_inteiro;

// entrada de dados e processamento de dados ler (i); s ← s + i; ler (i); s ← s + i; ler (i); s ← s + i; // retorno do módulo retornar s; fimmódulo; // SomaTudo

// módulo procedimento Pares que recebe um valor inteiroPares (par numérico_inteiro) início_módulo

// processamento de dados se ((par mod 2) = 0) então // saída de resultados escrever ("O número ", par, " é par "); senão // saída de resultados escrever ("O número ", par, " não é par "); fimse; fimmódulo; // Pares

// módulo função Divisivel3 que recebe um valor inteiro e retorna um valor lógicológico Divisivel3 (d numérico_inteiro) início_módulo // declaração de variáveis que só podem ser usadas dentro deste módulo Declarar res lógico;

// processamento de dadosCopyright – IBTA – Instituto Brasileiro de Tecnologia Avançada 121


se ((d mod 3) = 0) então res ← verdadeiro; senão res ← falso; fimse; // retorno da função retornar res; fimmódulo; // Divisivel3

// módulo principalAlgoritmo Somador início_algoritmo // declaração de variáveis que só podem ser usadas dentro do algoritmo Somador Declarar op, soma, num numérico_inteiro; log lógico;

// processamento de dados // chamada do módulo procedimento Menu, sem parametrização Menu(); // entrada de dados leia (op); escolha (op) caso 1 : // chamada do módulo função SomaTudo, sem parâmetrização e atribuindo o // retorno do módulo na variável soma soma ← SomaTudo(); // saída de resultados escrever ("A somatória de três números fornecidos pelo usuário é: " , soma); caso 2 : // entrada de dados pelo usuário ler (num); // chamada do módulo procedimento Pares, passando o número num como // parâmetro Pares(num); caso 3 : // entrada de dados pelo usuário ler (num); // chamada do módulo função Divisivel3, passando o número num como // parâmetro e atribuindo o retorno do módulo na variável log log ← Divisivel3(num); // processamento de dados se (log = verdadeiro) então // saída de resultados escrever ("O número ", num, " é divisível por 3 "); senão // saída de resultados escrever ("O número ", num, " não é divisível por 3 "); fimse; caso 0 : escrever ("Saindo do programa!"); caso contrário : escrever ("opção inválida, tente novamente"); fimescolha;fim_algoritmo.



3. Desenvolva um algoritmo modularizado que receba o nome e os dados para cálculo da área de uma figura geométrica conforme tabela abaixo, e a partir da escolha do usuário por um menu de opções, calcule e mostre a área da figura geométrica:

Figura geométrica Fórmulaquadrado lado * ladotriângulo (base * altura) / 2retângulo base * alturatrapézio ((Base maior + base menor) * altura) / 2

// módulo procedimento Menu Menu() início_módulo // mensagens ao usuário escrever ("Digite 1 para área do quadrado\n"); escrever ("Digite 2 para área do triângulo\n"); escrever ("Digite 3 para área do retângulo\n"); escrever ("Digite 4 para área do trapézio\n"); escrever ("Digite 0 para sair do programa\n"); fimmódulo; // Menu

// módulo função Quadrado que recebe um valor real e retorna um valor realnumérico_real Quadrado (l numérico_real) início_módulo // declaração de variáveis que só podem ser usadas dentro deste módulo Declarar res numérico_real;

// processamento de dados res ← l * l; // retorno do módulo retornar res; fimmódulo; // Quadrado

// módulo procedimento Triangulo que recebe dois valores reaisTriangulo (b numérico_real, h numérico_real) início_módulo // declaração de variáveis que só podem ser usadas dentro deste módulo Declarar res numérico_real;

// processamento de dados res ← (b * h) / 2; // saída de resultados escrever ("A área do triângulo de base " , b , " e altura " , h , " é " , res); fimmódulo; // Triangulo

// módulo procedimento Retangulo que recebe dois valores reaisRetangulo (b numérico_real, h numérico_real) início_módulo // declaração de variáveis que só podem ser usadas dentro deste módulo Declarar res numérico_real;

// processamento de dadosCopyright – IBTA – Instituto Brasileiro de Tecnologia Avançada 123


res ← b * h; // saída de resultados escrever ("A área do retângulo de base " , b , " e altura " , h , " é " , res); fimmódulo; // Retangulo

// módulo função Trapezio que retorna um valor realnumérico_real Trapezio ( ) início_módulo // declaração de variáveis que só podem ser usadas dentro deste módulo Declarar res, b1, b2, h numérico_real;

// entrada de dados ler (b1, b2, h); // processamento de dados res ← ((b1 + b2) * h) / 2; // retorno do módulo retornar res; fimmódulo; // Trapezio

// módulo principalAlgoritmo CalculoArea início_algoritmo // declaração de variáveis e/ou constantes que podem ser usadas no algoritmo // CalculoArea Declarar retorno, lado, base, altura numérico_real; figura numérico_inteiro;

// processamento de dados // chamada do módulo procedimento Menu, sem parametrização Menu(); // entrada de dados leia (figura); escolha (figura) caso 1 : // entrada de dados ler (lado); // chamada do módulo função Quadrado, passando lado como // parâmetro e atribuindo o retorno do módulo na variável retorno retorno ← Quadrado(lado); // saída de resultados escrever ("A área do quadrado de lado " , lado , " é " , retorno); caso 2 : // entrada de dados ler (base, altura); // chamada do módulo procedimento Triangulo, passando base e altura // como parâmetro Triangulo (base, altura); caso 3 : // entrada de dados ler (base, altura); // chamada do módulo procedimento Retangulo, passando base e altura // como parâmetro Retangulo (base, altura); caso 4 : // chamada do módulo função Trapezio e atribuindo o retorno do módulo na // variável retorno retorno ← Trapezio ( );



// saída de resultados escrever ("A area do trapézio é " , retorno); caso 0 : escrever ("Saindo do programa!"); caso contrário : // saída de resultados escrever ("operação inválida"); fimescolha; fim_algoritmo.

9.9 Exemplo de modularização em Java

1. Desenvolva um algoritmo que receba dois valores numéricos inteiros e o símbolo da operação conforme tabela abaixo, calcule e mostre a operação efetuada:

Símbolo da operação Nome da operação+ adição- subtração* multiplicação/ divisão

class Calculo { // módulo função Mais que recebe dois valores inteiros e retorna // um valor inteiro static int Mais (int n1 , int n2) { // declaração de variáveis que só podem ser usados dentro // deste módulo int res;

// processamento de dados res = n1 + n2; // retorno do módulo return res; } // fim do módulo Mais

// módulo procedimento Menos que recebe dois valores inteiros static void Menos (int n1 , int n2) { // declaração de variáveis que só podem ser usadas dentro // deste módulo int res;

// processamento de dados res = n1 - n2; // saída de resultados System.out.println ("A diferença de " + n1 + " com " + n2 + " é " + res); } // fim do módulo Menos

// módulo procedimento Vezes que recebe dois valores inteiros static void Vezes (int n1 , int n2) {



// declaração de variáveis que só podem ser usadas dentro // deste módulo int res;

// processamento de dados res = n1 * n2; // saída de resultados System.out.println ("O produto de " + n1 + " com " + n2 + " é " + res); } // fim do módulo Vezes

// módulo função Dividido que recebe dois valores inteiros e // retorna um valor real static double Dividido (int n1 , int n2) { // declaração de variáveis que só podem ser usadas dentro // deste módulo double res;

// processamento de dados res = n1 / n2; // retorno do módulo return res; } // fim do módulo Dividido

// módulo principal public static void main (String args [ ]) { // declaração de variáveis e/ou constantes que podem ser // usadas no algoritmo Calculo double d ; int oper, soma, num1, num2;

// mensagem ao usuário e entrada de dados num1 = Integer.parseInt(JOptionPane.showInputDialog("Digite um

número inteiro")); num2 = Integer.parseInt(JOptionPane.showInputDialog("Digite um

número inteiro")); oper = Integer.parseInt(JOptionPane.showInputDialog("Digite a operação: \n1 para somar \n2 para subtrair \n3 para multiplicar \n4 para dividir")); // processamento de dados switch (oper) { case 1: // chamada do módulo função Mais, passando num1 e // num2 como parâmetro e atribuindo o retorno do // módulo na variável soma soma = Mais(num1 , num2); // saída de resultados System.out.println ("A soma de " + num1 + " com " +

num2 + " é " + soma); break;



case 2: // chamada domódulo procedimento Menos, passando // num1 e num2 como parâmetro Menos (num1 , num2); break; case 3: // chamada do módulo procedimento vezes, passando // num1 e num2 como parâmetro Vezes (num1 , num2); break; case 4: // chamada do módulo função Dividido, passando num1

// e num2 como parâmetro e atribuindo o retorno do // módulo na variável d d = Dividido (num1 , num2); // saída de resultados System.out.println ("A divisão de " + num1 + " com " + num2 + " é " + d); break; default: // saída de resultados System.out.println ("operação inválida"); } // fim do switch System.exit(0); } // fim do void main } // fim da classe

2. Desenvolva um algoritmo que mostre um menu de opções para: calcular a soma de três números fornecidos pelo usuário; verificar se um número fornecido pelo usuário é par; e verificar se um número fornecido pelo usuário é divisível por 3.

class Somador { // módulo procedimento Menu public static void Menu() { System.out.println ("Digite 1 para somar três números\n"); System.out.println ("Digite 2 para verificar se um número é par\n"); System.out.println ("Digite 3 para verificar se um número é divisível por 3\n"); System.out.println ("Digite 0 para sair do programa\n"); } // Menu

// módulo função SomaTudo que retorna um valor inteiro public static int SomaTudo () { // declaração de variáveis que só podem ser usadas dentro // deste módulo int s = 0, i;

// processamento de dados i = Integer.parseInt(JOptionPane.showInputDialog ("Digite um número")); s = s + i; i = Integer.parseInt(JOptionPane.showInputDialog ("Digite um número")); s = s + i;



i = Integer.parseInt(JOptionPane.showInputDialog ("Digite um número")); s = s + i; // retorno do módulo return s; } // SomaTudo

// módulo procedimento Pares que recebe um valor inteiro public static void Pares (int par) {

// processamento de dados if ((par % 2) == 0) { // saída de resultados System.out.println ("O número " + par + " é par "); } else { // saída de resultados System.out.println ("O número " + par + " não é par "); } } // Pares

// módulo função Divisivel3 que recebe um valor inteiro e retorna // um valor booleano public static boolean Divisivel3 (int d) { // declaração de variáveis que só podem ser usadas dentro // deste módulo boolean res;

// processamento de dados if ((d % 3) == 0) { res = true; } else { res = false; } // retorno da função return res; } // Divisivel3

// módulo principal public static void main (String arg []) { // declaração de variáveis que só podem ser usadas dentro do // algoritmo principal int op, soma, num; boolean log;

// processamento de dados // chamada do módulo procedimento Menu, sem parametrização Menu();



// entrada de dados op = Integer.parseInt(JOptionPane.showInputDialog("Digite uma opção")); switch (op) { case 1 : // chamada do módulo função SomaTudo, sem // parâmetrização e atribuindo o retorno do módulo // na variável soma soma = SomaTudo(); // saída de resultados System.out.println ("A somatória de três números fornecidos pelo usuário é: " + soma); break; case 2 : // entrada de dados pelo usuário num = Integer.parseInt(JOptionPane.showInputDialog ("Digite um número")); // chamada do módulo procedimento Pares, // passando o número num como parâmetro Pares(num); break; case 3 : // entrada de dados pelo usuário num = Integer.parseInt(JOptionPane.showInputDialog ("Digite um número")); // chamada do módulo função Divisivel3, passando o // número num como parâmetro e atribuindo o // retorno do módulo na variável log log = Divisivel3(num); // processamento de dados if (log == true) { // saída de resultados System.out.println ("O número " + num + " é divisível por 3 "); } else { // saída de resultados System.out.println ("O número " + num + " não é divisível por 3 "); } break; case 0 : System.out.println ("Saindo do programa!"); System.exit(0); default : System.out.println ("opção inválida, tente novamente"); } } // main } // classe Somador

3. Desenvolva um algoritmo modularizado que receba o nome e os dados para cálculo da área de uma figura geométrica conforme tabela abaixo, e a partir da escolha do usuário por um menu de opções, calcule e mostre a área da figura geométrica:

Figura geométrica Fórmulaquadrado lado * lado



triângulo (base * altura) / 2retângulo base * alturatrapézio ((Base maior + base menor) * altura) / 2

class CalculoArea { // módulo procedimento Menu public static void Menu() { System.out.println ("Digite 1 para área do quadrado\n"); System.out.println ("Digite 2 para área do triângulo\n"); System.out.println ("Digite 3 para área do retângulo\n"); System.out.println ("Digite 4 para área do trapézio\n"); System.out.println ("Digite 0 para sair do programa\n"); } // Menu

// módulo função Quadrado que recebe um valor real e retorna um // valor real public static double Quadrado (double l) { // declaração de variáveis que só podem ser usadas dentro // deste módulo double res;

// processamento de dados res = l * l; // retorno do módulo return res; } // Quadrado

// módulo procedimento Triangulo que recebe dois valores reais public static void Triangulo (double b, double h) { // declaração de variáveis que só podem ser usadas dentro // deste módulo double res;

// processamento de dados res = (b * h) / 2; // saída de resultados System.out.println ("A área do triângulo de base " + b + " e altura " + h + " é " + res); } // Triangulo

// módulo procedimento Retangulo que recebe dois valores reais public static void Retangulo (double b, double h) { // declaração de variáveis que só podem ser usadas dentro // deste módulo double res;

// processamento de dados res = b * h; // saída de resultados System.out.println ("A área do retângulo de base " + b + " e altura " + h + " é " + res);



} // Retangulo

// módulo função Trapezio que retorna um valor real public static double Trapezio ( ) { // declaração de variáveis que só podem ser usadas dentro // deste módulo double res, b1, b2, h;

// entrada de dados b1 = Double.parseDouble(JOptionPane.showInputDialog("Digite a base menor")); b2 = Double.parseDouble(JOptionPane.showInputDialog("Digite a base maior")); h = Double.parseDouble(JOptionPane.showInputDialog("Digite a altura")); // processamento de dados res = ((b1 + b2) * h) / 2; // retorno do módulo return res; } // Trapezio

// módulo principal public static void main (String arg []) { // declaração de variáveis e/ou constantes que podem ser // usadas no algoritmo principal double retorno, lado, base, altura; int figura;

// processamento de dados // chamada do módulo procedimento Menu, sem parametrização Menu(); // entrada de dados figura = Integer.parseInt(JOptionPane.showInputDialog ("Digite a opção da figura")); switch (figura) { case 1: // entrada de dados lado = Double.parseDouble (JOptionPane.showInputDialog ("Digite o lado")); // chamada do módulo função Quadrado, passando lado

// como parâmetro e atribuindo o retorno do módulo // na variável retorno retorno = Quadrado(lado); // saída de resultados System.out.println ("A área do quadrado de lado " +

lado + " é " + retorno); break; case 2: // entrada de dados base = Double.parseDouble (JOptionPane.showInputDialog ("Digite a base")); altura = Double.parseDouble (JOptionPane.showInputDialog ("Digite a altura"));



// chamada do módulo procedimento Triangulo, // passando base e altura como parâmetro Triangulo (base, altura); break; case 3: // entrada de dados base = Double.parseDouble (JOptionPane.showInputDialog ("Digite a base")); altura = Double.parseDouble (JOptionPane.showInputDialog ("Digite a altura")); // chamada do módulo procedimento Retangulo, // passando base e altura como parâmetro Retangulo (base, altura); break;. case 4: // chamada do módulo função Trapezio e atribuindo // o retorno do módulo na variável retorno retorno = Trapezio ( ); // saída de resultados System.out.println ("A area do trapézio é " + retorno); break; case 0: System.out.println ("Saindo do programa!"); System.exit(0); default: // saída de resultados System.out.println ("operação inválida"); } } } // class CalculoArea

9.10 Exercícios de modularização

1. Desenvolva um módulo procedimento que receba dois números inteiros, calcule e mostre o resto da divisão entre os números inteiros, sem utilizar o operador mod.

2. Desenvolva um módulo função que receba dois números inteiros, calcule e retorne o quociente da divisão entre os números inteiros, sem utilizar o operador div.

3. Desenvolva um módulo função que receba um número inteiro, calcule e retorne a raiz quadrada inteira desse número.

4. Desenvolva um módulo procedimento que receba um número, verifique e mostre se esse número é ou não divisível por 5.

5. Desenvolva um módulo procedimento que receba um número, verifique e mostre se esse número é ou não primo.

6. Desenvolva um módulo procedimento que receba um número, verifique e mostre se esse número é ou não par.

7. Desenvolva um módulo procedimento que receba um número inteiro e mostre todos os divisores desse número.

8. Desenvolva um módulo função que receba um número real, calcule e retorne o valor absoluto desse número.



9. Desenvolva um módulo função que receba um número inteiro, calcule e retorne o fatorial desse número.

10. Desenvolva um módulo principal com um menu de opções para a chamada dos módulos desenvolvidos nos exercícios 1 até 9, mostrando os respectivos resultados dos módulos função. O usuário é quem deve escolher o módulo que será executado.

11. Desenvolva um algoritmo modularizado que receba cinco valores inteiros e, a partir de um menu de opções, permita o usuário escolher entre:

a. entrar e mostrar os valores a serem armazenados em cinco variáveis; (procedimento sem parâmetros);b. calcular e mostrar o valor da somatória dos valores das cinco variáveis; (procedimento com parâmetros)c. calcular e retornar a média aritmética dos valores das cinco variáveis; (função sem parâmetros)d. calcular e retornar a média ponderada dos valores das cinco variáveis, sendo peso 2 para as duas primeiras entradas, peso 5 para as duas próximas entradas e peso 10 para a última entrada; (função com parâmetros)e. mostrar os cinco valores em ordem crescente. (procedimento com parâmetros)Obs1.: após a chamada das funções, mostrar o resultado. Obs2.: uma das opções do menu deve ser a de sair do programa.

12. Desenvolva um algoritmo modularizado que receba um valor inteiro e, a partir de um menu de opções, permita o usuário escolher entre:

a. entrar e mostrar o valor a ser armazenado em uma variável n; (procedimento sem parâmetros)b. calcular e retornar o valor da somatória dos vinte primeiros termos da série de Fibonnacci; (função sem parâmetros)c. verificar e mostrar se o número armazenado na variável n é divisível por 7; (função com parâmetros)d. verificar e mostrar se o número armazenado na variável n é par ou ímpar; (procedimento com parâmetros)Obs1.: após a chamada das funções, mostrar os resultados.Obs2.: uma das opções do menu deve ser a de sair do programa.

13. Desenvolva um algoritmo modularizado que receba o valor da compra de um produto e, a partir de um menu de opções, permita ao usuário escolher entre:

a. calcular e retornar o pagamento a vista com 20% de desconto; (função com parâmetros)b. calcular e mostrar o pagamento em duas vezes com entrada e com 10% de desconto; (procedimento com parâmetros)c. calcular e retornar o pagamento a vista no cartão com 15% de desconto; (função com parâmetros)d. calcular e mostrar o pagamento em duas vezes no cartão com 5% de desconto; (função com parâmetros)e. calcular e mostrar o pagamento a prazo em duas vezes sem entrada com acréscimo de 5%; (procedimento com parâmetros)f.calcular e retornar o pagamento a prazo em três vezes sem entrada com acréscimo de 10%. (função com parâmetros)Obs1.: após a chamada das funções, mostrar o resultado.Obs2.: uma das opções do menu deve ser a de sair do programa.



14. Desenvolva um algoritmo modularizado que receba o nome de um aluno, o registro desse aluno e quatro valores reais referentes às notas bimestrais desse aluno e, a partir de um menu de opções, permita ao usuário escolher entre:

a. entrar e mostrar o nome e o registro do aluno bem como suas notas bimestrais; (procedimento sem parâmetros)b. calcular e mostrar o valor da média desse aluno com a mensagem de aprovação (média >= 5.0) ou reprovação, bem como, seu nome e seu registro; (procedimento com parâmetros)c. calcular e retornar o valor da média ponderada desse aluno com pesos 1, 2, 3 e 4, respectivamente para cada nota; (função com parâmetros)d. calcular a média aritmética desse aluno e retornar a mensagem de aprovado ou reprovado. (função com parâmetros)Obs1.: após a chamada das funções, mostrar o resultado.Obs2.: uma das opções do menu deve ser a de sair do programa.

15. Desenvolva um algoritmo modularizado que receba um mês e um dia da semana e a partir de um menu de opções, permita ao usuário escolher entre:

a. entrar e mostrar o mês e o dia da semana; (procedimento sem parâmetros)b. verificar e mostrar se no mês informado ele tem alguma avaliação; (procedimento com parâmetros)c. verificar e retornar se no mês e dia da semana informados ele precisa ir para o IBTA; (função com parâmetros)d. verificar e retornar quantos meses por ano ele está de férias escolares (função sem parâmetros)Obs1.: após a chamada das funções, mostrar o resultado.Obs2.: uma das opções do menu deve ser a de sair do programa.

16. Desenvolva um algoritmo modularizado que receba um valor inteiro positivo e, a partir de um menu de opções, permita ao usuário escolher entre:

a. entrar e mostrar o valor inteiro armazenado numa variável n; (procedimento sem parâmetros)b. calcular e mostrar a somatória dos números 100 e n ; (procedimento com parâmetros)c. calcular e retornar o produto dos números 20 e n; (função com parâmetros)d. verificar e retornar se n é primo ou não (função sem parâmetros)Obs1.: após a chamada das funções, mostrar o resultado.Obs2.: uma das opções do menu deve ser a de sair do programa.

17. Desenvolva um algoritmo modularizado que receba o nome e os dados para cálculo da área de uma figura geométrica conforme tabela abaixo e, a partir de um menu de opções, permita ao usuário escolher entre calcular e mostrar a área da figura geométrica:

Figura geométrica Fórmulaquadrado lado * ladotriângulo (base * altura) / 2retângulo base * alturatrapézio ((Base maior + base menor) * altura) / 2

Obs1.: usar procedimentos e funções com e sem parâmetros.Obs2.: uma das opções do menu deve ser a de sair do programa.

18. Desenvolva um algoritmo modularizado que receba dois valores reais e o código do produto notável conforme tabela abaixo e, a partir de um menu de opções, permita ao usuário escolher entre calcular e mostrar o valor do produto notável:



Código Produto Notável Fórmula1 quadrado da diferença de dois números (a – b) * (a – b)2 quadrado da soma de dois números (a + b) * (a + b)3 soma do quadrado de dois números a * a + b * b 4 diferença do quadrado de dois números a * a – b * b5 produto da soma com a diferença de dois números (a – b) * (a + b)


19. Desenvolva um algoritmo modularizado que receba o nome de um lugar e, a partir de um menu de opções, permita ao usuário escolher entre mostrar para o usuário o que ele deve fazer nesse lugar, conforme tabela abaixo:

Lugar O que fazerEscola EstudarBanco Pagar contarFarmácia Comprar remédiosCasa DescansarCorreio Remeter cartasObs1.: usar procedimentos e funções com e sem parâmetros.Obs2.: uma das opções do menu deve ser a de sair do programa.

20. Desenvolva um algoritmo modularizado que receba o código da condição de pagamento e o preço de um produto e, a partir de um menu de opções, permita ao usuário escolher entre calcular o que deve ser pago pelo produto e mostrar a condição de pagamento e o preço a ser pago, conforme a tabela abaixo:

Código Condição de pagamentoA a vista em dinheiro ou cheque tem 20% de descontoB a vista em cartão de crédito tem 10% de descontoC em 2 vezes, preço normal de etiqueta sem jurosD em 3 vezes, preço normal de etiqueta mais juros de 15%


21. Desenvolva um algoritmo modularizado que receba o salário de um funcionário e, a partir de um menu de opções, permita ao usuário escolher entre calcular e mostrar o valor do aumento salarial e o salário final a ser recebido pelo funcionário, considerando que:

a. se o funcionário recebe menos que 500,00, terá reajuste de 100%;b. se o funcionário recebe mais ou igual 500,00 e menos que 1.000,00, terá reajuste de 75%;c. se o funcionário recebe mais ou igual a 1.000,00 e menos que 1.500,00, terá reajuste de 50%;d. se o funcionário recebe mais ou igual a 1.500,00 e menos que 2.000,00, terá reajuste de 25%;e. se o funcionário recebe mais ou igual a 2.000,00 e menos que 3.000,00, terá reajuste de 10%;f. se o funcionário recebe mais ou igual a 3.000,00 e menos que 5.000,00, terá reajuste de 5%;g. se o funcionário recebe mais ou igual a 5.000,00, terá reajuste de 2%.Obs1.: usar procedimentos e funções com e sem parâmetros.Obs2.: uma das opções do menu deve ser a de sair do programa.



22. Desenvolva um algoritmo modularizado que receba o tipo de investimento e o valor do investimento e, a partir de um menu de opções, permita ao usuário escolher entre calcular e mostrar o valor corrigido do investimento após o período de 30 dias, considerando que o rendimento mensal para cada tipo de investimento varia conforme a tabela abaixo:

Tipo de investimento RendimentoPoupança 3%Fundo de renda fixa 5%CDB 6%Ações 10%Obs1.: usar procedimentos e funções com e sem parâmetros.Obs2.: uma das opções do menu deve ser a de sair do programa.

23. Desenvolva um algoritmo modularizado que receba a data de nascimento de uma pessoa e a data atual e, a partir de um menu de opções, permita ao usuário escolher entre verificar e mostrar:

a. em qual estação do ano (primavera, verão, outono ou inverno) essa pessoa nasceu;b. em qual século essa pessoa nasceu;c. se a pessoa nasceu em um ano bissexto;d. qual o signo dessa pessoa;e. quantos dias essa pessoa já viveu;f. quantos meses essa pessoa já viveu;g. quantos anos essa pessoa tem.Obs1.: usar procedimentos e funções com e sem parâmetros.Obs2.: uma das opções do menu deve ser a de sair do programa.

24. Desenvolva um algoritmo modularizado que receba três valores numéricos reais e um código e, a partir de um menu de opções, permita ao usuário escolher entre calcular e mostrar dados conforme a tabela abaixo:

código Operação1 os três valores em ordem crescente2 os três valores em ordem decrescente3 somente os valores pares4 somente os valores ímpares5 somente os valores positivos6 somente os valores negativos


25. Desenvolva um algoritmo modularizado que receba o preço atual e a venda mensal média de um produto e, a partir de um menu de opções, permita ao usuário calcular e mostrar o novo preço para um dos seguintes casos:

a. se a venda média mensal for menor que 500 e o preço atual menor que 30,00, então o produto sofrerá um aumento de 10%;b. se a venda média mensal for maior ou igual a 500 e menor que 1000 e o preço atual maior ou igual a 30,00 e menor que 80,00, então o produto sofrerá um aumento de 15%;c. se a venda mensal média for maior ou igual a 1000 e o preço atual maior ou igual a 80,00, então o produto sofrerá uma diminuição de 5%.Obs1.: usar procedimentos e funções com e sem parâmetros.Obs2.: uma das opções do menu deve ser a de sair do programa.



26. Desenvolva um algoritmo modularizado que receba o raio de uma circunferência e um código e, a partir de um menu de opções, permita o usuário calcular e mostrar os dados da circunferência, conforme a tabela abaixo:

Código Operaçãox calcula o comprimento: C = 2 . . raioy calcula a área: A = . raio2

z calcula o volume: V = 4/3 . . raio3


27. Desenvolva um algoritmo modularizado que receba um caracter alfanumérico e, a partir de um menu de opções, permita ao usuário verificar e mostrar se o caracter digitado é uma vogal, uma consoante, ou qualquer outro caracter.

28. Desenvolva um algoritmo modularizado que receba a medida de um ângulo em graus, calcule e mostre o quadrante em que esse ângulo se localiza. Considere os quadrantes da trigonometria e para ângulos maiores que 360 graus ou menores que –360 graus, reduzi-los, mostrando também o número de voltas e o sentido da volta (horário ou anti-horário).

29. Desenvolva um algoritmo modularizado que receba uma senha de quatro números, verifique a validade desta senha sabendo que a senha correta é 1234 e mostre ao usuário uma mensagem dizendo se a senha digitada é válida ou não.

30. Desenvolva um algoritmo modularizado que receba o tipo de investimento (poupança ou fundo de renda fixa) e o valor do investimento, calcule e mostre o valor corrigido do investimento após o período de 30 dias, considerando que o rendimento mensal da poupança é de 3% e o do fundo de renda fixa é de 5%.



Capítulo 10 – Estrutura de Dados Homogênea – Vetores

Quando desenvolvemos um algoritmo ou programa estruturado, muitas vezes, precisamos usar várias informações de um mesmo tipo de dado. Podemos fazer isso criando inúmeras variáveis, uma para cada informação, mas isso é inviável, pois é demasiado complexo desenvolvermos e manipularmos um algoritmo que utiliza inúmeras variáveis para várias informações de um mesmo tipo. Para solucionar este problema, podemos utilizar vetores e matrizes para armazenar essas informações, isto é, uma estrutura de dados homogênea.

Uma estrutura de dados homogênea é uma estrutura capaz de armazenar várias informações de um mesmo tipo de dado. Assim, com um único nome declarado para esta estrutura, podemos manipular várias informações.

Uma estrutura de dados homogênea pode ser vista como qualquer outra variável, podendo ser manipulada dentro de uma estrutura de decisão (seja ela simples, composta ou encadeada), dentro de uma estrutura de múltipla escolha, dentro das estruturas de repetição.

Temos dois tipos de estrutura de dados homogênea: vetores e matrizes. No capítulo seguinte, veremos matrizes e a seguir veremos como e quando trabalhar com um vetor, bem como, declarar e manipular um vetor.

10.1 Definição de vetor

Um vetor é um conjunto de informações de um mesmo tipo de dado. Note que vetor é um nome particular dado à matriz unidimensional. Por exemplo, considere uma fileira de 5 carteiras de uma sala de aula representando uma estrutura de dados e cada uma das carteiras representando partições dessa estrutura. Em outras palavras, a fileira de carteiras é um vetor e cada carteira um elemento deste vetor. Podemos representar, graficamente, este vetor da seguinte forma:

Vet0 1 2 3 4

carteira1 carteira2 carteira3 carteira4 carteira5

Neste exemplo, possuímos um vetor chamado Vet, com dimensão ou tamanho do vetor igual a 5 e com cinco posições: 0, 1, 2, 3 e 4. Na posição 0 do vetor Vet, temos a carteira1, na posição 1 do vetor Vet, temos a carteira2 e, assim por diante, até que na posição 4 do vetor Vet, temos a carteira5.

10.2 Declaração de vetor

Quando declaramos um vetor, precisamos saber qual o tipo de dados das informações que serão armazenadas no vetor e o número de elementos desse vetor. O nome atribuído para a declaração de vetor segue as mesmas regras da declaração de qualquer identificador.

Pseudocódigo

A declaração de um vetor em pseudocódigo terá a seguinte regra sintática:

Declarar <nome do vetor> [<número de elementos>] <tipo dos elementos do vetor>;



Por exemplo,

Declarar Vet_exemplo [100] numérico_inteiro;

Neste exemplo, declaramos um vetor chamado Vet_exemplo com 100 elementos do tipo inteiro.

Java

A declaração de um vetor em Java terá a seguinte regra sintática:

<tipo dos elementos> <nome vetor> [ ] = new <tipo elementos> [<nro. de elementos>];

ou

<tipo dos elementos>[ ] <nome vetor> = new <tipo elementos> [<nro. de elementos>];

Por exemplo,

int Vet_exemplo [ ] = new int [100];

ou

int [ ] Vet_exemplo = new int [100];

Neste exemplo, declaramos um vetor chamado Vet_exemplo com 100 elementos do tipo inteiro.

Podemos declarar um vetor em Java e depois determinar seu tamanho, seguindo a seguinte regra sintática:

<tipo dos elementos> <nome do vetor> [ ];<nome do vetor> = new <tipo dos elementos> [<nro. de elementos>];

Por exemplo:

int Vet_exemplo [ ];Vet_exemplo = new int [100];

Neste exemplo, declaramos um vetor chamado Vet_exemplo do tipo inteiro e depois determinamos seu tamanho com 100 elementos do tipo inteiro.

No Java, no momento da declaração do vetor, ele é automaticamente inicializado com zeros em cada posição do vetor.

10.3 Exemplo de vetor

Vamos exemplificar, graficamente, um vetor chamado notas, de 10 posições, contendo notas finais de 10 alunos. Como estamos considerando notas, então determinamos que essas informações são do tipo numérico_real.

notas 0 1 2 3 4 5 6 7 8 9Copyright – IBTA – Instituto Brasileiro de Tecnologia Avançada 139


9.5 10.0 8.5 5 8 7.5 6 9 8.5 7

- notas é o nome do vetor;- o vetor notas possui dez informações, por isso, tem tamanho 10, ou seja, 10 posições: de 0 até 9;- a posição 0 do vetor, notas[0], possui a nota 9.5;- a posição 1 do vetor, notas[1], possui a nota 10.0;- a posição 2 do vetor, notas[2], possui a nota 8.5;- a posição 3 do vetor, notas[3], possui a nota 5.0;- a posição 4 do vetor, notas[4], possui a nota 8.0;- a posição 5 do vetor, notas[5], possui a nota 7.5;- a posição 6 do vetor, notas[6], possui a nota 6.0;- a posição 7 do vetor, notas[7], possui a nota 9.0;- a posição 8 do vetor, notas[8], possui a nota 8.5;- a posição 9 do vetor, notas[9], possui a nota 7.0.

10.4 Atribuindo valores ao vetor

Quando atribuímos valores ao vetor, precisamos saber qual o tipo de dados das informações que serão armazenadas no vetor e o número de elementos desse vetor. Os valores são atribuídos a cada posição do vetor e a forma de atribuição é a mesma de qualquer variável ou constante.

Pseudocódigo

A atribuição de valores para cada posição do vetor em pseudocódigo terá a seguinte regra sintática:

<nome do vetor> [<posição>] ← <valor>;

Por exemplo,

notas [0] ← 9.5;

Neste exemplo, a posição 0 do vetor notas recebe o valor 9.5.

Podemos também atribuir valores no momento da declaração do vetor, conforme a seguinte regra sintática:

Declarar <nome vetor> [<nro dados>] ← {<vlr1> , <vlr2> , ... , <vlrn>} <tipo dados do vetor>;

Por exemplo,

Declarar notas [3] ← { 9.5 , 10.0 , 8.5} numérico_real;

Neste exemplo, declaramos um vetor chamado notas de tamanho 3, de forma que a posição 0 do vetor possua o valor 9.5, a posição 1 do vetor possua o valor 10.0 e a última posição do vetor possua o valor 8.5.

Java

A atribuição de valores para cada posição do vetor em Java terá a seguinte regra sintática:Copyright – IBTA – Instituto Brasileiro de Tecnologia Avançada 140


<nome do vetor> [<posição>] = <valor>;

Por exemplo,

notas [0] = 9.5;

Neste exemplo, a posição 0 do vetor notas recebe o valor 9.5.

Podemos também atribuir valores no momento da declaração do vetor, conforme a seguinte regra sintática:

<tipo dos dados> <nome do vetor> [ ] = {<vlr1> , <vlr2> , ... , <vlrn>};

Por exemplo,

double notas [ ] = { 9.5 , 10.0 , 8.5};

Neste exemplo, declaramos um vetor chamado notas de tamanho 3, de forma que a posição 0 do vetor possua o valor 9.5, a posição 1 do vetor possua o valor 10.0 e a última posição do vetor possua o valor 8.5.

10.5 Mostrando os elementos de um vetor

Quando mostramos valores do vetor, precisamos saber qual o tipo de dados das informações que foram armazenadas no vetor e o número de elementos desse vetor. Os valores são mostrados para cada posição do vetor e a forma de mostrar os elementos na tela é a mesma de qualquer variável ou constante.

Pseudocódigo

Para mostrar os valores de cada posição do vetor em pseudocódigo teremos a seguinte regra sintática:

escrever (<nome do vetor>[<posição>]);

Por exemplo,

escrever (notas [0]);

Neste exemplo, o conteúdo da posição 0 do vetor notas será mostrado ao usuário, ou seja, o valor 9.5 aparecerá na tela do usuário.

Note que a mensagem dentro do comando escrever pode vir concatenada com outros valores alfanuméricos. Por exemplo:

escrever ("A nota é: " , notas[0]);

Neste exemplo, a mensagem A nota é 9.5 aparecerá na tela do usuário.

Java

Para mostrar os valores de cada posição do vetor em Java teremos a seguinte regra sintática:



System.out.println (<nome do vetor> [<posição>]);

Por exemplo,

System.out.println(notas [0]);

Neste exemplo, o conteúdo da posição 0 do vetor notas será mostrado ao usuário, ou seja, o valor 9.5 aparecerá na tela do usuário.

Note que a mensagem dentro do comando System.out.println pode vir concatenada com outras Strings. Por exemplo:

System.out.println("A nota é: " + notas[0]);


10.6 Exemplos de vetores em pseudocódigo

1. Desenvolva um algoritmo que receba 25 valores numéricos inteiros e mostre esses números.

Algoritmo Mostrar início_algoritmo // declaração de variáveis e/ou constantes Declarar Vet [25] , i numérico_inteiro;

// processamento de dados para i de 0 até 24 passo + 1 faça // mensagem ao usuário escrever ("Digite um valor inteiro"); // entrada de dados ler (Vet[i]); // saída de resultados escrever (Vet[i]); fimpara; fim_algoritmo.

2. Desenvolva um algoritmo que receba 100 valores numéricos inteiros e mostre a soma desses 100 números.

Algoritmo Somar início_algoritmo // declaração de variáveis e/ou constantes Declarar VetSoma [100] , i , soma ← 0 numérico_inteiro;

// processamento de dados para i de 0 até 99 passo + 1 faça // mensagem ao usuário escrever ("Digite um valor inteiro"); // entrada de dados ler (VetSoma[i]);



soma ← soma + VetSoma[i]; fimpara; // saída de resultados escrever ("A soma dos 100 valores digitados é: " , soma); fim_algoritmo.

3. Desenvolva um algoritmo que receba 50 notas bimestrais, calcule e mostre a média aritmética destas 50 notas.

Algoritmo MediaAritmetica início_algoritmo // declaração de variáveis e/ou constantes Declarar i numérico_inteiro; Notas [50] , media, soma ← 0 numérico_real;

// processamento de dados para i de 0 até 49 passo + 1 faça // mensagem ao usuário escrever ("Digite uma nota"); // entrada de dados ler (Notas[i]); soma ← soma + Notas[i]; fimpara; // processamento de dados media ← soma/50; // saída de resultados escrever ("A média das 50 notas digitadas é: " , media); fim_algoritmo.

4. Desenvolva um algoritmo modularizado que recebe 200 valores numéricos reais e mostra esses valores e a soma dos números pares.

numérico_real FuncSoma (Vet[ ] numérico_real) início Declarar //declaração de variáveis e/ou constantes i numérico_inteiro; Vet [200] , soma numérico_real;

// processamento de dados para i de 0 até 199 passo + 1 faça // mensagem ao usuário escrever ("Digite um número"); // entrada de dados ler (Vet[i]); se ((Vet[i] mod 2) = 0 ) então soma soma + Vet[i]; fimse; // saída de resultados escrever ("O número digitado é " , Vet[i]); fimpara; retornar soma; fimmódulo;



Algoritmo SomaPares início_algoritmo Declarar // declaração de variáveis e/ou constantes s 0 numérico_real; // processamento de dados s FuncSoma( ); // saída de resultados escrever ("A soma dos números pares é: " , s); fim_algoritmo.

10.7 Exemplos de vetores em Java

1. Desenvolva um algoritmo que receba 25 valores numéricos inteiros e mostre esses números.

class Mostrar { public static void main(String args [ ]) { // declaração de variáveis e/ou constantes int Vet [ ] , i; Vet = new int [25]; // processamento de dados for ( i = 0 ; i < 25 ; i++ ) { // mensagem ao usuário e entrada de dados Vet[i] = Integer.parseInt(JOptionPane.showInputDialog ("Digite um valor inteiro")); // saída de resultados System.out.println (Vet[i]); } // for System.exit(0); } // void main } // classe Mostrar

2. Desenvolva um algoritmo que receba 100 valores numéricos inteiros e mostre a soma destes 100 números.

class Somar { public static void main(String args [ ]) { // declaração de variáveis e/ou constantes int VetSoma [ ] , i , soma = 0; VetSoma = new int [100]; // processamento de dados for ( i = 0 ; i <= 99 ; i++ ) { // mensagem ao usuário e entrada de dados VetSoma[i] = Integer.parseInt(JOptionPane.showInputDialog ("Digite um valor inteiro"));



soma = soma + VetSoma[i]; } // for // saída de resultados System.out.println ("A soma dos 100 valores digitados é: " + soma); System.exit(0); } // void main } // classe Somar

3. Desenvolva um algoritmo que receba 50 notas bimestrais, calcule e mostre a média aritmética destas 50 notas.

class MediaAritmetica { public static void main(String args [ ]) { // declaração de variáveis e/ou constantes int i ; double Notas[ ] , media , soma = 0; Notas = new double [50]; // processamento de dados for ( i = 0 ; i <= 49 ; i++ ) { // mensagem ao usuário e entrada de dados Notas[i] = Double.parseDouble(JOptionPane.showInputDialog ("Digite uma nota")); soma = soma + Notas[i]; } // for media = soma/50; // saída de resultados System.out.println ("A média das 50 notas digitadas é: " + media); System.exit(0); } // void main } // classe MediaAritmetica

4. Desenvolva um algoritmo modularizado que recebe 200 valores numéricos reais e mostra esses valores e a soma dos números pares.

class SomaPares { public static double FuncSoma ( ) { // declaração de variáveis e/ou constantes int i ; double Vet[ ] , soma = 0; Vet = new double [200]; // processamento de dados for ( i = 0 ; i < 200 ; i++ ) { // mensagem ao usuário e entrada de dados Vet[i] = Double.parseDouble(JOptionPane.showInputDialog ("Digite um número")); if ((Vet[i] % 2) == 0)



{ soma = soma + Vet[i]; } // if // saída de resultados System.out.println("O número digitado é" + Vet[i]); } // for return soma; }

public static void main(String args [ ]) { // declaração de variáveis e/ou contantes double s = 0;

// processamento de dados s = FuncSoma( ); // saída de resultados System.out.println ("A soma dos números pares é: " + s); System.exit(0); } // void main } // classe SomaPares

10.8 Exercícios de vetores

Para todos os exercícios abaixo, construir um algoritmo modularizado usando vetor.

1. Desenvolva um algoritmo que receba e mostre 120 valores alfanuméricos.

2. Desenvolva um algoritmo que receba 20 valores numéricos inteiros num vetor A e 20 valores numéricos inteiros num vetor B. Construa um vetor C com 20 posições, onde cada posição possua a soma dos elementos dos vetores A e B em suas respectivas posições. Mostrar os elementos dos três vetores.

3. Desenvolva um algoritmo que receba 50 valores numéricos reais num vetor X e 30 valores numéricos reais num vetor Y. Construa um vetor Z de 80 posições com a concatenação dos vetores X e Y, ou seja, os elementos das 50 primeiras posições são os mesmos elementos do vetor X e os elementos das 30 últimas posições são os mesmos do vetor Y. Mostre os elementos dos três vetores.

4. Desenvolva um algoritmo que receba 10 valores numéricos inteiros num vetor Num, calcule e mostre os números primos e suas respectivas posições.

5. Desenvolva um algoritmo que receba 50 valores numéricos reais num vetor, calcule e armazene, num segundo vetor, os 50 valores do primeiro vetor multiplicados por 5. Mostre os valores dos dois vetores.

6. Desenvolva um algoritmo que receba 30 valores numéricos inteiros num vetor, calcule e armazene, num segundo vetor, o quadrado dos 30 valores do primeiro vetor. Mostre os valores dos dois vetores.

7. Desenvolva um algoritmo que receba 45 valores numéricos inteiros num vetor, calcule e armazene, num segundo vetor, o fatorial de cada elemento do primeiro vetor. Mostre os dois vetores.



8. Desenvolva um algoritmo que receba 90 valores numéricos inteiros positivos num vetor, calcule e armazene, num segundo vetor, o negativo de cada elemento do primeiro vetor. Mostre os dois vetores.

9. Desenvolva um algoritmo que receba 85 valores numéricos reais num vetor, calcule e armazene, num segundo vetor, a metade de cada elemento do primeiro vetor. Mostre os dois vetores.

10. Desenvolva um algoritmo que calcule a tabuada de um número determinado pelo usuário e armazene, num vetor de 10 posições, o resultado da tabuada. Mostre os elementos do vetor.

11. Desenvolva um algoritmo que receba 15 valores referentes às temperaturas em graus Celsius e armazene num vetor de 15 posições. Calcule e armazene, num segundo vetor de 15 posições, os valores de cada temperatura em graus Celsius convertidos para graus Fahrenheit. Calcule e armazene, num terceiro vetor de 15 posições, os valores de cada temperatura em graus Celsius convertidos para graus Kelvin. Mostre os elementos dos três vetores.

12. Desenvolva um algoritmo que receba 35 valores numéricos inteiros num vetor, calcule e armazene o triplo dos valores divisíveis por 3 num segundo vetor, armazenando inalterados os valores que não são divisíveis por 3. Mostre os elementos dos dois vetores.

13. Desenvolva um algoritmo que receba 15 valores alfanuméricos num vetor e armazene invertido esses elementos num segundo vetor de 15 posições. O primeiro elemento do primeiro vetor será o último elemento do segundo vetor, o segundo elemento do primeiro vetor será o penúltimo elemento do segundo vetor e assim por diante. Mostre os elementos dos dois vetores.

14. Desenvolva um algoritmo que receba 50 valores numéricos inteiros e pares num vetor e receba 50 valores numéricos inteiros e ímpares num segundo vetor de forma que cada elemento recebido seja validado pelo programa e não pelo usuário. Armazene num terceiro vetor de 100 posições o resto da divisão de cada elemento do primeiro vetor por 3 e o quociente da divisão de cada elemento do segundo vetor por 3. Os 50 primeiros elementos do terceiro vetor são referentes ao primeiro vetor e os 50 últimos elementos do terceiro vetor são referentes ao segundo vetor. Mostre os elementos dos três vetores.

15. Desenvolva um algoritmo que receba 70 valores divisíveis por 2 e por 3 e armazene num vetor de 70 posições. O algoritmo e não o usuário é quem deve validar se um valor é divisível por 2 e por 3. Caso o valor digitado satisfaça a condição, então ele será armazenado no vetor, caso contrário, outro valor será recebido até que os 70 valores preencham o vetor. Mostre os elementos do vetor.

16. Desenvolva um algoritmo que receba 65 valores divisíveis por 5 ou por 7 e armazene num vetor de 65 posições. O algoritmo e não o usuário é quem deve validar se um valor é divisível por 5 ou 7. Caso o valor digitado satisfaça a condição, então ele será armazenado no vetor, caso contrário, outro valor será recebido até que os 65 valores preencham o vetor. Mostre os elementos do vetor.

17. Desenvolva um algoritmo que receba 40 valores numéricos inteiros, calcule e mostre os números primos e suas respectivas posições.

18. Desenvolva um algoritmo que receba 55 valores numéricos reais num vetor, calcule e mostre a média aritmética dos 55 valores.



19. Desenvolva um algoritmo que receba 10 valores numéricos inteiros num vetor, calcule e mostre a média ponderada dos 10 valores, considerando o peso de cada posição, sua própria posição, ou seja, o peso do elemento da posição 1 é 1, o peso do elemento da posição 2 é 2 e assim por diante.

20. Desenvolva um algoritmo que receba 50 valores alfanuméricos, verifique e mostre os elementos que começam com uma vogal. Para facilitar, classifique em ordem crescente esse vetor.

21. Desenvolva um algoritmo que receba 45 valores numéricos inteiros, calcule e mostre os números pares, suas posições e a soma dos números pares e os números ímpares, suas posições e a quantidade de números ímpares.

22. Desenvolva um algoritmo que receba 65 valores resultantes dos números sorteados em um dado jogado 65 vezes. Mostre os números sorteados e a freqüência com que apareceram.

23. Desenvolva um algoritmo que receba 100 valores alfanuméricos entre vogais, calcule e mostre quantas vezes cada vogal aparece e sua porcentagem.

24. Desenvolva um algoritmo que receba 35 valores numéricos reais e armazene cada elemento de forma ordenada. O primeiro valor digitado será armazenado na primeira posição do vetor, o segundo valor digitado será armazenado na segunda posição do vetor, se for maior que o primeiro elemento. Se for menor que o primeiro elemento, desloque esse valor para a segunda posição e armazene o segundo valor digitado na primeira posição. Continue essa regra até que todos os 35 valores sejam digitados e armazenados em ordem crescente no vetor de 35 posições. Mostre os elementos desse vetor.

25. Desenvolva um algoritmo que receba 15 valores numéricos inteiros num vetor X, receba 15 valores numéricos inteiros num vetor Y e concatene alternadamente os elementos dos vetores X e Y num terceiro vetor Z de 30 posições. Os elementos das posições ímpares do vetor Z são os mesmos do vetor X e os elementos das posições pares do vetor Z são os mesmos do vetor Y. Mostrar os elementos dos três vetores.

26. Desenvolva um algoritmo que receba 30 valores numéricos reais num vetor A, receba 30 valores numéricos reais num vetor B e concatene os elementos dos vetores A e B num terceiro vetor C de 60 posições. Os primeiros 30 elementos do vetor C são os mesmos do vetor A e os 30 últimos elementos do vetor C são os mesmos do vetor B. Mostre os elementos dos três vetores.

27. Desenvolva um algoritmo que receba 50 valores alfanuméricos num vetor, armazene de forma invertida os elementos deste vetor num segundo vetor de 50 posições, ou seja, o primeiro elemento do primeiro vetor estará na última posição do segundo vetor, o segundo elemento do primeiro vetor estará na penúltima posição do segundo vetor e assim por diante. Mostre os valores dos dois vetores.

28. Desenvolva um algoritmo que receba 75 valores alfanuméricos num vetor, armazene estes valores num segundo vetor a partir do centro para as bordas e de modo alternado, ou seja, o primeiro elemento do primeiro vetor estará na posição do meio do segundo vetor, o segundo elemento do primeiro vetor estará na posição à esquerda da posição do meio do segundo vetor, o terceiro elemento do primeiro vetor estará na posição à direita da posição do meio do segundo vetor e assim por diante. Mostre os elementos dos dois vetores.

29. Desenvolva um algoritmo que receba 100 valores numéricos inteiros num vetor. Armazene os restos das divisões dos elementos das posições pares por suas posições, num



segundo vetor, e os quocientes das divisões dos elementos das posições ímpares por suas posições neste segundo vetor. Mostre os elementos dos dois vetores.

30. Desenvolva um algoritmo que receba 35 valores numéricos reais num vetor e classifique em ordem crescente os elementos desse vetor, utilizando a seguinte regra:- selecione o menor elemento do vetor de 35 posições;- troque este elemento pelo primeiro elemento do vetor;- repita os dois primeiros itens, considerando agora os 34 elementos restantes do vetor, trocando o menor elemento com o segundo elemento do vetor;- repita os dois primeiros itens, considerando agora os 33 elementos restantes do vetor, trocando o menor elemento com o terceiro elemento do vetor;- continue até que se considere apenas o vetor com a última posição.Mostre os elementos ordenados do vetor.



Capítulo 11 – Estrutura de Dados Homogênea – Matrizes

Quando desenvolvemos um algoritmo ou programa estruturado, muitas vezes precisamos usar várias informações de um mesmo tipo de dado e de informações diferentes, por exemplo, notas bimestrais, notas semestrais e média, todos do tipo numérico real. Podemos fazer isso criando diversas variáveis, uma para cada informação, mas isso é inviável, pois é demasiado complexo desenvolvermos e manipularmos um algoritmo que utiliza diversas variáveis para várias informações de um mesmo tipo. Para solucionar este problema, podemos utilizar matrizes para armazenar essas informações, isto é, uma estrutura de dados homogênea.

Uma estrutura de dados homogênea, seja ela um vetor ou uma matriz, pode ser vista como qualquer outra variável, podendo ser manipulada dentro de uma estrutura de decisão (seja ela simples, composta ou encadeada), dentro de uma estrutura de múltipla escolha, dentro das estruturas de repetição.

A seguir veremos como e quando trabalhar com uma matriz, bem como declarar e manipular uma matriz.

11.1 Definição de matriz

Uma matriz é um conjunto de informações de um mesmo tipo de dados, podendo conter informações diferentes. Note que matriz é um nome particular dado à matriz multidimensional, seja ela de dimensão dois ou mais. Por exemplo, uma matriz bidimensional pode conter informações dispostas em duas coordenadas x e y, ou seja, linha e coluna; uma matriz tridimensional pode conter informações dispostas em três coordenadas x, y e z, ou seja, linha, coluna e altura e assim por diante. Neste capítulo, nos preocuparemos em estudar as matrizes bidimensionais.

Para um exemplo de uma matriz bidimensional, considere dez fileiras de 5 carteiras de uma sala de aula representando uma estrutura de dados, cada uma das fileiras e cada uma das carteiras representando partições dessa estrutura, em outras palavras, as dez fileiras de 5 carteiras são uma matriz bidimensional e cada carteira um elemento desta matriz. Podemos representar, graficamente, esta matriz da seguinte forma:

Mat 0 1 2 3 40 carteira1 carteira2 carteira3 carteira4 carteira51 carteira6 carteira7 carteira8 carteira9 carteira102 carteira11 carteira12 carteira13 carteira14 carteira153 carteira16 carteira17 carteira18 carteira19 carteira204 carteira21 carteira22 carteira23 carteira24 carteira255 carteira26 carteira27 carteira28 carteira29 carteira306 carteira31 carteira32 carteira33 carteira34 carteira357 carteira36 carteira37 carteira38 carteira39 carteira408 carteira41 carteira42 carteira43 carteira44 carteira459 carteira46 carteira47 carteira48 carteira49 carteira50

Neste exemplo, possuímos uma matriz chamada Mat, com dimensão, ou tamanho da matriz, igual a 10 por 5, ou seja, 10 linhas e 5 colunas, com cinqüenta posições: 0x0 , 0x1, 0x2, 0x3 , 0x4 , 1x0 , 1x1, 1x2, 1x3 , 1x4 , 2x0 , 2x1, 2x2, 2x3 , 2x4 , 3x0 , 3x1, 3x2, 3x3 , 3x4 , 4x0 , 4x1, 4x2, 4x3 , 4x4 , 5x0 , 5x1, 5x2, 5x3 , 5x4 , 6x0 , 6x1, 6x2, 6x3 , 6x4 , 7x0 , 7x1, 7x2, 7x3 , 7x4 , 8x0 , 8x1, 8x2, 8x3 , 8x4 , 9x0 , 9x1, 9x2, 9x3 e 9x4. Na posição 0x0 da



matriz Mat, temos a carteira1; na posição 0x1 da matriz Mat, temos a carteira2; até que na posição 9x4 da matriz Mat, temos a carteira50.

11.2 Declaração de matriz

Quando declaramos uma matriz, precisamos saber qual o tipo de dados das informações que serão armazenadas na matriz, quais as informações, o número de elementos dessa matriz, bem como, o número de linhas e colunas. O nome atribuído para a declaração da matriz segue as mesmas regras da declaração de qualquer identificador.

Pseudocódigo

A declaração de uma matriz em pseudocódigo terá a seguinte regra sintática:

Declarar <nome da matriz> [<nro de linhas>] [<nro de colunas>] <tipo dos elementos matriz>;

Por exemplo,

Declarar Mat_exemplo [100][5] numérico_inteiro;

Neste exemplo, declaramos uma matriz chamada Mat_exemplo com 100 linhas e 5 colunas totalizando 500 elementos do tipo inteiro.

Java

A declaração de uma matriz em Java terá a seguinte regra sintática:

<tipo elementos> <nome matriz> [ ][ ] = new <tipo elementos> [<nro lin>][<nro col>];

ou

<tipo elementos>[ ][ ] <nome matriz> = new <tipo elementos> [<nro lin>][<nro col>];

ou

<tipo elementos>[ ] <nome matriz> [ ] = new <tipo elementos> [<nro lin>][<nro col>];

Por exemplo,

int Mat_exemplo [ ][ ] = new int [100][5];

ou

int [ ][ ] Mat_exemplo = new int [100][5];

ou

int [ ] Mat_exemplo [ ] = new int [100][5];

Neste exemplo, declaramos uma matriz chamada Mat_exemplo com 100 linhas e 5 colunas totalizando 500 elementos do tipo inteiro.



Podemos declarar uma matriz em Java e depois determinar seu tamanho, seguindo a seguinte regra sintática:

<tipo dos elementos> <nome da matriz> [ ][ ];<nome da matriz> = new <tipo dos elementos> [<nro. de linhas>][<nro. de colunas>];

Por exemplo:

int Mat_exemplo [ ][ ];Mat_exemplo = new int [100][5];

Neste exemplo, declaramos uma matriz chamada Mat_exemplo do tipo inteiro e depois determinamos seu tamanho com 100 linhas e 5 colunas, totalizando 500 elementos do tipo inteiro.

11.3 Exemplo de matriz

Vamos exemplificar, graficamente, uma matriz chamada notas, de 10 linhas e 5 colunas, ou seja, 50 posições, contendo na primeira coluna as notas do primeiro bimestre de 10 alunos, na segunda coluna as notas do segundo bimestre de 10 alunos, na terceira coluna as notas do terceiro bimestre de 10 alunos, na quarta coluna as notas do quarto bimestre de 10 alunos e na quinta coluna as médias finais dos 10 alunos. Como estamos considerando notas, então determinamos que essas informações são do tipo numérico_real.

notas 1o Bim 2o Bim 3o Bim 4o BimMédia Final

posições 0 1 2 3 4

Aluno 1 0 9.0 8.0 8.5 9.0 8.5

Aluno 2 1 5.0 6.0 7.0 8.0 6.5

Aluno 3 2 7.5 7.5 7.5 7.5 7.5

Aluno 4 3 5.0 9.0 3.0 7.0 6.0

Aluno 5 4 8.0 6.0 6.0 7.0 7.0

Aluno 6 5 9.0 8.0 9.0 10.0 9.0

Aluno 7 6 8.0 8.0 8.0 8.0 8.0

Aluno 8 7 8.5 6.0 7.5 6.0 7.0

Aluno 9 8 9.5 8.5 8.5 9.5 9.0

Aluno 10 9 5.0 6.5 7.0 7.5 6.5

- notas é o nome da matriz;- a matriz notas possui 10 linhas e 5 colunas, totalizando 50 informações, por isso, tem tamanho 10x5, ou seja, 50 posições: de 0x0 até 9x4;- a posição 0x0 da matriz, notas[0], possui a nota 9.0;- a posição 0x1 da matriz, notas[1], possui a nota 8.0;- a posição 0x2 da matriz, notas[2], possui a nota 8.5;- a posição 0x3 da matriz, notas[3], possui a nota 9.0;- a posição 0x4 da matriz, notas[4], possui a nota 8.5;- a posição 1x0 da matriz, notas[0], possui a nota 5.0;



- a posição 1x1 da matriz, notas[1], possui a nota 6.0;- a posição 1x2 da matriz, notas[2], possui a nota 7.0;- a posição 1x3 da matriz, notas[3], possui a nota 8.0;- a posição 1x4 da matriz, notas[4], possui a nota 6.6;- a posição 2x0 da matriz, notas[0], possui a nota 7.5;- a posição 2x1 da matriz, notas[1], possui a nota 7.5;- a posição 2x2 da matriz, notas[2], possui a nota 7.5;- a posição 2x3 da matriz, notas[3], possui a nota 7.5;- a posição 2x4 da matriz, notas[4], possui a nota 7.5;- a posição 3x0 da matriz, notas[0], possui a nota 5.0;- a posição 3x1 da matriz, notas[1], possui a nota 9.0;- a posição 3x2 da matriz, notas[2], possui a nota 3.0;- a posição 3x3 da matriz, notas[3], possui a nota 7.0;- a posição 3x4 da matriz, notas[4], possui a nota 6.0;- a posição 4x0 da matriz, notas[0], possui a nota 8.0;- a posição 4x1 da matriz, notas[1], possui a nota 6.0;- a posição 4x2 da matriz, notas[2], possui a nota 6.0;- a posição 4x3 da matriz, notas[3], possui a nota 7.0;- a posição 4x4 da matriz, notas[4], possui a nota 7.0;- a posição 5x0 da matriz, notas[0], possui a nota 9.0;- a posição 5x1 da matriz, notas[1], possui a nota 8.0;- a posição 5x2 da matriz, notas[2], possui a nota 9.0;- a posição 5x3 da matriz, notas[3], possui a nota 10.0;- a posição 5x4 da matriz, notas[4], possui a nota 9.0;- a posição 6x0 da matriz, notas[0], possui a nota 8.0;- a posição 6x1 da matriz, notas[1], possui a nota 8.0;- a posição 6x2 da matriz, notas[2], possui a nota 8.0;- a posição 6x3 da matriz, notas[3], possui a nota 8.0;- a posição 6x4 da matriz, notas[4], possui a nota 8.0;- a posição 7x0 da matriz, notas[0], possui a nota 8.5;- a posição 7x1 da matriz, notas[1], possui a nota 6.0;- a posição 7x2 da matriz, notas[2], possui a nota 7.5;- a posição 7x3 da matriz, notas[3], possui a nota 6.0;- a posição 7x4 da matriz, notas[4], possui a nota 7.0;- a posição 8x0 da matriz, notas[0], possui a nota 9.5;- a posição 8x1 da matriz, notas[1], possui a nota 8.5;- a posição 8x2 da matriz, notas[2], possui a nota 8.5;- a posição 8x3 da matriz, notas[3], possui a nota 9.5;- a posição 8x4 da matriz, notas[4], possui a nota 9.0;- a posição 9x0 da matriz, notas[0], possui a nota 5.0;- a posição 9x1 da matriz, notas[1], possui a nota 6.5;- a posição 9x2 da matriz, notas[2], possui a nota 7.0;- a posição 9x3 da matriz, notas[3], possui a nota 7.5;- a posição 9x4 da matriz, notas[4], possui a nota 6.5.

11.4 Atribuindo valores à matriz

Quando atribuímos valores à matriz, precisamos saber qual o tipo de dados das informações que serão armazenadas na matriz e o número de linhas e colunas dessa matriz, ou seja, o número de elementos dessa matriz. Os valores são atribuídos a cada posição da matriz e a forma de atribuição é a mesma de qualquer variável ou constante.



Pseudocódigo

A atribuição de valores para cada posição da matriz em pseudocódigo terá a seguinte regra sintática:

<nome da matriz> [<nro. da linha>] [<nro. da coluna>] ← <valor>;

Por exemplo,

notas [0][0] ← 9.0;

Neste exemplo, a posição 0x0 da matriz notas recebe o valor 9.0.

Podemos também atribuir valores no momento da declaração da matriz, conforme a seguinte regra sintática:

Declarar <nome da matriz> [<nro linhas>][<nro colunas>] ← {{<vlr11> , <vlr12> , ... , <vlr1n>} , {<vlr21> , <vlr22> , ... , <vlr2n>} , ... , {<vlrm1> , <vlrm2> , ... , <vlrmn>}} <tipo de dados da matriz>;

Por exemplo,

Declarar notas [2][3] ← {{ 9.0 , 10.0 , 8.5} , { 5.5 , 5.0 , 7.5}} numérico_real;

Neste exemplo, declaramos uma matriz chamada notas de tamanho 2x3, ou seja, de 6 posições, de forma que a posição 0x0 da matriz possua o valor 9.0, a posição 0x1 da matriz possua o valor 10.0, a posição 0x2 da matriz possua o valor 8.5, a posição 1x0 da matriz possua o valor 5.5, a posição 1x1 da matriz possua o valor 5.0 e a posição 1x2 da matriz possua o valor 7.5.

Java

A atribuição de valores para cada posição da matriz em Java terá a seguinte regra sintática:

<nome da matriz> [<nro. da linha>] [<nro. da coluna>] = <valor>;

Por exemplo,

notas [0][0] = 9.0;

Neste exemplo, a posição 0x0 da matriz notas recebe o valor 9.0.

Podemos também atribuir valores no momento da declaração da matriz, conforme a seguinte regra sintática:

<tipo dos dados> <nome da matriz> [ ][ ] = {{<vlr11> , <vlr12> , ... , <vlr1n>} , {<vlr21> , <vlr22> , ... , <vlr2n>} , ... {<vlrm1> , <vlrm2> , ... , <vlrmn>}} <tipo dos dados da matriz>;

Por exemplo,

double notas [ ][ ] = {{ 9.0 , 10.0 , 8.5} , { 5.5 , 5.0 , 7.5}};



Neste exemplo, declaramos uma matriz chamada notas de tamanho 2x3, ou seja, de 6 posições, de forma que a posição 0x0 da matriz possua o valor 9.0, a posição 0x1 da matriz possua o valor 10.0, a posição 0x2 da matriz possua o valor 8.5, a posição 1x0 da matriz possua o valor 5.5, a posição 1x1 da matriz possua o valor 5.0 e a posição 1x2 da matriz possua o valor 7.5.

11.5 Mostrando os elementos de uma matriz

Quando mostramos valores da matriz, precisamos saber qual o tipo de dados das informações que foram armazenadas na matriz e o número de elementos dessa matriz. Os valores são mostrados para cada posição da matriz e a forma de mostrar os elementos na tela é a mesma de qualquer variável ou constante.

Pseudocódigo

Para mostrar os valores de cada posição da matriz em pseudocódigo teremos a seguinte regra sintática:

escrever (<nome da matriz>[<nro. da linha>][<nro. da coluna>]);

Por exemplo,

escrever (notas [0][0]);

Neste exemplo, o conteúdo da posição 0x0 da matriz notas será mostrado ao usuário, ou seja, o valor 9.0 aparecerá na tela do usuário.

Note que a mensagem dentro do comando escrever pode vir concatenada com outros valores alfanuméricos. Por exemplo:

escrever ("A nota é: " , notas[0][0]);


Java

Para mostrar os valores de cada posição da matriz em Java, teremos a seguinte regra sintática:

System.out.println (<nome da matriz> [<nro. da linha>][<nro. da coluna>]);

Por exemplo,

System.out.println(notas [0][0]);

Neste exemplo, o conteúdo da posição 0x0 da matriz notas será mostrado ao usuário, ou seja, o valor 9.0 aparecerá na tela do usuário.

Note que a mensagem dentro do comando System.out.println pode vir concatenada com outras Strings. Por exemplo:

System.out.println("A nota é: " + notas[0][0]);

Neste exemplo, a mensagem A nota é 9.0 aparecerá na tela do usuário.Copyright – IBTA – Instituto Brasileiro de Tecnologia Avançada 155


11.6 Exemplos de matrizes em pseudocódigo

1. Desenvolva um algoritmo que receba 25 valores numéricos inteiros numa matriz 5x5 e mostre esses números.

Algoritmo Mostrar início_algoritmo // declaração de variáveis e/ou constantes Declarar Mat [5][5] , i , j numérico_inteiro;

// processamento de dados para i de 0 até 4 passo + 1 faça para j de 0 até 4 passo + 1 faça // mensagem ao usuário escrever ("Digite um valor inteiro"); // entrada de dados ler (Mat[i][j]); // saída de resultados escrever (Mat[i][j]); fimpara; fimpara; fim_algoritmo.

2. Desenvolva um algoritmo que receba 120 valores numéricos inteiros em uma matriz 10x12 e mostre a soma destes 120 números.

Algoritmo Somar início_algoritmo // declaração de variáveis e/ou constantes Declarar MatSoma [10][12] , a , b , soma ← 0 numérico_inteiro;

// processamento de dados para a de 0 até 9 passo + 1 faça para b de 0 até 11 passo + 1 faça // mensagem ao usuário escrever ("Digite um valor inteiro"); // entrada de dados ler (MatSoma[a][b]); soma ← soma + MatSoma[a][b]; fimpara; fimpara; // saída de resultados escrever ("A soma dos 120 valores digitados é: " , soma); fim_algoritmo.

3. Desenvolva um algoritmo que receba 50 notas bimestrais de 10 alunos de 5 turmas, calcule e mostre a média aritmética destas 50 notas.

Algoritmo MediaAritmetica início_algoritmo // declaração de variáveis e/ou constantes



Declarar i , j numérico_inteiro; Notas [10][5] , media, soma ← 0 numérico_real;

// processamento de dados para i de 0 até 9 passo + 1 faça para j de 0 até 4 passo + 1 faça // mensagem ao usuário escrever ("Digite uma nota"); // entrada de dados ler (Notas[i][j]); soma ← soma + Notas[i][j]; fimpara; fimpara; // processamento de dados media ← soma/50; // saída de resultados escrever ("A média das 50 notas digitadas é: " , media); fim_algoritmo.

4. Desenvolva um algoritmo modularizado que recebe 200 valores numéricos reais numa matriz 20 x 10 e mostra esses valores e a soma dos números pares.

numérico_real FuncSoma ( ) início Declarar // declaração de variáveis e/ou constantes i , j numérico_inteiro; MatNum [20][10] , soma 0 numérico_real;

// processamento de dados para i de 0 até 19 passo + 1 faça para j de 0 até 9 passo + 1 faça // mensagem ao usuário escrever ("Digite um número"); ler (MatNum[i][j]); // entrada de dados se ((MatNum[i][j] mod 2) = 0 ) então soma soma + MatNum[i][j]; fimse; escrever ("O número digitado é " , MatNum[i][j]); fimpara; fimpara; // saída de resultados retornar soma; fimmódulo.

Algoritmo SomaPares início_algoritmo Declarar // declaração de variáveis e/ou constantes s 0 numérico_real;

// processamento de dados s FuncSoma ( ); // saída de resultados escrever ("A soma dos números pares é: " , s);



fim_algoritmo.

11.7 Exemplos de matrizes em Java

1. Desenvolva um algoritmo que receba 25 valores numéricos inteiros numa matriz 5x5 e mostre esses números.

class Mostrar { public static void main(String args [ ]) { // declaração de variáveis e/ou constantes int Mat [ ][ ] , i , j ; Mat = new int [5][5]; // processamento de dados for ( i = 0 ; i < 5 ; i++ ) { for ( j = 0 ; j < 5 ; j++) { // mensagem ao usuário e entrada de dados Mat[i][j] = Integer.parseInt(JOptionPane.showInputDialog ("Digite um valor inteiro")); // saída de resultados System.out.println (Mat[i][j]); } // for usando a variável j } // for usando a variável i System.exit(0); } // void main } // classe Mostrar

2. Desenvolva um algoritmo que receba 120 valores numéricos inteiros numa matriz 10x12 e mostre a soma desses 120 números.

class Somar { public static void main(String args [ ]) { // declaração de variáveis e/ou constantes int MatS [ ][ ] , a , b , soma = 0; MatS = new int [10][12]; // processamento de dados for ( a = 0 ; a <= 9 ; a++ ) { for ( b = 0 ; b <= 11 ; b++ ) { // mensagem ao usuário e entrada de dados MatS[a][b]= Integer.parseInt(JOptionPane.showInputDialog

("Digite um valor inteiro")); soma = soma + MatS[a][b]; } // for usando a variável b



} // for usando a variável a

// saída de resultados System.out.println ("A soma dos 120 valores digitados é: " + soma); System.exit(0); } // void main } // classe Somar

3. Desenvolva um algoritmo que receba 50 notas bimestrais de 10 alunos de 5 turmas, calcule e mostre a média aritmética dessas 50 notas.

class MediaAritmetica { public static void main(String args [ ]) { // declaração de variáveis e/ou constantes int i , j ; double Notas[ ][ ] , media , soma = 0; Notas = new double [10][5]; // processamento de dados for ( i = 0 ; i <= 9 ; i++ ) { for ( j = 0 ; j <= 4 ; j++ ) { // mensagem ao usuário e entrada de dados Notas[i][j] = Double.parseDouble( JOptionPane.showInputDialog ("Digite uma nota")); soma = soma + Notas[i][j]; } // for usando variável j } // for usando variável i media = soma/50; // saída de resultados System.out.println ("A média das 50 notas digitadas é: " + media); System.exit(0); } // void main } // classe MediaAritmetica

4. Desenvolva um algoritmo que recebe 200 valores numéricos reais numa matriz 20x10 e mostra esses valores e a soma dos números pares.

class SomaPares { public static void main(String args [ ]) { // declaração de variáveis e/ou constantes int i , j ; double MatNum[ ][ ] , soma = 0; MatNum = new double [20][10]; // processamento de dados for ( i = 0 ; i < 20 ; i++ ) { for ( j = 0 ; j < 10 ; j++ )



{ // mensagem ao usuário e entrada de dados MatNum[i][j] = Double.parseDouble( JOptionPane.showInputDialog ("Digite um número")); if ((MatNum[i][j] % 2) == 0) { soma = soma + MatNum[i][j]; } // if // saída de resultados System.out.println("O número digitado é" + MatNum[i][j]); } // for usando a variável j } // for usando a variável i // saída de resultados System.out.println ("A soma dos números pares é: " + soma); System.exit(0); } // void main } // classe SomaPares

11.8 Exercícios de matrizes

Para todos os exercícios abaixo, construir um algoritmo modularizado usando matriz.

1. Desenvolva um algoritmo que receba e mostre 120 valores alfanuméricos numa matriz 10x12.

2. Desenvolva um algoritmo que receba 20 valores numéricos inteiros numa matriz A de dimensões 10x2 e 20 valores numéricos inteiros numa matriz B de dimensões 10x2. Construa uma matriz C com dimensões 10x2, onde cada posição possua a soma dos elementos das matrizes A e B em suas respectivas posições. Mostre os elementos das três matrizes.

3. Desenvolva um algoritmo que receba 50 valores numéricos reais numa matriz X de dimensões 5x10 e 30 valores numéricos reais numa matriz Y de dimensões 3x10. Construa uma matriz Z de dimensões 8x10 com a concatenação das matrizes X e Y, ou seja, os elementos das 5 primeiras linhas são os mesmos elementos da matriz X e os elementos das três últimas linhas são os mesmos da matriz Y. Mostre os elementos das três matrizes.

4. Desenvolva um algoritmo que receba 10 valores numéricos inteiros numa matriz Num de dimensões 5x2, calcule e mostre os números primos e suas respectivas posições.

5. Desenvolva um algoritmo que receba 50 valores numéricos reais numa matriz 10x5, calcule e armazene numa segunda matriz os 50 valores da primeira matriz multiplicados por 7. Mostre os valores das duas matrizes.

6. Desenvolva um algoritmo que receba 35 valores numéricos inteiros numa matriz de dimensões 7x5, calcule e armazene numa segunda matriz o quadrado dos 35 valores da primeira matriz. Mostre os valores das duas matrizes.

7. Desenvolva um algoritmo que receba 45 valores numéricos inteiros numa matriz de dimensões 5x9, calcule e armazene numa segunda matriz o fatorial de cada elemento da primeira matriz. Mostre as duas matrizes.



8. Desenvolva um algoritmo que receba 90 valores numéricos inteiros positivos numa matriz de dimensões 10x9, calcule e armazene numa segunda matriz o negativo de cada elemento da primeira matriz. Mostre as duas matrizes.

9. Desenvolva um algoritmo que receba 75 valores numéricos reais numa matriz de dimensões 15x5, calcule e armazene numa segunda matriz a metade de cada elemento da primeira matriz. Mostre as duas matrizes.

10. Desenvolva um algoritmo que calcule a tabuada dos números de 1 a 10 e armazene numa matriz de dimensões 10x10 o resultado da tabuada. Mostre os elementos da matriz. Na primeira coluna da matriz, armazene a tabuada da número 1, na segunda coluna da matriz, armazene a tabuada do número 2 e assim por diante, até a última coluna da matriz, armazene a tabuada do número 10.

11. Desenvolva um algoritmo que receba 15 valores referentes a temperaturas em graus Celsius e armazene na primeira linha de uma matriz de dimensões 3x15. Calcule e armazene na segunda linha desta matriz os valores de cada temperatura em graus Celsius convertidos para graus Fahrenheit. Calcule e armazene na terceira linha desta matriz cada temperatura em graus Celsius convertidos para graus Kelvin. Mostre os elementos da matriz.

12. Desenvolva um algoritmo que receba 49 valores numéricos inteiros numa matriz de dimensões 7x7, calcule e armazene o triplo dos valores divisíveis por 3 numa segunda matriz, armazenando inalterados os valores que não forem divisíveis por 3. Mostre os elementos das duas matrizes.

13. Desenvolva um algoritmo que receba 15 valores alfanuméricos numa matriz de dimensões 3x5 e armazene invertido esses elementos numa segunda matriz de dimensões 3x5. O primeiro elemento da primeira matriz será o último elemento da segunda matriz, o segundo elemento da primeira matriz será o penúltimo elemento da segunda matriz e assim por diante. Mostre os elementos das duas matrizes.

14. Desenvolva um algoritmo que receba 25 valores numéricos inteiros e pares numa matriz de dimensões 5x5 e receba 25 valores numéricos inteiros e ímpares numa segunda matriz de dimensões 5x5 de forma que cada elemento recebido seja validado pelo programa e não pelo usuário. Armazene numa terceira matriz de 50 posições de dimensões 10x5 o resto da divisão de cada elemento da primeira matriz por 3 e o quociente da divisão de cada elemento da segunda matriz por 3. Os elementos das 5 primeiras linhas da terceira matriz são referentes à primeira matriz e os elementos das 5 últimas linhas da terceira matriz são referentes à segunda matriz. Mostre os elementos das três matrizes.

15. Desenvolva um algoritmo que receba 70 valores divisíveis por 2 e por 3 e armazene numa matriz de dimensões 7x10. O algoritmo e não o usuário é quem deve validar se um valor é divisível por 2 e por 3. Caso o valor digitado satisfaça a condição, então ele será armazenado na matriz, caso contrário, outro valor será recebido até que os 70 valores preencham a matriz. Mostre os elementos da matriz.

16. Desenvolva um algoritmo que receba 81 valores divisíveis por 5 ou por 7 e armazene numa matriz de dimensões 9x9. O algoritmo e não o usuário é quem deve validar se um valor é divisível por 5 ou 7. Caso o valor digitado satisfaça a condição, então ele será armazenado na matriz, caso contrário, outra valor será recebido até que os 81 valores preencham a matriz. Mostre os elementos da matriz.

17. Desenvolva um algoritmo que receba 40 valores numéricos inteiros numa matriz de dimensões 10x4, calcule e mostre os números primos e suas respectivas posições.



18. Desenvolva um algoritmo que receba 55 valores numéricos reais numa matriz de dimensões 5x11, calcule e mostre a média aritmética dos 55 valores.

19. Desenvolva um algoritmo que receba 10 valores numéricos inteiros numa matriz de dimensões 2x5, calcule e mostre a média ponderada dos 10 valores, considerando o peso de cada valor, o número correspondente da coluna em que se encontra mais um, ou seja, o peso do elemento da posição 0x0 é 1, o peso do elemento da posição 0x1 é 2 e assim por diante.

20. Desenvolva um algoritmo que receba 50 valores alfanuméricos numa matriz de dimensões 10x5, verifique e mostre os elementos que começam com uma vogal. Para facilitar, classifique em ordem crescente essa matriz.

21. Desenvolva um algoritmo que receba 49 valores numéricos inteiros numa matriz de dimensões 7x7, calcule e mostre os números pares, suas posições e a soma dos números pares, bem como os números ímpares, suas posições e a quantidade de números ímpares.

22. Desenvolva um algoritmo que receba 65 valores resultantes dos números sorteados em um dado jogado 65 vezes. Esses valores devem ser armazenados numa matriz 13x5. Mostre os números sorteados e a freqüência com que apareceram.

23. Desenvolva um algoritmo que receba 100 valores alfanuméricos entre vogais armazenadas numa matriz de dimensões 10x10, calcule e mostre quantas vezes cada vogal aparece e sua porcentagem.

24. Desenvolva um algoritmo que receba 35 valores numéricos reais e armazene cada elemento de forma ordenada, numa matriz de dimensões 7x5. O primeiro valor digitado será armazenado na primeira posição da matriz, ou seja, na posição 0x0; o segundo valor digitado será armazenado na segunda posição da matriz, ou seja, na posição 0x1, se for maior que o primeiro elemento. Se for menor que o primeiro elemento, deslocar esse valor para a segunda posição e armazenar o segundo valor digitado na primeira posição. Continue com essa regra até que todos os 35 valores sejam digitados e armazenados em ordem crescente na matriz de 35 posições. Mostre os elementos dessa matriz.

25. Desenvolva um algoritmo que receba 15 valores numéricos inteiros numa matriz X de dimensões 3x5, receba 15 valores numéricos inteiros numa matriz Y de dimensões 3x5 e concatene alternadamente os elementos das matrizes X e Y numa terceira matriz Z de dimensões 3x10. Os elementos das colunas pares da matriz Z são os mesmos da matriz X e os elementos das colunas ímpares da matriz Z são os mesmos da matriz Y. Mostre os elementos das três matrizes.

26. Desenvolva um algoritmo que receba 30 valores numéricos reais numa matriz A de dimensões 10x3, receba 30 valores numéricos reais numa matriz B de dimensões 10x3 e concatene os elementos das matrizes A e B numa terceira matriz C de dimensões 20x3. Os primeiros 30 elementos da matriz C são os mesmos da matriz A e os 30 últimos elementos da matriz C são os mesmos da matriz B. Mostre os elementos das três matrizes.

27. Desenvolva um algoritmo que receba 64 valores alfanuméricos numa matriz de dimensões 8x8, armazene de forma invertida os elementos desta matriz numa segunda matriz de dimensões 8x8, ou seja, o primeiro elemento da primeira matriz estará na última posição da segunda matriz, o segundo elemento da primeira matriz estará na penúltima posição da segunda matriz e assim por diante. Mostre os valores das duas matrizes.



28. Desenvolva um algoritmo que receba 75 valores alfanuméricos numa matriz de dimensões 15x5, armazene estes valores numa segunda matriz de dimensões 15x5 a partir do centro para a primeira e a última posições e de modo alternado, ou seja, o primeiro elemento da primeira matriz estará na posição do meio da segunda matriz, o segundo elemento da primeira matriz estará na posição à esquerda da posição do meio da segunda matriz, o terceiro elemento da primeira matriz estará na posição à direita da posição do meio da segunda matriz e assim por diante. Mostre os elementos das duas matrizes.

29. Desenvolva um algoritmo que receba 100 valores numéricos inteiros numa matriz de dimensões 10x10. Armazene os restos das divisões dos elementos das posições pares pela soma da sua posição (linha + coluna) numa segunda matriz de dimensões 10x10 e os quocientes das divisões dos elementos das posições ímpares pela soma da sua posição (linha + coluna) na segunda matriz. Mostre os elementos das duas matrizes.

30. Desenvolva um algoritmo que receba 35 valores numéricos reais numa matriz de dimensões 7x5 e classifique em ordem crescente os elementos dessa matriz, utilizando a seguinte regra:- selecione o menor elemento da matriz de 35 posições;- troque este elemento pelo primeiro elemento da matriz;- repita os dois primeiros itens, considerando agora os 34 elementos restantes da matriz, trocando o menor elemento com o segundo elemento da matriz;- repita os dois primeiros itens, considerando agora os 33 elementos restantes da matriz, trocando o menor elemento com o terceiro elemento da matriz;- continue até que se considere apenas a matriz com a última posição.Mostre os elementos ordenados da matriz.



Documents

Algoritmos 2o Bim