สร้าง CHECKER โซลูชัน Sudoku

มีเยอะแยะของ Sudoku SOLVERS อยู่ที่นี่ แต่ฉันต้องการให้คุณสร้าง CHECKER ที่มีขนาดเล็กที่สุดเท่าที่มนุษย์สามารถทำได้ (code-golf)

• รายการที่ถูกต้องจะสามารถใช้อาร์เรย์ 9x9 เป็นอาร์กิวเมนต์ (ส่งผ่านโดยอ้างอิงต่อเนื่องบนบรรทัดคำสั่งหรืออย่างไรก็ตามคุณต้องการที่จะใช้มัน) หรือยอมรับไฟล์อินพุตที่เป็นเก้าเก้าบรรทัดของตารางสุดท้าย . ดูตัวอย่างของการป้อนข้อมูลด้านล่าง

• อินพุตที่ถูกต้องควรเป็นเลขฐาน 10 (1-9)

• ตำแหน่งที่ขาดหายไปว่างเกินหรือไม่ใช่ตัวเลขหรือตำแหน่งที่มีตัวเลขที่อยู่นอก 1-9 ควรถูกปฏิเสธว่าเป็นอินพุตที่ไม่ถูกต้องโดยส่งกลับผลลัพธ์ที่ไม่เป็นศูนย์พิมพ์ข้อผิดพลาดหรือทั้งสองอย่าง

• โปรแกรมของคุณต้องทดสอบว่าแต่ละหมายเลขปรากฏหนึ่งครั้งต่อหนึ่งคอลัมน์ต่อหนึ่งบรรทัดและหนึ่งครั้งต่อ 3x3 ตารางย่อย หากผ่านให้ส่งคืน "0" และหากไม่ส่งคืนผลลัพธ์ที่ไม่เป็นศูนย์

• หลีกเลี่ยงการใช้ทรัพยากรภายนอก (เว็บไซต์ ฯลฯ )

• หากโซลูชันของคุณเป็นโปรแกรมแบบสแตนด์อะโลนการออกจากสถานะออกหรือการพิมพ์ "0" หรือไม่ใช่ศูนย์สำหรับ "Pass" หรือ "Fail" ตามลำดับก็โอเค

ให้คำตอบที่เล็กที่สุดชนะ!

ตัวอย่างอินพุต:

อาร์เรย์ c:

int input[9][9]={{1,2,3,4,5,6,7,8,9},
                 {4,5,6,7,8,9,1,2,3},
                 {7,8,9,1,2,3,4,5,6},
                 {2,3,1,5,6,4,8,9,7},
                 {5,6,4,8,9,7,2,3,1},
                 {8,9,7,2,3,1,5,6,4},
                 {3,1,2,6,4,5,9,7,8},
                 {6,4,5,9,7,8,3,1,2},
                 {9,7,8,3,1,2,6,4,5}
                };

ไฟล์:

123456789
456789123
789123456
231564897
564897231
897231564
312645978
645978312
978312645

9 ตารางย่อย:

+---+---+---+
|123|456|789|
|456|789|123|
|789|123|456|
+---+---+---+
|231|564|897|
|564|897|231|
|897|231|564|
+---+---+---+
|312|645|978|
|645|978|312|
|978|312|645|
+---+---+---+

GolfScript, 39 ตัวอักษร

.zip.{3/}%zip{~}%3/{[]*}%++{$10,1>=!},,

มันต้องใช้อาร์เรย์ของอาร์เรย์เป็นอินพุต (ดูตัวอย่างออนไลน์ ) และเอาท์พุท0ถ้ามันเป็นกริดที่ถูกต้อง

คำอธิบายสั้น ๆ ของรหัส

.zip         # Copy the input array and transpose it
.{3/}%       # Split each line into 3 blocks
zip{~}%      # Transpose these blocks
3/{[]*}%     # Do the same for the lines themselves and join again
++           # Make one large list of 27 9-element arrays 
             # (9 for rows, 9 for columns, 9 for blocks)
{$10,1>=!},  # From those 27 select the ones which are not a permutation of [1 2 3 ... 9]
             #   $      -> sort
             #   10,1>  -> [1 2 3 ... 9]
             #   =!     -> not equal
,            # Count after filtering

Python, 103

ฉันเกลียดซูโดกุ

b = [[1,2,3,4,5,6,7,8,9],
     [4,5,6,7,8,9,1,2,3],
     [7,8,9,1,2,3,4,5,6],
     [2,3,1,5,6,4,8,9,7],
     [5,6,4,8,9,7,2,3,1],
     [8,9,7,2,3,1,5,6,4],
     [3,1,2,6,4,5,9,7,8],
     [6,4,5,9,7,8,3,1,2],
     [9,7,8,3,1,2,6,4,5]]

e=enumerate;print 243-len(set((a,t)for(i,r)in e(b)for(j,t)in e(r)for a in e([i,j,i/3*3+j/3]*(0<t<10))))

