1

目前我有一个代码可以生成 0-100 之间的 200 个随机数（每行 10 个数字），但现在我被卡住了，因为我想让它计算 0-20,21-40,41-60,61- 之间的所有数字80,81-100 并告诉我该范围内有多少个数字。我该怎么做？我已经尝试过，但我刚刚在这些范围之间生成了数字。这是我当前的代码：（如果可能的话，如何使用数组来做到这一点？我是初学者，还在学习）

import java.util.Random;

public class RandomStats1 {

public static void main(String[] args) {
    Random random = new Random ();

System.out.println("200 Generated numbers, 10 per line: ");
int numbersOnThisLine = 0;
    for (int i = 0; i < 200; i++)
{
int nextNumber = random.nextInt(100);
    System.out.print(nextNumber + " ");
    numbersOnThisLine++;

 if (numbersOnThisLine == 10)
 {
   System.out.print("\n");
   numbersOnThisLine = 0;
}

}
}
}
4

3 回答 3

1

由于您处于学习阶段并且应该使用数组，因此我只会给您一些建议：

  1. nextInt(100)给出从 0 到 99 的值，而不是 100。

  2. 您的相等尺寸范围将是 0-19、20-39、40-59、60-79、80-99。0-20 是 21 个数字。

    （以上注释取自Peter Lawrey 的评论）。

  3. 您可以使用一个数组来存储每个组的计数器。由于您有 5 个组，因此也将数组的大小定义为 5。

  4. 利用该语言的一些优势，两个数字的整数除法的结果是双精度结果的整数部分。换句话说，当除以 时int x，int y结果int z将是结果的整数部分，没有模数和浮点部分需要考虑。例如：
    • 15 / 20 = 0
    • 20 / 20 = 1
    • 21 / 20 = 1
  5. 通过上面的注释，您可以轻松获得将用作计数器的数组的索引，将生成的数字在 0 和 100 之间除以 20。

一个小伪代码：

int counterSize <- 5
int groupSize <- 20
int[] counter = new int[counterSize]
for i <- 0 to 200
    int nextNumber <- random(100)
    int index <- nextNumber / groupSize
    counter[index] <- counter[index] + 1
end for
于 2013-11-04T22:56:33.403 回答
0

创建一个HashMap<Integer,HashSet<Integer>>并使用以下值初始化它：0、20、40、60 和 80（以及空集）：

HashMap<Integer,HashSet<Integer>> map = new HashMap<Integer,HashSet<Integer>>();
map.put(0, new HashSet<Integer>());
map.put(20, new HashSet<Integer>());
...

每当您生成一个数字时，请检查它落在哪个范围内，例如，如果它在 21-40 范围内，则应将其添加到 HashMap 中，如下所示：

map.get(20).add(number);

在您完成生成数字后，您将按集合中的范围对它们进行排序。

备注：
一个 Set 不允许重复的成员，所以如果你想允许重复，不要使用HashSet, 使用一个List或其他允许它的数据结构。

于 2013-11-04T22:35:37.180 回答
0

首先，您必须将它们存储在像ArrayList.

private List<Integer> numbers = new ArrayList<>();

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 numbers.add(nextNumber);
}

这将使我们所有的数字保持在一起。

现在要确定特定范围内的数字数量，我们可以创建自己的自定义类，因为 Java 不提供此功能。

private class Range {
 private int lower;
 private int higher;

 public Range(int low, int high) {
  lower = low;
  higher = high;
 }

 // Getters

 public bool isValid(int i){
  return (i > lower && i < higher);
 }

 @Override 
 public int GetHashCode(){
  return lower;
 }

 @Override
 public bool Equals(Object o){
  if(!(o instanceOf Range)) { return false; }
  return ((Range)o).GetLower() == this.lower;
 }
}

现在我们可以在 a 中使用它Map：

private Map<Range, Integer> occurrences = new HashMap<Range, Integer>();

并用范围初始化它：

for(int i = 0; i < 100; i+= 20){
 occurrences.put(new Range(i, i + 20), 0);
}

并简单地迭代我们之前的列表：

for(int i : numbers) {
 for(Range key : occurrences.KeySet()){
  if(key.isValid(i) { occurrences.put(i); } 
 }
}

我意识到它很复杂，可能不适合您所需的水平。至少这是我会采取的思考过程，你可以从中得到你喜欢的东西。毕竟它可能对未来的浏览器有所帮助。

更简单（不需要额外的类）：

private List<Integer> numbers = new ArrayList<>();
private Map<Integer, Integer> occurrences = new HashMap<>();

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 numbers.add(nextNumber);
}

for(int i = 0; i < 100; i++){
 occurrences.put(i, 0);
}

for(int i : numbers){
 int sofar = occurrences.get(i);
 occurrences.put(i, sofar + 1);
}

并获取一个范围内的实际数据：

int count = 0;
for(int i = 0; i < 100; i++){
 count+= occurences.get(i);
 if(i % 20 == 0) {
  System.out.println("From " + i - 20 + " to " + i + ":" + count);
  count = 0;
 }
}

使用数组，更简单和丢失单个值：

private int[] occ = new int[5];

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 System.out.println(nextnumber);

 if(i <= 20) { occ[0]++; }
 if(i <= 40) { occ[1]++; }
 if(i <= 60) { occ[2]++; }
 if(i <= 80) { occ[3]++; }
 if(i <= 100) { occ[4]++; }
}

System.out.println("Numbers from 0 to 20: " + occ[0]); 
System.out.println("Numbers from 20 to 40: " + occ[1]); 
System.out.println("Numbers from 40 to 60: " + occ[2]); 
System.out.println("Numbers from 60 to 80: " + occ[3]); 
System.out.println("Numbers from 80 to 100: " + occ[4]);
于 2013-11-04T22:37:35.147 回答