脚本之家,脚本语言编程技术及教程分享平台!
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - Go语言实现的最简单数独解法

Go语言实现的最简单数独解法

2020-04-24 11:47脚本之家 Golang

前面给大家介绍过使用javascript实现的简单的数独解法,小伙伴们都非常喜欢,今天我们再来分享一则go语言实现的简单的数独解法,有需要的小伙伴来参考下。

soduku.go

 

复制代码 代码如下:

package main
import (
    "fmt"
)
type node []int
var sudokuMay [9][9]node
var Sudoku = [9][9]int{
    {0, 0, 0, 0, 0, 0, 8, 0, 0},
    {0, 8, 2, 4, 0, 0, 0, 0, 0},
    {1, 9, 0, 0, 6, 3, 0, 0, 0},
    {0, 5, 0, 0, 8, 0, 7, 0, 0},
    {6, 7, 8, 2, 0, 9, 1, 4, 3},
    {0, 0, 3, 0, 4, 0, 0, 8, 0},
    {0, 0, 0, 6, 2, 0, 0, 9, 4},
    {0, 0, 0, 0, 0, 5, 6, 1, 0},
    {0, 0, 0, 6, 0, 0, 0, 0, 0}}
func main() {
    n := inited(Sudoku)
    SudokuSure, _ := sure(sudokuMay)
    for n > 0 {
        n = Subinit(SudokuSure)
        // Output(sudokuMay)
        // fmt.Println(n)
        SudokuSure, _ = sure(sudokuMay)
    }
    Output(sudokuMay)
    fmt.Println(isEnable(sudokuMay))
    // test()
}
func isEnable(tn [9][9]node) bool {
    for i := 0; i < 9; i++ {
        for j := 0; j < 9; j++ {
            if len(tn[i][j]) == 0 {
                return false
            }
        }
    }
    return true
}
func sure(may [9][9]node) (sure [9][9]int, n int) {
    n = 0
    for i := 0; i < 9; i++ {
        for j := 0; j < 9; j++ {
            if len(may[i][j]) == 1 {
                sure[i][j] = may[i][j][0]
                n++
            } else {
                sure[i][j] = 0
            }
        }
    }
    return
}
func test() {
    i, j := 1, 3
    fmt.Println(Sudoku[i][j])
    for k := ((i / 3) * 3); k < ((i/3)*3)+3; k++ {
        for l := ((j / 3) * 3); l < ((j/3)*3)+3; l++ {
            fmt.Print(Sudoku[k][l])
        }
        fmt.Println(" ")
    }
}
func inited(Sud [9][9]int) (changeCount int) {
    tmp := 0
    changeCount = 0
    for i := 0; i < 9; i++ {
        for j := 0; j < 9; j++ {
            if Sud[i][j] != 0 {
                sudokuMay[i][j] = append(sudokuMay[i][j], Sud[i][j])
            } else {
                for k := 0; k < 9; k++ {
                    sudokuMay[i][j] = append(sudokuMay[i][j], k+1)
                }
                sudokuMay[i][j], tmp = excludeMay(i, j, sudokuMay[i][j], Sud)
                changeCount += tmp
            }
        }
    }
    return
}
func Subinit(Sud [9][9]int) (changeCount int) {
    tmp := 0
    changeCount = 0
    for i := 0; i < 9; i++ {
        for j := 0; j < 9; j++ {
            if Sud[i][j] != 0 {
                sudokuMay[i][j][0] = Sud[i][j]
            } else {
                sudokuMay[i][j], tmp = excludeMay(i, j, sudokuMay[i][j], Sud)
                changeCount += tmp
            }
        }
    }
    return
}
func excludeMay(ti, tj int, t node, S [9][9]int) (rmay node, changeCount int) {
    changeCount = 0
    var tmpChangeCount int
    for i := 0; i < 9; i++ {
        if S[i][tj] != 0 {
            t, tmpChangeCount = exclude(t, S[i][tj])
            changeCount += tmpChangeCount
        }
        if S[ti][i] != 0 {
            t, tmpChangeCount = exclude(t, S[ti][i])
            changeCount += tmpChangeCount
        }
    }
    for k := ((ti / 3) * 3); k < ((ti/3)*3)+3; k++ {
        for l := ((tj / 3) * 3); l < ((tj/3)*3)+3; l++ {
            if S[k][l] != 0 {
                t, tmpChangeCount = exclude(t, S[k][l])
                changeCount += tmpChangeCount
            }
        }
    }
    rmay = t
    return
}
func excludeFirstOne(smay node, n int) (rmay node, changeCount int) {
    changeCount = 0
    rmay = smay
    for i := 0; i < len(smay); i++ {
        if smay[i] == n {
            changeCount++
            rmay = append(smay[:i], smay[i+1:]...)
            return
        }
        if i == len(smay)-1 {
            return
        }
    }
    return
}
func exclude(smay node, n int) (tmp node, changeCount int) {
    var nc int
    changeCount = 0
    tmp, nc = excludeFirstOne(smay, n)
    for nc > 0 {
        tmp, nc = excludeFirstOne(tmp, n)
        changeCount++
    }
    return
}
func Output(sudoku [9][9]node) {
    for i := 0; i < 9; i++ {
        for j := 0; j < 9; j++ {
            fmt.Print(sudokuMay[i][j])
        }
        fmt.Println("")
    }
}

 

