ฉันพยายามหาตัวเลขสุ่มระหว่าง 0 ถึง 100 แต่ฉันต้องการให้ตัวเลขไม่ซ้ำกันไม่ซ้ำกันในลำดับ ตัวอย่างเช่นถ้าฉันได้ 5 ตัวเลขควรเป็น 82,12,53,64,32 ไม่ใช่ 82,12,53,12,32 ที่ฉันใช้ แต่มันสร้างตัวเลขเดียวกันในลำดับ
Random rand = new Random();
selected = rand.nextInt(100);
คำตอบ:
นี่คือการใช้งานง่ายๆ สิ่งนี้จะพิมพ์ตัวเลขสุ่มที่ไม่ซ้ำกัน 3 หมายเลขจากช่วง 1-10
import java.util.ArrayList;
import java.util.Collections;
public class UniqueRandomNumbers {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i=1; i<11; i++) {
list.add(new Integer(i));
}
Collections.shuffle(list);
for (int i=0; i<3; i++) {
System.out.println(list.get(i));
}
}
}
ส่วนแรกของการแก้ไขด้วยแนวทางดั้งเดิมตามที่ Mark Byers ได้ชี้ให้เห็นในคำตอบที่ถูกลบไปแล้วคือการใช้เพียงRandomอินสแตนซ์ เดียว
นั่นคือสิ่งที่ทำให้ตัวเลขไม่เหมือนกัน Randomเช่นเป็นเมล็ดที่โดยเวลาปัจจุบันในหน่วยมิลลิวินาที สำหรับค่าเมล็ดพันธุ์ที่เฉพาะเจาะจงอินสแตนซ์ 'สุ่ม' จะส่งกลับลำดับเดียวกันทั้งหมดของตัวเลขสุ่มหลอก
โปรดทราบว่าตัว
public Integer(int value)สร้างนั้นdeprecatedมาจาก Java 9
ครั้งแรกสำหรับลูปสามารถเปลี่ยนเป็น:
for (int i = 1; i < 11; i++) {
list.add(i);
}
ด้วย Java 8+ คุณสามารถใช้intsวิธีRandomการรับIntStreamค่าสุ่มจากนั้นdistinctและlimitเพื่อลดสตรีมเป็นค่าสุ่มที่ไม่ซ้ำกัน
ThreadLocalRandom.current().ints(0, 100).distinct().limit(5).forEach(System.out::println);
Randomนอกจากนี้ยังมีวิธีการที่สร้างLongStreams และDoubleStreams หากคุณต้องการแทน
หากคุณต้องการตัวเลขทั้งหมด (หรือจำนวนมาก) ในช่วงในลำดับแบบสุ่มอาจมีประสิทธิภาพมากกว่าในการเพิ่มตัวเลขทั้งหมดลงในรายการสับเปลี่ยนและใช้ n ตัวแรกเนื่องจากตัวอย่างด้านบนถูกนำไปใช้ในปัจจุบัน โดยการสร้างตัวเลขสุ่มในช่วงที่ร้องขอและส่งผ่านชุด (เช่นเดียวกับคำตอบของ Rob Kielty ) ซึ่งอาจต้องสร้างจำนวนมากกว่าจำนวนที่ส่งผ่านเพื่อ จำกัด เนื่องจากความน่าจะเป็นของการสร้างจำนวนเฉพาะใหม่จะลดลงเมื่อพบแต่ละครั้ง นี่คือตัวอย่างของวิธีอื่น:
List<Integer> range = IntStream.range(0, 100).boxed()
.collect(Collectors.toCollection(ArrayList::new));
Collections.shuffle(range);
range.subList(0, 99).forEach(System.out::println);
Arrays#setAll()เร็วกว่าสตรีมเล็กน้อย ดังนั้น: `Integer [] indices = new Integer [n]; Arrays.setAll (ดัชนี, i -> i); Collections.shuffle (Arrays.asList (ดัชนี)); ส่งคืน Arrays.stream (ดัชนี) .mapToInt (Integer :: intValue) .toArray (); `
longที่คุณเลื่อนและมาสก์เพื่อเข้าถึงแต่ละบิต)HashSetซึ่งเก็บตัวเลขที่คุณสร้างไว้แล้วและใช้containsเพื่อทดสอบว่าคุณได้สร้างตัวเลขนั้นแล้วหรือไม่ HashSetอาจจะช้ากว่าอาร์เรย์แบบบูเล็กน้อย แต่ใช้หน่วยความจำน้อย
ฉันรู้สึกว่าวิธีนี้คุ้มค่าที่จะกล่าวถึง
private static final Random RANDOM = new Random();
/**
* Pick n numbers between 0 (inclusive) and k (inclusive)
* While there are very deterministic ways to do this,
* for large k and small n, this could be easier than creating
* an large array and sorting, i.e. k = 10,000
*/
public Set<Integer> pickRandom(int n, int k) {
final Set<Integer> picked = new HashSet<>();
while (picked.size() < n) {
picked.add(RANDOM.nextInt(k + 1));
}
return picked;
}
ฉันสรุปคำตอบของ Anand อีกครั้งเพื่อใช้ประโยชน์ไม่เพียง แต่คุณสมบัติเฉพาะของชุด แต่ยังใช้บูลีนเท็จที่ส่งคืนset.add()เมื่อการเพิ่มลงในชุดล้มเหลว
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
public class randomUniqueNumberGenerator {
public static final int SET_SIZE_REQUIRED = 10;
public static final int NUMBER_RANGE = 100;
public static void main(String[] args) {
Random random = new Random();
Set set = new HashSet<Integer>(SET_SIZE_REQUIRED);
while(set.size()< SET_SIZE_REQUIRED) {
while (set.add(random.nextInt(NUMBER_RANGE)) != true)
;
}
assert set.size() == SET_SIZE_REQUIRED;
System.out.println(set);
}
}
SET_SIZE_REQUIREDใหญ่พอ (สมมติว่ายิ่งไปกว่าNUMBER_RANGE / 2นั้นคุณมีเวลาทำงานที่คาดหวังมากขึ้นมาก
ฉันทำแบบนี้แล้ว
Random random = new Random();
ArrayList<Integer> arrayList = new ArrayList<Integer>();
while (arrayList.size() < 6) { // how many numbers u need - it will 6
int a = random.nextInt(49)+1; // this will give numbers between 1 and 50.
if (!arrayList.contains(a)) {
arrayList.add(a);
}
}
สิ่งนี้จะทำงานเพื่อสร้างตัวเลขสุ่มที่ไม่ซ้ำกัน ................
import java.util.HashSet;
import java.util.Random;
public class RandomExample {
public static void main(String[] args) {
Random rand = new Random();
int e;
int i;
int g = 10;
HashSet<Integer> randomNumbers = new HashSet<Integer>();
for (i = 0; i < g; i++) {
e = rand.nextInt(20);
randomNumbers.add(e);
if (randomNumbers.size() <= 10) {
if (randomNumbers.size() == 10) {
g = 10;
}
g++;
randomNumbers.add(e);
}
}
System.out.println("Ten Unique random numbers from 1 to 20 are : " + randomNumbers);
}
}
วิธีหนึ่งที่ชาญฉลาดในการทำเช่นนี้คือการใช้เลขชี้กำลังขององค์ประกอบดั้งเดิมในโมดูลัส
ตัวอย่างเช่น 2 คือม็อดรูทดั้งเดิม 101 ซึ่งหมายความว่าพลังของ 2 mod 101 ให้ลำดับที่ไม่ซ้ำซึ่งจะเห็นทุก ๆ ตัวเลขตั้งแต่ 1 ถึง 100
2^0 mod 101 = 1
2^1 mod 101 = 2
2^2 mod 101 = 4
...
2^50 mod 101 = 100
2^51 mod 101 = 99
2^52 mod 101 = 97
...
2^100 mod 101 = 1
ในโค้ด Java คุณจะต้องเขียน:
void randInts() {
int num=1;
for (int ii=0; ii<101; ii++) {
System.out.println(num);
num= (num*2) % 101;
}
}
การหารากดั้งเดิมสำหรับโมดูลัสที่เฉพาะเจาะจงอาจเป็นเรื่องยุ่งยาก แต่ฟังก์ชัน "primroot" ของ Maple จะช่วยคุณได้
ฉันมาที่นี่จากคำถามอื่นซึ่งซ้ำกับคำถามนี้ (การสร้างหมายเลขสุ่มที่ไม่ซ้ำกันใน java )
จัดเก็บตัวเลข 1 ถึง 100 ในอาร์เรย์
สร้างตัวเลขสุ่มระหว่าง 1 ถึง 100 เป็นตำแหน่งและส่งกลับอาร์เรย์ [ตำแหน่ง -1] เพื่อรับค่า
เมื่อคุณใช้ตัวเลขในอาร์เรย์ให้ทำเครื่องหมายค่าเป็น -1 (ไม่จำเป็นต้องดูแลอาร์เรย์อื่นเพื่อตรวจสอบว่ามีการใช้หมายเลขนี้แล้วหรือไม่)
หากค่าในอาร์เรย์เป็น -1 ให้รับหมายเลขสุ่มอีกครั้งเพื่อดึงตำแหน่งใหม่ในอาร์เรย์
ฉันมีวิธีง่ายๆสำหรับปัญหานี้ด้วยเหตุนี้เราจึงสามารถสร้างตัวเลขสุ่มที่ไม่ซ้ำกัน n จำนวนได้อย่างง่ายดายตรรกะเดียวที่ทุกคนสามารถใช้ในภาษาใดก็ได้
for(int i=0;i<4;i++)
{
rn[i]= GenerateRandomNumber();
for (int j=0;j<i;j++)
{
if (rn[i] == rn[j])
{
i--;
}
}
}
break;หลังจากi—;
แม้ว่าจะเป็นกระทู้เก่า แต่การเพิ่มตัวเลือกอื่นอาจไม่เป็นอันตราย (ฟังก์ชั่นแลมบ์ดา JDK 1.8 ดูเหมือนจะทำให้ง่าย);
ปัญหาอาจแบ่งออกเป็นขั้นตอนต่อไปนี้
นี่คือฟังก์ชั่นพร้อมคำอธิบาย:
/**
* Provided an unsequenced / sequenced list of integers, the function returns unique random IDs as defined by the parameter
* @param numberToGenerate
* @param idList
* @return List of unique random integer values from the provided list
*/
private List<Integer> getUniqueRandomInts(List<Integer> idList, Integer numberToGenerate) {
List<Integer> generatedUniqueIds = new ArrayList<>();
Integer minId = idList.stream().mapToInt (v->v).min().orElseThrow(NoSuchElementException::new);
Integer maxId = idList.stream().mapToInt (v->v).max().orElseThrow(NoSuchElementException::new);
ThreadLocalRandom.current().ints(minId,maxId)
.filter(e->idList.contains(e))
.distinct()
.limit(numberToGenerate)
.forEach(generatedUniqueIds:: add);
return generatedUniqueIds;
}
ดังนั้นเพื่อให้ได้ตัวเลขสุ่มที่ไม่ซ้ำกัน 11 หมายเลขสำหรับวัตถุรายการ 'allIntegers' เราจะเรียกฟังก์ชันเช่น;
List<Integer> ids = getUniqueRandomInts(allIntegers,11);
ฟังก์ชันจะประกาศ arrayList ใหม่ 'createdUniqueIds' และเติมข้อมูลด้วยจำนวนเต็มสุ่มที่ไม่ซ้ำกันจนถึงจำนวนที่ต้องการก่อนส่งคืน
คลาส PS ThreadLocalRandom หลีกเลี่ยงค่า seed ทั่วไปในกรณีที่มีเธรดพร้อมกัน
ลองดูสิ
public class RandomValueGenerator {
/**
*
*/
private volatile List<Double> previousGenValues = new ArrayList<Double>();
public void init() {
previousGenValues.add(Double.valueOf(0));
}
public String getNextValue() {
Random random = new Random();
double nextValue=0;
while(previousGenValues.contains(Double.valueOf(nextValue))) {
nextValue = random.nextDouble();
}
previousGenValues.add(Double.valueOf(nextValue));
return String.valueOf(nextValue);
}
}
สิ่งนี้ไม่แตกต่างจากคำตอบอื่น ๆ อย่างมีนัยสำคัญ แต่ฉันต้องการอาร์เรย์ของจำนวนเต็มในตอนท้าย:
Integer[] indices = new Integer[n];
Arrays.setAll(indices, i -> i);
Collections.shuffle(Arrays.asList(indices));
return Arrays.stream(indices).mapToInt(Integer::intValue).toArray();
คุณสามารถใช้อาร์เรย์บูลีนเพื่อเติมค่า true if value taken else set นำทางผ่านอาร์เรย์บูลีนเพื่อรับค่าตามที่ระบุด้านล่าง
package study;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/*
Created By Sachin Rane on Jul 18, 2018
*/
public class UniqueRandomNumber {
static Boolean[] boolArray;
public static void main(String s[]){
List<Integer> integers = new ArrayList<>();
for (int i = 0; i < 10; i++) {
integers.add(i);
}
//get unique random numbers
boolArray = new Boolean[integers.size()+1];
Arrays.fill(boolArray, false);
for (int i = 0; i < 10; i++) {
System.out.print(getUniqueRandomNumber(integers) + " ");
}
}
private static int getUniqueRandomNumber(List<Integer> integers) {
int randNum =(int) (Math.random()*integers.size());
if(boolArray[randNum]){
while(boolArray[randNum]){
randNum++;
if(randNum>boolArray.length){
randNum=0;
}
}
boolArray[randNum]=true;
return randNum;
}else {
boolArray[randNum]=true;
return randNum;
}
}
}
เลือก n ตัวเลขสุ่มที่ไม่ซ้ำกันตั้งแต่ 0 ถึง m-1
int[] uniqueRand(int n, int m){
Random rand = new Random();
int[] r = new int[n];
int[] result = new int[n];
for(int i = 0; i < n; i++){
r[i] = rand.nextInt(m-i);
result[i] = r[i];
for(int j = i-1; j >= 0; j--){
if(result[i] >= r[j])
result[i]++;
}
}
return result;
}
ลองนึกภาพรายการที่มีตัวเลขตั้งแต่ 0 ถึงม -1 rand.nextInt(m)เพื่อเลือกหมายเลขแรกเราก็ใช้ จากนั้นลบหมายเลขออกจากรายการ ตอนนี้ยังมีเลข m-1 อยู่เราเลยโทรrand.nextInt(m-1). ตัวเลขที่เราได้รับแสดงถึงตำแหน่งในรายการ หากมีค่าน้อยกว่าหมายเลขแรกแสดงว่าเป็นหมายเลขที่สองเนื่องจากส่วนของรายการก่อนหมายเลขแรกไม่ได้เปลี่ยนแปลงโดยการนำหมายเลขแรกออก ถ้าตำแหน่งมากกว่าหรือเท่ากับตัวเลขแรกตัวเลขที่สองคือตำแหน่ง + 1 หาข้อมูลเพิ่มเติมคุณจะได้รับอัลกอริทึมนี้
อัลกอริทึมนี้มีความซับซ้อน O (n ^ 2) ดังนั้นจึงเป็นการดีสำหรับการสร้างตัวเลขที่ไม่ซ้ำกันจำนวนเล็กน้อยจากชุดใหญ่ ในขณะที่อัลกอริทึมที่ใช้การสุ่มต้องมีอย่างน้อย O (m) ในการสับเปลี่ยน
นอกจากนี้อัลกอริทึมที่ใช้การสับเปลี่ยนยังต้องใช้หน่วยความจำในการจัดเก็บทุกผลลัพธ์ที่เป็นไปได้เพื่อทำการสุ่มอัลกอริทึมนี้ไม่จำเป็นต้องใช้
คุณสามารถใช้คลาส Collections
คลาสยูทิลิตี้ที่เรียกว่า Collections นำเสนอการดำเนินการต่างๆที่สามารถดำเนินการกับคอลเลกชันเช่น ArrayList (เช่นค้นหาองค์ประกอบค้นหาองค์ประกอบสูงสุดหรือต่ำสุดย้อนกลับลำดับขององค์ประกอบและอื่น ๆ ) การดำเนินการอย่างหนึ่งที่ทำได้คือการสับเปลี่ยนองค์ประกอบ การสุ่มจะสุ่มย้ายแต่ละองค์ประกอบไปยังตำแหน่งอื่นในรายการ ทำได้โดยใช้วัตถุสุ่ม ซึ่งหมายความว่าเป็นการสุ่มแบบกำหนด แต่จะทำในสถานการณ์ส่วนใหญ่
ในการสับเปลี่ยน ArrayList ให้เพิ่มการนำเข้า Collections ที่ด้านบนสุดของโปรแกรมจากนั้นใช้วิธีการสุ่มแบบคงที่ ต้องใช้ ArrayList เพื่อสับเป็นพารามิเตอร์:
import java.util.Collections;
import java.util.ArrayList;
public class Lottery {
public static void main(String[] args) {
//define ArrayList to hold Integer objects
ArrayList numbers = new ArrayList();
for(int i = 0; i < 100; i++)
{
numbers.add(i+1);
}
Collections.shuffle(numbers);
System.out.println(numbers);
}
}
คุณสามารถสร้างหมายเลขสุ่มเฉพาะ n ระหว่าง 0 ถึง n-1 ใน java
public static void RandomGenerate(int n)
{
Set<Integer> st=new HashSet<Integer>();
Random r=new Random();
while(st.size()<n)
{
st.add(r.nextInt(n));
}
}
นี้เป็นที่ง่ายที่สุดวิธีการในการสร้างค่าสุ่มที่ไม่ซ้ำกันในช่วงหรือจากอาร์เรย์
ในตัวอย่างนี้ฉันจะใช้อาร์เรย์ที่กำหนดไว้ล่วงหน้า แต่คุณสามารถปรับวิธีนี้เพื่อสร้างตัวเลขสุ่มได้เช่นกัน ขั้นแรกเราจะสร้างอาร์เรย์ตัวอย่างเพื่อดึงข้อมูลของเราจาก
ArrayList<Integer> sampleList = new ArrayList<>();
sampleList.add(1);
sampleList.add(2);
sampleList.add(3);
sampleList.add(4);
sampleList.add(5);
sampleList.add(6);
sampleList.add(7);
sampleList.add(8);
จากนี้sampleListเราจะสร้างตัวเลขสุ่มห้าหมายเลขที่ไม่ซ้ำกัน
int n;
randomList = new ArrayList<>();
for(int i=0;i<5;i++){
Random random = new Random();
n=random.nextInt(8); //Generate a random index between 0-7
if(!randomList.contains(sampleList.get(n)))
randomList.add(sampleList.get(n));
else
i--; //reiterating the step
}
นี่เป็นแนวคิดที่ง่ายมาก หากค่าสุ่มที่สร้างขึ้นมีอยู่แล้วเราจะย้ำขั้นตอนนี้ สิ่งนี้จะดำเนินต่อไปจนกว่าค่าทั้งหมดที่สร้างขึ้นจะไม่ซ้ำกัน
หากคุณพบคำตอบที่มีประโยชน์นี้แล้วคุณสามารถลงคะแนนขึ้นเป็นมันเป็นเรื่องง่ายมากในแนวคิดเมื่อเทียบกับคำตอบอื่น ๆ
ตรวจสอบสิ่งนี้
public class RandomNumbers {
public static void main(String[] args) {
// TODO Auto-generated method stub
int n = 5;
int A[] = uniqueRandomArray(n);
for(int i = 0; i<n; i++){
System.out.println(A[i]);
}
}
public static int[] uniqueRandomArray(int n){
int [] A = new int[n];
for(int i = 0; i< A.length; ){
if(i == A.length){
break;
}
int b = (int)(Math.random() *n) + 1;
if(f(A,b) == false){
A[i++] = b;
}
}
return A;
}
public static boolean f(int[] A, int n){
for(int i=0; i<A.length; i++){
if(A[i] == n){
return true;
}
}
return false;
}
}
ด้านล่างนี้เป็นวิธีที่ฉันใช้ในการสร้างหมายเลขเฉพาะเสมอ ฟังก์ชั่นสุ่มสร้างตัวเลขและเก็บไว้ในไฟล์ข้อความจากนั้นในครั้งต่อไปที่ตรวจสอบในไฟล์จะเปรียบเทียบและสร้างหมายเลขเฉพาะใหม่ด้วยวิธีนี้จึงมีหมายเลขเฉพาะใหม่อยู่เสมอ
public int GenerateRandomNo()
{
int _min = 0000;
int _max = 9999;
Random _rdm = new Random();
return _rdm.Next(_min, _max);
}
public int rand_num()
{
randnum = GenerateRandomNo();
string createText = randnum.ToString() + Environment.NewLine;
string file_path = System.IO.Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath) + @"\Invoices\numbers.txt";
File.AppendAllText(file_path, createText);
int number = File.ReadLines(file_path).Count(); //count number of lines in file
System.IO.StreamReader file = new System.IO.StreamReader(file_path);
do
{
randnum = GenerateRandomNo();
}
while ((file.ReadLine()) == randnum.ToString());
file.Close();
return randnum;
}
1..100(มีอัลกอริทึมที่มีชื่อเสียงสำหรับสิ่งนั้น) แต่หยุดหลังจากที่คุณกำหนดnองค์ประกอบแรกแล้ว