Exercicios sobre vetores

Preparação (ainda sem o uso de vetores):
Solicitar uma relação de pessoas, cada uma com o seu nome e a idade. A quantidade de pessoas será também solicitada ao usuário. Ao término da entrada de dados, exiba: o nome da pessoa mais velha, a média das idades, a quantidade de pessoas que possuem idade entre 18 e 60 anos (incluindo 18 e 60).

// solução da questão 3 da segunda prova
import java.util.Scanner;
public class Principal {
    public static void main(String[] args) {
        int idade, qtdePessoas, somaIdades = 0, idadeMaisVelha = 0, qtde18a60 = 0;
        String nome, nomeMaisVelha = "";
 
        System.out.println("Entre com a quantidade de pessoas:");
        qtdePessoas = new Scanner(System.in).nextInt();
 
        for(int contador = 1; contador <= qtdePessoas; contador++) {
            // entrada de dados
            System.out.println("Entrada número " + contador);
            System.out.println("Digite o nome e a idade:");
            nome  = new Scanner(System.in).nextLine();
            idade = new Scanner(System.in).nextInt();
 
            // preparação para o calculo da média
            somaIdades = somaIdades + idade;
 
            // seleção do nome e idade da pessoa mais velha
            if(idade > idadeMaisVelha) {
                idadeMaisVelha = idade;
                nomeMaisVelha  = nome;
            }
 
            // contagem da pessoas com idade de 18 a 60 anos
            if(idade >= 18 && idade <= 60)
                qtde18a60++;
        }
        // Exibição dos resultados
        System.out.println("Resultados: \n"
                + "Nome da pessoa mais velha: " + nomeMaisVelha
                + "\nMédia das idades: " + (double)somaIdades/qtdePessoas
                + "\nQtde de pessoas de 18 a 60 anos: " + qtde18a60);
    }
}

Primeiro exercício sobre vetores proposto no laboratório:

// solução da questão 3 da segunda prova, com a seguinte alteração:
// Exibe a quantidade de pessoas cuja idade é maior que a média 
import java.util.Scanner;
public class Principal {
    public static void main(String[] args) {
        int qtdePessoas, somaIdades = 0, idadeMaisVelha = 0, qtde18a60 = 0;
        String nome, nomeMaisVelha = "";
 
        // declaração do vetor 'idade' capaz de armazenar inteiros
        int[] idades;
 
        System.out.println("Entre com a quantidade de pessoas:");
        qtdePessoas = new Scanner(System.in).nextInt();
 
        // alocação de memória para o vetor 'idades'
        idades = new int[qtdePessoas];
 
        for(int contador = 0; contador < qtdePessoas; contador++) {
            // entrada de dados
            System.out.println("Entrada número " + (contador+1));
            System.out.println("Digite o nome e a idade:");
            nome  = new Scanner(System.in).nextLine();
            idades[contador] = new Scanner(System.in).nextInt();
 
            // preparação para o calculo da média
            somaIdades = somaIdades + idades[contador];
 
            // seleção do nome e idade da pessoa mais velha
            if(idades[contador] > idadeMaisVelha) {
                idadeMaisVelha = idades[contador];
                nomeMaisVelha  = nome;
            }
 
            // contagem da pessoas com idade de 18 a 60 anos
            if(idades[contador] >= 18 && idades[contador] <= 60)
                qtde18a60++;
        }
        // calcula a média
        double media = (double)somaIdades/qtdePessoas;
 
        // calcula quantidade de pessoas cuja idade é maior que a média
        int qtdeMaioresMedia = 0;
        for(int i = 0; i < qtdePessoas; i++) {
            if(idades[i] > media) {
                qtdeMaioresMedia++;
            }
        }
 
        // Exibição dos resultados
        System.out.println("Resultados: \n"
                + "Nome da pessoa mais velha: " + nomeMaisVelha
                + "\nMédia das idades: " + media
                + "\nQtde de pessoas de 18 a 60 anos: " + qtde18a60
                + "\nQtde de pessoas cuja idade é maior que a média: " + qtdeMaioresMedia);
    }
}

Segundo exercício sobre vetores proposto no laboratório:

