20

推測を使用して最短の数独ソルバーを実装します。いくつかのリクエストを受け取ったので、ブルートフォースの数独ソルバーを実装したい人のための代替の質問としてこれを追加しました。

数独パズル：

 | 1 2 3 | 4 5 6 | 7 8 9
-+-----------------------
A|   3   |     1 |
B|     6 |       |   5
C| 5     |       | 9 8 3
-+-----------------------
D|   8   |     6 | 3   2
E|       |   5   |
F| 9   3 | 8     |   6
-+-----------------------
G| 7 1 4 |       |     9
H|   2   |       | 8
I|       | 4     |   3

回答：

 | 1 2 3 | 4 5 6 | 7 8 9
-+-----------------------
A| 8 3 2 | 5 9 1 | 6 7 4
B| 4 9 6 | 3 8 7 | 2 5 1
C| 5 7 1 | 2 6 4 | 9 8 3
-+-----------------------
D| 1 8 5 | 7 4 6 | 3 9 2
E| 2 6 7 | 9 5 3 | 4 1 8
F| 9 4 3 | 8 1 2 | 7 6 5
-+-----------------------
G| 7 1 4 | 6 3 8 | 5 2 9
H| 3 2 9 | 1 7 5 | 8 4 6
I| 6 5 8 | 4 2 9 | 1 3 7

ルール：

すべての迷路はロジックのみで解決できると仮定します。
入力はすべて81文字です。欠落している文字は0になります。
ソリューションを単一の文字列として出力します。
「グリッド」は、必要に応じて内部に保存できます。
ソリューションは、ブルートフォース推測ソリューションを使用する必要があります。
ソリューションは、妥当な時間内に解決する必要があります。

I / Oの例：

>sudoku.py "030001000006000050500000983080006302000050000903800060714000009020000800000400030"
832591674496387251571264983185746392267953418943812765714638529329175846658429137

— スナックドナルド
ソース

入力はどのようにして27文字にすることができますか？長さ81文字-9行x 9列である必要があります。それもあなたの例がしていることです。また、「欠落文字が0になる」とは、文字数が81未満の場合、最後にゼロが続くことを意味すると思いますか？

— ジョナサンMデイビス

あ、待って。不足している文字は0ビットになります。ああ。これらは推測する必要があるものです。いずれの場合も、文字の数は81、いない27である必要はない

— ジョナサン・M・デービス

8

それは....ちょっと葛藤ルール5及び6のようだ

— pseudonym117

11

k（72バイト）

これは、k言語の作成者であるArthur Whitneyの功績によるものです。

