Игра Sudoku в Golang - Пишем игру с нуля в Golang

Судоку является логической головоломкой, действие которой разыгрывается на сетке размером 9 х 9. Каждый квадрат содержит цифру от 1 до 9. Ноль означает пустой квадрат.

Сетка разделена на девять частей, размер каждого 3 х 3. При размещении цифры нужно учитывать определенные ограничения. Размещенная цифра не должна повторяться в следующих местах:

Премиум 👑 канал по Golang

Рекомендуем вам супер TELEGRAM канал по Golang где собраны все материалы для качественного изучения языка. Удивите всех своими знаниями на собеседовании! 😎

Подписаться на канал

Уроки, статьи и Видео

Мы публикуем в паблике ВК и Telegram качественные обучающие материалы для быстрого изучения Go. Подпишитесь на нас в ВК и в Telegram. Поддержите сообщество Go программистов.

Go в ВК ЧАТ в Telegram

Горизонтальный ряд размещения;
Вертикальный столбец размещения;
Часть 3 х 3 размещения.

Используйте массив с фиксированным размером (9 х 9) для хранения сетки Судоку. Если функция или метод нуждается в редактировании массива, помните, что вам нужно передать массив с указателем.

Имплементируйте метод для установки цифры на определенное местоположение. Данный метод должен возвращать ошибку, если размещение цифры нарушает правила.

Также создайте метод для очищения квадрата от цифры. Данный метод не должен придерживаться правил, так как пустыми могут быть несколько квадратов (ноль).

Головоломка Судоку начинается с определенным набором установленных цифр. Напишите функцию конструктора для подготовки Судоку, используйте композитный литерал для уточнения начальных значений. Далее дан пример:

массив судоку

Начальные цифры находятся в фиксированном месте, их нельзя переписать или очистить. Модифицируйте программу так, чтобы она могла идентифицировать, какие цифры фиксированные, а какие вписаны пользователем. Добавьте подтверждение, что возвращает ошибку при попытке установить или очистить цифру к клетку, где уже есть фиксированная цифра. Изначально цифры, что являются нулями, могут быть установлены, переписаны или очищены.

Вам не обязательно писать решение Судоку для данного упражнения, но обязательно протестируйте программу и убедитесь, что все правила соблюдаются правильно.

В конце можете сравнить свой вариант с нашим.

Программа Судоку Golang

package main

import (
    "errors"
    "fmt"
    "os"
)

const (
    rows, columns = 9, 9
    empty         = 0
)

// Cell является квадратом сетки Судоку
type Cell struct {
    digit int8
    fixed bool
}

// Grid является сеткой Судоку
type Grid [rows][columns]Cell

// Ошибки, что могут возникнуть
var (
    ErrBounds     = errors.New("за пределами")
    ErrDigit      = errors.New("неправильная цифра")
    ErrInRow      = errors.New("эта цифра уже есть в ряду")
    ErrInColumn   = errors.New("эта цифра уже есть в столбце")
    ErrInRegion   = errors.New("в данной части эта цифра уже есть")
    ErrFixedDigit = errors.New("начальные цифры нельзя переписать")
)

// NewSudoku делает новую сетку Судоку
func NewSudoku(digits [rows][columns]int8) *Grid {
    var grid Grid
    for r := 0; r < rows; r++ {
        for c := 0; c < columns; c++ {
            d := digits[r][c]
            if d != empty {
                grid[r][c].digit = d
                grid[r][c].fixed = true
            }
        }
    }
    return &grid
}

// Устанавливает цифры на сетку
func (g *Grid) Set(row, column int, digit int8) error {
    switch {
    case !inBounds(row, column):
        return ErrBounds
    case !validDigit(digit):
        return ErrDigit
    case g.isFixed(row, column):
        return ErrFixedDigit
    case g.inRow(row, digit):
        return ErrInRow
    case g.inColumn(column, digit):
        return ErrInColumn
    case g.inRegion(row, column, digit):
        return ErrInRegion
    }

    g[row][column].digit = digit
    return nil
}

// Очищает клетку на сетке Судоку
func (g *Grid) Clear(row, column int) error {
    switch {
    case !inBounds(row, column):
        return ErrBounds
    case g.isFixed(row, column):
        return ErrFixedDigit
    }

    g[row][column].digit = empty
    return nil

}

func inBounds(row, column int) bool {
    if row < 0 || row >= rows || column < 0 || column >= columns {
        return false
    }
    return true
}

func validDigit(digit int8) bool {
    return digit >= 1 && digit <= 9
}

func (g *Grid) inRow(row int, digit int8) bool {
    for c := 0; c < columns; c++ {
        if g[row][c].digit == digit {
            return true
        }
    }
    return false
}

func (g *Grid) inColumn(column int, digit int8) bool {
    for r := 0; r < rows; r++ {
        if g[r][column].digit == digit {
            return true
        }
    }
    return false
}

func (g *Grid) inRegion(row, column int, digit int8) bool {
    startRow, startColumn := row/3*3, column/3*3
    for r := startRow; r < startRow+3; r++ {
        for c := startColumn; c < startColumn+3; c++ {
            if g[r][c].digit == digit {
                return true
            }
        }
    }
    return false
}

