java 二维数组实操

最新推荐文章于 2024-04-30 17:28:01 发布

A Python 萌新花花

最新推荐文章于 2024-04-30 17:28:01 发布

阅读量423

点赞数 2

分类专栏： java学习文章标签： java 算法彩票二维数组

本文链接：https://blog.csdn.net/weixin_56177871/article/details/123955245

版权

java学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

java 二维数组实操

一、灵感来源

这个文章主要是在看了一个十分厉害的大佬的有关双色球的一篇文章之后，有感而发，写出的一个小小的代码。

这个代码主要是针对双色球的随机生成，统计数字出现频率，并整合出一个双色球号码，让随机生成的双色球数字与这个号码的数字的重合率越低越好。

PS：我这里指的双色球是1~32里面选5个，1~16里面选两个。（别问为啥）

二、代码

2.1 双色球生成代码（没有抄）

import java.util.*;
 
public class lotterySimulator
{
   public static int[][] generator(int a, int b)
   {
      int[][] arr = new int[a][b];
      Random random = new Random();
      int c = 0;
      for(int i = 0 ; i < arr.length ; i++)
      {
         for(int j = 0; j < arr[i].length ; j++)
         {           
            while(true)
            {
               c = j == 5 || j == 6 ? random.nextInt(15)+1 : random.nextInt(31)+1;
               if(!contains(c,arr[i]))
               {
                  break;
               }
            } 
            arr[i][j] = c;       
         }
      }
      return arr;
   }
   public static boolean contains(int a, int[] sss)
   {
      boolean result = false;
      for(int er : sss)
      {
         result = er == a ? true : false;
         if(result == true)
         {
            break;
         }
      }
      return result;
   }
   public static void main(String[] args)
   {
      int[][] arra = generator(10,7);
      for(int[] a : arra)
      {
         for(int b : a)
         {
            System.out.print(b+",");
         }
         System.out.println("");
      }
   }
}

2.2 选择排序

毕竟最后做出来的那个号码还是需要验证一下，所以需要一个选择排序来整理一下自动生成的号码，乱糟糟的毕竟不容易检查。

注：这里的代码不是常规的选择排序，请不要直接拿去用，会出问题。

private static int[] selectionSort(int[] arr)
   {
      for (int i = 0; i <arr.length - 3; i++) 
      {
          int index = i;
          for (int j = i + 1; j<arr.length-2; j++) 
          {
              if (arr[j] < arr[index]) 
              {
                  index = j;
              }
          }
          int tmp = arr[index];
          arr[index] = arr[i];
          arr[i] = tmp;
      }
      if(arr[arr.length-2]>arr[arr.length-1])
      {
         int temp = 0;
         temp = arr[arr.length-1];
         arr[arr.length-1] = arr[arr.length-2];
         arr[arr.length-2] = temp;
      }
      return arr;
   }

这里因为最后两个数只需要if比较就好了，不用再多加一个for-for嵌套来遍历。要注意的是第一个for循环的循环次数需要减少，内外for的次数都需要减少2。

PS：这是正常的选择排序

2.3 遍历判断

因为最后需要的是重合率最低的一个号码，所以我们需要将自动生成的二维数组的每个数据进行统计，然后根据出现的次数，选择组成号码的数字。（这个不一定是最好的方法，但一定是在你不想思考的时候可以用的最简单的。）

统计的方法，就是用两个二维数组（因为有1~32 和1~16的），这个二维数组是【2】【32】和【2】【16】。就是一个一维数组用来装1~32和1~16这些数字，一个用来装他们出现的次数。

for(int i = 0; i < store32[0].length; i++)
      {
         store32[0][i] = i+1;
      }
      for(int i = 0; i < store16[0].length; i++)
      {
         store16[0][i] = i+1;
      }
      for(int i = 0; i < arra.length; i++)
      {
         for(int j = 0; j < 5; j++)
         {
            for(int k = 0; k < store32[0].length; k++)
            {
               if(arra[i][j] == store32[0][k])
               {
                  store32[1][k] += 1;
               }
            }
         }
      }
      for(int i = 0; i < arra.length; i++)
      {
         for(int j = 5; j < 7; j++)
         {
            for(int k = 0; k < store16[0].length; k++)
            {
               if(arra[i][j] == store16[0][k])
               {
                  store16[1][k] += 1;
               }
            }
         }
      }

格式有亿点怪，不过不要紧。这里必须用三重for嵌套，因为它是在同时对于三个数据进行遍历。一个是arra这个二维数组所含有的所有一维数组，一个是arra里面的一维数组里面的数据，一个是装了1~32和1~16的数组的数据。一定要用三重，不然会出问题。理论上说，这段代码是可以缩短的，但是我懒，简化的事情就交给你们了。

2.4 筛选最少出现数字

这个筛选的方法有很多，比如说借用选择排序利用索引的方法，选最小然后判断。。。。。。

方法很多，这里我就说一下我的方法。

我的方法主要是while-for嵌套。利用while可以不限制循环次数的特点，配合for的索引，从0开始，将出现次数为0的数字写进一个一维数组，然后+=1，不断遍历。最后for和while都来一个break，就可以了。

