Android开发实例-自动生成题库的数独

最新推荐文章于 2022-03-27 19:21:04 发布
最新推荐文章于 2022-03-27 19:21:04 发布
阅读量1.7k 收藏 6
点赞数 1
分类专栏： Android 文章标签： android

本系列文章主要介绍如何利用Android开发一个自动生成题目的数独游戏。涉及的知识和技术如下所示：
挖洞算法自动生成数独题目实现自定义View用于绘制数独盘数据库的基本操作

看着市场上千篇一律的数独应用，他们大都来自于同一个开源应用，题目都是固定不变的那么100多道。我们就没有方法改变数独题目吗？经过百度搜索，终于找到了一篇自动生成数独题库的算法，感谢原作者的理论以及网络上的部分代码。算法文档题库： IBTlo2hrjqcUOMcQ39ddYx1PaOnF0wjQycQTSYKIHJ5JUK-7WCK9Tz_BvDXQcio8I22k_xu1RZkwUYlUqFTZSa-jzyxgDfY3Ga93U34u

算法思想在文档中已经描述的十分具体，我们根据算法以及网络上的部分代码封装了可以生成任意难度数独的实体Sudoku，代码如下所示：

import java.util.ArrayList;
import java.util.Random;

/**
* 采用挖洞算法实现。不同难度将会有不同的最小填充格子数和已知格子数
*
*/
public class Sudoku {
private int[][] orginData; //保存初始状态的数独
// 初始化生成数组
private int[][] sudokuData = { { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0 } };
// 终盘数组
private int[][] resultData;
// 最小填充格子数
private int minFilled;
// 最小已知格子数
private int minKnow;
// 当前难度级别;1-2简单难度；3普通难度；4高级难度；5骨灰级难度
private int level;

private Random ran = new Random();

public Sudoku() {

// this(3); // 默认为普通难度
}

public Sudoku(int level) {
    if (level < 0 || level > 6) {
        this.level = 3;
    } else {
        this.level = level;
    }
    switch (level) {
    case 1:
    case 2:
        int ranNum = ran.nextInt(10);
        if(ranNum > 4) {
            minKnow = 5;
        } else {
            minKnow = 4;
        }
        minFilled = 45 + ranNum;
        break;

// case 2:
// minFilled = 45 + ran.nextInt(5);
// minKnow = 4;
// break;
case 3:
minFilled = 31 + ran.nextInt(10);
minKnow = 3;
break;
case 4:
minFilled = 21 + ran.nextInt(10);
minKnow = 2;
break;
case 5:
minFilled = 17 + ran.nextInt(10);
minKnow = 0;
break;
default:
break;
}
genSuduku();
orginData = new int[9][9];
for(int i = 0; i < 9; i++) {
System.arraycopy(sudokuData[i], 0, orginData[i], 0, 9);
}
}

/**
 * 生成唯一解的数独
 */
public void genSuduku() {
    int startX = ran.nextInt(9), startY = ran.nextInt(9); // 初始挖洞格子
    int orignStartX = startX, orignStartY = startY; // 暂存初始格子
    int filledCount = 81; // 当前已知格子数

// int curMinKnow = 9; // 当前已知行列已知格子的下限
genShuduKnow(11);
if (solve(sudokuData, true)) {
// 将终盘赋值给初始数独数组
for (int i = 0; i < 9; i++) {
System.arraycopy(resultData[i], 0, sudokuData[i], 0, 9);
}
// 实行等量交换
sudokuData = equalChange(sudokuData);
Point nextP; // 下一个挖洞位置
do {
int temMinKnow = getMinknow(sudokuData, startX, startY);
if (isOnlyAnswer(sudokuData, startX, startY)
&& temMinKnow >= minKnow) {
sudokuData[startX][startY] = 0;
filledCount–;
// curMinKnow = temMinKnow;
}
nextP = next(startX, startY);
startX = nextP.x;
startY = nextP.y;
//校验此洞是否已挖
while(sudokuData[startX][startY] == 0 && (orignStartX != startX || orignStartY != startY)) {
nextP = next(startX, startY);
startX = nextP.x;
startY = nextP.y;
}
//初级难度处理
if(level == 1 || level == 2) {
while(startX == orignStartX && startY == orignStartY) {
nextP = next(startX, startY);
startX = nextP.x;
startY = nextP.y;
}
}
} while (filledCount > minFilled
&& (orignStartX != startX || orignStartY != startY));
} else {
// 重新生成唯一解数独，直到成功为止
genSuduku();
}
}

/**
 * 获取下一个挖洞点
 * 
 * @param x
 * @param y
 * @return
 */
public Point next(int x, int y) {
    Point p = null;
    switch (level) {
    case 1:
    case 2: // 难度1、2均为随机算法
        p = new Point(ran.nextInt(9), ran.nextInt(9));
        break;
    case 3: // 难度3 间隔算法
        if (x == 8 && y == 7) {
            p = new Point(0, 0);
        } else if (x == 8 && y == 8) {
            p = new Point(0, 1);
        } else if ((x % 2 == 0 && y == 7) || (x % 2 == 1) && y == 0) {
            p = new Point(x + 1, y + 1);
        } else if ((x % 2 == 0 && y == 8) || (x % 2 == 1) && y == 1) {
            p = new Point(x + 1, y - 1);
        } else if (x % 2 == 0) {
            p = new Point(x, y + 2);
        } else if (x % 2 == 1) {
            p = new Point(x, y - 2);
        }
        break;
    case 4: // 难度4 蛇形算法
        p = new Point();
        if (x == 8 && y == 8) {
            p.y = 0;
        } else if (x % 2 == 0 && y < 8) { // 蛇形顺序，对下个位置列的求解
            p.y = y + 1;
        } else if ((x % 2 == 0 && y == 8) || (x % 2 == 1 && y == 0)) {
            p.y = y;
        } else if (x % 2 == 1 && y > 0) {
            p.y = y - 1;
        }

        if (x == 8 && y == 8) { // 蛇形顺序，对下个位置行的求解
            p.x = 0;
        } else if ((x % 2 == 0 && y == 8) || (x % 2 == 1) && y == 0) {
            p.x = x + 1;
        } else {
            p.x = x;
        }
        break;
    case 5: // 从左至右，从上到下
        p = new Point();
        if (y == 8) {
            if (x == 8) {
                p.x = 0;
            } else {
                p.x = x + 1;
            }
            p.y = 0;
        } else {
            p.x = x;
            p.y = y + 1;
        }
    default:
        break;
    }
    return p;
}

/**
 * 生成指定个数的已知格子
 * 
 * @param n
 */
public void genShuduKnow(int n) {
    // 生成n个已知格子
    Point[] knowPonits = new Point[n];
    for (int i = 0; i < n; i++) {
        knowPonits[i] = new Point(ran.nextInt(9), ran.nextInt(9));
        // 检测是否重复
        for (int k = 0; k < i; k++) {
            if (knowPonits[k].equals(knowPonits[i])) {
                i--;
                break;
            }
        }
    }
    // 填充数字
    int num;
    Point p;
    for (int i = 0; i < n; i++) {
        num = 1 + ran.nextInt(9);
        p = knowPonits[i];
        sudokuData[p.x][p.y] = num;
        if (!validateIandJ(sudokuData, p.x, p.y)) {
            // 生成格子填充数字错误
            i--;
        }
    }

}

/**
 * 等量交换
 * 
 * @param data
 * @return
 */
public int[][] equalChange(int[][] data) {
    Random rand = new Random();
    int num1 = 1 + rand.nextInt(9);
    int num2 = 1 + rand.nextInt(9);
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            if (data[i][j] == 1) {
                data[i][j] = num1;
            } else if (data[i][j] == num1) {
                data[i][j] = 1;
            }

            if (data[i][j] == 2) {
                data[i][j] = num2;
            } else if (data[i][j] == num2) {
                data[i][j] = 2;
            }
        }
    }
    return data;
}

