java编程
搜索
分类

Java二维数组实现数字拼图效果

作者：Msy丿P 时间：2021-11-21 20:39:17　

二维数组实现数字拼图，供大家参考，具体内容如下

二维数组可以自己随意定义大小，通过方法判断来实现对所有的数字进行随机打乱，并可以通过移动来正确还原，并可以判断0（表示空格）是否可以移动，是否在范围内。


public static void main(String[] args) {
 Scanner scanner = new Scanner(System.in);
 int[][] arrays = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 0 } };
 int sum = 1;
 String direction;
 bianLi(arrays);
 daLuanErWeiShuZu(arrays);
 System.out.println("========================================");
 while (true) {
  bianLi(arrays);
  if (isOk(arrays)) {
   break;
  }
  sum++;
  try {
   Thread.sleep(500);
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  System.out.println("请输入移动方向(W 上、S 下、A 左、D 右)");
  direction = scanner.next();
  switch (direction) {
  case "W":
  case "w":
   tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "上", arrays);

break;
  case "S":
  case "s":
   tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "下", arrays);
   break;
  case "A":
  case "a":
   tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "左", arrays);
   break;
  case "D":
  case "d":
   tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "右", arrays);
   break;
  default:
   System.out.println("非法输入，重新输入");
   break;
  }
 }
 System.out.println("一共走了" + sum + "步");
 System.out.println("挑战成功");

}

判断当前坐标是否可以移动


/**
 * 判断当前坐标是否可以移动
 *
 * @param arrays
 * @return 可以移动返回true
 */
public static boolean isYiDong(int[][] arrays) {
 int returnX = returnX(arrays);
 int returnY = returnY(arrays);
 System.out.println(returnX + ":" + returnY);
 if (returnX >= 0 && returnX + 1 < arrays.length && returnY >= 0 && returnY + 1 < arrays.length) {
  return true;
 }
 return false;
}

获取当前0所在行的具体地址


// 获取0所在行的位置
public static int returnX(int[][] arrays) {
 for (int i = 0; i < arrays.length; i++) {
  for (int j = 0; j < arrays[i].length; j++) {
   if (0 == arrays[i][j]) {
    return i;
   }
  }
 }
 return -1;
}

获取当前0所在列的具体地址


// 获取0所在列的位置
public static int returnY(int[][] arrays) {
 for (int i = 0; i < arrays.length; i++) {
  for (int j = 0; j < arrays[i].length; j++) {
   if (0 == arrays[i][j]) {
    return j;
   }
  }
 }
 return -1;
}

二维数组随机打乱，需要判断左上角、右上角、左下角、右下角、中间、上中、下种、左中、右中，那些方向可以移动，生成随机数来确定移动方向