// solução da questão 3 da segunda prova, com as seguintes alterações:
// Exibe a quantidade de pessoas cuja idade é maior que a média 
// Exibe a relação de pessoas cuja idade é maior do que a média. 
import java.util.Scanner;
public class Principal {
    public static void main(String[] args) {
        int qtdePessoas, somaIdades = 0, idadeMaisVelha = 0, qtde18a60 = 0;
        String nomeMaisVelha = "";
 
        // declaração do vetor 'idade' capaz de armazenar inteiros
        int[] idades;
        // delaração do vetor 'nome' capaz de armazenar Strings
        String[] nomes;
 
        System.out.println("Entre com a quantidade de pessoas:");
        qtdePessoas = new Scanner(System.in).nextInt();
 
        // alocação de memória para o vetor 'idades'
        idades = new int[qtdePessoas];
 
        // alocação de memória para o vetor 'nomes'
        nomes = new String[qtdePessoas];
 
        for(int contador = 0; contador < qtdePessoas; contador++) {
            // entrada de dados
            System.out.println("Entrada número " + (contador+1));
            System.out.println("Digite o nome e a idade:");
            nomes[contador]  = new Scanner(System.in).nextLine();
            idades[contador] = new Scanner(System.in).nextInt();
            // preparação para o calculo da média
            somaIdades = somaIdades + idades[contador];
            // seleção do nome e idade da pessoa mais velha
            if(idades[contador] > idadeMaisVelha) {
                idadeMaisVelha = idades[contador];
                nomeMaisVelha  = nomes[contador];
            }
            // contagem da pessoas com idade de 18 a 60 anos
            if(idades[contador] >= 18 && idades[contador] <= 60)
                qtde18a60++;
        }
        // calcula a média
        double media = (double)somaIdades/qtdePessoas;
        // calcula quantidade de pessoas cuja idade é maior que a média
        int qtdeMaioresMedia = 0;
        for(int i = 0; i < qtdePessoas; i++) {
            if(idades[i] > media) {
                qtdeMaioresMedia++;
            }
        }
        // Exibição dos resultados
        System.out.println("Resultados: \n"
                + "Nome da pessoa mais velha: " + nomeMaisVelha
                + "\nMédia das idades: " + media
                + "\nQtde de pessoas de 18 a 60 anos: " + qtde18a60
                + "\nQtde de pessoas cuja idade é maior que a média: " + qtdeMaioresMedia);
 
        // Exibe nomes das pessoas cuja idade é superior e média
        System.out.println("Pessoas cuja idade é maior que a média");
        for(int i = 0; i < qtdePessoas; i++) {
            if(idades[i] > media) {
                System.out.println(nomes[i]);
            }
        }
    }
}

Exercícios:

Para cada um dos itens escreva um programa em Java para solucionar o problema.

1. Leia um conjunto de 10 notas. Em seguida exiba todas que são maiores que a média do conjunto.

Resolução:

// Leia um conjunto de 10 notas.
// Exibe todas que são maiores do que média do conjunto.
public class Principal {
    public static void main(String[] args) {
       int contador = 0;
       // declaração do vetor ‘notas’ capaz de armazenar valores do tipo double
       double[] notas;
       // alocação de memória para o vetor ‘notas’: pode armazenar até 10 double
       notas = new double[10];
       double soma = 0;
       while(contador < 10) {           
           System.out.println("Entre com a nota "+(contador+1));
         // uso de um elemento do vetor ‘notas’ cuja posição é ‘contador’
           notas[contador] = new Scanner(System.in).nextDouble();
           soma = soma + notas[contador];
           contador = contador + 1;
       }
       double media = soma/contador;
       contador = 0;
       System.out.println("Notas maiores do que a média "+media);
       while(contador < 10) {
           if(notas[contador] >= media) {
               System.out.println(notas[contador]);
           }
           contador = contador + 1;
       }
    }
}

2. Leia um conjunto de notas, cuja quantidade seja determinada pelo usuário. Calcule a média de todas elas. Exiba o conjunto das notas maiores do que a média calculada. Em seguida, de forma agrupada, exiba o outro conjunto de notas (menores do que a média).

import java.util.*;
 