/**
 * 判断挖去i,j位置后，是否有唯一解
 * 
 * @param data
 * @param i
 * @param j
 * @return
 */
public boolean isOnlyAnswer(int[][] data, int i, int j) {
    int k = data[i][j]; // 待挖洞的原始数字
    for (int num = 1; num < 10; num++) {
        data[i][j] = num;
        if (num != k && solve(data, false)) {
            // 除待挖的数字之外，还有其他的解，则返回false
            data[i][j] = k;
            return false;
        }
    }
    data[i][j] = k;
    return true;
}

/**
 * 删除指定位置后，新的行列下限
 * 
 * @param data
 * @param p
 * @param q
 * @return
 */
public int getMinknow(int[][] data, int p, int q) {
    int temp = data[p][q];
    int minKnow = 9;
    int tempKnow = 9;
    data[p][q] = 0;
    for (int i = 0; i < 9; i++) {
        // 行下限
        for (int j = 0; j < 9; j++) {
            if (data[i][j] == 0) {
                tempKnow--;
                if (tempKnow < minKnow) {
                    minKnow = tempKnow;
                }
            }
        }
        tempKnow = 9;
    }
    tempKnow = 9;
    for (int j = 0; j < 9; j++) {
        // 列下限
        for (int i = 0; i < 9; i++) {
            if (data[i][j] == 0) {
                tempKnow--;
                if (tempKnow < minKnow) {
                    minKnow = tempKnow;
                }
            }
        }
        tempKnow = 9;
    }
    data[p][q] = temp;
    // 返回删除后的下限
    return minKnow;
}