// 二维数组随机打乱
public static void daLuanErWeiShuZu(int[][] arrays) {
 for (int i = 0; i < arrays.length; i++) {
  for (int j = 0; j < arrays[i].length; j++) {
   // 左上
   if (i == 0 && j == 0) {
    // 根据生成的随机数确定向右边边移动还是向下移动
    if (ouShuOrJiShu()) {
     tiHuanShuZuWeiZhi(i, j, "下", arrays);
    } else {
     tiHuanShuZuWeiZhi(i, j, "右", arrays);
    }
   }

// 右上
   if (i == 0 && j == arrays[0].length - 1) {
    // 根据生成的随机数确定向左边边移动还是向下移动
    if (ouShuOrJiShu()) {
     tiHuanShuZuWeiZhi(i, j, "下", arrays);
    } else {
     tiHuanShuZuWeiZhi(i, j, "左", arrays);
    }
   }

// 左下
   if (i == arrays.length - 1 && j == 0) {
    // 根据生成的随机数确定向左边边移动还是向下移动
    if (ouShuOrJiShu()) {
     tiHuanShuZuWeiZhi(i, j, "上", arrays);
    } else {
     tiHuanShuZuWeiZhi(i, j, "右", arrays);
    }
   }

// 右下
   if (i == arrays.length - 1 && j == arrays[i].length - 1) {
    // 根据生成的随机数确定向左边边移动还是向下移动
    if (ouShuOrJiShu()) {
     tiHuanShuZuWeiZhi(i, j, "上", arrays);
    } else {
     tiHuanShuZuWeiZhi(i, j, "左", arrays);
    }
   }

// 上中
   if (i == 0 && j > 0 && j < arrays[i].length - 1) {
    switch (oneToThree(3)) {
    case 0:
     tiHuanShuZuWeiZhi(i, j, "右", arrays);
     break;
    case 1:
     tiHuanShuZuWeiZhi(i, j, "下", arrays);
     break;
    case 2:
     tiHuanShuZuWeiZhi(i, j, "左", arrays);
     break;

default:
     break;
    }
   }
   // 左中
   if (j == 0 && i > 0 && i < arrays.length - 1) {
    switch (oneToThree(3)) {
    case 0:
     tiHuanShuZuWeiZhi(i, j, "上", arrays);
     break;
    case 1:
     tiHuanShuZuWeiZhi(i, j, "右", arrays);
     break;
    case 2:
     tiHuanShuZuWeiZhi(i, j, "下", arrays);
     break;

default:
     break;
    }
   }
   // 下中
   if (i == arrays.length - 1 && j > 0 && j < arrays[i].length - 1) {
    switch (oneToThree(3)) {
    case 0:
     tiHuanShuZuWeiZhi(i, j, "上", arrays);
     break;
    case 1:
     tiHuanShuZuWeiZhi(i, j, "右", arrays);
     break;
    case 2:
     tiHuanShuZuWeiZhi(i, j, "左", arrays);
     break;

default:
     break;
    }
   }
   // 右中
   if (j == arrays[i].length - 1 && i > 0 && i < arrays[i].length - 1) {
    switch (oneToThree(3)) {
    case 0:
     tiHuanShuZuWeiZhi(i, j, "上", arrays);
     break;
    case 1:
     tiHuanShuZuWeiZhi(i, j, "左", arrays);
     break;
    case 2:
     tiHuanShuZuWeiZhi(i, j, "下", arrays);
     break;

default:
     break;
    }
   }
   if (i > 0 && j > 0 && i < arrays.length - 2 && j < arrays[i].length - 2) {
    switch (oneToThree(4)) {
    case 0:
     tiHuanShuZuWeiZhi(i, j, "上", arrays);
     break;
    case 1:
     tiHuanShuZuWeiZhi(i, j, "右", arrays);
     break;
    case 2:
     tiHuanShuZuWeiZhi(i, j, "下", arrays);
     break;
    case 3:
     tiHuanShuZuWeiZhi(i, j, "左", arrays);
     break;

default:
     break;
    }
   }
  }
 }
}

该方法实现对0的位置和需要替换位置数据的替换，并对0范围进行验证，怕0出现数组下标越位。


/**
 * 根据输入的数据，对二维数组进行数据替换
 *
 * @param i         高位坐标
 * @param j         地位坐标
 * @param direction 移动方向
 * @param arrays    需要交换数据的数组
 */
public static void tiHuanShuZuWeiZhi(int i, int j, String direction, int[][] arrays) {
 int tem = -1;
 switch (direction) {
 case "上":
  if (i > 0) {
   tem = arrays[i][j];
   arrays[i][j] = arrays[i - 1][j];
   arrays[i - 1][j] = tem;
  }
  break;
 case "下":
  if (i < arrays.length - 1) {
   tem = arrays[i][j];
   arrays[i][j] = arrays[i + 1][j];
   arrays[i + 1][j] = tem;
  }
  break;
 case "左":
  if (j > 0) {
   tem = arrays[i][j];
   arrays[i][j] = arrays[i][j - 1];
   arrays[i][j - 1] = tem;
  }
  break;
 case "右":
  if (j < arrays.length - 1) {
   tem = arrays[i][j];
   arrays[i][j] = arrays[i][j + 1];
   arrays[i][j + 1] = tem;
  }
  break;

default:
  break;
 }
}

完整代码如下


import java.util.Random;
import java.util.Scanner;

public class Demo {
public static void main(String[] args) {
 Scanner scanner = new Scanner(System.in);
 int[][] arrays = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 0 } };
 int sum = 1;
 String direction;
 bianLi(arrays);
 daLuanErWeiShuZu(arrays);
 System.out.println("========================================");
 while (true) {
  bianLi(arrays);
  if (isOk(arrays)) {
   break;
  }
  sum++;
  try {
   Thread.sleep(500);
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  System.out.println("请输入移动方向(W 上、S 下、A 左、D 右)");
  direction = scanner.next();
  switch (direction) {
  case "W":
  case "w":
   tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "上", arrays);

break;
  case "S":
  case "s":
   tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "下", arrays);
   break;
  case "A":
  case "a":
   tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "左", arrays);
   break;
  case "D":
  case "d":
   tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "右", arrays);
   break;
  default:
   System.out.println("非法输入，重新输入");
   break;
  }
 }
 System.out.println("一共走了" + sum + "步");
 System.out.println("挑战成功");

}