func (g *Grid) isFixed(row, column int) bool {
    return g[row][column].fixed
}

func main() {
    s := NewSudoku([rows][columns]int8{
        {5, 3, 0, 0, 7, 0, 0, 0, 0},
        {6, 0, 0, 1, 9, 5, 0, 0, 0},
        {0, 9, 8, 0, 0, 0, 0, 6, 0},
        {8, 0, 0, 0, 6, 0, 0, 0, 3},
        {4, 0, 0, 8, 0, 3, 0, 0, 1},
        {7, 0, 0, 0, 2, 0, 0, 0, 6},
        {0, 6, 0, 0, 0, 0, 2, 8, 0},
        {0, 0, 0, 4, 1, 9, 0, 0, 5},
        {0, 0, 0, 0, 8, 0, 0, 7, 9},
    })

    err := s.Set(1, 1, 4)
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }

    for _, row := range s {
        fmt.Println(row)
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

package main

import (

"errors"

"fmt"

"os"

)

const (

rows, columns = 9, 9

empty = 0

)

// Cell является квадратом сетки Судоку

type Cell struct {

digit int8

fixed bool

}

// Grid является сеткой Судоку

type Grid [rows][columns]Cell

// Ошибки, что могут возникнуть

var (

ErrBounds = errors.New("за пределами")

ErrDigit = errors.New("неправильная цифра")

ErrInRow = errors.New("эта цифра уже есть в ряду")

ErrInColumn = errors.New("эта цифра уже есть в столбце")

ErrInRegion = errors.New("в данной части эта цифра уже есть")

ErrFixedDigit = errors.New("начальные цифры нельзя переписать")

)

// NewSudoku делает новую сетку Судоку

func NewSudoku(digits [rows][columns]int8) *Grid {

var grid Grid

for r := 0; r < rows; r++ {

for c := 0; c < columns; c++ {

d := digits[r][c]

if d != empty {

grid[r][c].digit = d

grid[r][c].fixed = true

}

return &grid

}

// Устанавливает цифры на сетку

func (g *Grid) Set(row, column int, digit int8) error {

switch {

case !inBounds(row, column):

return ErrBounds

case !validDigit(digit):

return ErrDigit

case g.isFixed(row, column):

return ErrFixedDigit

case g.inRow(row, digit):

return ErrInRow

case g.inColumn(column, digit):

return ErrInColumn

case g.inRegion(row, column, digit):

return ErrInRegion

}

g[row][column].digit = digit

return nil

}

// Очищает клетку на сетке Судоку

func (g *Grid) Clear(row, column int) error {

switch {

case !inBounds(row, column):

return ErrBounds

case g.isFixed(row, column):

return ErrFixedDigit

}

g[row][column].digit = empty

return nil

}

func inBounds(row, column int) bool {

if row < 0 || row >= rows || column < 0 || column >= columns {

return false

}

return true

}

func validDigit(digit int8) bool {

return digit >= 1 && digit <= 9

}

func (g *Grid) inRow(row int, digit int8) bool {

for c := 0; c < columns; c++ {

if g[row][c].digit == digit {

return true

}

return false

}

func (g *Grid) inColumn(column int, digit int8) bool {

for r := 0; r < rows; r++ {

if g[r][column].digit == digit {

return true

}

return false

}

func (g *Grid) inRegion(row, column int, digit int8) bool {

startRow, startColumn := row/3*3, column/3*3

for r := startRow; r < startRow+3; r++ {

for c := startColumn; c < startColumn+3; c++ {

if g[r][c].digit == digit {

return true

}

return false

}

func (g *Grid) isFixed(row, column int) bool {

return g[row][column].fixed

}

func main() {

s := NewSudoku([rows][columns]int8{

{5, 3, 0, 0, 7, 0, 0, 0, 0},

{6, 0, 0, 1, 9, 5, 0, 0, 0},

{0, 9, 8, 0, 0, 0, 0, 6, 0},

{8, 0, 0, 0, 6, 0, 0, 0, 3},

{4, 0, 0, 8, 0, 3, 0, 0, 1},

{7, 0, 0, 0, 2, 0, 0, 0, 6},

{0, 6, 0, 0, 0, 0, 2, 8, 0},

{0, 0, 0, 4, 1, 9, 0, 0, 5},

{0, 0, 0, 0, 8, 0, 0, 7, 9},

})

err := s.Set(1, 1, 4)

if err != nil {

fmt.Println(err)

os.Exit(1)

}

for _, row := range s {

fmt.Println(row)

}

Vasile Buldumac

Администрирую данный сайт с целью распространения как можно большего объема обучающего материала для языка программирования Go. В IT с 2008 года, с тех пор изучаю и применяю интересующие меня технологии. Проявляю огромный интерес к машинному обучению и анализу данных.

E-mail: vasile.buldumac@ati.utm.md

Образование

Технический Университет Молдовы (utm.md), Факультет Вычислительной Техники, Информатики и Микроэлектроники

2014 — 2018 Universitatea Tehnică a Moldovei, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
2018 — 2020 Universitatea Tehnică a Moldovei, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»