/**
 * 判断数独是否能解
 * 
 * @param data
 * @return
 */
public boolean solve(int[][] data, boolean flag) {
    int blankCount = 0; // 保存空位个数
    int[][] tempData = new int[9][9]; // 中间数组
    ArrayList blankList = new ArrayList(70); // 保存各个空格坐标
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            tempData[i][j] = data[i][j];
            if (tempData[i][j] == 0) {
                blankCount++;
                blankList.add(new Point(i, j));
            }
        }
    }
    // 校验数独合法性
    if (!validate(tempData)) {
        return false;
    }
    if (blankCount == 0) {
        // 玩家已经成功解出数独
        return true;
    } else if (put(tempData, 0, blankList)) {
        if(flag) {
            // 智能解出答案，供生成数独终盘使用
            resultData = tempData;
        }
        return true;

    }
    return false;
}

/**
 * 在第n个空位子放入数字
 * 
 * @param data
 * @param n
 * @param blankList
 * @return
 */
public boolean put(int[][] data, int n, ArrayList blankList) {
    if (n < blankList.size()) {
        Point p = blankList.get(n);
        for (int i = 1; i < 10; i++) {
            data[p.x][p.y] = i;
            if (validateIandJ(data, p.x, p.y)
                    && put(data, n + 1, blankList)) {
                return true;
            }
        }
        data[p.x][p.y] = 0;
        return false;
    } else {
        return true;
    }
}

/**
 * 校验x, y位置填充的数字是否可行
 * 
 * @param data
 * @param x
 * @param y
 * @return
 */
public boolean validateIandJ(int[][] data, int x, int y) {
    int m = 0, n = 0, p = 0, q = 0; // m,n是计数器，p,q用于确定测试点的方格位置
    for (m = 0; m < 9; m++) {
        if (m != x && data[m][y] == data[x][y]) {
            return false;
        }
    }
    for (n = 0; n < 9; n++) {
        if (n != y && data[x][n] == data[x][y]) {
            return false;
        }
    }
    for (p = x / 3 * 3, m = 0; m < 3; m++) {
        for (q = y / 3 * 3, n = 0; n < 3; n++) {
            if ((p + m != x || q + n != y)
                    && (data[p + m][q + n] == data[x][y])) {
                return false;
            }
        }
    }
    return true;
}

/**
 * 校验整个数独数组的合法性
 * 
 * @param data
 * @return
 */