// /**
//  * 判断当前坐标是否可以移动
//  *
//  * @param arrays
//  * @return 可以移动返回true
//  */
// public static boolean isYiDong(int[][] arrays) {
//  int returnX = returnX(arrays);
//  int returnY = returnY(arrays);
//  System.out.println(returnX + ":" + returnY);
//  if (returnX >= 0 && returnX + 1 < arrays.length && returnY >= 0 && returnY + 1 < arrays.length) {
//   return true;
//  }
//  return false;
// }

/**
 *
 * @param arrays 需要验证的数据
 * @return 成功返回true
 */
public static boolean isOk(int[][] arrays) {
 int sum = 1;
 for (int i = 0; i < arrays.length; i++) {
  for (int j = 0; j < arrays.length; j++) {
   if (sum == 9) {
    sum = 0;
   }
   if (arrays[i][j] != sum) {
    return false;
   }
   sum++;
  }
 }
 return true;
}

// 获取0所在行的位置
public static int returnX(int[][] arrays) {
 for (int i = 0; i < arrays.length; i++) {
  for (int j = 0; j < arrays[i].length; j++) {
   if (0 == arrays[i][j]) {
    return i;
   }
  }
 }
 return -1;
}

// 获取0所在列的位置
public static int returnY(int[][] arrays) {
 for (int i = 0; i < arrays.length; i++) {
  for (int j = 0; j < arrays[i].length; j++) {
   if (0 == arrays[i][j]) {
    return j;
   }
  }
 }
 return -1;
}

// 遍历二维数组
public static void bianLi(int[][] arrays) {
 for (int[] is : arrays) {
  for (int is2 : is) {
   System.out.print(is2 + "\t");
  }
  System.out.println();
 }
}

// 二维数组随机打乱
public static void daLuanErWeiShuZu(int[][] arrays) {
 for (int i = 0; i < arrays.length; i++) {
  for (int j = 0; j < arrays[i].length; j++) {
   // 左上
   if (i == 0 && j == 0) {
    // 根据生成的随机数确定向右边边移动还是向下移动
    if (ouShuOrJiShu()) {
     tiHuanShuZuWeiZhi(i, j, "下", arrays);
    } else {
     tiHuanShuZuWeiZhi(i, j, "右", arrays);
    }
   }

// 右上
   if (i == 0 && j == arrays[0].length - 1) {
    // 根据生成的随机数确定向左边边移动还是向下移动
    if (ouShuOrJiShu()) {
     tiHuanShuZuWeiZhi(i, j, "下", arrays);
    } else {
     tiHuanShuZuWeiZhi(i, j, "左", arrays);
    }
   }

// 左下
   if (i == arrays.length - 1 && j == 0) {
    // 根据生成的随机数确定向左边边移动还是向下移动
    if (ouShuOrJiShu()) {
     tiHuanShuZuWeiZhi(i, j, "上", arrays);
    } else {
     tiHuanShuZuWeiZhi(i, j, "右", arrays);
    }
   }

// 右下
   if (i == arrays.length - 1 && j == arrays[i].length - 1) {
    // 根据生成的随机数确定向左边边移动还是向下移动
    if (ouShuOrJiShu()) {
     tiHuanShuZuWeiZhi(i, j, "上", arrays);
    } else {
     tiHuanShuZuWeiZhi(i, j, "左", arrays);
    }
   }

// 上中
   if (i == 0 && j > 0 && j < arrays[i].length - 1) {
    switch (oneToThree(3)) {
    case 0:
     tiHuanShuZuWeiZhi(i, j, "右", arrays);
     break;
    case 1:
     tiHuanShuZuWeiZhi(i, j, "下", arrays);
     break;
    case 2:
     tiHuanShuZuWeiZhi(i, j, "左", arrays);
     break;

default:
     break;
    }
   }
   // 左中
   if (j == 0 && i > 0 && i < arrays.length - 1) {
    switch (oneToThree(3)) {
    case 0:
     tiHuanShuZuWeiZhi(i, j, "上", arrays);
     break;
    case 1:
     tiHuanShuZuWeiZhi(i, j, "右", arrays);
     break;
    case 2:
     tiHuanShuZuWeiZhi(i, j, "下", arrays);
     break;

default:
     break;
    }
   }
   // 下中
   if (i == arrays.length - 1 && j > 0 && j < arrays[i].length - 1) {
    switch (oneToThree(3)) {
    case 0:
     tiHuanShuZuWeiZhi(i, j, "上", arrays);
     break;
    case 1:
     tiHuanShuZuWeiZhi(i, j, "右", arrays);
     break;
    case 2:
     tiHuanShuZuWeiZhi(i, j, "左", arrays);
     break;

default:
     break;
    }
   }
   // 右中
   if (j == arrays[i].length - 1 && i > 0 && i < arrays[i].length - 1) {
    switch (oneToThree(3)) {
    case 0:
     tiHuanShuZuWeiZhi(i, j, "上", arrays);
     break;
    case 1:
     tiHuanShuZuWeiZhi(i, j, "左", arrays);
     break;
    case 2:
     tiHuanShuZuWeiZhi(i, j, "下", arrays);
     break;

default:
     break;
    }
   }
   if (i > 0 && j > 0 && i < arrays.length - 2 && j < arrays[i].length - 2) {
    switch (oneToThree(4)) {
    case 0:
     tiHuanShuZuWeiZhi(i, j, "上", arrays);
     break;
    case 1:
     tiHuanShuZuWeiZhi(i, j, "右", arrays);
     break;
    case 2:
     tiHuanShuZuWeiZhi(i, j, "下", arrays);
     break;
    case 3:
     tiHuanShuZuWeiZhi(i, j, "左", arrays);
     break;

default:
     break;
    }
   }
  }
 }
}