public class exercicio2 {
    // Uma simples variável para some de notas pode substituir esta procedure,
    // mas eu queria testar como funciona parametros de array em java =D
    public static double returnSum(double[] array) {
        double sum = 0;
        for (int i = 0; i < array.length; i++)
            sum += array[i];
        return sum;
    }
    public static void main(String[] args) {
        double[] notas;
        int    qt_notas, i;
        System.out.println("Informe a quantidade de notas:");
        qt_notas = new Scanner(System.in).nextInt();
        notas = new double[qt_notas];
        for (i = 0; i < qt_notas; i++) {
            System.out.println("Informe a " + (i + 1) + "ª nota:");
            notas[i] = new Scanner(System.in).nextDouble();
        }
        System.out.println("Média: " + returnSum(notas)/qt_notas + "\n\n" +
                           "Notas acima da média:");
        for (i = 0; i < qt_notas; i++) {
            if (notas[i] > (returnSum(notas)/qt_notas)) 
                System.out.println(notas[i]);
        }
        System.out.println("Notas abaixo da média:");
        for (i = 0; i < qt_notas; i++) {
            if (notas[i] < (returnSum(notas)/qt_notas)) 
                System.out.println(notas[i]);
        }    
    }
}
// por: Vitor Oliveira
 
Versão simples.
 
package exerVetores02;
import java.util.Scanner;
public class Principal {
    public static void main(String[] args) {
        // Um jeito mais tranqüilo.
        int quantNotas;
        double media, somaNotas = 0;
        double [] notas;
        System.out.println("Entre com a quantidade de Notas.");
        quantNotas = new Scanner(System.in).nextInt();
        notas = new double [quantNotas];
 
        for (int i = 0; i < quantNotas; i++){
            System.out.println("Entre com a nota de N°" +(i + 1));
            notas[i] = new Scanner(System.in).nextDouble();
            somaNotas = somaNotas + notas[i];            
        }
        media = somaNotas/quantNotas;
        System.out.println("Notas maiores que a média:" +media);
        for (int i = 0; i < quantNotas; i++){
            if (notas[i] > media){
                System.out.println(notas[i]);
            }
        }
        System.out.println("Agora as notas inferiores a média:" +media);
        for (int i = 0; i < quantNotas; i++){
            if (notas[i] < media){
                System.out.println(notas[i]);
            }
        }
    }
}
// Dorly Junior.

3. Leia um conjunto de alunos, cada uma com o nome e a nota. Em seguida exiba o nome dos alunos que possuem a nota maior do que a média da turma.

import java.util.*;
 
public class exercicio3 {
    // Classe avaliação com as procedures para definição de nome e nota
    public static class Avaliacao {
        double notaAvaliacao;
        String nomeAluno;
 
        void notaAvaliacao(double valor) {
            this.notaAvaliacao = valor;
        }
        void nomeAluno(String nome) {
            this.nomeAluno = nome;
        }
    }
 
    public static void main(String[] args) {
        // Declara lista de alunos, vetor dinâmico para armazenamento de objetos, 
        // Ex.: Avaliação declarada acima
        ArrayList ListaAlunos = new ArrayList();
        int continuar;
        double sumNotas = 0;
        // Declara classe avaliação como aluno
        Avaliacao aluno;
        do {
            // Cria objeto avaliação para cada aluno
            aluno = new Avaliacao();
            System.out.println("Informe o nome do aluno:");
            aluno.nomeAluno = new Scanner(System.in).nextLine();
            System.out.println("Informe a nota do aluno:");
            aluno.notaAvaliacao = new Scanner(System.in).nextDouble();
            sumNotas += aluno.notaAvaliacao;
            // Adiciona objeto ao vetor dinâmico
            ListaAlunos.add(aluno);
            System.out.println("Para terminar o cadastro de alunos digite 0, para continuar " +
                    "digite qualquer outro número maior > 0");
            continuar = new Scanner(System.in).nextInt();
        } while (continuar != 0);
 
        // Resgata objeto através do indice gerado pelo contador do loop
        for (int i = 0; i < ListaAlunos.size(); i++) {
            aluno = (Avaliacao)ListaAlunos.get(i);
            if (aluno.notaAvaliacao > sumNotas/ListaAlunos.size())
                System.out.println(aluno.nomeAluno);
        }
    }
}
// por: Vitor Oliveira
 
// Outra versão.
 
