Arquivo Discussoes de Programacao e Tecnologia Boa Tarde, Galera!
Será que alguem pode me dar um help?
Tenho uma arraylist de inteiros, onde seto 10 valor e armazeno eles.
Como consigo verificar se existem algum par?
Por exemplo:
array.add(5);
array.add(5);
array.add(10);
array.add(5);
array.add(15);
quero que a saída seja falando que existe 1 par(sendo 5 e 5);
Valeus!
Boa tarde rapaz.
Sua questão é interessante. Tenta fazer assim… Cria uma lista secundária e dentro de um laço de repetição vai adicionando os valores de sua lista. Antes de adicionar faça uma verificação, se aquele valor já existe na sua lista, se sim, incrementa um contador e remove esse valor da lista, se não apenas adicione o valor.
A questão de remover o valor assim que detectar o par é para que caso exista um segundo par desse valor, seja possível achá-lo também. 
Ordene sua list e depois compare o valor com o próximo, assim você conseguirá saber se existe ou não valores iguais. (i == i+1)
Engraçado que a tendência é a gente ficar naquele pensamento dentro da caixa. A primeira coisa que me veio à cabeça foi entrar num for, comparando valor, incrementado e o paranauê todo. kkkk
Solução bem elegante e prática essa!!!
Valeu por abrir minha mente.
Opa valeu irmão estou junto com o Rodrigo eu fiz um for e fui incrementando, mas ta rolando algo que não estou vendo pq não tras as informações que preciso, mas irei testar sua ideia.
Valeu!
Só tome cuidado na hora de realizar a comparação, pois por utilizar o i+1, pode ser que estoure a list, então o seu for deve ser i<list.length e não <=.
Cara, lendo isso:
Pensei: pega o valor da iésima posição e divide por 2, se o resto for zero, é par.
Porém, só lendo as respostas é que entendi que o tal “par” é a combinação de dois valores iguais em posições distintas.
A pergunta que não quer calar é: o que você está estudando? Especificamente, sobre o quê é este exercício?
Explico: existe mais de uma forma de obter esta resposta, por isso preciso entender exatamente o cenário.
O exercicio é tenho uma caixa cheio de luvas, mas só podem sair da caixa pares do mesmo tamanho.
desenvolva um algortimo que receba a quantidade de luvas e o tamanho a quantidade maximo de pares.
Formato de entrada
condições
1 <= n <= 100
1 <= ci <= 100
exemplo de entrada
9 - quantidade
10 20 20 10 10 30 50 10 20 - tamanhos
exemplo de resposta
3 - pares sendo ele (10 e 10; 20 e 20; 10 e 10)
Deu para entender? é trabalho da Facul!
Agora ficou mais fácil.
Porém, você está estudando estrutura de repetição (for/while/do-while)? Ou está vendo a classe Array?
public class Logica {
private int quantidadeLuvas = 0;
private ArrayList<Integer> tamanhos = new ArrayList<Integer>();
private int flag = 0;
private int y = 0;
public int getQuantidadeLuvas() {
return quantidadeLuvas;
}
public int insereQuantidade () {
do {
Scanner scan = new Scanner(System.in);
System.out.println("Entre com uma quantidade de luvas na caixa");
try {
quantidadeLuvas = scan.nextInt();
if(quantidadeLuvas < 1 || quantidadeLuvas > 100) {
System.out.println("Quantidade invalida entre com um valor de 1 a 100");
}
} catch(InputMismatchException e) {
System.out.println("Digite apenas numeros");
}
} while(quantidadeLuvas < 1 || quantidadeLuvas > 100);
return quantidadeLuvas;
}
public List<Integer> insereTamanho() {
do {
Scanner scanner = new Scanner(System.in);
System.out.println("Entre com os Tamanhos");
try {
y = scanner.nextInt();
if(y < 1 || y > 100) {
System.out.println("Tamanhos invalido entre com um tamanho de 1 a 100");
} else {
tamanhos.add(y);
flag++;
}
} catch(InputMismatchException e) {
System.out.println("Digite apenas numeros");
}
} while(flag < quantidadeLuvas);
return tamanhos;
}
}
Isso foi oq fiz, mas to travado aqui é um desafio não importa como eu faço!
Vc poderia usar um Map<Integer, Integer> ou um List<int[]>.
Seria melhor criar uma classe e usar um List<Luvas> ou Map<int,Luvas> assim:
class Luvas {
int tamanho;
int qtd;
public void adicionar() {
qtd++;
}
public int qtdDePares() {
return qtd / 2;
}
}
public void adicionarTamanho(int t) {
Luvas luvas = buscarLuvas(t);
if (luvas == null) {
luvas = new Luvas();
luvas.atribuirTamanho(t);
listaDeLuvas.add(luva);
}
luva.adicionar();
}
Minha solução.
import java.util.ArrayList;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
public class Logica {
private int quantidade = 0;
private int flag = 0;
private ArrayList<Integer> tamanho = new ArrayList<Integer>();
private int y = 0;
private int pares = 0;
public int getQuantidade() {
return quantidade;
}
public int inserirQuantidade() {
do {
Scanner scan = new Scanner(System.in);
try {
System.out.println("Entre com uma quantidade");
quantidade = scan.nextInt();
if(quantidade <1 || quantidade > 100) {
System.out.println("Quantidade invalida entre com uma quantidade de 1 a 100");
}
} catch(InputMismatchException e) {
System.out.println("Digite apenas numeros");
}
} while(quantidade <1 || quantidade >100);
return quantidade;
}
public List<Integer> inserirTamanho() {
do {
Scanner scan = new Scanner(System.in);
System.out.println("Digite um tamanho");
try {
y = scan.nextInt();
if(y < 1 || y > 100) {
System.out.println("Numero invalido entre com um numero de 1 a 100");
}else {
tamanho.add(y);
flag++;
}
} catch(InputMismatchException e) {
System.out.println("Digite apenas numeros");
}
} while(flag < quantidade);
return tamanho;
}
public List<Integer> mostraPares() {
Map<Integer, Integer> pairs = new HashMap<Integer, Integer>();
for(int i=0;i<tamanho.size();i++) {
if (!pairs.containsKey(tamanho.get(i))) {
pairs.put(tamanho.get(i), 1);
} else {
int total = pairs.get(tamanho.get(i));
pairs.put(tamanho.get(i), ++total);
}
}
for (Map.Entry<Integer, Integer> item : pairs.entrySet()) {
if (item.getValue() > 1) {
pares += (int) item.getValue() / 2;
}
}
return tamanho;
}
public List<Integer> mostraLista() {
for(int i=0;i<tamanho.size();i++) {
System.out.print(tamanho.get(i) + " ");
}
return tamanho;
}
public int getPares() {
return pares;
}
}
Talvez até tenha dado algumas voltas mas funcionou rsrs
Lembrando que existem N soluções para um mesmo problema, algumas mais fáceis, mais trabalhosas.
Mas o mais importante é que funcione. Só lembre que pode ser que não você a dar continuidade no trabalho para sempre, então procure aquela que você entenda e que o “talvezpróximo” possa entender com facilidade também.
Coloca como resolvido 