p,:3/:_(p:9\:!81)%3
s:{*(,x)(,/{@[x;y;:;]'&21=x[&|/p[;y]=p]?!10}')/&~x}

— 調査
ソース

クラシック！私もこれを投稿するつもりでした！

— nightTrevors 14

9

Python、188バイト

これは、CodeSprint Sudokuの受賞作品をさらに短縮したもので、stdinではなくコマンドライン入力用に変更されています（OPによる）。

def f(s):
 x=s.find('0')
 if x<0:print s;exit()
 [c in[(x-y)%9*(x/9^y/9)*(x/27^y/27|x%9/3^y%9/3)or s[y]for y in range(81)]or f(s[:x]+c+s[x+1:])for c in'%d'%5**18]
import sys
f(sys.argv[1])

Python 2を使用している場合は、3バイトを節約するために'%d'%5**18置き換えることができ`5**18`ます。

より高速に実行するには、1バイトのコストで'%d'%5**18任意の順列に置き換えることができ'123456789'ます。

あなたはそれではなく、標準入力上の入力を受け付けるようにしたい場合は、交換することが可能import sys;f(sys.argv[1])とf(raw_input())し、それをダウンさせ、177バイト。

def f(s):
 x=s.find('0')
 if x<0:print s;exit()
 [c in[(x-y)%9*(x/9^y/9)*(x/27^y/27|x%9/3^y%9/3)or s[y]for y in range(81)]or f(s[:x]+c+s[x+1:])for c in'%d'%5**18]
f(raw_input())

編集： 詳細なウォークスルーへのリンクはこちらです。

— 細胞期
ソース

とてもいい解決策。

— プリモ

8

Python、197文字

def S(s):
 i=s.find('0')
 if i<0:print s;return
 for v in'123456789':
  if sum(v==s[j]and(i/9==j/9or i%9==j%9or(i%9/3==j%9/3and i/27==j/27))for j in range(81))==0:S(s[:i]+v+s[i+1:])
S(raw_input())

— キース・ランドール
ソース

6

Dの回答：

import std.algorithm;
import std.conv;
import std.ascii;
import std.exception;
import std.stdio;

void main(string[] args)
{
    enforce(args.length == 2, new Exception("Missing argument."));
    enforce(args[1].length == 81, new Exception("Invalid argument."));
    enforce(!canFind!((a){return !isDigit(to!dchar(a));})
                     (args[1]),
                      new Exception("Entire argument must be digits."));

    auto sudoku = new Sudoku(args[1]);
    sudoku.fillIn();

    writeln(sudoku);
}

class Sudoku
{
public:

    this(string str) nothrow
    {
        normal = new int[][](9, 9);

        for(size_t i = 0, k =0; i < 9; ++i)
        {
            for(size_t j = 0; j < 9; ++j)
                normal[i][j] = to!int(str[k++]) - '0';
        }

        reversed = new int*[][](9, 9);

        for(size_t i = 0; i < 9; ++i)
        {
            for(size_t j = 0; j < 9; ++j)
                reversed[j][i] = &normal[i][j];
        }

        boxes = new int*[][](9, 9);
        indexedBoxes = new int*[][][](9, 9);

        for(size_t boxRow = 0, boxNum = 0; boxRow < 3; ++boxRow)
        {
            for(size_t boxCol = 0; boxCol < 3; ++boxCol, ++boxNum)
            {
                for(size_t i = 3 * boxRow, square = 0; i < 3 * (boxRow + 1); ++i)
                {
                    for(size_t j = 3 * boxCol; j < 3 * (boxCol + 1); ++j)
                    {
                        boxes[boxNum][square++] = &normal[i][j];
                        indexedBoxes[i][j] = boxes[boxNum];
                    }
                }
            }
        }
    }

    void fillIn()
    {
        fillIn(0, 0);
    }

    @property bool valid()
    {
        assert(full);

        for(size_t i = 0; i < 9; ++i)
        {
            for(int n = 1; n < 10; ++n)
            {
                if(!canFind(normal[i], n) ||
                   !canFind!"*a == b"(reversed[i], n) ||
                   !canFind!"*a == b"(boxes[i], n))
                {
                    return false;
                }
            }
        }

        return true;
    }

    override string toString() const
    {
        char[81] retval;

        for(size_t i = 0, k =0; i < 9; ++i)
        {
            for(size_t j = 0; j < 9; ++j)
                retval[k++] = to!char(normal[i][j] + '0');
        }

        return to!string(retval);
    }

private:

    @property bool full()
    {
        for(size_t i = 0; i < 9; ++i)
        {
            if(canFind(normal[i], 0))
                return false;
        }

        return true;
    }

    bool fillIn(size_t row, size_t col)
    {
        if(row == 9)
            return valid;

        size_t nextRow = row;
        size_t nextCol = col + 1;

        if(nextCol == 9)
        {
            nextRow = row + 1;
            nextCol = 0;
        }

        if(normal[row][col] == 0)
        {
            for(int n = 1; n < 10; ++n)
            {
                if(canFind(normal[row], n) ||
                   canFind!"*a == b"(reversed[col], n) ||
                   canFind!"*a == b"(indexedBoxes[row][col], n))
                {
                    continue;
                }

                normal[row][col] = n;

                if(fillIn(nextRow, nextCol))
                    return true;
            }

            normal[row][col] = 0;

            return false;
        }
        else
            return fillIn(nextRow, nextCol);
    }

    int[][] normal;
    int*[][] reversed;
    int*[][] boxes;
    int*[][][] indexedBoxes;
}

サンプル入力すると、それはとり.033sをしてコンパイルするときに私のPhenom II X6 1090Tにdmd -w（すなわち最適化なし）、そして、それはとり.011sをしてコンパイルする場合dmd -w -O -inline -release（つまり、最適化を含みます）。

— ジョナサン・M・デイビス
ソース

4

J、103

'p n'=:(;#)I.0=a=:("."0)Y
((a p}~3 :'>:?n#9')^:([:(27~:[:+/[:(9=#@~.)"1[:,/(2 2$3),;.3],|:,])9 9$])^:_)a

予想実行時間：O（億兆年）

— エルベックス
ソース

1

そして、なぜ予想される実行時間は「O（億兆年）」ですか？（Oがなければ、単なる「兆億年」ではないでしょうか？

— ジャスティン

1

この質問を見たとき、私はJがこの質問を押しつぶそうとしていることをすぐに知りました。これをKより短くする方法が必要です。

— koko14年

1

@Quincunx、厳密に言えば、これはbig-Oの誤った使用です。「ジョーク」は、「一定の実行時間、漸近的に数億億年」と読むことになっています。

— エルベックス14

@koko、私はもっと良いものを見つけることができませんでしたが、私はまだそれに取り組んでいます。

— エルベックス14

4

Perl、120バイト

ああ、私は2008年にゴルフをしたことを覚えています...そして、分割による暗黙的な@_の設定が削除されたため、実際にはperl 5.12で動作しなくなりました。したがって、これは十分に古いperlでのみ試してください。

STDINの入力で実行します。

sudoku.pl <<< "030001000006000050500000983080006302000050000903800060714000009020000800000400030"

sudoku.pl：

${/[@_[map{$i-($i="@-")%9+$_,9*$_+$i%9,9*$_%26+$i-$i%3+$i%9-$i%27}0..8%split""]]/o||do$0}for$_=$`.$_.$'.<>,/0/||print..9

— トン・ホスペル
ソース

2

それはだクラークの三法則が、逆に！

— コナーオブライエン

3

Perl、235文字

$_=$s=<>;$r=join$/,map{$n=$_;'.*(?!'.(join'|',map+($_%9==$n%9||int($_/9)==int($n/9)||int($_/27)==int($n/27)&&int($_/3%3)==int($n/3%3)and$_<$n?'\\'.($_+1):$_>$n&&substr$s,$_,1)||X,@a).')(.).*'}@a=0..80;s!.!($&||123456789).$/!eg;say/^$r/

これは何年も前にFun With Perlメーリングリストに投稿したもののゴルフバージョンです：数独解決正規表現。

基本的に、入力を81行に変換します。各行には、対応する正方形で発生する可能性のあるすべての数値が含まれています。次に、後方参照と負の先読みアサーションを使用して、行、列、または領域の制約に違反するソリューションを拒否し、各行の1つの数値に一致する正規表現を作成します。次に、文字列を正規表現と照合し、Perlの正規表現エンジンに試行錯誤とバックトラックのハードワークをさせます。

驚いたことに、私の元のプログラムのように、あらゆる入力に対して機能する単一の正規表現を作成することが可能です。残念ながら、それは非常に遅いので、ここでゴルフコードをハードコーディングされたバージョンに基づいています（ FWPスレッドで後ほど見つけます）。これにより、簡単なレベルから中程度のレベルの数独が合理的に高速になりますが、特に難しい数独の解決にはかなり時間がかかります。

でコードを実行してperl -M5.010、Perl 5.10+ say機能を有効にします。入力は標準入力で行う必要があり、ソリューションは標準出力に出力されます。例：

$ perl -M5.010 golf/sudoku.pl
030001000006000050500000983080006302000050000903800060714000009020000800000400030
832591674496387251571264983185746392267953418943812765714638529329175846658429137

— イルマリ・カロネン
ソース

2

1ライナーコーヒースクリプト

solve = (s, c = 0) -> if c is 81 then s else if s[x = c/9|0][y = c%9] isnt 0 then solve s, c+1 else (([1..9].filter (g) -> ![0...9].some (i) -> g in [s[x][i], s[i][y], s[3*(x/3|0) + i/3|0][3*(y/3|0) + i%3]]).some (g) -> s[x][y] = g; solve s, c+1) or s[x][y] = 0

サンプル使用の大きなバージョンは次のとおりです。

solve = (sudoku, cell = 0) ->
  if cell is 9*9 then return sudoku

  x = cell%9
  y = (cell - x)/9

  if sudoku[x][y] isnt 0 then return solve sudoku, cell+1

  row = (i) -> sudoku[x][i]
  col = (i) -> sudoku[i][y]
  box = (i) -> sudoku[x - x%3 + (i - i%3)/3][y - y%3 + i%3]

  good = (guess) -> [0...9].every (i) -> guess not in [row(i), col(i), box(i)]

  guesses = [1..9].filter good

  solves = (guess) -> sudoku[x][y] = guess; solve sudoku, cell+1

  (guesses.some solves) or sudoku[x][y] = 0

sudoku = [
  [1,0,0,0,0,7,0,9,0],
  [0,3,0,0,2,0,0,0,8],
  [0,0,9,6,0,0,5,0,0],
  [0,0,5,3,0,0,9,0,0],
  [0,1,0,0,8,0,0,0,2],
  [6,0,0,0,0,4,0,0,0],
  [3,0,0,0,0,0,0,1,0],
  [0,4,0,0,0,0,0,0,7],
  [0,0,7,0,0,0,3,0,0]
]
console.log if solve sudoku then sudoku else 'could not solve'

— パシクリット
ソース

1

短くすることによって短縮することができsolve（のような代わりの単語の記号を使用して、空白（私はそれが重要だ知っているが、多くの場所で、それを除去することができる）の多くを削除する!=代わりにisntするのではなく、インデントを使用して、）then置き換えて、キーワード[0...9]で[0..8]。

— コンラッドボロウスキ

1

Clojure-480バイト

サイズは爆発しましたが、少なくともかなりの数です。1Dベクトルのみを使用することで大幅に改善できると思います。とにかく、テストケースは私のラップトップで4秒弱かかります。やはり関数型言語なので、関数を定義するのが適切だと思いました。

(defn f[o &[x y]](if x(if(> y 8)(apply str(map #(apply str %)o))(first(for[q[(o y)]v(if(=(q x)0)(range 1 10)[(q x)])d[(assoc o y(assoc(o y)x v))]s[(and(every? true?(concat(for[i(range 9)](and(or(not=((d y)i)v)(= i x))(or(not=((d i)x)v)(= i y))))(for[m[#(+ %2(- %(mod % 3)))]r[(range 3)]a r b r c[(m y b)]e[(m x a)]](or(and(= e x)(= c y))(not=((d y)x)((d c)e))))))(f d(mod(+ x 1)9)(if(= x 8)(+ 1 y)y)))]:when s]s)))(f(vec(for[a(partition 9 o)](vec(map #(Integer.(str %))a))))0 0)))

例：

(f "030001000006000050500000983080006302000050000903800060714000009020000800000400030")
=> "832591674496387251571264983185746392267953418943812765714638529329175846658429137"
(f "004720900039008005001506004040010520028050170016030090400901300100300840007085600")
=> "654723981239148765871596234743819526928654173516237498482961357165372849397485612"

わずかに手に入れられていない（そしてよりきれいな）バージョン：

(defn check-place [o x y v]
  (and (every? true? (for [i (range 9)]
                       (and (or (not= ((o y) i) v) (= i x))
                            (or (not= ((o i) x) v) (= i y)))))
       (every? true?
         (for [r [(range 3)]
               a r
               b r
               c [(+ b (- y (mod y 3)))]
               d [(+ a (- x (mod x 3)))]]
           (or (and (= d x) (= c y)) (not= ((o y) x) ((o c) d)))))))

(defn solve-sudoku [board & [x y]]
  (if x
    (if (> y 8)
      (apply str (map #(apply str %) board))
      (first
        (for [v (if (= ((board y) x) 0) (range 1 10) [((board y) x)])
              :let [a (mod (+ x 1) 9)
                    b (if (= x 8) (+ 1 y) y)
                    d (assoc board y (assoc (board y) x v))
                    s (and (check-place d x y v) (solve-sudoku d a b))]
              :when s]
          s)))
    (solve-sudoku (vec (for [a (partition 9 board)]
                         (vec (map #(Integer. (str %)) a)))) 0 0)))

— Seequ
ソース

1

PowerShellの、244の 242 218 215バイト

$a=(24,24,6)*3|%{,(0..8|%{($r++)});,(0..8|%{$c%81;$c+=9});$c++;,((1,1,7)*3|%{+$q;$q+=$_});$q-=$_}
$f={param($s)$l,$r=$s-split0,2;if($p=$a|?{$l.length-in$_}){1..9|?{"$_"-notin($p|%{$s[$_]})}|%{&$f "$l$_$r"}}else{$s}}

オンラインでお試しください！

このスクリプトは、数独のすべてのソリューションを見つけます。

展開：

$a=(24,24,6)*3|%{                       # array of indexes for a sudoku...
    ,(0..8|%{($r++)})                   # rows
    ,(0..8|%{$c%81;$c+=9});$c++         # columns
    ,((1,1,7)*3|%{+$q;$q+=$_});$q-=$_   # and squares
}

$f = {
    param($s)

    # optional log. remove this statement in a release version.
    if($script:iter++ -lt 100 -or ($script:iter%100)-eq0){
        Write-Information ('{0}: {1,6}: {2}'-f (get-Date), $script:iter, ($s-replace0,' ')) -InformationAction Continue
    }

    $left,$right=$s-split0,2                # split by a first 0; $left.length is a position of this 0 if $s contains the 0
    if( $parts=$a|?{$left.length-in$_} ){   # get sudoku parts (rows, columns, squares) contain the position
        1..9|?{                             # try a digit
            "$_"-notin($parts|%{$s[$_]})    # all digits in these parts will be unique if parts do not contain the digit
        }|%{
            &$f "$left$_$right"             # recursive call with the digit
        } #|select -f 1                     # uncomment this to get a first result only
    }
    else{
        $s
    }

}

テストケース：

@(
    # 5 iterations, my notebook: 00:00:00, all
    # 5 iterations, my notebook: 00:00:00, first only
    , ( "832591674496387251571264983185746392267953418943812765714638529329175846658400030",
        "832591674496387251571264983185746392267953418943812765714638529329175846658429137" )

    # ~29600 iterations, my notebook: 00:01:27, all
    #  ~2100 iterations, my notebook: 00:00:10, first only
    # , ( "830001000006000050500000983080006302000050000903800060714000009020000800000400030",
    #     "832591674496387251571264983185746392267953418943812765714638529329175846658429137" )

    # ~49900 iterations, my notebook: 00:02:39, all
    # ~22400 iterations, my notebook: 00:01:20, first only
    # , ( "030001000006000050500000983080006302000050000903800060714000009020000800000400030",
    #     "832591674496387251571264983185746392267953418943812765714638529329175846658429137" )

) | % {
    $sudoku, $expected = $_
    $time = Measure-Command {
        $result = &$f $sudoku
    }
    "$($result-contains$expected): $time"
    $result
}

— かっこいい
ソース

0

D（322文字）

未解決の正方形ごとに、使用可能なオプションの配列を作成し、ループします。

import std.algorithm,std.range,std.stdio;void main(char[][]args){T s(T)(T p){foreach(i,ref c;p)if(c<49){foreach(o;"123456789".setDifference(chain(p[i/9*9..i/9*9+9],p[i%9..$].stride(9),p[i/27*27+i%9/3*3..$][0..21].chunks(3).stride(3).joiner).array.sort)){c=o&63;if(s(p))return p;}c=48;return[];}return p;}s(args[1]).write;}

空白あり：

import std.algorithm, std.range, std.stdio;

void main(char[][] args) {
    T s(T)(T p) {
        foreach (i, ref c; p) if (c < 49) {
            foreach (o; "123456789".setDifference(chain(
                    p[i/9*9..i/9*9+9],
                    p[i%9..$].stride(9),
                    p[i/27*27+i%9/3*3..$][0..21].chunks(3).stride(3).joiner
                ).array.sort))
            {
                c = o&63;
                if (s(p)) return p;
            }
            c=48;
            return [];
        }
        return p;
    }
    s(args[1]).write;
}

— mleise
ソース

0

Perl（195文字）

use integer;@A=split//,<>;sub R{for$i(0..80){next if$A[$i];my%t=map{$_/9==$/9||$_%9==$i%9||$_/27==$i/27&&$_%9/3==$i%9/3?$A[$_]:0=>1}0..80;R($A[$i]=$_)for grep{!$t{$_}}1..9;return$A[$i]=0}die@A}R

すべてのクレジットはここで作成者に送られ、説明もそこにあります。

— Qwix
ソース

1

自分で作成していない場合は、[コミュニティWiki]ボタンをチェックする必要があります。

— カイルKanos

それが何であるかについてのいくつかの研究の後、それは私には不可能に見えます。どうやら、チェックボックスを表示するには100人の担当者が必要です（この投稿の 2

— 番目

うーん、その要件を認識していませんでした。

— カイルカノス14

0

J、94バイト

Kバージョンとまったく同じ方法で、つまりBFSで動作します（したがって、すべてのソリューションを出力します）。出力数字の間にスペースを出力しますが、Kプログラムも出力します。「s =：」はカウントしません。これは単に関数に名前を付けるためです（別の言語でファイル名をカウントしないように）。

   s=: [:<@((]i.0:)}"0 _~(>:i.9)-.{&((+./ .=|:)3(],.[,@#.<.@%~)9 9#:i.81)@i.&0#])"1^:(0 e.,)@;^:_"."0

   s'030001000006000050500000983080006302000050000903800060714000009020000800000400030'
8 3 2 5 9 1 6 7 4 4 9 6 3 8 7 2 5 1 5 7 1 2 6 4 9 8 3 1 8 5 7 4 6 3 9 2 2 6 7 9 5 3 4 1 8 9 4 3 8 1 2 7 6 5 7 1 4 6 3 8 5 2 9 3 2 9 1 7 5 8 4 6 6 5 8 4 2 9 1 3 7

— オリウス
ソース

ブルートフォース数独ソルバーを実装する