package exerVetores03;
import java.util.Scanner;
public class Principal {
    public static void main(String[] args) {
        int quantAlunos;
        double media, soma = 0;
        double [] notas;
        String [] nomes;
 
        System.out.println("Entre com a quantidade de alunos.");
        quantAlunos = new Scanner(System.in).nextInt();
        notas = new double [quantAlunos];
        nomes = new String [quantAlunos];
 
        for (int i = 0; i < quantAlunos; i++){
            System.out.println("Entre com o nome do Aluno e sua nota.");
            nomes[i] = new Scanner (System.in).nextLine();
            notas[i] = new Scanner(System.in).nextDouble();
            soma = soma + notas[i];
        }
        media = soma/quantAlunos;
 
        System.out.println("Os alunos com nota maior que a média:"+media+"são:");
        for (int i = 0; i < quantAlunos; i++){
            if (notas[i] > media){
                System.out.println(nomes[i]);
 
                }
            }
        }
    }
// Dorly Junior.

4. Leia um conjunto de salários. Leia também um valor de reajuste. Em seguida exiba todos os salários já reajustados.

package lista3;
import java.util.Scanner;
public class Principal {
    public static void main(String[] args) {
        int reajuste;  
        int salario[], salreaj[], quantsal;
        System.out.println("Qual vai ser a quantidade de salario que o Sr vai reajusta ");
        quantsal = new Scanner (System.in) .nextInt();
        salario = new int [quantsal];
        salreaj = new int [quantsal];
        for(int i=0 ; i < quantsal; i++){
            System.out.println("Entre com os salarios");
            salario [i] = new Scanner (System.in) .nextInt();
        }
        System.out.println("Entre com a taxa de reajuste");
        reajuste = new Scanner (System.in) .nextInt();
        for(int i=0; i <quantsal; i++){
            salreaj[i] = ((salario[i] * reajuste)/100) + salario[i]; 
            System.out.println("Os salarios reajustado é:" +salreaj[i]);
        }
 
    }
 
}
// por: Ricardo Emiliano

5. Leia um conjunto de valores inteiros e em seguida exiba-os na ordem inversa em que foram digitados.

package Exercicios;
 
import java.util.*;
 
public class Inteiros {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int inteiros[], qtde = 0;
        System.out.println("Entre com a quantidade de numeros:");
        qtde = new Scanner(System.in).nextInt();
        inteiros = new int [qtde]; 
        for (int i = 0; i < qtde; i++){
            System.out.println("Entrada numero: " + i);
            System.out.println("Entre com um numero inteiro:");
            inteiros[i] = new Scanner(System.in).nextInt();
        }
        for (int x = qtde; x > 0; x--){
            System.out.println("Entrada numero: " + x);
            System.out.println(inteiros[x-1]);
        }
 
    }
 
} //By Will

6. Crie um vetor capaz de armazenar 50 números inteiros. Em seguida faça o seu preenchimento automático com os números de 101 a 150, ou seja, na posição número 0 ponha 101, na posição 1 ponha o número 102, e assim sucessivamente.
Em seguida exiba os valores deste vetor.

package Exercicios;
 
public class Armazena50 {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int armazena[], valor = 101;
        String aux; //Padroniza a descrição do valor em 2 dígitos
        armazena = new int [50];
        System.out.println("Vetor criado...");
        System.out.println("Iniciando preenchimento...");
        for (int i = 0; i < 50; i++){
            armazena[i] = valor;
            valor++;
        }
        System.out.println("Preenchimento concluído!!!");
        System.out.println("Iniciando Exibição de Valores...");
        for (int x = 0; x < 50; x++){
            aux = "";
            if (x < 10)
                aux = "0";
            System.out.println("Valor " + aux + x + ": " + armazena[x]);
        }
 
    }
 
}
//By Will

7. Leia nomes de pessoas, sendo a quantidade determinada pelo usuário. Logo a seguir pergunte o número do nome que ele gostaria de consultar. Após sua resposta, exiba o nome que fica na posição informada.