วิธีการทำงาน: แต่ละแถวคอลัมน์และบล็อกจะต้องมีตัวเลขแต่ละตัวตั้งแต่วันที่ 1 ถึง 9 ดังนั้นสำหรับแต่ละ0 <= i, j < 9เซลล์ที่อยู่ในบล็อกi,j 3*floor(i/3) + floor(j/3)ดังนั้นจึงมีข้อกำหนด 243 ข้อที่จะทำให้พอใจ ฉันจะทำให้ความต้องการแต่ละขอบเขตของ((item index,item type number),symbol)ที่item indexเป็นตัวเลขระหว่าง 0 และ 8 (รวม) item type numberคือ 0,1, หรือ 2 เพื่อแสดงว่าแถวคอลัมน์หรือปิดกั้นตามลำดับและเป็นรายการsymbolb[i][j]

แก้ไข: ฉันไม่ได้ตรวจสอบรายการที่ถูกต้องโดยไม่ตั้งใจ ตอนนี้ฉันทำ

APL (46)

{∧/,↑∊∘Z¨(/∘(,⍵)¨↓Z∘.=,3/3⌿3 3⍴Z←⍳9),(↓⍵),↓⍉⍵}

นี่ใช้เมทริกซ์ขนาด 9 คูณ 9 ตัวอย่างหนึ่งสามารถป้อนใน TryAPL ได้เช่น:

     sudoku ← ↑(1 2 3 4 5 6 7 8 9)(4 5 6 7 8 9 1 2 3)(7 8 9 1 2 3 4 5 6)(2 3 1 5 6 4 8 9 7)(5 6 4 8 9 7 2 3 1)(8 9 7 2 3 1 5 6 4)(3 1 2 6 4 5 9 7 8)(6 4 5 9 7 8 3 1 2)(9 7 8 3 1 2 6 4 5)
     {∧/,↑∊∘Z¨(/∘(,⍵)¨↓Z∘.=,3/3⌿3 3⍴Z←⍳9),(↓⍵),↓⍉⍵} sudoku
1

คำอธิบาย:

• ↓⍉⍵: คอลัมน์ได้รับของ⍵,
• ↓⍵: ได้รับแถวของ⍵,
• 3/3⌿3 3⍴Z←⍳9: ทำเมทริกซ์ 3 โดย 3 มีตัวเลข1ไป9แล้วเพิ่มขึ้นสามเท่าแต่ละหมายเลขได้ทั้งสองทิศทางให้เมทริกซ์ 9 โดย 9 กับตัวเลข1ที่จะ9แสดงให้เห็นแต่ละกลุ่ม
• Z∘.=สำหรับแต่ละหมายเลข1ให้9สร้าง bitmask สำหรับกลุ่มที่กำหนด
• /∘(,⍵)¨และหน้ากากกันให้กลุ่มของ⍵⍵
• ∊∘Z¨: สำหรับแต่ละย่อยอาร์เรย์ดูว่ามันมีตัวเลข1ไป9,
• ∧/,↑: เอาตรรกะandของตัวเลขทั้งหมดเหล่านี้มารวมกัน

Java / C # - 183/180 181/178 173/170 bytes

boolean s(int[][]a){int x=0,y,j;int[]u=new int[27];for(;x<(y=9);x++)while(y>0){j=1<<a[x][--y];u[x]|=j;u[y+9]|=j;u[x/3+y/3*3+18]|=j;}for(x=0;x<27;)y+=u[x++];return y==27603;}

