Olá galera, preciso de ajuda para fazer um programinha que faça o seguinte:
1º Criar um array que guarde 50 combinações de 05 números gerados aleatoriamente, usando os números de 1 a 25, sem que a sequencia seja repetida, onde o usuário possa digitar os números que ele não quer que sejam usados…
2º criar uma array que guarde 50 combinações de 05 números, sendo que os números serão digitados pelo usuário, e um método que diga quantas vezes cada numero apareceu.
E o seguinte, no 1º exercício preciso guardar em um array 50 combinações de 05 números aleatorios, entre 1 a 25, sem que a sequencia seja repetida, onde o usuário possa digitar os números que ele não quer que sejam usados…
Já no segundo, as sequencias de números nao serão geradas aleatoriamente, mas sim, serao digitadas pelo usuário, e no final, que imprima quantas vezes cada numero apareceu.
Fiz o 1º exercício, mas tenho uma dúvida: quando o usuário digita os números, ele digita os que não podem ser utilizados na combinação, ou digita os números que não podem ser gerados aleatoriamente?
Existem basicamente duas maneiras de resolver.
A primeira é utilizando arrays e a segunda é utilizando Collections.
Fiz utilizando arrays. É um pouco mais demorado e o código fica maior, claro, mas funciona do mesmo jeito.
Mas minha solução foi a seguinte:
import java.util.Random;
public class Combinacoes {
public static void main(String[] args) {
Random r = new Random();
StringBuilder n = new StringBuilder();
int nums[] = new int[5];
int combinacoes[] = new int[50];
boolean c = true;
// populando o array com números aleatórios não repetidos
for (int i = 0; i < nums.length;) {
nums[i] = r.nextInt(25) + 1;
for (int j = 0; j < i; j++) {
if (nums[i] != nums[j]) {
c = true;
} else {
c = false;
break;
}
}
if (c)
i++;
}
System.out.println("Números gerados ");
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "\t");
}
// criando as combinações
for (int i = 0; i < combinacoes.length;) {
embaralhar(nums);
n.setLength(0);
for (int k : nums) {
n.append(k);
}
int num = Integer.parseInt(n.toString());
// adicionando e verificando as combinações
combinacoes[i] = num;
for (int j = 0; j < i; j++) {
if (combinacoes[i] != combinacoes[j]) {
c = true;
}else {
c = false;
break;
}
}
if(c)
i++;
}
System.out.println("\n\nCombinações ");
for (int i = 0; i < combinacoes.length; i++) {
if(i % 10 == 0 && i > 0)
System.out.println();
System.out.print(combinacoes[i] + "\t");
}
}
// método para embaralhar e de fato criar as combinações
public static void embaralhar(int[] x) {
Random r = new Random();
int aux;
for (int i = 0; i < x.length; i++) {
int pos = r.nextInt(x.length);
aux = x[i];
x[i] = x[pos];
x[pos] = aux;
}
}
}
Ele digita os números que não deverão ser usados no processo. Na verdade eu estou tentando aprender a programação em Java. E estou pouco familiarizado com a linguagem. E pra ser bem sincero, a lógica desses dois exercícios me confundiram muito.
Ah, entendi, você é iniciante na linguagem.
No código que postei, conseguiu entender mais ou menos o que fiz? Ficou com dúvida em qual parte? Posta aí que eu deixo melhor explicado.
bem, voce instanciou um objeto Ramdom “r”, criou um array nums de 5 posições e um array combinações de 50 posiçoes.
no 1º laço FOR voce percorre todo o array “nums” e faz com que a posição [i] seja preenchidas pelo proximo inteiro aleatorio gerado pelo metodo Random entre os numeros 1 a 25.
Nao entendi bem o 2º laço FOR, pois voce inicializa a variavel J, faz J < i (ai reside a duvida) , depois voce compara o numero colocado na posição[i] de nums com o da posição[j]. Nao entendi bem a logica dessa variavel do tipo boolean e porque a iteração do 1º FOR vem depois disso tudo e nao no corpo do proprio FOR.
Já a estrutura pra criar as combinações eu tambem nao compreendi. Fui até onde o básico me permitiu compreender
O laço inicializado com j, é o que verifica se não serão gerados números iguais. A variável do c, do tipo boolean é basicamente nosso controlador. Ela controla se foram ou não encontrados números iguais dentro do nosso array.
Só incrementamos i, se não forem encontrados números iguais, caso contrário, voltamos ao início desse laço.
Na verdade, quem cria a combinação é o método embaralhar. Ele que troca os números de posição.
Repare que estou gerando um número aleatório entre 0 e 4 para representar a posição que será trocada, uma vez que nosso array possui 5 posições.
Quando eu adiciono as combinações, tenho que ter certeza de que não serão adicionadas combinações iguais. Dessa forma, se já existe a combinação, eu não passo para a próxima posição, mas sim chamo o método embaralhar, para gerar novamente uma combinação. Se não existe aquela combinação, então eu a adiciono e passo para a próxima posição.
Dando uma olhada mais detidamente no código que gera os números, consegui compreender com clareza o que fez. Já em relação as combinações confesso que fiquei um tanto perdido. E tem uma coisa que acho que eu não expliquei direito. O sistema deve gerar 10 combinações de 6 números, devendo utilizar números de 1 a 25.
Eu peguei o que você fez fiz algo parecido. Veja :
public static void main(String[] args){
int num[]=new int[6];
int num2[]=new int[6];
Random r = new Random();//Criando vetor
boolean existe=false;
for(int i=0;i<num.length;i++){
int randomico = r.nextInt(25)+ 1;
for(int cont=0;cont<i;cont++){ //função que percorre o vetor até onde já tenha sido preenchido
if(num[cont]==randomico){ //verifica se o item no vetor é igual ao gerado
existe=true; //se é igual a variavel existe recebe verdadeiro
break; //e o laço de verificação é interrompido
}else{ //se não é igual
existe=false; //existe recebe falso
}
} //fim do laço que verifica a existencia
if(!existe){ //se existe é igual a false
num[i]=randomico; //o indice do vetor recebe o número gerado
}else{ //se é verdadeiro
i--; //o indice é decrementado para que haja um novo teste
}
} // fim do laço que percorre todo o vetor
for (int i=0; i<num.length;i++) {
System.out.print(num[i]+ "\t");
}
for (int i=0; i<num.length; i++){
int randomico2 = r.nextInt(25) + 1;
for(int j=0; j<num2.length; j++){ //função que percorre o vetor até onde já tenha sido preenchido
if(num2[j]==randomico2 && num2[j]==num[i]){
existe=true; //se é igual a variavel existe recebe verdadeiro
break; //e o laço de verificação é interrompido
}else{ //se não é igual
existe=false; //existe recebe falso
}
} //fim do laço que verifica a existencia
if(!existe){ //se existe é igual a false
num2[i]=randomico2; //o indice do vetor recebe o número gerado
}else{ //se é verdadeiro
i--; // o indice é decrementado para que haja um novo teste
}
}
for (int i=0; i<num2.length;i++) {
System.out.println(num2[i]+ "\t");
}
}
o problema é que tive que fazer um novo FOR para uma nova variável que armazenasse a segunda combinação, NUM2. ou seja, se eu quiser fazer mais combinações terei que criar mais variáveis e fazer vários outros FOR. Isso que acho que ta errado. Gostaria de tornar o trabalho menor e mais pratico
Nesse caso, pelo que li, deveria ser usado uma lista ao invés de array para armazenar os números gerados, sendo que a lista receberia 6 números por loop. Correto ?
Agora eu não sei como se faz ?