ใช้ตัวแก้ Sudoku ที่สั้นที่สุดโดยใช้การเดา เนื่องจากฉันได้รับคำขอไม่กี่ครั้งฉันจึงได้เพิ่มสิ่งนี้เป็นคำถามทางเลือกสำหรับผู้ที่ต้องการใช้งานตัวแก้แรงซูโดกุ

ปริศนา Sudoku:

 | 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

กฎ:

1. สมมติว่าเขาวงกตทั้งหมดสามารถแก้ไขได้ด้วยตรรกะเท่านั้น
2. อินพุตทั้งหมดจะมีความยาว 81 ตัวอักษร อักขระที่หายไปจะเป็น 0
3. เอาต์พุตโซลูชันเป็นสตริงเดี่ยว
4. "กริด" อาจถูกเก็บไว้ภายใน แต่คุณต้องการ
5. การแก้ปัญหาจะต้องใช้วิธีการคาดเดากำลังดุร้าย
6. การแก้ปัญหาควรแก้ไขภายในระยะเวลาที่เหมาะสม

ตัวอย่าง I / O:

>sudoku.py "030001000006000050500000983080006302000050000903800060714000009020000800000400030"
832591674496387251571264983185746392267953418943812765714638529329175846658429137

k (72 ไบต์)

เครดิตสำหรับสิ่งนี้ไปที่ Arthur Whitney ผู้สร้างภาษา k

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

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 คุณ'%d'%5**18สามารถแทนที่ด้วย`5**18`เพื่อบันทึก 3 ไบต์

เพื่อให้ทำงานได้เร็วขึ้นคุณสามารถแทนที่'%d'%5**18ด้วยการเปลี่ยนรูปแบบใดก็ได้'123456789'ที่ราคา 1 ไบต์

หากคุณต้องการที่จะยอมรับการป้อนข้อมูลบน stdin แทนคุณสามารถแทนที่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())

แก้ไข: นี่คือลิงค์ไปยังคำแนะนำแบบละเอียดเพิ่มเติม

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())

คำตอบใน 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;
}

ด้วยอินพุตตัวอย่างมันใช้เวลา0.33 วินาทีใน Phenom II X6 1090T ของฉันเมื่อคอมไพล์ด้วยdmd -w (เช่นไม่มีการเพิ่มประสิทธิภาพ) และใช้เวลา0.011เมื่อรวบรวมด้วยdmd -w -O -inline -release(เช่นด้วยการปรับให้เหมาะสม)

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 (พันล้านล้านล้านปี)

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

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 : regexp ซูโดกุ

โดยพื้นฐานแล้วมันจะทำการอินพุตเป็น 81 บรรทัดซึ่งแต่ละอันจะมีตัวเลขทั้งหมดที่อาจเกิดขึ้นในจตุรัสที่สอดคล้องกัน จากนั้นจะสร้าง regexp เพื่อจับคู่หนึ่งหมายเลขจากแต่ละบรรทัดโดยใช้การอ้างอิงย้อนกลับและการยืนยันแบบเชิงลบเพื่อปฏิเสธการแก้ปัญหาที่ละเมิดข้อ จำกัด ของแถวคอลัมน์หรือภูมิภาค จากนั้นมันจะจับคู่สตริงกับ regexp เพื่อให้เครื่องมือ regexp ของ Perl ทำงานหนักในการทดลองและการย้อนรอย

น่าประหลาดใจที่เป็นไปได้ที่จะสร้าง regexp เดี่ยวที่เหมาะกับอินพุตใด ๆ เช่นโปรแกรมดั้งเดิมของฉัน น่าเสียดายที่มันค่อนข้างช้าดังนั้นฉันจึงใช้รหัส golfed ที่นี่ในรุ่น hardcoded-givens ( พบในภายหลังในเธรด FWP ) ซึ่ง tweaks regexp เพื่อปฏิเสธวิธีแก้ปัญหาใด ๆ ที่รู้ว่าจะละเมิดข้อ จำกัด ในภายหลัง สิ่งนี้ทำให้มันเร็วพอสมควรสำหรับซูโดคุสในระดับปานกลางถึงง่ายแม้ว่าคนที่ยากเป็นพิเศษสามารถใช้เวลาค่อนข้างนานในการแก้ปัญหา

เรียกใช้รหัสด้วยperl -M5.010เพื่อเปิดใช้งานsayคุณสมบัติPerl 5.10+ อินพุตควรถูกกำหนดให้กับอินพุตมาตรฐานและโซลูชันจะถูกพิมพ์ไปยังเอาต์พุตมาตรฐาน ตัวอย่าง:

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

1-liner coffee-script

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'

Clojure - 480 ไบต์

ขนาดระเบิด แต่อย่างน้อยมันก็เป็นจำนวนที่ค่อนข้างดี ฉันคิดว่ามันสามารถปรับปรุงได้มากมายโดยใช้เพียง 1D-vector อย่างไรก็ตามกรณีทดสอบใช้เวลาน้อยกว่าสี่วินาทีบนแล็ปท็อปของฉัน ฉันคิดว่ามันเหมาะสมที่จะกำหนดฟังก์ชั่นเนื่องจากเป็นภาษาที่ใช้งานได้หลังจากทั้งหมด

(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)))

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
}

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;
}

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

เครดิตทั้งหมดไปที่ผู้สร้างที่นี่และคำอธิบายสามารถพบได้ที่นั่นเช่นกัน

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