Takuzu เป็นเกมลอจิกที่คุณต้องทำกริดกับเซลล์ที่มี0s และ1s กริดต้องเป็นไปตามกฎ 3 ข้อ:

1. ไม่มีเซลล์ติดต่อกันสามเซลล์ในแนวนอนหรือแนวตั้ง
2. จะต้องมีจำนวน0s และ1s เท่ากันในแต่ละแถวและคอลัมน์
3. ไม่มีสองแถวที่เหมือนกันและไม่มีสองคอลัมน์ที่เหมือนกัน

ลองดูตารางที่เสร็จแล้ว:

0011
1100
0101
1010

ที่คุณสามารถดูบอร์ดนี้เป็นไปตามกฎ1, และ2 3ไม่มีเซลล์แนวนอนหรือแนวตั้งสามเซลล์ที่เหมือนกันแถวและคอลัมน์ทั้งหมดมีจำนวน0s และ1s เท่ากันและไม่มีสองแถวและไม่มีสองคอลัมน์เหมือนกัน

ลองดูตารางที่ไม่ถูกต้อง:

110100
010011
011010
101100
100011
001101

มีปัญหามากมายกับกริดนี้ ตัวอย่างเช่นแถว5มีสาม0s ในแถวและคอลัมน์2มีสาม1s ในแถวตามด้วยสาม0s ดังนั้นนี่ไม่ใช่กริดที่ถูกต้อง

งาน:

งานของคุณคือการทำโปรแกรมที่กำหนดให้อาร์เรย์n* n 0s และ1s เป็นแบบ 2 มิติตรวจสอบบอร์ดเพื่อดูว่าบอร์ดทาคูซุที่ใช้งานได้นั้นถูกต้องหรือไม่

ตัวอย่าง:

0011
1100
0101
1010

บอร์ดนี้ปฏิบัติตามกฎทั้งหมดและดังนั้นจึงเป็นบอร์ด Takuzu ที่ถูกต้อง คุณต้องส่งคืนค่าความจริงสำหรับสิ่งนี้

11
00

นี้ไม่ได้เป็นคณะกรรมการที่ถูกต้อง - แถวไม่เป็นไปตามกฎ1 2คุณต้องส่งคืนค่าเท็จสำหรับสิ่งนี้

100110
101001
010101
100110
011010
011001

นี่ไม่ใช่บอร์ดที่ถูกต้อง แต่ล้มเหลว (เฉพาะ) เนื่องจากกฎ 3 - แถวแรกและแถวที่สี่เหมือนกัน

110100
001011
010011
101100
100110
011001

นี่ไม่ใช่บอร์ดที่ถูกต้อง แต่ล้มเหลว (เฉพาะ) เนื่องจากกฎ 3 - คอลัมน์แรกและคอลัมน์ที่สี่เหมือนกัน

011010
010101
101100
010011
100110
101001

นี่คือคณะกรรมการที่ถูกต้อง

กฎและข้อกำหนด:

• คุณสามารถสมมติว่าบอร์ดทั้งหมดเป็นสแควร์ขนาดn * nซึ่งnเป็นจำนวนเต็มบวก
• คุณสามารถสมมติได้ว่าบอร์ดทั้งหมดเสร็จสิ้นแล้ว
• คุณอาจรับอินพุตเป็นอาร์เรย์ 2D ที่มีค่าที่บ่งบอกถึง0และ1หรือเป็นสตริง
• คุณต้องส่งออกค่าความจริงและค่าคงที่ที่สอดคล้องกันสำหรับกระดานความจริงและค่าความเท็จและค่าที่เป็นตัวแทนของ "ความจริง" และ "เท็จ" จะต้องไม่เหมือนกัน

นี่คือรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ!

Brachylog , 20 18 ไบต์

≠\≠,?¬{∋s₃=|∋ọtᵐ≠}

ลองออนไลน์!

คำอธิบาย

≠                           All rows are different
 \                          Transpose
  ≠                         All columns are different
   ,?                       Append the list of rows to the list of columns
     ¬{          }          It is impossible that:
       ∋                      A row/column of the matrix…
        s₃=                   …contains a substring of 3 equal elements
           |                Or that:
            ∋ọ                The occurences of 1s and 0s in a row/column…
              tᵐ≠             …are not equal

