J'utilise actuellement Java's RNG Random R = Nouveau Random () Code>, et le permet de générer un nouvel entiers entre 0 et 5 dans une boucle de temps. while (someBoolean == false) {
int i = r.nextInt(6);
if (i == removedInt) { continue; }
....
}
4 Réponses :
Bien que vous puissiez utiliser une liste si vous souhaitez générer des numéros aléatoires dans la plage de Si vous souhaitez exprimer un numéro, par exemple Il ressemble à ceci: p> code> énumérer les chiffres que vous souhaitez générer et exclure / supprimer celui que vous souhaitez exclure, ce n'est que efficace pour les petites gammes. Si vous souhaitez générer un nombre aléatoire dans une large gamme, cette solution devient tout à fait inefficace em> et sans faille em>. solution à l'aide de 1
aléatoire.nextint () code> appel h2> 0..5 code> inclusif, vous pouvez le faire avec r.nexint (6 ) code>. p> 4 code>, cela signifie que la plage est plus petite par 1, utilisez donc r.nextint (5) code> et si le résultat est le numéro exclu, puis renvoie le maximum autorisé qui est 5 code> (car il ne sera jamais généré parce que vous avez utilisé max-1). P> /**
* Returns a random number in the range min..max both included, but never the excluded.
*/
public int nextRand(int min, int max, int excluded) {
if (max <= min || excluded < min || excluded > max)
throw new IllegalArgumentException(
"Must be: min <= excluded <= max AND min < max");
int i = min + r.nextInt(max - min); // r is a java.util.Random instance
return i == excluded ? max : i;
}
Et que se passe-t-il lorsque le nombre d'exclusion est-il au milieu de la gamme? C'est-à-dire 2 ou 3
@CHANCEA Pourquoi importerait-il quel numéro vous voulez exclure? Vous voulez des sorties de 1 moins possibles. Donc, vous générez des nombres jusqu'à max-1. Et si le résultat est le numéro que vous souhaitez exclure, vous retournez celui qui n'est pas généré en raison du MAX-1 est utilisé.
@CHANCEA Je pense que vous avez mal compris ou je n'ai pas compris l'intention de passer max-1 à Nextint () . Ce n'est pas pour que le nombre maximum ne puisse jamais être généré; C'est afin que le nombre de sorties possibles soit inférieur à 1. Le nombre exclu est vérifié dans une étape ultérieure.
Cela fonctionne pour une seule valeur, mais elle ne donne pas une distribution normalisée, car il existe un 2 / (max-min) (double) chance que max sera renvoyé par rapport aux autres valeurs. Cependant, l'OP veut plusieurs chiffres dans l'exclusion.
@CHANCEA L'OP veut exclure 1 nombre, je ne vois pas plusieurs numéros mentionnés nulle part. Et max ne sera renvoyé qu'avec la même probabilité que tout autre numéros de la plage min.. / code> (à l'exception de exclu qui sera ne jamais être retourné). Veuillez noter que si vous voulez un nombre aléatoire entre min..max , vous devez appeler Nextint (max - min + 1) , Notez le +1 En attendant, j'appelle Nextint (max - min) Il n'y a pas +1.
Op: " Le nombre qui est renvoyé est une colonne dans une grille Connect4 ou une matrice 2D INT. La méthode placant aléatoirement des mouvements dans les colonnes jusqu'à ce qu'une colonne se remplisse, à quel point je ne veux plus être capable de Jouez dans cette colonne "
On dirait que vous êtes correct sur la distribution, je l'ai mal interprété
@chancea S'il vous plaît voir Cette réponse pour clarifier que tous les numéros de cette gamme auront la même chance.
@CHANCEA Aussi à propos de seulement 1 numéro à exclure: votre devis utilise singular pas pluriel : "Le numéro que est Être retourné est une colonne dans une grille Connect4 "
Si vous pensez à la déclaration de l'OP. Une fois qu'une colonne est remplie dans la grille, ils ne veulent plus que le générateur aléatoire puisse sélectionner cette colonne. Cependant plus d'une colonne peut être rempli dans la grille, c'est Connect4
Ceci est une solution fine pour une seule valeur. La distribution est bonne et je pense que cette réponse peut aider les autres dans similaires Bateaux comme op. J'étais incorrect auparavant, pour lequel je m'excuse.
ArrayList<Integer> myInts = new ArrayList<Integer>(); myInts.add(1); myInts.add(2); myInts.add(3); myInts.add(4); int i = myInts.get(r.nextInt(myInts.size())); // 1,2,3,4 myInts.remove(3); int j = myInts.get(r.nextInt(myInts.size())); // 1,2,4 The code selects random entry from allowed list of integers.PS Please note, that if you have a big range of numbers, then creating an ArrayList of thousands upon thousands of integers might not be the best idea.
Cela semble répondre à ma question meilleure. Merci!
Si vous souhaitez modifier les conventions de nommage, je vais "accepter" la réponse (afin que d'autres puissent voir aussi) ajouter et supprimer doivent être minuscules, int devrait être entier et . getLength () devrait être .Size () :)
Changé :) C'est incroyable à quelle vitesse vous pouvez oublier des choses lors de la commutation entre les langues :)
Cette solution n'est valable que pour les petites gammes. Une autre solution est requise pour les grandes gammes. Quoi qu'il en soit, par votre exemple, vous souhaitez appliquer cela aux dés afin de résoudre votre problème.
Assez plausible. C'est assez lisible et dans ce cas spécifique ne devrait pas ajouter beaucoup de frais généraux ni rien. C'est certainement plus brut que la solution basée sur les mathématiques, mais beaucoup plus facile de déboguer et de maintenir :) Je vais ajouter un commentaire cependant.
J'espère que cela vous aide avec votre situation. Il n'exclut pas vraiment aucun chiffre mais à la place de faire une décision sur quel endroit pour effectuer un déplacement dans la base d'une valeur initiale donnée à partir d'un nombre aléatoire.
//Change these to what you want
int numberColumns = 7;
int numberRows = 6;
/**
* A way for my snippet to determine what column has a piece in its very top spot.
*/
boolean[][] hasPiece = new boolean[numberRows][numberColumns];
/**
* Get a random number between 0 and numberColumns - 1 and set it equal
* to the column you want the computer to place it in.
*/
int columnToPlace = (int) (0 +Math.random()*numberColumns);
/**
* A boolean check to determine what side of the chosen column to check first.
* This way it doesn't always check to the left or right first.
*/
if(Math.random() < 0.5){
//Forwards for loop to start at the initial random number given.
for(int runner = columnToPlace; runner < numberColumns; runner++){
if(!hasPiece[0][runner]){/**Check First Row And Next Column To The Right For A Piece.*/
columnToPlace = runner;/**If there is no piece their set it equal to that number/empty column.*/
break;/**Break out of the loop*/
}
}
}else{
//Reversed for loop to start at the initial random number given.
for(int backwardsRunner = columnToPlace; backwardsRunner > 0; backwardsRunner--){
if(!hasPiece[0][backwardsRunner]){/**Check First Row And Next Column To The Left For A Piece.*/
columnToPlace = backwardsRunner;/**If there is no piece their set it equal to that number/empty column.*/
break;/**Break out of the loop*/
}
}
}
//The final number/empty column the computer will make it's move in.
System.out.println(columnToPlace);
Votre cerveau est fixé sur l'idée que les chiffres hors aléatoire () doivent être les mêmes numéros que vous utilisez réellement pour les lignes ou quoi que ce soit. Séparez la simple ordinale de ce qu'elle représente en utilisant un petit tableau: dans le ... Vous retirez et ajoutez des colonnes au besoin.
Voulez-vous supprimer un seul int? Que se passe-t-il si vous génèverez cinq chiffres, ils doivent-ils tous être différents?
Pensez à utiliser une liste
. Générer un nombre aléatoire entre 0 et la taille() - 1 de la liste, supprimez cet élément.Cette question pourrait être utile
Connexes: Stackoverflow.com/questions/14935997/ ...
int i = r.nexint (5); Si (i> = 4) i ++;Oui, @ njzk2 a la bonne réponse.
BTW, vous pouvez écrire en toute sécurité
tandis que (! Quelqueboolan) {