Arquivo Discussoes de Programacao e Tecnologia 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.
Alguem poderia me ajudar ?
No 1º exercício, você quer gerar 5 números aleatórios entre 1 e 25 e criar 50 combinações sem repetições com esses 5 números?
Por exemplo:
1 2 3 4 5
2 5 3 4 1
5 1 2 3 4
…
É isso?
exatamente
No segundo eu quero poder dizer quais números não poderão ser usados e saber quantas vezes cada numero apareceu.
Desculpa, acabei me atrapalhando.
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;
}
}
}
Saída da execução:
Números gerados
12 6 19 7 24
Combinações
67241219 19247612 24671219 61219247 19127624 19762412 12247619 12196724 19672412 71924612
71912246 71224196 12241967 71962412 12672419 72412196 61272419 76192412 61924127 72461912
24191276 67121924 24719612 12671924 62419127 24612719 71261924 19612247 12247196 62419712
19761224 62412197 24126719 12196247 71219246 76241219 61224197 24127196 12192467 71912624
71219624 19127246 12719624 71262419 12719246 24761912 67241912 19624712 72419126 62471219
Quanto ao 2º exercício, ele é um tanto fácil. Tem certeza de que não consegue faze-lo? Está com dúvida em qual parte?
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
E muito menos a logica do metodo embaralhar.
Não conheço muito por isso fiquei meio perdido.
Tentei fazer algo usando Collections, veja <img src="//https://cdn.jsdelivr.net/gh/twitter/twemoji@14/assets/72x72/s.pnglight_smile.png?v=5" title=":slight_smile:" class="emoji" alt=":slight_smile:">`public static void main(String[] args) {
}
public int sorteia(){
List lista = new ArrayList () ;
for ( int i = 1 ; i <= 25 ; i++ ){
lista.add ( new Integer ( i )) ;
}
Collections.shuffle(lista) ;
return (( Integer ) lista.get (0)) .intValue () ;
O problema é que não sei como usar o System.Out.Print para imprimir o resultado da lista na tela. `
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 ?