package Exercicios;
import java.util.*;
public class Consulta {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int qtde = 0, pos = -1, continua = 1; //continua permite fazer várias consultas enquanto valor é 1
        String nomes[];
        System.out.println("Preparando para alimentar base de dados...");
        System.out.println("Entre com a quantidade de registros: ");
        qtde = new Scanner(System.in).nextInt();
        nomes = new String[qtde];
        for (int i = 0; i < qtde; i++){
            System.out.println("Entre com o nome do Reg. No.: " + i);
            nomes[i] = new Scanner(System.in).next();            
        }
        System.out.println("Base de dados concluída!");
        System.out.println("Entrando no modo de consulta...");
 
        while (continua == 1){
            pos = -1;
            while (pos < 0){
                System.out.println("Entre com a posição a ser consultada (Entre 0 e " + (qtde-1) + ") :");
                pos = new Scanner(System.in).nextInt();            
            }
            System.out.println("Resultado da Consulta: '" + nomes[pos] + "'");
            System.out.println("Para consultar novamente entre com 1.");
            continua = 0;
            continua = new Scanner(System.in).nextInt();
        }
    }
 
}
//Will
 
Outra Versão.
 
package exerVetores07;
import java.util.Scanner;
public class Principal {
    public static void main(String[] args) {
        // Um jeito mais simples.
        String [] nomes;
        int quantPessoas, nPessoa;
 
        System.out.println("Entre com a quantidade de pessoas.");
        quantPessoas = new Scanner(System.in).nextInt();
        nomes   = new String [quantPessoas];
 
        for (int i = 0; i < quantPessoas; i++){
            System.out.println("Entre com os nomes. Nome N°" +i);
            nomes[i] = new Scanner(System.in).nextLine();
        }
        System.out.println("Entre com o N° da pessoa que deseja consultar.");
        nPessoa = new Scanner(System.in).nextInt();
        System.out.println("O Nome da pessoa é:"+(nomes [nPessoa]));
    }
 
}
// Dorly Junior.

8. Leia nomes de pessoas com seus respectivos telefones, sendo a quantidade determinada pelo usuário. Em seguida pergunte ao usuário qual o nome que ele deseja consultar o telefone. Após sua resposta, exiba o telefone da pessoa procurada.

package Exercicios;
import java.util.*;
public class Agenda {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int qtde = 0, continua = 1;
        String nomes[], telefones[];
        String nome = "", fone = "";
        System.out.println("Preparando para alimentar base de dados...");
        System.out.println("Entre com a quantidade de registros: ");
        qtde = new Scanner(System.in).nextInt();
        nomes = new String[qtde];
        telefones = new String[qtde];
        for (int i = 0; i < qtde; i++){
            System.out.println("Entre com o nome e em seguida com o telefone do Reg. No.: " + i);
            nomes[i] = new Scanner(System.in).next();
            telefones[i] = new Scanner(System.in).next();
        }
        System.out.println("Base de dados concluída!");
        System.out.println("Entrando no modo de consulta...");
 
        while (continua == 1){
            fone = "não encontrado";
            System.out.println("Entre com o nome da pessoa a ser consultada: ");
            nome = new Scanner(System.in).next(); 
            for (int x = 0; x < qtde; x++){
                if (nomes[x].equalsIgnoreCase(nome)){
                    fone = telefones[x];
                }
            }
            System.out.println("Resultado da Consulta: '" + fone + "'");
            continua = 0;
            System.out.println("Para fazer uma nova consulta, entre com o valor 1:");
            continua = new Scanner(System.in).nextInt();
        }
        System.out.println("");
        System.out.println("Programa Finalizado!");
    }
 
}
//Will

9. Leia um conjunto de números. Exiba este conjunto acompanhado do seu elemento simétrico em relação a sua posição no conjunto. Veja o exemplo:
Entrada: 5, 7, 9, 2
Saída:
5 - 2
7 - 9
9 - 7
2 - 5

package Exercicios;
import java.util.*;
public class Simetria {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int qtde = 0, numeros[];
        String sequencia = "";
        System.out.println("Entre com a quantidade de numeros:");
        qtde = new Scanner(System.in).nextInt();
        numeros = new int [qtde];
        for (int i = 0; i < qtde; i++){
            System.out.println("Entre com o numero da posição: " + i);
            numeros[i] = new Scanner(System.in).nextInt();
            if (sequencia.length() > 0) sequencia = sequencia + ", ";
            sequencia = sequencia + numeros[i];
        }
 
