python实现数独游戏 java简单实现数独游戏

使用python和java实现数独游戏,有比较才有收获哦。

1、Python版

#--coding:utf-8--

import random
import itertools
from copy import deepcopy

def make_board(m=3):
 numbers = list(range(1,m**2+1))
 #可能出现的数字为1-9
 board = None
 #board是数度二维列表
 while board is None:
 board = get_board(m,numbers)
 return board

def get_board(m,numbers):
 n = m**2
 board = [[None for _ in range(n)] for _ in range(n)]
 for i,j in itertools.product(range(n),repeat=2):
 i0,j0 = i-i%m,j-j%m

 # i,j分别代表的是我们的行和列
 # i0和j0代表的是board[i][j]所在的区块的起始位置

 random.shuffle(numbers)
 #shuffle() 方法将序列的所有元素随机排序。
 for x in numbers:
  if(x not in board[i]
  and all(row[j]!=x for row in board)
  and all(x not in row[j0:j0+m]
  for row in board[i0:i])):
  board[i][j] = x
  break
 else:#当循环正常结束时会执行else
  return None
 return board

def print_board(board,m=3):
 numbers = list(range(1,m**2+1))

 #每一行随机把5个数字变成None
 omit = 5 #omit变量掌控着每一行被抹去的数字个数
 challange = deepcopy(board)
 for i,j in itertools.product(range(omit),range(m**2)):
 x = random.choice(numbers) - 1
 challange[x][j] = None

 spacer = "++-----+-----+-----++-----+-----+-----++-----+-----+-----++"
 print(spacer.replace('-','='))
 for i,line in enumerate(challange):
 print("|| {} | {} | {} || {} | {} | {} || {} | {} | {} ||"
 .format(*(cell or ' ' for cell in line)))

 #format()函数中的 * 号,则是将所有的 cell 的不同值放入一个元组 tuple 之中,方便format函数调用
 if(i+1)%3==0:
  print(spacer.replace('-','='))
 else:
  print(spacer)
 return challange

Board = make_board()
print_board(Board)

效果:

2、Java版

package com.jimo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class Shudu {

 public String[][] make_board(int m) {
 String[][] board = null;
 int n = m * m;
 List<Integer> numbers = new ArrayList<>();
 for (int i = 1; i <= n; i++) {
  numbers.add(i);
 }
 while (board == null) {
  board = get_board(m, numbers);
 }
 return board;
 }

 private String[][] get_board(int m, List<Integer> numbers) {
 int n = m * m;
 String[][] board = new String[n][n];
 for (int i = 0; i < n; i++) {
  for (int j = 0; j < n; j++) {
  boolean ok = true;
  // 打乱顺序
  Collections.shuffle(numbers);
  for (int x = 0; x < n; x++) {
   if (isOk(numbers.get(x) + "", board, i, j, m)) {
   board[i][j] = numbers.get(x) + "";
   ok = false;
   break;
   }
  }
  if (ok) {
   return null;
  }
  }
 }
 return board;
 }

 public void print_board(String[][] board, int m) {
 int n = m * m;
 int hard = 5;
 String[][] b = new String[n][n];
 System.arraycopy(board, 0, b, 0, board.length);
 Random rd = new Random();
 for (int i = 0; i < hard; i++) {
  for (int j = 0; j < n; j++) {
  int x = rd.nextInt(9);
  b[x][j] = null;
  }
 }
 String spacer = "+-----+-----+-----+-----+-----+-----+-----+-----+-----+";
 System.out.println(spacer);
 for (int i = 0; i < n; i++) {
  for (int j = 0; j < n; j++) {
  if (null == board[i][j]) {
   System.out.print("| |");
  } else {
   System.out.print("| " + b[i][j] + " |");
  }
  }
  System.out.println();
  System.out.println(spacer);
 }
 }

 /**
 * 判断行列和9格里是否重复
 *
 * @param x
 * @param board
 * @return
 */
 private boolean isOk(String x, String[][] board, int i, int j, int m) {
 int i0 = i - i % m, j0 = j - j % m;
 int n = m * m;
 for (int k = 0; k < n; k++) {
  if (x.equals(board[i][k]) || x.equals(board[k][j])) {
  return false;
  }
 }
 for (int k = i0; k < i; k++) {
  for (int g = j0; g < j0 + m; g++) {
  if (board[k][g].equals(x)) {
   return false;
  }
  }
 }
 return true;
 }

 public static void main(String[] args) {
 Shudu s = new Shudu();
 int m = 3;
 String[][] b = s.make_board(m);
 for (int i = 0; i < 9; i++) {
  for (int j = 0; j < 9; j++) {
  System.out.print(b[i][j] + " ");
  }
  System.out.println();
 }
 s.print_board(b, m);
 }
}

效果:

3 4 7 6 5 2 8 1 9
5 9 6 8 3 1 4 2 7
2 1 8 9 7 4 5 3 6
1 3 4 7 9 5 6 8 2
7 5 2 1 8 6 9 4 3
6 8 9 4 2 3 1 7 5
4 7 5 3 1 9 2 6 8
8 2 1 5 6 7 3 9 4
9 6 3 2 4 8 7 5 1
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| || || || 6 || 5 || || 8 || 1 || 9 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| 5 || 9 || 6 || || || || 4 || || 7 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| 2 || || || 9 || 7 || 4 || 5 || || 6 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| 1 || 3 || 4 || 7 || 9 || || 6 || || |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| || 5 || 2 || 1 || || || || 4 || |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| || || || || 2 || 3 || || 7 || |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| 4 || 7 || || || 1 || 9 || || 6 || 8 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| || 2 || 1 || 5 || 6 || 7 || || || 4 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| 9 || 6 || || || || || || 5 || 1 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+