Husk , 19 18 ไบต์

S=‼(Tf§=LṁDum(ṁ↑2g

ลองออนไลน์!

บันทึก 1 ไบต์ต้องขอบคุณ H.PWiz!

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

คำอธิบาย

S=‼(Tf§=LṁDum(ṁ↑2g
            m(ṁ↑2g    in each line, take at most two items for each sequence of equal items
           u          remove duplicate lines
     f§=LṁD          keep only those lines where the sum of each element doubled is equal to the length of the line
    T                 transpose the matrix (swap rows with columns)
  ‼                   do all the previous operations again
S=                    check if the final result is equal to the original input

เยลลี่ขนาด 17 ไบต์

-*S;E3Ƥ€F$TȯQZµ⁺⁼

ลองออนไลน์!

-6 ไบต์ต้องขอบคุณไมล์และโจนาธานอัลลัน

Mathematica, 143 ไบต์

And@@Flatten@(((s=#;Equal@@(Count[s,#]&/@{0,1})&&FreeQ[Subsequences@s,#]&/@{{1,1,1},{0,0,0}})&/@#)&&(DeleteDuplicates@#==#)&/@{#,Transpose@#})&

อินพุต

[{{0, 0, 1, 1}, {1, 1, 0, 0}, {0, 1, 0, 1}, {1, 0, 1, 0}}]

Python 2 , 127 ไบต์

a=input()
n=len(a)
b=zip(*a)
print[n/2]*n*2==map(sum,a+b)>len(set(a))==len(set(b))==n<'0, 0, 0'not in`a+b`>'1, 1, 1'not in`a+b`

ลองออนไลน์!

อ่านรายการของn n -tuples เป็นอินพุต

ฉันสามารถส่งออกโดยใช้รหัสทางออกโดยการเขียน1/(…)แทนprint…แต่มันให้ความรู้สึกแย่ ฉันควร?

คำอธิบาย

nคือขนาดของกระดาน bคือรายการของคอลัมน์ (การแปลงจากa) ส่วนที่เหลือคือการเปรียบเทียบที่ถูกโยงโซ่ยาวหนึ่ง:

• [n/2]*n*2==map(sum,a+b) ตรวจสอบกฎ 2. แต่ละแถวและคอลัมน์ควรรวมกับ n / 2
• map(sum,a+b)>len(set(a)) เป็นจริงเสมอ (รายการ> int)
• len(set(a))==len(set(b))==n ตรวจสอบกฎ 3
• n<'0, 0, 0' เป็นจริงเสมอ (int <str)

• '0, 0, 0'not in`a+b`>'1, 1, 1'not in`a+b`กฎการตรวจสอบ 1. `a+b`เป็นตัวแทนสตริงของแถวและคอลัมน์ทั้งหมด; สำหรับตัวอย่างอินพุตของ TIO

  "[(0, 0, 1, 1), (1, 1, 0, 0), (0, 1, 0, 1), (1, 0, 1, 0), (0, 1, 0, 1), (0, 1, 1, 0), (1, 0, 0, 1), (1, 0, 1, 0)]"

  `a+b`>'1, 1, 1'ในศูนย์เป็นจริงเสมอตั้งแต่สายนี้รับประกันได้ว่าจะเริ่มต้นด้วยซึ่งมีค่ามากกว่า"[""1"

Husk , 27 25 ไบต์

Λ§&Λȯ¬VEX3§&Λ§=#0#1S=uSeT

อินพุตเป็นรายการของรายการและเอาท์พุท1สำหรับTrueและ0สำหรับFalse

ลองออนไลน์!

ชี้แจง

                      SeT    Create a list with the input and itself transposed
Λ                            Is the following function true for all in the list
 §&                          And the results of the following functions
   Λȯ¬VEX3                     Test for rule 1
          §&                   The and of:
            Λ§=#0#1                Test for rule 2
                   S=u             Test for rule 3

ทดสอบ 1

Λȯ¬VEX3
Λ         Is it True for all ...
   V      Are any of the ...
     X3   Substrings of length 3 ...
    E     All equal
 ȯ¬       Logical not

ทดสอบ 2

Λ§=#0#1
Λ         Is it true for all that ...
 §=       The results of the two functions are equal
   #0         Number of 0s
     #1       Number of 1s

ทดสอบ 3

S=u
S=    Is the result of the following function equal two its argument
  u   Remove duplicates

Retina , 129 89 85 ไบต์

.+
$&,$&
O#$`.(?=.*,)
$.%`
.+
$&;$&
+`(01|10)(?=.*;)

1ms`(.)\1\1|\d,?;|(\D\d+\b).*\2

ลองออนไลน์! เอาต์พุต 0 สำหรับถูกต้อง 1 สำหรับไม่ถูกต้อง แก้ไข: บันทึกแล้ว 4 ไบต์ด้วย @MartinEnder คำอธิบาย:

.+
$&,$&

ทำซ้ำแต่ละแถวด้วย,ตัวคั่น

O#$`.(?=.*,)
$.%`

ย้ายสำเนาแรก

.+
$&;$&

ทำซ้ำอีกครั้งคราวนี้มี;ตัวคั่น

+`(01|10)(?=.*;)

ลบคู่ของตัวเลขที่ตรงกับเซมิโคลอน

1ms`(.)\1\1|\d,?;|(\D\d+\b).*\2

ตรวจสอบเพื่อดูว่าคอลัมน์หรือแถวใด ๆ ล้มเหลวในกฎใด ๆ ; (.)\1\1ตรวจสอบตัวเลขสามหลักที่เหมือนกันในแถว\d,?;ตรวจสอบตัวเลขที่ไม่ได้คู่และ(\D\d+\b).*\2ตรวจสอบตัวเลขที่ซ้ำกัน

Pyth , 31 ไบต์

ขอบคุณมากที่@Leaky Nunนูน

.Asm++mqy/k\0lQdm<hk3srL8d{Id,C

ตรวจสอบกรณีทดสอบทั้งหมดหรือลองที่นี่!

Pyth ,  48 46 44  42 ไบต์

นี่คือทางออกแรก

&{IQ&{I.TQ.Am&q/d\0/d\1!+/d*3\0/d*3\1sC,.T

ตรวจสอบกรณีทดสอบทั้งหมดหรือลองที่นี่!

& {IQ & {I.TQ.Am & q / d \ 0 / d \ 1! + / d * 3 \ 0 / d * 3 \ 1sC, .T โปรแกรมเต็มรูปแบบพร้อมอินพุตโดยนัย

 {IQ เป็นค่าคงที่ของการป้อนข้อมูลซ้ำซ้อนหรือไม่?
& {I.TQ และค่าคงตัวการแปลงเป็นเท่ากันหรือไม่
                                        .TQ Transpose
                                           Q การป้อนข้อมูล
                                     sC, ซิปด้านบน, [^, ^^] (และแบน)
    & และเป็นไปตามเงื่อนไขต่อไปนี้หรือไม่
          . องค์ประกอบทั้งหมดเป็นความจริงเมื่อทำแผนที่มากกว่า ^^
              q / d \ 0 / d \ 1 มี 0s มากเท่ากับ 1s
             &! + / d * 3 \ 0 / d * 3 \ 1 และไม่มีการวิ่งขององค์ประกอบที่เท่ากัน 3 รายการ

MATL , 27 ไบต์

,G@?!]tEqts~w7BZ+|3<bXBSdvA

การป้อนข้อมูลเป็นเมทริกซ์ที่มีและ0 1เอาท์พุทเป็น0เท็จ1สำหรับความจริง

ลองออนไลน์! หรือดูกรณีทดสอบ: 1 , 2 , 3 , 4 ,5

คำอธิบาย

,       % Do twice. First iteration will use the input, second its transpose
  G     %   Push input
  @     %   Push iteration index: first 0, then 1
  ?     %   If nonzero
    !   %     Transpose
  ]     %   End
  t     %   The top of the stack contains the input or its transpose. Duplicate
  Eq    %   Convert to bipolar form, i.e. replace 0 by -1
  t     %   Duplicate
  s     %   Sum of each column
  ~     %   Negate. If all results are true, condition 2 is fulfilled
  w     %   Swap. Moves copy of bipolar input/transposed input to top
  7B    %   Push [1 1 1], obtained as 7 converted to binary
  Z+    %   2D convolution. Gives a matrix of the same size as the input
  |3<   %   Is each entry less than 3 in absolute value? If all results are true,
        %   condition 1 is fulfilled
  b     %   Bubble up. Moves copy of input/transposed input to top
  XB    %   Convert each row from binary to a number
  Sd    %   Sort, consecutive differences. If all results are nonzero, condition 3
        %   is fulfilled
  v     %   Concatenate all results so far into a column vector
  A     %   True if all entries are nonzero
        % End (implicit). Display (implicit)

R , 114 107 ไบต์

-7 ต้องขอบคุณ Giuseppe การเรียกฟังก์ชั่นผิดปกติและการบีบอัดเงื่อนไขลง

function(x)any(f(x),f(t(x)))
f=function(x)c(apply(x,1,function(y)max(rle(y)$l)>2+mean(y)-.5),duplicated(x))

ลองออนไลน์!

นี่ใช้กฎกับคอลัมน์ของเมทริกซ์จากนั้นคอลัมน์ของทรานสโพสของเมทริกซ์

รับอินพุตในแบบฟอร์ม:

matrix(c(0,0,1,1,1,1,0,0,0,1,0,1,1,0,1,0), ncol=4)

ซึ่งเป็นวิธีการที่ใช้เวลา R อาร์เรย์ 2 มิติ

เอาต์พุต TRUE สำหรับความล้มเหลว, FALSE สำหรับการส่งผ่าน

เพิร์ล 6 ,100 93 ไบต์

ทางแยก FTW! พวกเขาบันทึก 7 ไบต์

ในขณะนี้ดูเหมือนว่าจะมีการตีส่งอื่น ๆ ทั้งหมดที่เขียนในภาษาที่ไม่ใช่กอล์ฟ Yippie!

{!max (@(.map(*.join)).&{.repeated| |.map:{$_~~/000|111/|.comb(0)-.comb(1)}}for @^a,[Z] @^a)}

ลองออนไลน์!

คำอธิบาย : มันเป็นบล็อกที่ใช้กระดานเป็นรายการ เราทำการโอนย้ายด้วย[Z] @^a(ลดรายการของรายการที่มีตัวดำเนินการ zip) ดังนั้น@^a,[Z] @^aรายชื่อของคณะกรรมการและการเปลี่ยนแปลงคือ เราวนซ้ำไปเรื่อย ๆforซึ่งใช้งานได้mapดีเพียงแค่ 1 ถ่านถูกกว่าในกรณีนี้

ข้างในอันดับแรกเราเข้าร่วมรายการที่ประกอบด้วยแถวเป็นสตริงดังนั้นเราจึงมีรายการสตริงแทนที่จะเป็นรายการ ( @(.map(*.join))) จากนั้นเราใช้บล็อกที่ไม่ระบุชื่อ ( .&{...}) ซึ่งเราประเมินกฎ เราจะประเมินเฉพาะแถวที่ฉลาดเท่านั้น (เนื่องจากเราทำเพื่ออาร์เรย์ดั้งเดิมและการแปลงด้วย)

หากต้องการบันทึกค่อนข้างบาง!ของเราใช้บิตของตรรกะและแทนการทดสอบเราทดสอบ(NO repeated rows) AND (NO 3 consecutive same symbols) AND (NOT different counts of 0 and 1) NOT[ (repeated rows) OR (3 consecutive same symbols) OR (different counts) ]นั่นคือสิ่งที่เราทำในบล็อกนิรนาม: .repeatedให้ทุกแถวที่เกิดขึ้นมากกว่าหนึ่งครั้งจากนั้นเราแมปข้ามแถวพยายามจับคู่สัญลักษณ์ 3 ตัวติดต่อกันโดยใช้ regex และลบจำนวน 0 และ 1 ออก เหล่านี้จะ OR'red |กับ (อันที่จริงมันสร้างสิ่งที่ทรงพลังมากที่เรียกว่าทางแยกแต่เราไม่ได้ใช้พลังใด ๆ ของมัน :)) หลังจากทั้งหมดนี้เราจะได้รับรายชื่อ 2 "bools" (junctions ที่ไม่มีการยุบ) ในที่สุดเราหรือพวกเขา (ใช้max) และลบล้าง ( !) ซึ่งให้ผลลัพธ์ที่ต้องการ

J, _{40 38} 55 ไบต์

0=[:([:+/^:_(3(0=3|+/)\"1 ]),:-.@~:,:#=[:+/"1+:@])|:,:]

ลองออนไลน์!

นิยามฟังก์ชันที่รับเมทริกซ์จตุรัสเป็นอินพุต

อย่างน้อยก็เต้น Pyth (ตอนนี้ ... ) (ผิดพลาด) ฉันควรกลับไปนับอิโมจิที่ซ่อนอยู่ในรหัสของฉันตั้งแต่ J ยังให้ยืมตัวเองดี:

[: /^: :1 |: :] :-.@ :# :@] :~@

คำอธิบาย (ล้าสมัยเล็กน้อย)

สิ่งนี้ดูแตกต่างจากคำตอบของฉันและฉันอาจได้รับการอัปเดต บางส่วนของมันยังคงเหมือนเดิม - ฉันเพิ่งไม่ได้ตรวจสอบกฎ 3 และตรวจสอบกฎ 2 ก่อนอย่างไม่เหมาะสม

แบ่งออกเป็นฟังก์ชั่นบางอย่างและไม่ดี:

join_trans  =. |: ,: ]
part_3      =. 3 (0 = 3 | +/)\"1 ]
f           =. 1 - 2 * ]
main        =. 0 = [: ([: +/^:_ part_3 , f) join_trans

join_trans

|: ,: ]
|:       Transpose
   ,:    Laminated to
      ]  Input

นี่เป็นการรวมทรานสดิวเซอร์ของเมทริกซ์เข้ากับตัวเองเพื่อสร้างอาเรย์ของเมทริกซ์

part_3

3 (0 = 3 | +/)\"1 ]
                  ]  Input (matrix and transpose)

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

ฉ

1 - 2 * ]

fสำหรับการขาดชื่อที่ดีกว่าผมเรียกนี้ มันแทนที่ 0s ด้วย _1 และปล่อย 1s ไม่เปลี่ยนแปลง นี่คือการอนุญาตให้ฉันตรวจสอบในที่สุดถ้าจำนวน 0 และ 1s เท่ากันในแต่ละแถวและคอลัมน์ (ผลรวมของแต่ละแถวควรเป็น 0)

หลัก

0 = [: ([: +/^:_ part_3 , f) join_trans
                             join_trans  Join transpose to input
                 part_3 , f              Apply the validity checks and join them
           +/^:_                         Sum until it converges
0 =                                      Equate to 0

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

Haskell , 137 136 127 ไบต์

บันทึกไปแล้ว 9 ไบต์ด้วย Lynn!

import Data.List
j=isSubsequenceOf
l x=x==nub x&&and[sum y*2==length x&&not(j[0,0,0]y||j[1,1,1]y)|y<-x]
g x=l x&&l(transpose x)

ลองออนไลน์!

Java 8, 350 326 325 312 303 299 298 259 255 ไบต์

int r,z,c,p,i,j,k,d,u,v=1;int c(int[][]b){v(b);k=v-=u=1;v(b);return r;}void v(int[][]b){String m="",x;for(d=b.length;j<d|k<d;k+=u,j+=v,r=m.contains(x)|z!=0?1:r,m+=x)for(x="#",c=0,k*=u,j*=v;j<d&k<d;z+=i|i-1,c*=i^p^1,x+=p=i,r=++c>2?1:r,k+=v,j+=u)i=b[k][j];}

ผลตอบแทน0เมื่อมันเป็นคณะกรรมการที่ถูกต้อง; 1หากไม่ถูกต้องสำหรับหนึ่งหรือสามกฎ

-95 ไบต์ขอบคุณที่@Nevay

คำอธิบาย:

ลองที่นี่

int r,z,c,p,i,j,k,d,u,v=1;
                     // Temp integers on class-level

int c(int[][]b){     // Method (1) with int-matrix parameter and int return-type
  v(b);              //  Validate the rows
  k=v-=u=1;          //  Switch rows with columns, and reset `u` to 1
  v(b);              //  Validate the columns
  return r;          //  Return the result
}                    // End of method (1)

void v(int[][]b){    // Separated method (2) with int-matrix parameter and no return-type
  String m="",s;     //  Two temp Strings to validate uniqueness of rows
  for(d=b.length;    //  Set the dimension of the matrix to `d`
      j<d|k<d        //  Loop (1) as long as either `j` or `k` is smaller than `d`
    ;                //   After every iteration:
     k+=u,j+=v       //    Increase the loop-indexes
     r=m.contains(s) //    If we've found a duplicated row,
     |z!=0?          //    or if the amount of zeroes and ones on this row aren't equal
      1:r,           //     Set `r` to 1 (invalid due to either rule 2 or 3)
     m+=s)           //    Append the current row to the String `m`
    for(s=",",       //   Set String `x` to a separator-character
        c=0,         //   Reset the counter to 0
        k*=u,j*=v,   //   Increase the loop-indexes
        j<d&k<d      //   Inner loop (2) as long as both `j` and `k` are smaller than `d`
     ;               //    After every iteration:
      z+=i|i-1,      //     Increase or decrease `z` depending on whether it's a 0 or 1
      c*=i^p^1,      //     Reset `c` if current digit `i` does not equal previous `p`
      s+=p=i,        //     Set previous `p` to current digit, and append it to String `s`
      r=++c>2?       //     If three of the same adjacent digits are found:
         1:r;        //      Set `r` to 1 (invalid due to rule 1)
        k+=v,j+=u)   //      Increase the loop-indexes
      i=b[k][j];     //    Set `i` to the current item in the matrix
                     //   End of inner loop (2) (implicit / single-line body)
                     //  End of loop (2) (implicit / single-line body)
}                    // End of separated method (2)

Python 3, 187 ไบต์

lambda m,c=lambda m:all([len({*m})==len(m),sum(~-("000"in x)*~-("111"in x)and x.count("1")==x.count("0")for x in m)==len(m)]):c(["".join(x[i]for x in m)for i in range(len(m[0]))])and c(m)

ลองออนไลน์!

รับอินพุตเป็นรายการของบรรทัด

05AB1E , 29 ไบต์

ø‚D€ÙQIDøì©O·IgQP®εŒ3ù€Ë_P}PP

ลองออนไลน์!

คำอธิบาย

กฎ: 3

ø‚        # pair the input with the zipped input
  D       # duplicate
   €Ù     # deduplicate each
     Q    # check for equality with the unmodified copy

กฎ: 2

IDøì          # prepend zipped input to input
    ©         # store a copy in register for rule 1
     O        # sum each row/column
      ·       # double
       IgQ    # check each for equality to length of input
          P   # product

กฎ: 1

®ε            # apply to each row/column in register
  Œ3ù         # get sublists of length 3
     €Ë       # check each if all elements are equal
       _      # logical not
        P     # product
         }    # end apply
          P   # product

จากนั้นเราก็นำผลคูณของ 3 กฎมารวมกัน P

Dyalog APL, 64 52 51 49 48 bytes

Requires ⎕IO←0

{⍲/{(∨/∊⍷∘⍵¨3/¨⍳2)∧((⊢≡∪)↓⍵)∧∧/(≢=2×+/)⍵}¨⍵(⍉⍵)}

Try it online!

PHP, 245+1 bytes

ew this is bulky. linebreaks are for reading convenience only:

$t=_;foreach($a=($i=str_split)($s=$argn)as$i=>$c)$t[$i/($e=strlen($s)**.5)+$i%$e*$e]=$c;
for(;$k++<2;$s=$t)$x|=preg_match("#000|111|(\d{"."$e}).*\\1#s",chunk_split($s,$e))
|($m=array_map)(array_sum,$m($i,$i($s,$e)))!=array_fill(0,$e,$e/2);echo!$x;

Takes a single string without newlines, prints 1 for truthy, nothing for falsy.

Run as pipe with -nR or try it online.