(เปลี่ยนbooleanเป็นboolC #)

จัดรูปแบบ:

boolean s(int[][] a){
    int x=0, y, j;
    int[] u=new int[27];
    for(;x<(y=9);x++)
        while(y>0){
            j=1<<a[x][--y];
            u[x]|=j;
            u[y+9]|=j;
            u[x/3+y/3*3+18]|=j;
        }

    for(x=0;x<27;)
        y+=u[x++];

    return y==27603;
}

วิธีการสร้างอาร์เรย์ที่uมี 27 bitmasks แสดงถึงตัวเลขที่พบในเก้าแถวคอลัมน์และสี่เหลี่ยม

จากนั้นจะวนซ้ำทุกเซลล์ทำการแสดงการดำเนินการ1 << a[x][y]เพื่อสร้าง bitmask ซึ่งเป็นตัวเลขและ ORs ของคอลัมน์แถวและสี่เหลี่ยม bitmask ด้วย

จากนั้นมันจะทำซ้ำทั้งหมด 27 bitmasks เพื่อให้แน่ใจว่าพวกเขาทั้งหมดเพิ่มขึ้นถึง 27594 (1022 * 9, 1022 เป็น bitmask สำหรับทุกหลัก 1-9 อยู่) (โปรดทราบว่าyลงท้ายด้วย 27603 เนื่องจากประกอบด้วย 9 ต่อไปนี้ double loop)

แก้ไข: ทิ้งไว้โดยไม่ได้ตั้งใจ%3ซึ่งไม่จำเป็นอีกต่อไป

แก้ไข 2: แรงบันดาลใจจากความคิดเห็นของ Bryce Wagner รหัสถูกบีบอัดอีกเล็กน้อย

python = 196

ไม่ใช่นักกอล์ฟมากที่สุด แต่มีความคิดอยู่ที่นั่น เซตมีประโยชน์ทีเดียว

คณะกรรมการ:

b = [[1,2,3,4,5,6,7,8,9],
     [4,5,6,7,8,9,1,2,3],
     [7,8,9,1,2,3,4,5,6],
     [2,3,1,5,6,4,8,9,7],
     [5,6,4,8,9,7,2,3,1],
     [8,9,7,2,3,1,5,6,4],
     [3,1,2,6,4,5,9,7,8],
     [6,4,5,9,7,8,3,1,2],
     [9,7,8,3,1,2,6,4,5]]

โปรแกรม:

n={1,2,3,4,5,6,7,8,9};z=0
for r in b:
 if set(r)!=n:z=1
for i in zip(*b):
 if set(i)!=n:z=1
for i in (0,3,6):
 for j in (0,3,6):
  k=j+3
  if set(b[i][j:k]+b[i+1][j:k]+b[i+2][j:k])!=n:z=1
print(z)

Java - 385 306 328 260 ตัวอักษร

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

ดังนั้นเป็นสิ่งที่ท้าทายสำหรับตัวฉันเองฉันคิดว่าฉันจะลองใช้ตัวตรวจสอบโซลูชัน Java ที่เล็กที่สุด

เพื่อให้บรรลุสิ่งนี้ฉันสมมติว่าตัวต่อซูโดกุจะถูกส่งผ่านเป็นอาร์เรย์หลายมิติของจาวาเช่น:

s(new int[][] {
    {1,2,3,4,5,6,7,8,9},
    {4,5,6,7,8,9,1,2,3},
    {7,8,9,1,2,3,4,5,6},
    {2,3,1,5,6,4,8,9,7},
    {5,6,4,8,9,7,2,3,1},
    {8,9,7,2,3,1,5,6,4},
    {3,1,2,6,4,5,9,7,8},
    {6,4,5,9,7,8,3,1,2},
    {9,7,8,3,1,2,6,4,5}});

จากนั้นเรามีเครื่องมือแก้ปัญหาจริงซึ่งส่งกลับค่าเป็น "0" ถ้าวิธีแก้ปัญหาที่ถูกต้องคือ "1" ถ้าไม่ใช่

golfed อย่างเต็มที่:

int s(int[][] s){int i=0,j,k=1;long[] f=new long[9];long r=0L,c=r,g=r,z=45L,q=r;for(f[0]=1L;k<9;){f[k]=f[k-1]*49;z+=f[k++]*45;}for(;i<9;i++){for(j=0;j<9;){k=s[i][j];r+=k*f[i];c+=k*f[j];g+=k*f[j++/3+3*(i/3)];q+=5*f[k-1];}}return (r==z&&c==z&&g==z&&q==z)?0:1;}

อ่านได้:

    int s(int[][] s) {
        int i=0,j,k=1;
        long[] f=new long[9]; 
        long r=0L,c=r,g=r,z=45L,q=r;
        for(f[0]=1L;k<9;){f[k]=f[k-1]*49;z+=f[k++]*45;}
        for(;i<9;i++) {
            for (j=0;j<9;) {
                k=s[i][j];
                r+=k*f[i];
                c+=k*f[j];
                g+=k*f[j++/3+3*(i/3)];
                q+=5*f[k-1];
            }
        }
        return (r==z&&c==z&&g==z&&q==z)?0:1;
    }

แล้วมันทำงานอย่างไร ฉันเพียงแค่สร้างฐานจำนวนของตัวเองโดยมีความละเอียดเพียงพอในแต่ละหลักที่ฉันต้องทำการเปรียบเทียบตัวเลขสามตัวหลังจากผ่านการไขปริศนาหนึ่งครั้งเพื่อรู้ว่ามันถูกต้องหรือไม่ ฉันเลือกฐาน 49 สำหรับปัญหานี้ แต่ฐานใดก็ตามที่ใหญ่กว่า 45 จะเพียงพอ

ตัวอย่างที่ชัดเจน (หวังว่า): ลองจินตนาการว่า "ทุกแถว" ในปริศนาซูโดกุนั้นเป็นตัวเลขตัวเดียวในจำนวนฐาน -49 เราจะแสดงตัวเลขแต่ละตัวในเลขฐาน -49 เป็นหมายเลขฐาน -10 ในเวกเตอร์เพื่อความง่าย ดังนั้นหากทุกแถว "ถูกต้อง" เราคาดหวังว่าเลขฐาน 49 ต่อไปนี้ (เป็นเวกเตอร์ฐาน 10):

(45,45,45,45,45,45,45,45,45)

หรือแปลงเป็นตัวเลขฐาน 10 เดียว: 1526637748041045

ปฏิบัติตามตรรกะที่คล้ายกันสำหรับคอลัมน์ทั้งหมดและเหมือนกันสำหรับ "ตารางย่อย" ค่าใด ๆ ที่พบในการวิเคราะห์ขั้นสุดท้ายที่ไม่เท่ากับ "อุดมคติหมายเลข" นี้หมายถึงการแก้ปัญหาปริศนาไม่ถูกต้อง

แก้ไขเพื่อแก้ไขช่องโหว่-5s ทั้งหมดและปัญหาอื่น ๆ ที่เกี่ยวข้อง: ฉันเพิ่มหมายเลข base-49 ตัวที่สี่ตามความคิดที่ว่าควรมี 9 ของแต่ละหมายเลขในปริศนาทุกตัว ดังนั้นฉันเพิ่ม 5 หลักแต่ละหลักในหมายเลขฐาน 49 สำหรับแต่ละหมายเลขฐาน 10 ที่เกิดขึ้นซึ่งแสดงถึงดัชนีของหลักแต่ละ ตัวอย่างเช่นหากมี 10 9 และ 9 8, 9 7, 8 6 และอื่น ๆ ทั้งหมดคุณจะได้รับเลขฐาน 49 (เป็นเวกเตอร์ฐาน 10 ขนาด 10 เพื่อจัดการกับล้น):

(1, 1, 45, 45, 40, 45, 45, 45, 45, 45)

ซึ่งจะล้มเหลวเมื่อเปรียบเทียบกับหมายเลข "อุดมคติ" ของเรา -49

โซลูชันของฉันใช้ประโยชน์จากโซลูชันทางคณิตศาสตร์นี้เพื่อหลีกเลี่ยงการวนซ้ำและการเปรียบเทียบให้ได้มากที่สุด ฉันเพียงแค่ใช้longค่าเพื่อเก็บแต่ละหมายเลข base-49 เป็นหมายเลข base-10 และใช้อาร์เรย์การค้นหาเพื่อรับ "ปัจจัย" สำหรับแต่ละหลัก -49 หลักในระหว่างการคำนวณค่าคอลัมน์ / แถว / subgrid

เนื่องจาก Java ไม่ได้ออกแบบมาให้รัดกุมการใช้ความระมัดระวังในการสร้างทางคณิตศาสตร์จึงเป็นวิธีเดียวที่ฉันคิดว่าฉันสามารถสร้างตัวตรวจสอบรัดกุมได้

แจ้งให้เราทราบสิ่งที่คุณคิด.

R 145

function(x)colSums(do.call(rbind,lapply(list(R<-row(b<-matrix(1,9,9)),C<-col(b),(R-1)%/%3+1+3*(C-1)%/%3),sapply,`==`,1:9))%*%c(2^(x-1))==511)==27

รหัส de-แข็งแรงเล่นกอล์ฟ (มากหรือน้อย) สามารถพบได้ที่นี่/programming//a/21691541/1201032

Haskell (แลมบ์บ็อต), 65 ไบต์

k x=and$(all$([1..9]==).sort)<$>[x,transpose x,join$chunksOf 3 x]

Perl, 193 ไบต์

for(@x=1..9){$i=$_-1;@y=();push@y,$a[$i][$_-1]for@x;@y=sort@y;$r+=@y~~@x;@y=();push@y,$a[3*int($i/3)+$_/3][3*($i%3)+$_%3]for 0..8;@y=sort@y;$r+=@y~~@x}for(@a){@y=sort@$_;$r+=@y~~@x}exit($r!=27)

อินพุตคาดว่าจะอยู่ในรูปแบบอาร์เรย์:

@a=(
    [1,2,3,4,5,6,7,8,9],
    [4,5,6,7,8,9,1,2,3],
    [7,8,9,1,2,3,4,5,6],
    [2,3,1,5,6,4,8,9,7],
    [5,6,4,8,9,7,2,3,1],
    [8,9,7,2,3,1,5,6,4],
    [3,1,2,6,4,5,9,7,8],
    [6,4,5,9,7,8,3,1,2],
    [9,7,8,3,1,2,6,4,5]
);

รหัสทางออกคือ 0 หาก@aเป็นวิธีแก้ปัญหามิฉะนั้น1จะถูกส่งคืน

เวอร์ชันที่ไม่ถูกปรับแต่ง:

@x = (1..9);
for (@x) {
    $i = $_ - 1;
    # columns
    @y = ();
    for (@x) {
        push @y, $a[$i][$_-1];
    }
    @y = sort @y;
    $r += @y ~~ @x;
    # sub arrays
    @y = ();
    for (0..8) {
        push @y, $a[ 3 * int($i / 3) + $_ / 3 ][ 3 * ($i % 3) + $_ % 3 ];
    }
    @y = sort @y;
    $r += @y ~~ @x
}
# rows
for (@a) {
    @y = sort @$_;
    $r += @y ~~ @x
}
exit ($r != 27);

แต่ละแถว 9, 9 คอลัมน์และอาร์เรย์ย่อย 9 รายการจะถูกใส่เข้าไปในอาร์เรย์ที่เรียงลำดับแล้วตรวจสอบว่าตรงกับอาร์เรย์(1..9)หรือไม่ จำนวน$rจะเพิ่มขึ้นสำหรับการจับคู่แต่ละครั้งที่ประสบความสำเร็จซึ่งจะต้องรวมได้ถึง 27 สำหรับโซลูชันที่ถูกต้อง

J 52 54

-.*/,(9=#)@~.@,"2(0 3 16 A.i.4)&|:(4#3)($,)".;._2]0 :0

ใช้เป็นอาร์กิวเมนต์วางบนบรรทัดคำสั่งแล้วลงท้ายด้วย a) เป็น:

1 2 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 3 1 5 6 4 8 9 7
5 6 4 8 9 7 2 3 1
8 9 7 2 3 1 5 6 4
3 1 2 6 4 5 9 7 8
6 4 5 9 7 8 3 1 2
9 7 8 3 1 2 6 4 5
)