while(true)
      {
         for(int i = 0; i < store32[0].length; i++)
         {
            if(store32[1][i] == a)
            {
               output[b] = store32[0][i];
               b += 1;
            }
            if(b == 5)
         {
            break;  
         }
         }
         a += 1;
         if(b == 5)
         {
            break;  
         }
      }
      a = 0;
      b = 5;
      while(true)
      {
         for(int i = 0; i < store16[0].length; i++)
         {
            if(store16[1][i] == a && !contains(store16[0][i],output))
            {
               output[b] = store16[0][i];
               b += 1;
            }
            if(b == 7)
            {
               break;  
            }
         }
         a += 1;
         if(b == 7)
         {
            break;  
         }
      }

三、总代码

import java.util.*;

public class lotterySimulator
{
   public static int[][] generator(int a, int b)
   {
      int[][] arr = new int[a][b];
      Random random = new Random();
      int c = 0;
      for(int i = 0 ; i < arr.length ; i++)
      {
         for(int j = 0; j < arr[i].length ; j++)
         {           
            while(true)
            {
               c = j == 5 || j == 6 ? random.nextInt(15)+1 : random.nextInt(31)+1;
               if(!contains(c,arr[i]))
               {
                  break;
               }
            } 
            arr[i][j] = c;       
         }
      }
      return arr;
   }
   public static boolean contains(int a, int[] sss)
   {
      boolean result = false;
      for(int er : sss)
      {
         result = er == a ? true : false;
         if(result == true)
         {
            break;
         }
      }
      return result;
   }
   public static void main(String[] args)
   {
      int[][] arra = generator(10,7);
      int[][] store32 = new int[2][32];
      int[][] store16 = new int[2][16];
      int[] output = new int[7];     
      for(int i = 0; i < arra.length; i++)
      {
         selectionSort(arra[i]);
      }
      for(int[] a : arra)
      {
         for(int b : a)
         {
            System.out.print(b+ (b == a[a.length-1] ? "\n" : ","));
         }
      }
      for(int i = 0; i < store32[0].length; i++)
      {
         store32[0][i] = i+1;
      }
      for(int i = 0; i < store16[0].length; i++)
      {
         store16[0][i] = i+1;
      }
      for(int i = 0; i < arra.length; i++)
      {
         for(int j = 0; j < 5; j++)
         {
            for(int k = 0; k < store32[0].length; k++)
            {
               if(arra[i][j] == store32[0][k])
               {
                  store32[1][k] += 1;
               }
            }
         }
      }
      for(int i = 0; i < arra.length; i++)
      {
         for(int j = 5; j < 7; j++)
         {
            for(int k = 0; k < store16[0].length; k++)
            {
               if(arra[i][j] == store16[0][k])
               {
                  store16[1][k] += 1;
               }
            }
         }
      }
      int a = 0;
      int b = 0;
      while(true)
      {
         for(int i = 0; i < store32[0].length; i++)
         {
            if(store32[1][i] == a)
            {
               output[b] = store32[0][i];
               b += 1;
            }
            if(b == 5)
         {
            break;  
         }
         }
         a += 1;
         if(b == 5)
         {
            break;  
         }
      }
      a = 0;
      b = 5;
      while(true)
      {
         for(int i = 0; i < store16[0].length; i++)
         {
            if(store16[1][i] == a && !contains(store16[0][i],output))
            {
               output[b] = store16[0][i];
               b += 1;
            }
            if(b == 7)
            {
               break;  
            }
         }
         a += 1;
         if(b == 7)
         {
            break;  
         }
      }
  
      for(int x : output)
      {
         System.out.print(x == output[output.length-1] ? x : x + ",");
      } 
   }
   private static int[] selectionSort(int[] arr)
   {
      for (int i = 0; i <arr.length - 3; i++) 
      {
          int index = i;
          for (int j = i + 1; j<arr.length-2; j++) 
          {
              if (arr[j] < arr[index]) 
              {
                  index = j;
              }
          }
          int tmp = arr[index];
          arr[index] = arr[i];
          arr[i] = tmp;
      }
      if(arr[arr.length-2]>arr[arr.length-1])
      {
         int temp = 0;
         temp = arr[arr.length-1];
         arr[arr.length-1] = arr[arr.length-2];
         arr[arr.length-2] = temp;
      }
      return arr;
   }
}

就是多了一些初始化和一些输入的代码，用来检查一下程序错没错。

3.1 效果

自动生成：

6,11,15,21,22,1,14
10,22,25,28,29,4,14
5,9,16,24,29,1,11
3,4,15,21,23,6,10
7,12,15,24,27,5,10
1,2,6,14,26,8,13
5,6,10,24,31,4,8
6,14,17,18,26,1,8
3,7,12,23,29,1,10
10,15,19,21,29,3,4

结果：8,13,20,30,32,2,7

自动生成：

5,10,15,19,28,4,14
3,5,12,16,25,8,9
10,21,24,26,27,8,12
1,5,12,21,30,3,15
3,6,14,19,31,4,11
3,9,18,24,26,4,15
9,24,27,28,30,7,10
2,17,18,26,30,10,12
3,11,21,27,28,8,12
3,9,10,27,30,14,15

结果：4,7,8,13,20,1,2

A Python 萌新花花

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
java 二维数组实操

java 二维数组实操一、灵感来源这个文章主要是在看了一个十分厉害的大佬的有关双色球的一篇文章之后，有感而发，写出的一个小小的代码。这个代码主要是针对双色球的随机生成，统计数字出现频率，并整合出一个双色球号码，让随机生成的双色球数字与这个号码的数字的重合率越低越好。PS：我这里指的双色球是1~32里面选5个，1~16里面选两个。（别问为啥）二、代码2.1 双色球生成代码（没有抄）import java.util.*; public class lotterySimulato
复制链接

扫一扫