        System.out.println("Sequência completa: " + sequencia);
        for (int x = 0; x < qtde; x++)
        System.out.println(numeros[x] + " - " + numeros[qtde-1-x]);
 
    }
 
}
//WILL

10. Leia dois conjuntos de números com a mesma quantidade. Exiba a intersecção dos conjuntos, ou seja, os números que são repetidos nos dois conjuntos.
package Exercicios;
import java.util.*;
public class Intercessao {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int qtde = 0;
        String conjuntoA[], conjuntoB[], aux = "Conjunto A", result = "";
        System.out.println("Intercessão entre dois conjuntos");
        System.out.println("Entre com a quantidade de elementos:");
        qtde = new Scanner(System.in).nextInt();
        conjuntoA = new String [qtde];
        conjuntoB = new String [qtde];
        for (int a = 0; a < qtde; a++){
            System.out.println(aux + " - Entre com o elemento: " + a);
            conjuntoA[a] = new Scanner(System.in).next();
        }
        aux = "Conjunto B";
        for (int b = 0; b < qtde; b++){
            System.out.println(aux + " - Entre com o elemento: " + b);
            conjuntoB[b] = new Scanner(System.in).next();
            for (int a = 0; a < qtde; a++){
                if (conjuntoA[a].equals(conjuntoB[b])){
                    if (result.length() > 0) result = result + ", ";
                    result = result + conjuntoB[b];
                }
            }
        }
        System.out.println("Coleta de dados concluída!");
        System.out.println("Intercessão entre A e B: " + result);
 
    }
 
}
//Will

11. Leia um conjunto de números. Exiba-os em ordem numérica crescente.
/* Ai Will, um dica: Quando for postar não apaga a linha "code type="Java" entre chaves e nem a "/code"
entre chaves. VLW!*/
package Exercicios;
import java.util.*;
public class OrdemNum {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int qtde = 0, numeros[], aux, concluido = 0;
        System.out.println("Entre com a quantidade de numeros a serem ordenados:");
        qtde = new Scanner(System.in).nextInt();
        numeros = new int [qtde];
        for (int i = 0; i < qtde; i++){
            System.out.println("Entre com o numero da posição " + i + ":");
            numeros[i] = new Scanner(System.in).nextInt();
        }
        Arrays.sort(numeros); //Ordenação Crescente
        System.out.println("Numeros ordenados:");
        for (int y = 0; y < qtde; y++){
            System.out.println(numeros[y]);
        }
 
    }
 
}
//Will

12. Leia um conjunto de nomes de pessoas. Exiba-os em ordem alfabética crescente.

package Exercicios;
import java.util.*;
 
public class OrdemAlfa {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int qtde = 0, concluido = 0;
        String nomes[], aux;
        System.out.println("Entre com a quantidade de nomes a serem ordenados:");
        qtde = new Scanner(System.in).nextInt();
        nomes = new String [qtde];
        for (int i = 0; i < qtde; i++){
            System.out.println("Entre com o nome da posição " + i + ":");
            nomes[i] = new Scanner(System.in).next();
        }
        Arrays.sort(nomes);
        System.out.println("Nomes ordenados:");
        for (int y = 0; y < qtde; y++){
            System.out.println(nomes[y]);
        }
 
    }
 
}
//Will
 
// Matheus, usando variável booleana...
 
package Exercício_12;
import java.util.Scanner;
public class Principal {
    public static void main(String[] args) {
        int qtdeNomes, contador=0;
        String aux;
        String[] nomes;
        System.out.println("Entre com a quantidade de pessoas");        
        qtdeNomes = new Scanner(System.in).nextInt();
        nomes = new String[qtdeNomes];
        while(contador<qtdeNomes){
            System.out.println("Entre com o "+(contador+1)+"º nome:");
            nomes[contador] = new Scanner(System.in).nextLine();
            contador++;
        }
        boolean troca = true;
        while(troca){
            troca = false;
            contador = 0;
            while(contador < (qtdeNomes-1)){
                int resultado = nomes[contador].compareToIgnoreCase(nomes[contador+1]);
                if(resultado >= 1){
                    aux = nomes[contador];
                    nomes[contador] = nomes[contador+1];
                    nomes[contador+1] = aux;
                    troca = true;
                }
                contador++;
            }
        }
        contador=0;
        while(contador<qtdeNomes){
            System.out.println(nomes[contador]);
            contador++;
        }
    }
}