ส่งคืน 1 ถ้าผ่าน, 0 ถ้าไม่ใช่

ภายในจะแปลงกริด 9x9 เป็นกริด 3x3x3x3 และทำการเรียงสับเปลี่ยนบนแกนเพื่อให้ได้หน่วยที่ต้องการ (แถวเส้นและกล่อง) ใน 2 มิติสุดท้าย

หลังจากทำเช่นนั้นจะมีการตรวจสอบว่าแต่ละหน่วยมี 9 ค่าที่ไม่ซ้ำกัน

อาจไกลจากที่สมบูรณ์แบบ แต่เต้นส่วนใหญ่แล้ว ;-)

Mathematica, 84 79 ตัวอักษร

f=Tr[Norm[Sort@#-Range@9]&/@Join[#,Thread@#,Flatten/@Join@@#~Partition~{3,3}]]&

ตัวอย่าง:

f[{{1,2,3,4,5,6,7,8,9},
   {4,5,6,7,8,9,1,2,3},
   {7,8,9,1,2,3,4,5,6},
   {2,3,1,5,6,4,8,9,7},
   {5,6,4,8,9,7,2,3,1},
   {8,9,7,2,3,1,5,6,4},
   {3,1,2,6,4,5,9,7,8},
   {6,4,5,9,7,8,3,1,2},
   {9,7,8,3,1,2,6,4,5}}]

0

f[{{2,1,3,4,5,6,7,8,9},
   {4,5,6,7,8,9,1,2,3},
   {7,8,9,1,2,3,4,5,6},
   {2,3,1,5,6,4,8,9,7},
   {5,6,4,8,9,7,2,3,1},
   {8,9,7,2,3,1,5,6,4},
   {3,1,2,6,4,5,9,7,8},
   {6,4,5,9,7,8,3,1,2},
   {9,7,8,3,1,2,6,4,5}}]

2

f[{{0,2,3,4,5,6,7,8,9},
   {4,5,6,7,8,9,1,2,3},
   {7,8,9,1,2,3,4,5,6},
   {2,3,1,5,6,4,8,9,7},
   {5,6,4,8,9,7,2,3,1},
   {8,9,7,2,3,1,5,6,4},
   {3,1,2,6,4,5,9,7,8},
   {6,4,5,9,7,8,3,1,2},
   {9,7,8,3,1,2,6,4,5}}]

3

Javascript ES6, 150 ตัวอักษร

รับอินพุตเป็นสตริง 81-char โดยไม่มี delimeter ใด ๆ

s=>s.match("^(?=(#.{0,8}#.{9})+$)(?=(#(.{9}){0,8}#.){9})((#.?.?(.{9}){0,2}#...){3}.{18})+$".replace(/#(.*?)#/g,"123456789".replace(/./g,"(?=$$1$&)")))

ฟังก์ชันส่งคืน nullเป็นคำตอบเชิงลบและอาร์เรย์ที่มีสตริงเดิมในองค์ประกอบแรกเป็นหนึ่งบวก สามารถเปลี่ยนเป็นบูลโดยการเพิ่ม!!ฟังก์ชั่นเริ่มต้น

ทดสอบ (ดูความท้าทายที่เกี่ยวข้องสำหรับ detais เพิ่มเติม):

f=s=>s.match("^(?=(#.{0,8}#.{9})+$)(?=(#(.{9}){0,8}#.){9})((#.?.?(.{9}){0,2}#...){3}.{18})+$".replace(/#(.*?)#/g,"123456789".replace(/./g,"(?=$$1$&)")))
;`123456789456789123789123456231564897564897231897231564312645978645978312978312645
725893461841657392396142758473516829168429537952378146234761985687935214519284673
395412678824376591671589243156928437249735186738641925983164752412857369567293814
679543182158926473432817659567381294914265738283479561345792816896154327721638945
867539142324167859159482736275398614936241587481756923592873461743615298618924375
954217683861453729372968145516832497249675318783149256437581962695324871128796534
271459386435168927986273541518734269769821435342596178194387652657942813823615794
237541896186927345495386721743269158569178432812435679378652914924813567651794283
168279435459863271273415986821354769734692518596781342615947823387526194942138657
863459712415273869279168354526387941947615238138942576781596423354821697692734185
768593142423176859951428736184765923572389614639214587816942375295837461347651298`
.split`
`.every(f)
&&
`519284673725893461841657392396142758473516829168429537952378146234761985687935214
839541267182437659367158924715692843624973518573864192298316475941285736456729381
679543182158926473432817659567381294914256738283479561345792816896154327721638945
867539142324167859159482736275398684936241517481756923592873461743615298618924375
754219683861453729372968145516832497249675318983147256437581962695324871128796534
271459386435168927986273541518734269769828435342596178194387652657942813823615794
237541896186927345378652914743269158569178432812435679495386721924813567651794283
168759432459613278273165984821594763734982516596821347615437829387246195942378651
869887283619214453457338664548525781275424668379969727517385163319223917621449519
894158578962859187461322315913849812241742157275462973384219294849882291119423759
123456789456789123564897231231564897789123456897231564312645978645978312978312645
145278369256389147364197258478512693589623471697431582712845936823956714931764825`
.split`
`.every(s => !f(s))

R, 63 50 ไบต์

ถือว่าอินพุตmเป็นเมทริกซ์ขนาด 9x9 ของตัวเลข

all(apply(m,1,match,x=1:9),apply(m,2,match,x=1:9))

ฉันพูดถูกว่าการเล่นกอล์ฟต่อไปเป็นไปได้

คำอธิบาย:

    apply(m,1,match,x=1:9),

ใช้mและสำหรับแต่ละแถวใช้matchฟังก์ชัน เราระบุข้อโต้แย้งต่อไปที่จะถูกส่งผ่านไปยังx=1:9 เป็นค่าเริ่มต้นครั้งแรกอาร์กิวเมนต์ตำแหน่งและดังนั้นแต่ละแถวจะถูกวางในตำแหน่งที่อาร์กิวเมนต์ที่สองซึ่งเป็น ฟังก์ชั่นรูปลักษณ์สำหรับกรณีของใน ในกรณีนี้มันกำลังมองหาmatchxtablematchxtable1:9 (หมายเลข 1 ถึง 9) ในแต่ละแถว สำหรับแต่ละอัน1:9จะส่งคืนTRUE(หรือFALSE) หากพบหมายเลขนั้น (หรือไม่)

ดังนั้นสิ่งนี้ให้ชุดของค่าบูลีน 81

                           apply(m,2,match,x=1:9)

ทำซ้ำด้านบนสำหรับแต่ละคอลัมน์ของอินพุต

all(                                             )

สุดท้ายallตรวจสอบว่าองค์ประกอบทั้งหมดของรายการบูลีนเป็นTRUEหรือไม่ นี่จะเป็นกรณีที่หากวิธีการแก้ไขนั้นถูกต้อง (เช่นแต่ละหมายเลข1:9จะแสดงเพียงครั้งเดียวในแต่ละคอลัมน์และแต่ละแถว)

วิธีเก่า:

for(i in 1:2)F=F+apply(m,i,function(x)sort(x)==1:9);sum(F)==162

[1, 2, ... 9]มันต้องใช้เวลาแต่ละแถวเรียงลำดับจากนั้นเปรียบเทียบกับ แถวที่ถูกต้องควรตรงกันทั้งหมด จากนั้นทำเช่นเดียวกันสำหรับแต่ละคอลัมน์ โดยรวมเราควรมีการแข่งขันที่แน่นอน 162 ครั้งซึ่งเป็นสิ่งที่ส่วนสุดท้ายจะตรวจสอบ อาจมีขอบเขตสำหรับการเล่นกอล์ฟเพิ่มเติมที่นี่ ...

Haskell - 175

import Data.List
c=concat
m=map
q=[1..9]
w=length.c.m (\x->(x\\q)++(q\\x))
b x=c.m(take 3.drop(3*mod x 3)).take 3.drop(3*div x 3)
v i=sum$m(w)[i,transpose i,[b x i|x<-[0..8]]]

ฟังก์ชั่นvเป็นหนึ่งในการโทร มันทำงานได้โดยรับความแตกต่างของแต่ละแถวคอลัมน์และบล็อกกับรายการ[1..9]และรวมความยาวของรายการผลต่างเหล่านั้น

การสาธิตโดยใช้ตัวอย่าง Sudoku:

*Main> :l so-22443.hs 
[1 of 1] Compiling Main             ( so-22443.hs, interpreted )
Ok, modules loaded: Main.
*Main> v [[1,2,3,4,5,6,7,8,9],[4,5,6,7,8,9,1,2,3],[7,8,9,1,2,3,4,5,6],[2,3,1,5,6,4,8,9,7],[5,6,4,8,9,7,2,3,1],[8,9,7,2,3,1,5,6,4],[3,1,2,6,4,5,9,7,8],[6,4,5,9,7,8,3,1,2],[9,7,8,3,1,2,6,4,5]]
0

Javascript - 149 ตัวอักษร

r=[];c=[];g=[];for(i=9;i;)r[o=--i]=c[i]=g[i]=36;for(x in a)for(y in z=a[x]){r[v=z[y]-1]-=y;c[v]-=x;g[v]-=3*(x/3|0)+y/3|0}for(i in r)o|=r[i]|c[i]|g[i]

คาดหวังอาร์เรย์ aจะมีอยู่และสร้างตัวแปรoสำหรับเอาต์พุตซึ่งก็คือ0ประสบความสำเร็จและไม่เป็นศูนย์

ทำงานโดยตรวจสอบว่าผลรวมของตำแหน่งที่แต่ละค่าเกิดขึ้นสำหรับแต่ละแถวคอลัมน์และ 3 * 3 ตารางเท่ากับ 36 (0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8)

การทดสอบ

a=[
    [1,2,3, 4,5,6, 7,8,9],
    [4,5,6, 7,8,9, 1,2,3],
    [7,8,9, 1,2,3, 4,5,6],

    [2,3,1, 5,6,4, 8,9,7],
    [5,6,4, 8,9,7, 2,3,1],
    [8,9,7, 2,3,1, 5,6,4],

    [3,1,2, 6,4,5, 9,7,8],
    [6,4,5, 9,7,8, 3,1,2],
    [9,7,8, 3,1,2, 6,4,5]
  ];

ให้ 'o = 0'

a=[
    [1,2,3, 4,5,6, 7,8,9],
    [4,5,6, 7,8,9, 1,2,3],
    [7,8,9, 1,2,3, 4,5,6],

    [2,3,1, 5,6,4, 8,9,7],
    [5,6,4, 8,9,7, 2,3,1],
    [8,9,7, 2,3,1, 5,6,4],

    [3,1,2, 6,4,5, 9,7,8],
    [6,4,5, 9,7,8, 3,1,2],
    [9,7,8, 3,1,2, 6,5,4]
  ];

(สลับตัวเลข 2 ตัวสุดท้าย)

จะช่วยให้ o=-1

a=[
    [5,5,5, 5,5,5, 5,5,5],
    [5,5,5, 5,5,5, 5,5,5],
    [5,5,5, 5,5,5, 5,5,5],

    [5,5,5, 5,5,5, 5,5,5],
    [5,5,5, 5,5,5, 5,5,5],
    [5,5,5, 5,5,5, 5,5,5],

    [5,5,5, 5,5,5, 5,5,5],
    [5,5,5, 5,5,5, 5,5,5],
    [5,5,5, 5,5,5, 5,5,5]
  ];

จะช่วยให้ o=-284

Haskell, 121 130 127 ไบต์ (87 Lambdabot)

import Data.List
import Data.List.Split
c=concat
t=transpose
k=chunksOf
p x=all(==[1..9])$(sort<$>)=<<[x,t x,k 9.c.c.t$k 3<$>x]

การใช้งาน:

-- k 9.c.c.t$k 3<$> x = chunksOf 9 $ concat $ concat $ transpose $ map chunksOf 3 x

let ts = k 9$[10*a+b|a<-[1..9],b<-[1..9]] --yep, this is ugly
in k 9.c.c.t$k 3<$>ts
-- prints:
--[[11,12,13,21,22,23,31,32,33],[41,42,43,51,52,53,61,62,63],[71,72,73,81,82,83,91,92,93],[14,15,16,24,25,26,34,35,36],[44,45,46,54,55,56,64,65,66],[74,75,76,84,85,86,94,95,96],[17,18,19,27,28,29,37,38,39],[47,48,49,57,58,59,67,68,69],[77,78,79,87,88,89,97,98,99]]

Lambdabot โหลด Data.List และ Data.List.Split ตามค่าเริ่มต้น (ฉันไม่คิดว่าโซลูชันของ BlackCap จะตรวจสอบกล่อง)

แนวคิดสำหรับการปรับปรุงการต้อนรับ

// แก้ไข: ฉันทำผิด :)
// แก้ไข: บันทึกได้ 3 ไบต์โดย BlackCap

05AB1E , 36 ไบต์ | ไม่มีการแข่งขัน |

|©vy3ô})3ôøvyJvyê}}®øvyê}®vyê})êžh¦Q