以上就是本文给大家分享的代码的全部内容了,希望大家能够喜欢。

延伸 · 阅读

精彩推荐
  • Golanggo语言获取系统盘符的方法

    go语言获取系统盘符的方法

    这篇文章主要介绍了go语言获取系统盘符的方法,涉及Go语言调用winapi获取系统硬件信息的技巧,具有一定参考借鉴价值,需要的朋友可以参考下 ...

    无尽海3862020-04-24
  • GolangGo语言基础单元测试与性能测试示例详解

    Go语言基础单元测试与性能测试示例详解

    这篇文章主要为大家介绍了Go语言基础单元测试与性能测试示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助祝大家多多进步...

    枫少文7812021-12-05
  • Golang深入浅析Go中三个点(...)用法

    深入浅析Go中三个点(...)用法

    这篇文章主要介绍了深入浅析Go中三个点(...)用法,需要的朋友可以参考下...

    踏雪无痕SS6472021-11-17
  • GolangGO语言字符串处理Strings包的函数使用示例讲解

    GO语言字符串处理Strings包的函数使用示例讲解

    这篇文章主要为大家介绍了GO语言字符串处理Strings包的函数使用示例讲解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步早日升职加...

    Jeff的技术栈6882022-04-14
  • GolangGolang实现四种负载均衡的算法(随机,轮询等)

    Golang实现四种负载均衡的算法(随机,轮询等)

    本文介绍了示例介绍了Golang 负载均衡的四种实现,主要包括了随机,轮询,加权轮询负载,一致性hash,感兴趣的小伙伴们可以参考一下...

    Gundy_8442021-08-09
  • GolangGo语言实现自动填写古诗词实例代码

    Go语言实现自动填写古诗词实例代码

    这篇文章主要给大家介绍了关于Go语言实现自动填写古诗词的相关资料,这是最近在项目中遇到的一个需求,文中通过示例代码介绍的非常详细,需要的朋...

    FengY5862020-05-14
  • GolangGo语言range关键字循环时的坑

    Go语言range关键字循环时的坑

    今天小编就为大家分享一篇关于Go语言range关键字循环时的坑,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来...

    benben_20154202020-05-23
  • GolangGolang 语言极简类型转换库cast的使用详解

    Golang 语言极简类型转换库cast的使用详解

    本文我们通过 cast.ToString() 函数的使用,简单介绍了cast 的使用方法,除此之外,它还支持很多其他类型,在这没有多多介绍,对Golang 类型转换库 cast相关知...

    Golang语言开发栈6112021-12-02