public boolean validate(int[][] data) {
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            if (data[i][j] != 0 && !validateIandJ(data, i, j)) {
                // 任何一个数字填充错误，则返回false
                return false;
            }
        }
    }
    return true;
}

/**
 * 获取冲突列表
 * @return
 */
public ArrayList validateForList() {
    ArrayList pList = new ArrayList();
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            if (sudokuData[i][j] != 0 && !validateIandJ(sudokuData, i, j)) {
                pList.add(new Point(i, j));
            }
        }
    }
    return pList;
}

public int[][] myResultData() {
    return resultData;
}

public int[][] myInitData() {
    return orginData;
}

public int[][] mySudoku() {
    return sudokuData;
}

/**
 * 判断格子是否为已知格子
 * @param x
 * @param y
 * @return
 */
public boolean isKnownCell(int x, int y) {
    return orginData[x][y] != 0;
}

public void makeToInitData() {
    for(int i = 0; i < 9; i++) {
        System.arraycopy(orginData[i], 0, sudokuData[i], 0, 9);
    }
}

public void set(int x, int y, int num) {
    sudokuData[x][y] = num;
}

public boolean isSuccess() {
    for(int i = 0; i < 9; i++) {
        for(int j = 0; j < 9; j++) {

// if(sudokuData[i][j] == 0 || sudokuData[i][j] != resultData[i][j]) {
// return false;
// }
if(sudokuData[i][j] == 0) {
return false;
}
}
}
return validate(sudokuData);
// return true;
}

public void setOrginData(int[][] orginData) {
    this.orginData = orginData;
}

public void setSudokuData(int[][] sudokuData) {
    this.sudokuData = sudokuData;
}

public void setResultData(int[][] resultData) {
    this.resultData = resultData;
}

}