ลองออนไลน์!

1 เป็นจริงสิ่งอื่นใดเป็นเท็จ

Clojure 151 ไบต์

ค่อนข้างนาน แต่คนอื่น ๆ ก็ดูเหมือนจะดีเช่นกัน ยังน่ารำคาญที่ต้องมีการรวมกันของชุดrequireดังนั้นฉันจึงใช้เวกเตอร์พล็อตแทน

วนซ้ำทุกแถวและคอลัมน์และหากค่าอยู่ระหว่าง 1 ถึง 9 จะปล่อยเวกเตอร์สามตัวหนึ่งรายการสำหรับแถว, คอลัมน์และเซลล์ 3x3 ส่งกลับค่า 0 เมื่อสำเร็จและnilมิฉะนั้นอักขระพิเศษสองตัวสามารถส่งคืน 1 เมื่อล้มเหลว จัดการตัวเลขที่อยู่นอก 1 - 9 ด้วยการส่งคืนnilแต่จะผิดพลาดในความผิดปกติอื่น ๆ เช่นค่าที่ไม่ใช่จำนวนเต็ม Quotients คือ 0 - 2 ดังนั้นจึงปลอดภัยที่จะใช้ค่า8และ9เพื่อแยกความแตกต่างของค่าเซลล์จากแถวและคอลัมน์