可以看出java的代码量是python的两倍。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

您可能感兴趣的文章:

  • 简单实现python数独游戏
  • python实现解数独程序代码
  • Python如何判断数独是否合法
  • python实现数独算法实例
  • Java基于二维数组实现的数独问题示例
  • java数独游戏完整版分享
  • java版数独游戏界面实现(二)
  • java版数独游戏核心算法(一)
  • 简单实现java数独游戏
  • Java实现解数独的小程序
(0)

相关推荐

  • java版数独游戏界面实现(二)

    本文实例为大家分享了java版数独游戏界面实现的具体代码,供大家参考,具体内容如下 实现效果图: 这里写图片描述 主函数用于启动程序: package hlc.shudu.app; import hlc.shudu.src.ShuduHelper; import hlc.shudu.ui.ShuduMainFrame; public class AppStart { public static void main(String[] args) { ShuduMainFrame mainFrame

  • 简单实现java数独游戏

    本文实例为大家分享了java数独游戏的具体代码,供大家参考,具体内容如下 打算把javaFx需要的组件装好以后直接用javaFx的,但似乎eclipse的版本不对,安装了也不能用... 数独代码是在之前寒假受命写的,学了一个月java的成果,现在看来有些不足但毕竟是第一个程序,就直接放上来,数独终盘的实现直接用了暴力,时间复杂度有点高,懒得改了直接放代码 终盘实现: import java.util.Random; public class SudokuPuzzleGenerator { pri

  • java数独游戏完整版分享

    本文实例为大家分享了java数独游戏的具体代码,供大家参考,具体内容如下 自己写的数独游戏,共9关,代码如下: 1.DoShudu类用于产生数独数组 import java.util.Random; public class DoShudu { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub int[][] cells=newshudu(); //ce

  • Python如何判断数独是否合法

    介绍 该数独可能只填充了部分数字,其中缺少的数字用 . 表示. 注意事项 一个合法的数独(仅部分填充)并不一定是可解的.我们仅需使填充的空格有效即可. 解体思路 将数独按照行.列和块进行预处理,然后分别判断是否合法. 利用Python的表达式推导,匿名函数和all函数可以很方便的进行处理. 代码 class Solution: # @param board, a 9x9 2D array # @return a boolean def isValidSudoku(self, board): ro

  • python实现数独算法实例

    本文实例讲述了python实现数独算法的方法.分享给大家供大家参考.具体如下: # -*- coding: utf-8 -*- ''' Created on 2012-10-5 @author: Administrator ''' from collections import defaultdict import itertools a = [ [ 0, 7, 0, 0, 0, 0, 0, 0, 0], #0 [ 5, 0, 3, 0, 0, 6, 0, 0, 0], #1 [ 0, 6, 2

  • java版数独游戏核心算法(一)

    之前学习javascript时用javascript写过一个数独游戏,最近看了一点java的内容,于是就心血来潮想搞一个java版的数独游戏. 现在将全部代码分享出来和大家学习交流,当然代码中有着各种各样的问题和不足之处,望各位朋友批评指点. 以下是生成数独地图的核心算法,算法不是很好,也是之前参考过网上的一些思想: package hlc.shudu.src; /* * 数独的帮助类,里面提供数据所需的所有算法 */ public class ShuduHelper { //数独地图数组 pr

  • 简单实现python数独游戏

    网上看到一个python写的数独,很好玩,分享给大家. import random import itertools from copy import deepcopy def make_board(m = 3): numbers = list(range(1, m**2 + 1)) board = None while board is None: board = attempt_board(m, numbers) return board def attempt_board(m, numbe

  • python实现解数独程序代码

    偶然发现linux系统附带的一个数独游戏,打开玩了几把.无奈是个数独菜鸟,以前没玩过,根本就走不出几步就一团浆糊了. 于是就打算借助计算机的强大运算力来暴力解数独,还是很有乐趣的. 下面就记录一下我写解数独程序的一些思路和心得. 一.数独游戏的基本解决方法 编程笼统的来说,就是个方法论.不论什么程序,都必须将问题的解决过程分解成计算机可以实现的若干个简单方法.俗话说,大道至简.对于只能明白0和1的计算机来说,就更需要细分步骤,一步一步的解决问题了. 首先来思考一下解数独的基本概念. 数独横九竖九

  • Java基于二维数组实现的数独问题示例

    本文实例讲述了Java基于二维数组实现的数独问题.分享给大家供大家参考,具体如下: 这里利用Java二维数组实现数独问题. (1)生成简易数独 (2)生成数独问题** 代码 import java.util.Random; import java.util.ArrayList; public class Suduku { /** *打印二维数组,数独矩阵 */ public static void printArray(int a[][]) { for (int i = 0; i < 9; i+

  • Java实现解数独的小程序

    前言 数独相信很多人都玩过,趣味性很强,十分的耐玩.可有没有程序员想过玩实现一个数独布局的算法呢?算法是个很有意思,很神奇的东西. 算法如下,需要预先给出几个固定的值,目前解决的一个最难的数独是大概26个已知值的情况,理论上应该能解决任意已知值的数独,不过不知道会不会迭代栈溢出--因为在26个已知值的情况下就迭代了3000多次了,囧~~~ 结果显示如下: 这是已知值: 1 1 2 1 4 8 1 5 5 1 6 1 1 7 7 1 8 3 2 1 1 2 2 6 2 4 4 3 5 9 3 7

随机推荐