Java：创建简单的彩票号码生成器
我必须以Lotto6/49（加拿大安大略省）为原型创建一个简单的Java彩票号码生成器。询问用户希望生成多少票证。车票必须按数字的升序排列，并且没有重复的车票。例如，如果我想要3张票，则输出可能是：Java：创建简单的彩票号码生成器,java,Java,我必须以Lotto6/49（加拿大安大略省）为原型创建一个简单的Java彩票号码生成器。询问用户希望生成多少票证。车票必须按数字的升序排列，并且没有重复的车票。例如，如果我想要3张票，则输出可能是： 8 12 17 25 32 47 6 10 21 30 39 42 1 8 16 37 45 49 尝试对数字进行排序时会出现问题。我们被教导使用冒泡排序，但是我的重复检查无法正常工作，因此我将得到如下输出： 8 18 29 29 29 29 4 12 18 18 24 24 4 12 18 24
8 12 17 25 32 47
6 10 21 30 39 42
1 8 16 37 45 49
8 18 29 29 29 29
4 12 18 18 24 24
4 12 18 24 46 46
// The "Lotto" class.
import java.awt.*;
import hsa.Console;
public class Lotto
{
static Console c; // The output console
public static void main (String[] args)
{
c = new Console ();
int t = 0;
int num[];
num = new int[10];
c.println("How many Lotto 6/49 tickets do you wish to generate?");
t = c.readInt();
c.println("****************");
for (int a = 1; a <= t; a++)
{
for (int i = 1; i <= 6; i++)
{
num[i] = (int)(Math.random() * 49 + 1);
for (int x = 1; x <= 6; x++) // duplicate check
{
for (int y = x + 1; y <= 7; y++)
{
if (num[x] == num[y])
{
num[y] = (int)(Math.random() * 49 + 1);
}
}
} // end check
for (int p = 1; p <=6; p++) // start sort
{
for (int q = 1; q <=7; q++)
{
if (num[p] < num[q])
{
int temp = num[p];
num[p] = num[q];
num[q] = temp;
}
}
} // end sort
c.print(num[i] + " ");
}
c.println();
}
} // main method
} // Lotto class
//乐透”类。
导入java.awt.*；
导入hsa.Console；
公共类彩票
{
静态控制台c；//输出控制台
公共静态void main（字符串[]args）
{
c=新控制台（）；
int t=0；
int num[]；
num=新整数[10]；
c、 println（“您希望生成多少张彩票6/49？”）；
t=c.readInt（）；
c、 println（“****************”）；
对于（inta=1；a这是一个糟糕的抽象。我建议将所有逻辑嵌入一个类中。面向对象编程涉及抽象、封装和隐藏细节
我是这样做的：
package gambling;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
/**
* Created by Michael
* Creation date 3/21/2017.
* @link https://stackoverflow.com/questions/42932262/java-creating-simple-lottery-number-generator
*/
public class LottoTicket {
public static final int DEFAULT_NUM_TICKETS = 10;
public static final int DEFAULT_MAX_VALUE = 49;
public static final int DEFAULT_NUM_VALUES = 6;
private Random random;
public static void main(String[] args) {
int numTickets = (args.length > 0) ? Integer.parseInt(args[0]) : DEFAULT_NUM_TICKETS;
LottoTicket lottoTicket = new LottoTicket();
for (int i = 0; i < numTickets; ++i) {
System.out.println(lottoTicket.getNumbers(DEFAULT_NUM_VALUES, DEFAULT_MAX_VALUE));
}
}
public LottoTicket() {
this(null);
}
public LottoTicket(Long seed) {
this.random = (seed != null) ? new Random(seed) : new Random();
}
public Set<Integer> getNumbers(int numValues, int maxValue) {
Set<Integer> numbers = new TreeSet<>();
while (numbers.size() < numValues) {
numbers.add(this.random.nextInt(maxValue) + 1);
}
return numbers;
}
}
包赌博；
导入java.util.Random；
导入java.util.Set；
导入java.util.TreeSet；
/**
*迈克尔创作的
*创建日期2017年3月21日。
*@linkhttps://stackoverflow.com/questions/42932262/java-creating-simple-lottery-number-generator
*/
公共类彩票{
公共静态最终整数默认数票证=10；
公共静态最终int默认值_MAX_值=49；
公共静态最终int默认值为6；
私有随机；
公共静态void main（字符串[]args）{
int numTickets=（args.length>0）？Integer.parseInt（args[0]）：默认的\u NUM\u票证；
lototicket lototicket=新的lototicket（）；
对于（int i=0；i
这是一个糟糕的抽象。我建议将所有逻辑嵌入类中。面向对象编程是关于抽象、封装和隐藏细节的
我是这样做的：
package gambling;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
/**
* Created by Michael
* Creation date 3/21/2017.
* @link https://stackoverflow.com/questions/42932262/java-creating-simple-lottery-number-generator
*/
public class LottoTicket {
public static final int DEFAULT_NUM_TICKETS = 10;
public static final int DEFAULT_MAX_VALUE = 49;
public static final int DEFAULT_NUM_VALUES = 6;
private Random random;
public static void main(String[] args) {
int numTickets = (args.length > 0) ? Integer.parseInt(args[0]) : DEFAULT_NUM_TICKETS;
LottoTicket lottoTicket = new LottoTicket();
for (int i = 0; i < numTickets; ++i) {
System.out.println(lottoTicket.getNumbers(DEFAULT_NUM_VALUES, DEFAULT_MAX_VALUE));
}
}
public LottoTicket() {
this(null);
}
public LottoTicket(Long seed) {
this.random = (seed != null) ? new Random(seed) : new Random();
}
public Set<Integer> getNumbers(int numValues, int maxValue) {
Set<Integer> numbers = new TreeSet<>();
while (numbers.size() < numValues) {
numbers.add(this.random.nextInt(maxValue) + 1);
}
return numbers;
}
}
包赌博；
导入java.util.Random；
导入java.util.Set；
导入java.util.TreeSet；
/**
*迈克尔创作的
*创建日期2017年3月21日。
*@linkhttps://stackoverflow.com/questions/42932262/java-creating-simple-lottery-number-generator
*/
公共类彩票{
公共静态最终整数默认数票证=10；
公共静态最终int默认值_MAX_值=49；
公共静态最终int默认值为6；
私有随机；
公共静态void main（字符串[]args）{
int numTickets=（args.length>0）？Integer.parseInt（args[0]）：默认的\u NUM\u票证；
lototicket lototicket=新的lototicket（）；
对于（int i=0；i
实际上，气泡排序和重复检查都不起作用
对于重复检查，如果检测到重复，则生成一个新的随机数，但没有任何东西阻止代码生成相同的重复。请尝试将if（num[x]==num[y]）
更改为，而（num[x]==num[y]）
对于冒泡排序，我认为您误解了算法。一般形式应为：
boolean changed = false;
do {
for (int i = 0; i < size - 1; i++) {
if (num[i] > num[i+1]) {
// swap
changed = true;
}
}
} while (changed);
这被解释为：生成一个介于1和49之间的无限随机数流，删除重复数，获取前6个，对它们进行排序并将其作为数组返回。实际上，冒泡排序和重复检查都不起作用
对于重复检查，如果检测到重复，则生成一个新的随机数，但没有任何东西阻止代码生成相同的重复。请尝试将if（num[x]==num[y]）
更改为，而（num[x]==num[y]）
对于冒泡排序，我认为您误解了算法。一般形式应为：
boolean changed = false;
do {
for (int i = 0; i < size - 1; i++) {
if (num[i] > num[i+1]) {
// swap
changed = true;
}
}
} while (changed);
这被解释为：生成一个介于1和49之间的无限随机数流，删除重复项，获取前6个，对它们进行排序并将其作为数组返回。以下是我的版本：
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
class LotoTicket {
private static final int NUM_NUMBERS = 6;
private static final int NUM_BALLS = 99;
private static final Random random = new Random();
private final int[] numbers;
private LotoTicket(final int[] numbers) {
this.numbers = numbers;
}
public static LotoTicket generateTicket() {
final int[] numbers = new int[NUM_NUMBERS];
final List<Integer> ballPool = IntStream.range(1, 1 + NUM_BALLS)
.mapToObj(i -> i)
.collect(Collectors.toList());
for (int i = 0; i < NUM_NUMBERS; i++) {
final int draw = random.nextInt(NUM_BALLS - i);
numbers[i] = ballPool.remove(draw);
}
Arrays.sort(numbers);
return new LotoTicket(numbers);
}
public int[] getNumbers() {
return numbers;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("LotoTicket{");
sb.append("numbers=").append(Arrays.toString(numbers));
sb.append('}');
return sb.toString();
}
public static void main(final String... args) {
System.out.println(LotoTicket.generateTicket());
System.out.println(LotoTicket.generateTicket());
System.out.println(LotoTicket.generateTicket());
}
}
导入java.util.array；
导入java.util.List；
导入java.util.Random；
导入java.util.stream.collector；
导入java.util.stream.IntStream；
LotoTicket类{
私有静态最终整数=6；
私有静态最终int NUM_BALLS=99；
私有静态最终随机=新随机（）；
私人最终整数[]编号；
私有LotoTicket（最终整数[]个）{
这个。数字=数字；
}
公共静态LotoTicket generaticket（）{
最终整数[]个数=新整数[个数]；
最终列表ballPool=IntStream.range（1，1+个球）
.mapToObj（i->i）
.collect（Collectors.toList（））；
对于（int i=0；i