(fn[s](if(= 243(count(set(apply concat(for[i(range 9)j(range 9)](let[v(nth(nth s i)j)q #(quot % 3)](if(<= 1 v 9)[[8 v i][9 v j][(q i)(q j)v]])))))))0))

อินพุตเป็นเวกเตอร์ซ้อนของเวกเตอร์ (เพื่อให้nthทำงานได้):

(def sudoku [[1 2 3 4 5 6 7 8 9]
             [4 5 6 7 8 9 1 2 3] 
             [7 8 9 1 2 3 4 5 6] 
             [2 3 1 5 6 4 8 9 7] 
             [5 6 4 8 9 7 2 3 1] 
             [8 9 7 2 3 1 5 6 4] 
             [3 1 2 6 4 5 9 7 8] 
             [6 4 5 9 7 8 3 1 2] 
             [9 7 8 3 1 2 6 4 5]])

Ungolfed:

(defn f [s]
  (->> (for [i (range 9) j (range 9)]
         (let [v (-> s (nth i) (nth j)) q #(quot % 3)]
           (if (<= 1 v 9)
             [[:row v i] [:col v j] [:cell [(q i) (q j)] v]])))
    (apply concat)
    set
    count
    (#(if (= 243 %) :pass :fail))))

PHP, 196 190 ไบต์

while($i<9){for($b=$c=$k=$y="";$y++<9;)$b.=($a=$argv)[$y][$i];for(;$k<3;)$c.=substr($a[++$k+$i-$i%3],$i%3*3,3);if(($u=count_chars)($a[++$i],3)<($d=123456789)|$u($b,3)<$d|$u($c,3)<$d)die(1);}

โปรแกรมรับอาร์กิวเมนต์บรรทัดคำสั่งแยก 9 ตัว (หนึ่งสตริงของตัวเลขสำหรับแต่ละบรรทัดของตาราง)
ออกด้วย1(ข้อผิดพลาด) สำหรับสิ่งที่ไม่ถูกต้อง0 (ok) สำหรับถูกต้อง

php -nr '<code>' <row1> <row2> ...ทำงานด้วย

ทำให้พังถล่ม

while($i<9)
{
    for($b=$c=$k=$y="";$y++<9;)$b.=($a=$argv)[$y][$i];  // column to string
    for(;$k++<3;)$c.=substr($a[$i-$i%3+$k],$i%3*3,3);   // sub-grid to string
    if(($u=count_chars)($a[++$i],3)<($d=123456789)      // check row
        |$u($b,3)<$d                                    // check column
        |$u($c,3)<$d                                    // check sub-grid
    )die(1);                                            // test failed: exit with 1
}

คำอธิบาย

count_charsนับอักขระในสตริงและมักจะสร้างอาร์เรย์ด้วยรหัส ascii เป็นคีย์และนับตัวอักษรเป็นค่า แต่ด้วย3พารามิเตอร์โหมดจะสร้างสตริงที่เรียงลำดับจากอักขระ และที่สามารถนำมาเปรียบเทียบกับตัวเลขกับตัวเลขที่ต้องการได้อย่างง่ายดาย

การเปรียบเทียบไม่เพียง แต่ตรวจสอบรายการซ้ำ แต่ยังรวมถึงการตรวจสอบอักขระที่ไม่ถูกต้อง และมันแค่ต้องการ<ไม่ใช่!=เพราะนี่เป็นการเปรียบเทียบเชิงตัวเลข: PHP จะตีความสตริงเป็นตัวเลขเท่าที่จะทำได้ 123e56789, 0x3456789หรือคล้ายกันไม่สามารถปรากฏเพราะตัวละครจะเรียง; และจำนวนเต็มจริงใด ๆ ที่มีตัวเลขหายไปนั้นเล็กกว่า123456789... และ.23456789แน่นอน

$a=$argvบันทึกหนึ่งไบต์$d=123456789บันทึกเก้าและ$u=count_charsบันทึก 13

C # - 306 298 288 ตัวอักษร

โปรแกรม Console ต่อไปนี้ถูกใช้เพื่อเรียกใช้ฟังก์ชันการตรวจสอบ

static void Main(string[] args)
    {
        int[,] i={{1,2,3,4,5,6,7,8,9},
             {4,5,6,7,8,9,1,2,3},
             {7,8,9,1,2,3,4,5,6},
             {2,3,1,5,6,4,8,9,7},
             {5,6,4,8,9,7,2,3,1},
             {8,9,7,2,3,1,5,6,4},
             {3,1,2,6,4,5,9,7,8},
             {6,4,5,9,7,8,3,1,2},
             {9,7,8,3,1,2,6,4,5}
            };

            Console.Write(P(i).ToString());
    }

ทั้งหมดนี้จะเริ่มต้นอาร์เรย์และส่งผ่านเข้าไปในฟังก์ชันการตรวจสอบ P

ฟังก์ชั่นการตรวจสอบมีดังนี้ (ในแบบฟอร์ม Golfed);

private static int P(int[,]i){int[]r=new int[9],c=new int[9],g=new int[9];for(int p=0;p<9;p++){r[p]=45;c[p]=45;g[p]=45;}for(int y=0;y<9;y++){for(int x=0;x<9;x++){r[y]-=i[x,y];c[x]-=i[x,y];int k=(x/3)+((y/3)*3);g[k]-=i[x,y];}}for(int p=0;p<9;p++)if(r[p]>0|c[p]>0|g[p]>0)return 1;return 0;}

หรือในรูปแบบที่จัดวางอย่างเต็มที่;

    private static int P(int[,] i)
    {
        int[] r = new int[9],c = new int[9],g = new int[9];
        for (int p = 0; p < 9; p++)
        {
            r[p] = 45;
            c[p] = 45;
            g[p] = 45;
        }

        for (int y = 0; y < 9; y++)
        {
            for (int x = 0; x < 9; x++)
            {
                r[y] -= i[x, y];

                c[x] -= i[x, y];

                int k = (x / 3) + ((y / 3) * 3);
                g[k] -= i[x, y];
            }
        }

        for (int p = 0; p < 9; p++)
            if (r[p] > 0 | c[p] > 0 | g[p] > 0) return 1;

        return 0;
    }

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

ตามที่ร้องขอจะคืนค่า 0 หากอาร์เรย์เป็นโซลูชัน Sudoku ที่ถูกต้องและไม่ใช่ศูนย์ (1) ซึ่งไม่ใช่