calm_IT
关注
专栏目录
android游戏开发项目实战——数独
黄俊东的专栏
01-25 5864
一、程序运行效果图 二、代码实现 1、main.xml <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="m
Android核心技术与实例详解—Android游戏开发实践—快乐数独(附完整源码)
05-29
NULL 博文链接：https://suyuening.iteye.com/blog/854759
数独自动生成题库
09-09
学习了Mars老师的数独游戏教程，奈何题库太单调，于是查找资料，增加了难度选择自动生成题库功能，游戏胜利后会弹框提示
Android经典实例_快乐数独_源文件
12-13
Android经典实例快乐数独的源文件，希望对大家有帮助
自动生成指定特征的数独题目（未完待续）
weixin_34122548的博客
09-14 677
　　我中学时常填数独，好像是来自《课堂内外》杂志，倒数一二页有时候会有个数独。 　　而现在，我想做个数独机，预设功能如下：用户选择特征，数独机随机生成符合此特征的一个数独。 　　因为选择的特征一般来说是若干个数独共有的特征，只有极特别的特征单属于一两个数独题。 　　首先可以计算一下所有的数独题目共有多少个，这个不难，毕竟每个数独只有9*9==81个格子，并且只能填入1—9这9个数字，所有数独...
源代码-iOS开发实例-数独小游戏
11-01
这是一个实现非常简单的数独游戏APP项目源代码，推荐在iPhone11上运行。没有复杂算法，主要难度只在于故事板的搭建上...缺点是数独盘面相对固定，未实现数独盘面的随机生成、不同难度题目的生成以及自动计算数独的解。
数独九宫格，excel自动生成版
最新发布
07-08
excel为数独9宫格自动生成版本。下载excel后，打开下方的sheet1，即为九宫格题目，复制到word内打印即可。 详细说明： 1.更改sheet2内的A1单元格内的数字（范围1-9），可以调节数独的难度，1难度最低，9难度最高，...
微信小程序开发-游戏类-数独案例源码.zip
08-15
这包括初始化数独盘面、验证用户输入、生成新游戏、检查游戏是否解决等功能。这部分代码可能会涉及到数组操作、递归算法（如深度优先搜索）以及错误处理。 5. **事件绑定**：用户与界面交互时，例如点击单元格输入...
c++趣味编程------数独
06-06
c++趣味编程------数独 无解释 可以自己改代码 无bug
数独问题的一种简单算法代码实现
MulinB的技术博客
05-06 2977
五一期间无聊时想起去年考研复试有一道上机题目当时没作出来，于是一时兴起想重新拾起看看是当时太紧张，还是自己能力不足。然后发现这道题目还真稍微有些难度，相当于一道数独问题(sudoku)的简化版。自己想来想去也只能想到两种算法，一种是拿剩余元素做全排列测试，一种是回溯法测试。最后只实现了一个全排列测试的算法。然后又发现自己要写一个非递归的全排列(permutation)也有难度，想了两天，也没搞出来
Android开发的数独（特别好用的课程设计）
01-03
特别好用的课程设计，改改就能交，代码能直接运行，好东西，注释全，好东西 当然贵，自己在工作中研发的小项目
AutoClicker:使用Android Studio辅助功能制作的自动答题器应用
05-28
自动点击器 使用android studio辅助功能制作的自动答题器应用程序在可拖动的浮动窗口上按下“开始”按钮后，该应用程序将代表用户在浮动窗口的当前位置“点击”屏幕
九宫格数独题目生成器.rar
04-16
九宫格数独题目生成器，已更新多线程处理。本人原创，请勿转载。
数独游戏答案生成器 真牛逼
03-31
数独游戏终结者 不要再为数独游戏而纠结了 只要一输入 答案马上给出 当之无愧的数独游戏"终结者"
数独游戏的生成以及自动求解
06-10
一款非常精美的熟读游戏，游戏界面色彩绚丽。菜单分三个选项，第1、2个为玩家模式（需要将文件放在子目录下），3为自动演示模式，第2、3个都通过上下滑动的菜单选择，只要是有解的数独都能完成，如果无解会提示有错。游戏在cmd窗口下运行，无需下载其余头文件等，在vs上运行通过。
Android 游戏开发之 数独游戏
哈怂的博客
09-19 7796
数独游戏(日语:数独 すうどく)是一种源自18世纪末的瑞士的游戏，后在美国发展、并在日本得以发扬光大的数学智力拼图游戏。在每一个小九宫格中，分别填上1至9的数字，让整个大九宫格每一列、每一行的数字都不重复。 数独的玩法逻辑简单，数字排列方式千变万化，是锻炼脑筋的好方法。       本文实现简单的数独游戏，通过mars的视频教程完成编程 1.自定义View： package com.ex
1.数独游戏（生成题目解唯一）
热门推荐
一条咸鱼的博客
09-06 2万+
前几天在玩数独游戏的时候，产生了一个大胆的想法： 数独app上的题目都是现成的，干脆自己写一个可以随机生成数独的程序算了 一、需求提出： 1.随机生成数独题目，要求该题目有解（有一个解最好）； 2.当填数违反数独操作（填到题目原本的数字去了，填数违规等）时，禁止操作，弹出提示; 3.当81格都填满时，判断对错; 二、需求分析 总： 需求2,3相对简单，尤其是...
Android随机出加减乘除的四则运算算术题
Abtxr的博客
03-27 2015
点击显示题目即可在指定范围内随机出算数题目，适合初学者上手，易懂，另外，我没有把每一种运算的可能性都写出来，只写了部分的，不过两个数，三个数和四个数运算的可能性我都写了1-2中，你们可以比划模仿去写出其他的运算可能性，也很容易的，下面上代码！ xml布局 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
无重复数独题目生成
weixin_42420126的博客
06-02 563
我算半个数独爱好者，但是市面上的数独软件很多都有广告，web版则需要联网，就想着自己用写一个。简简单单用swing，搭建好GUI后，发现最大的问题居然是数独题目的生成。从网上找题库实在是不甘心，github ...
Android游戏开发实战：快乐数独教程
Android游戏开发-Android开发实例是一份针对Android平台的实战教程，特别关注于将数独游戏设计和实现的过程。该教程以"快乐数独"为主题，旨在帮助开发者理解和掌握Android游戏开发的基本原理和技术，同时强调游戏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值