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

soduku.go

Arrays:数组

复制代码 代码如下:

在go语言中数组array是一组特定长度的有序的元素集合。

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(“”)
    }
}

复制代码 代码如下:

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

package main

您可能感兴趣的文章:

import “fmt”

func main() {

    //这里我们创建了一个长度为5的数组.
这一组数组的初值是zero-valued。整型就是0
    var a [5]int
    fmt.Println(“emp:”, a)

    //可以通过array[index] = value语法赋值
    a[4] = 100
    fmt.Println(“set:”, a)
    fmt.Println(“get:”, a[4])

    //内置的len函数会返回数组长度
    fmt.Println(“len:”, len(a))

    //通过这个语法声明数组的默认初值
    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println(“dcl:”, b)

    //数组类型是一维的,但是你可以通过组合创建多维数组结构
    var twoD [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println(“2d: “, twoD)
}

$ go run arrays.go
emp: [0 0 0 0 0]
set: [0 0 0 0 100]
get: 100
len: 5
dcl: [1 2 3 4 5]
2d:  [[0 1 2] [1 2 3]]

Slices:切片

Slices是Go语言中的关键数据类型,它有比数组(arrays)更强的访问接口。

复制代码 代码如下:

package main

import “fmt”

func main() {

   
//跟数组(arrays)不同,slices的类型跟所包含的元素类型一致(不是元素的数量)。使用内置的make命令,构建一个非零的长度的空slice对象。这里我们创建了一个包含了3个字符的字符串
。(初始化为零值zero-valued)
    s := make([]string, 3)
    fmt.Println(“emp:”, s)

    //我们可以像数组一样进行设置和读取操作。
    s[0] = “a”
    s[1] = “b”
    s[2] = “c”
    fmt.Println(“set:”, s)
    fmt.Println(“get:”, s[2])

    //获取到的长度就是当时设置的长度。
    fmt.Println(“len:”, len(s))

   
//相对于这些基本的操作,slices支持一些更加复杂的功能。有一个就是内置的append,可以在现有的slice对象上添加一个或多个值。注意要对返回的append对象重新赋值,以获取最新的添加了元素的slice对象。
    s = append(s, “d”)
    s = append(s, “e”, “f”)
    fmt.Println(“apd:”, s)

    //Slices也可以被复制。这里我们将s复制到了c,长度一致。
    c := make([]string, len(s))
    copy(c, s)
    fmt.Println(“cpy:”, c)

   
//Slices支持”slice”操作,语法为slice[low:high](即截取slice中的某段值)。下面这段代码就会获取这些字符:
s[2], s[3], 和 s[4]。
    l := s[2:5]
    fmt.Println(“sl1:”, l)

    //从开始截取到每5个字符(除了值)
    l = s[:5]
    fmt.Println(“sl2:”, l)

    //从第二个(包括)字符开始截取到最后一个
    l = s[2:]
    fmt.Println(“sl3:”, l)

    //我们可以将声明和赋值放在一行。
    t := []string{“g”, “h”, “i”}
    fmt.Println(“dcl:”, t)

   
//Slices可以被组合成多维数组。里面一维的slices对象可以不等长,这一点跟多维数组不太一样。
    twoD := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println(“2d: “, twoD)
}

注意slices跟arrays是两种不同的数据类型,但是他们的fmt.Println打印方式很相似。

复制代码 代码如下:

$ go run slices.go
emp: [  ]
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
2d:  [[0] [1 2] [2 3 4]]

相关文章