/**
 * 判断是否是偶数
 *
 * @return 偶数返回true
 */
public static boolean ouShuOrJiShu() {
 return new Random().nextInt(1000) ％ 2 == 0 ? true : false;
}

/**
 *
 * @param n 需要模的值
 * @return 返回0-(n-1)的值
 */
public static int oneToThree(int n) {
 return new Random().nextInt(1000) ％ n;
}

/**
 * 根据输入的数据，对二维数组进行数据替换
 *
 * @param i         高位坐标
 * @param j         地位坐标
 * @param direction 移动方向
 * @param arrays    需要交换数据的数组
 */
public static void tiHuanShuZuWeiZhi(int i, int j, String direction, int[][] arrays) {
 int tem = -1;
 switch (direction) {
 case "上":
  if (i > 0) {
   tem = arrays[i][j];
   arrays[i][j] = arrays[i - 1][j];
   arrays[i - 1][j] = tem;
  }
  break;
 case "下":
  if (i < arrays.length - 1) {
   tem = arrays[i][j];
   arrays[i][j] = arrays[i + 1][j];
   arrays[i + 1][j] = tem;
  }
  break;
 case "左":
  if (j > 0) {
   tem = arrays[i][j];
   arrays[i][j] = arrays[i][j - 1];
   arrays[i][j - 1] = tem;
  }
  break;
 case "右":
  if (j < arrays.length - 1) {
   tem = arrays[i][j];
   arrays[i][j] = arrays[i][j + 1];
   arrays[i][j + 1] = tem;
  }
  break;

default:
  break;
 }
}

}

来源：https://blog.csdn.net/MsyLaoLi/article/details/107675610

标签：java,数字拼图
0
投稿

猜你喜欢

  • Java多文件以ZIP压缩包导出的实现方法

    2023-10-08 14:05:20

  • C# 获取程序集版本、文件版本

    2022-12-14 13:47:31

  • unity里获取text中文字宽度并截断省略的操作

    2023-11-02 07:48:52

  • C# 7.2中结构体性能问题的解决方案

    2022-08-12 23:04:26

  • C#实现六大设计原则之依赖倒置原则

    2023-06-27 04:02:57

  • 通过Java实现文件断点续传功能

    2022-06-22 16:30:42

  • Android实现移动小球和CircularReveal页面切换动画实例代码

    2023-03-03 03:45:50

  • 深入Android 五大布局对象的应用

    2022-03-23 15:25:15

  • Java 网络编程总结

    2023-11-10 22:19:29

  • centos 安装java环境的多种方法

    2023-08-10 16:01:37

  • C# 线程同步详解

    2021-12-30 04:50:03

  • java 2d画图示例分享(用java画图)

    2023-07-25 22:03:52

  • maven profile自动切换环境参数的2种方法详解

    2022-10-28 09:18:39

  • Android基础教程数据存储之文件存储

    2023-08-05 18:18:10

  • Java OpenCV图像处理之仿射变换,透视变换,旋转详解

    2022-04-18 23:56:01

  • C#开发WinForm之DataGridView开发详解

    2023-06-25 06:31:35

  • Flutter 弹性布局基石flex算法flexible示例详解

    2021-10-16 01:05:41

  • Java经典算法汇总之选择排序（SelectionSort）

    2021-12-23 03:59:52

  • Android利用HorizontalScrollView仿ViewPager设计简单相册

    2022-07-29 12:28:33

  • Java8 Stream教程之collect()的技巧

    2023-05-01 00:45:15
    • asp之家 软件编程 m.aspxhome.com