13. Leia dois conjuntos de números (podem ter o tamanho diferente) já ordenados de forma crescente. Crie um outro vetor para armazenar os dois conjuntos unidos, sendo que os números devem permanecer ordenados.
Finalmente, exiba este vetor resultante.
// Matheus: nao entendi muito bem essa parte "já ordenados de forma crescente", por isso ficou um pouco grande, mas se alguem tiver feito de outra forma mais simples, por favor...
 
package Exercício_13;
import java.util.Scanner;
public class Principal {
    public static void main(String[] args) {
        int qtdeNumeros1, qtdeNumeros2,qtdeNumeros3, aux, contador=0;
        int[] numeros1, numeros2, numeros3;
        System.out.println("Entre com a quantidade de números do 1º conjunto:");        
        qtdeNumeros1 = new Scanner(System.in).nextInt();
        numeros1 = new int[qtdeNumeros1];
        while(contador<qtdeNumeros1){
            System.out.println("Entre com o "+(contador+1)+"º número:");
            numeros1[contador] = new Scanner(System.in).nextInt();
            contador++;
        }
        boolean troca = true;
        while(troca){
            troca = false;
            contador = 0;
            while(contador < (qtdeNumeros1-1)){
                if(numeros1[contador] > numeros1[contador+1]){
                    aux = numeros1[contador];
                    numeros1[contador] = numeros1[contador+1];
                    numeros1[contador+1] = aux;
                    troca = true;
                }
                contador++;
            }
        }
        contador=0;
        System.out.println("Entre com a quantidade de números do 2º conjunto:");        
        qtdeNumeros2 = new Scanner(System.in).nextInt();
        numeros2 = new int[qtdeNumeros2];
        while(contador<qtdeNumeros2){
            System.out.println("Entre com o "+(contador+1)+"º número:");
            numeros2[contador] = new Scanner(System.in).nextInt();
            contador++;
        }    
        boolean muda = true;
        while(muda){
            muda = false;
            contador = 0;
            while(contador < (qtdeNumeros2-1)){
                if(numeros2[contador] > numeros2[contador+1]){
                    aux = numeros2[contador];
                    numeros2[contador] = numeros2[contador+1];
                    numeros2[contador+1] = aux;
                    muda = true;
                }
                contador++;
            }
        }
        System.out.println("Os dois conjuntos ordenados de forma crescente separadamente");
        contador = 0;
        System.out.print("1º conjunto: ");
        while(contador<qtdeNumeros1){
            System.out.print(+numeros1[contador]+",");    
            contador++;
        }
        System.out.print("\n");
        contador = 0;
        System.out.print("2º conjunto: ");
        while(contador<qtdeNumeros2){
            System.out.print(+numeros2[contador]+",");    
            contador++;
        }
        System.out.println("\n");
        qtdeNumeros3 = qtdeNumeros1 + qtdeNumeros2;
        numeros3 = new int[qtdeNumeros3];
        int i = 0;
        contador = 0;
        while(contador < qtdeNumeros1){
            numeros3[i] = numeros1[contador];
            contador++;
            i++;
        }
        contador = 0;
        while(contador < qtdeNumeros2){
            numeros3[i] = numeros2[contador];
            contador++;
            i++;
        }
        boolean agrupa = true;
        while(agrupa){
            agrupa = false;
            i = 0;
            while(i < (qtdeNumeros3-1)){
                if(numeros3[i] > numeros3[i+1]){
                    aux = numeros3[i];
                    numeros3[i] = numeros3[i+1];
                    numeros3[i+1] = aux;
                    agrupa = true;
                }
                i++;
            }
        }
        i = 0;
        System.out.println("Os numeros dos dois conjuntos ordenados de forma crescente:");
        while(i < qtdeNumeros3){
            System.out.print(+numeros3[i]+",");    
            i++;
        }
    }
}
// Entrada:   1º - 6,4,5,7
//               2º -  3,1,2
//Saída:
//Os dois conjuntos ordenados de forma crescente separadamente
//1º conjunto: 4,5,6,7,
//2º conjunto: 1,2,3,
 
//Os numeros dos dois conjuntos ordenados de forma crescente:
//1,2,3,4,5,6,7, /
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License