เมทริกซ์สลับสัญญาณเป็นnโดยnเมทริกซ์ที่ประกอบด้วยตัวเลข -1, 0, 1, ดังกล่าวว่า:

• ผลรวมของแต่ละแถวและคอลัมน์คือ 1
• รายการที่ไม่ใช่ศูนย์ในแต่ละแถวและคอลัมน์สลับกันลงชื่อเข้าใช้

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

นี่คือตัวอย่างบางส่วนของเมทริกซ์สัญญาณ 4 คูณ 4:

 0  1  0  0          1  0  0  0          0  0  1  0          0  0  1  0    
 0  0  1  0          0  0  1  0          0  1 -1  1          1  0 -1  1
 1  0  0  0          0  1 -1  1          1 -1  1  0          0  1  0  0
 0  0  0  1          0  0  1  0          0  1  0  0          0  0  1  0

และนี่คือตัวอย่างของเมทริกซ์ 4 คูณ 4 ซึ่งไม่ได้สลับเมทริกซ์เครื่องหมาย:

 0  1  0  0
 0  0  0  1
 1  0  0  0
 0  0  1 -1    (last row and last column don't add to 1)

 0  0  0  1
 1  0  0  0
-1  1  1  0
 1  0  0  0    (third row does not alternate correctly)

โปรแกรมหรือฟังก์ชั่นของคุณจะได้รับnโดยnเมทริกซ์ ( n >= 1) ของ -1s, 0s และ 1s - ส่งออกค่าความจริงหากเมทริกซ์ที่กำหนดเป็นเมทริกซ์สัญญาณสลับหรือมิฉะนั้นส่งออกค่าเท็จ

นี่คือรหัสกอล์ฟดังนั้นเป้าหมายคือเพื่อลดจำนวนไบต์ที่ใช้

กรณีทดสอบ

กรณีทดสอบต่อไปนี้มีให้ในรูปแบบรายการ 2D เหมือน Python

Truthy:

[[1]]
[[1,0],[0,1]]
[[0,1],[1,0]]
[[0,1,0],[0,0,1],[1,0,0]]
[[0,1,0],[1,-1,1],[0,1,0]]
[[0,1,0,0],[0,0,1,0],[1,0,0,0],[0,0,0,1]]
[[1,0,0,0],[0,0,1,0],[0,1,-1,1],[0,0,1,0]]
[[0,0,1,0],[0,1,-1,1],[1,-1,1,0],[0,1,0,0]]
[[0,0,1,0],[1,0,-1,1],[0,1,0,0],[0,0,1,0]]
[[0,0,1,0,0],[0,1,-1,1,0],[1,-1,1,0,0],[0,1,0,-1,1],[0,0,0,1,0]]
[[0,0,1,0,0,0,0,0],[1,0,-1,0,1,0,0,0],[0,0,0,1,-1,0,0,1],[0,0,1,-1,1,0,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,1,0,0],[0,1,-1,1,0,0,0,0],[0,0,1,0,0,0,0,0]]
[[0,0,0,0,1,0,0,0],[0,0,1,0,-1,1,0,0],[0,0,0,1,0,0,0,0],[1,0,0,-1,1,-1,1,0],[0,1,-1,1,-1,1,0,0],[0,0,0,0,1,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1]]

Falsy:

[[0]]
[[-1]]
[[1,0],[0,0]]
[[0,0],[0,1]]
[[-1,1],[1,0]]
[[0,1],[1,-1]]
[[0,0,0],[0,0,0],[0,0,0]]
[[0,1,0],[1,0,1],[0,1,0]]
[[-1,1,1],[1,-1,1],[1,1,-1]]
[[0,0,1],[1,0,0],[0,1,-1]]
[[0,1,0,0],[0,0,0,1],[1,0,0,0],[0,0,1,-1]]
[[0,0,1,0],[0,0,1,0],[1,0,-1,1],[0,1,0,0]]
[[0,0,0,1],[1,0,0,0],[-1,1,1,0],[1,0,0,0]]
[[1,0,1,0,-1],[0,1,0,0,0],[0,0,0,0,1],[0,0,0,1,0],[0,0,0,0,1]]
[[0,0,1,0,0],[0,1,-1,1,0],[1,-1,1,0,0],[0,1,1,-1,0],[0,0,-1,1,1]]
[[0,-1,0,1,1],[1,-1,1,-1,1],[0,1,1,0,-1],[1,1,-1,1,-1],[-1,1,0,0,1]]
[[0,0,1,0,0,0,0,0],[1,0,1,0,1,0,0,0],[0,0,0,1,-1,0,0,1],[0,0,1,-1,1,0,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,1,0,0],[0,1,-1,1,0,0,0,0],[0,0,1,0,0,0,0,0]]

เรติน่า , 62 58 56 53 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1 และ\tควรแทนที่ด้วยแท็บจริง (0x09 ซึ่งจะกลายเป็นช่องว่างโดย SE มิฉะนั้น)

$
\t$`¶
O$#`...(?<=^[^\t]*(.+))
$.1
T` 0
^(1(-11)*\s)+$

รูปแบบการป้อนข้อมูลเป็นเมทริกซ์ที่แต่ละคอลัมน์ใช้อักขระสามตัวที่จัดแนวชิดขวาเช่น:

  0  0  1  0
  1  0 -1  1
  0  1  0  0
  0  0  1  0

เอาท์พุทเป็น0(เท็จ) หรือ1(จริง)

ชุดทดสอบ (สองสามบรรทัดแรกเปลี่ยนรูปแบบการป้อนข้อมูลและปล่อยให้ Retina เรียกใช้กรณีทดสอบหลายรายการพร้อมกัน)

คำอธิบาย

โชคดีที่การป้อนข้อมูลเป็นเมทริกซ์จตุรัส: การเคลื่อนกำลังสองเป็นสี่เหลี่ยมทำได้ใน Retina ในขณะที่การเคลื่อนย้ายสี่เหลี่ยมเป็นความเจ็บปวดขนาดใหญ่

$
\t$`¶

เราเริ่มต้นด้วยการผนวกแท็บอินพุตทั้งหมดอีกครั้ง (ใช้ส่วนนำหน้า$`) จากนั้นป้อนบรรทัดที่ส่วนท้าย (ใช้นามแฝงของ Retina ¶) เรากำลังใช้แท็บเพื่อแยกสำเนาสองชุดเพื่อให้เราสามารถแยกแยะความแตกต่างระหว่างพวกเขาเมื่อเราทำการย้ายหนึ่งในนั้นและโดยการใช้อักขระช่องว่างเราสามารถบันทึกสองไบต์ในภายหลัง

O$#`...(?<=^[^\t]*(.+))
$.1

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

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

ส่วนที่เหลือค่อนข้างง่าย:

T` 0

เราลบช่องว่างและเลขศูนย์ออกจากอินพุต

^(1(-11)*\s)+$

และในที่สุดเราก็ตรวจสอบว่าอินพุตทั้งหมดประกอบด้วยแถวที่ปิดท้ายด้วยช่องว่างของฟอร์ม1(-11)*นั่นคือลำดับสลับของ1และ-1ที่เริ่มต้นและสิ้นสุดด้วย1(เพราะไม่เช่นนั้นจะไม่รวม1)

เยลลี่ 15 ไบต์

;Zḟ€0;€-;@€-IFP

ลองออนไลน์!

;Zḟ€0;€-;@€-IFP   Main monadic chain. Argument: z

;Z                Concatenate with its transpose.
  ḟ€0             Remove zeros from each sub-list. At this point,
                  one expects lists of the form [1, -1, 1, -1, ..., 1] for truthy,
                  and any other arrays containing purely 1 and -1 for falsey.
     ;€-          Append -1 to each sub-list.
        ;€@-      Prepend -1 to each sub-list.
            I     Compute the difference between each term. At this point,
                  for truthy, one expects arrays filled with 2, and arrays
                  containing 0 otherwise.
             FP   Product of every item. This checks if any item is equal to zero.

Pyth, 16 ไบต์

!sm-sM._+d_1U2+C

ลองใช้ออนไลน์: การสาธิตหรือชุดทดสอบ

คำอธิบาย:

!sm-sM._+d_1U2+CQQ   two implicit Qs (=input matrix) at the end
              +CQQ   zip Q and connect it with Q (=list of columns and rows)
  m                  map each column/row d to:
        +d_1            append -1 to d
      ._                compute all prefixes of ^
    sM                  compute the sums of the prefixes
   -        U2          remove zeros and ones
                        a column/row is correct, if this gives an empty list 
 s                   connect up all resulting lists
!                    check, if this result is empty

เยลลี่ 11 ไบต์

;Zj-+\ṚQḄ=2

ส่งคืน1สำหรับเมทริกซ์การสลับเครื่องหมาย0มิฉะนั้น ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

พื้นหลัง

โดยไม่คำนึงถึงศูนย์แต่ละแถวและคอลัมน์จะต้องประกอบด้วยรูปแบบ(1, -1) * 1คือการสลับเกิดขึ้นของ1และ-1เริ่มต้นและสิ้นสุดด้วย1 (ดังนั้นผลรวมคือ1 )

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

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

เราย้อนกลับผลรวมสะสมและขจัดข้อมูลซ้ำโดยรักษาลำดับของการเกิดครั้งแรกขององค์ประกอบที่ไม่ซ้ำกันทั้งหมด สำหรับการป้อนข้อมูล truthy ที่ผลจะเป็นรายการ[1, 0]

ในการส่งออกบูลีนที่สอดคล้องกันเราจะแปลงผลรวมสะสมที่ซ้ำกันจากไบนารีเป็นจำนวนเต็มและทดสอบว่าผลลัพธ์เป็น2 2

มันทำงานอย่างไร

;Zj-+\ṚQḄ=2  Main link. Argument: M (matrix / 2D array)

 Z           Zip; transpose M's rows and columns.
;            Concatenate M and zipped M.
  j-         Join, separating by -1.
    +\       Take the cumulative sum of the result.
      Ṛ      Reverse the array of partial sums.
       Q     Unique; deduplicate the partial sums.
        Ḅ    Unbinary; convert from base 2 to integer.
         =2  Test for equality with 2.

MATL, 18 16 15 13 ไบต์

บันทึก 3 ไบต์ด้วย @Luis

t!h"@s1=@Xzdv

วิธีการแก้ปัญหานี้ยอมรับอาร์เรย์ 2D เป็นอินพุตและจะส่งออกอาร์เรย์จริงหรือเท็จ มันเป็นสิ่งสำคัญที่จะต้องทราบว่าใน MATL อาร์เรย์ที่เป็นความจริงประกอบด้วยองค์ประกอบที่ไม่เป็นศูนย์ทั้งหมดในขณะที่ผลลัพธ์ที่เป็นเท็จมีองค์ประกอบศูนย์อย่างน้อยหนึ่งองค์ประกอบ นี่คือการสาธิตของ truthy / อาร์เรย์

ลองออนไลน์

เวอร์ชั่นที่แก้ไขเพื่อแสดงกรณีทดสอบทั้งหมด

คำอธิบาย

        % Implicitly grab input matrix
t!      % Duplicate and transpose input
h       % Horizontally concatenate input with transpose. This allows us to 
        % process only columns since now the columns *also* contain the rows.
"       % For each column (of our column/row combined matrix)
  @s1=  % Compute the sum and ensure it is equal to 1
  @Xz   % Get the non-zeros
  d     % Compute the element-to-element difference. The 1 and -1 alternate only if
        % all these differences are non-zero
  v     % Vertically concatenate everything on the stack
        % Implicit end of loop and implicitly display truthy/falsey value

Julia, 36 ไบต์

!x=[x^0 x^0;-x -x'][:]|>cumsum⊆0:1

ลองออนไลน์!

JavaScript (ES6), 112 100 ไบต์

a=>!/(^|,)(?!0*10*(-10*10*)*(,|$))/.test(a.map(b=>b.join``)+','+a.map((_,i)=>a.map(b=>b[i]).join``))

แผ่อาร์เรย์และเปลี่ยนให้เป็นสตริงจากนั้น (ไม่สนใจ0s) ตรวจสอบรูปแบบ1-11...1-11ในแต่ละสตริง

แก้ไข: บันทึก 12 ไบต์ขอบคุณ @PeterTaylor

Python 2, 63 60 ไบต์

s=0;x=input()
for r in x+zip(*x):
 for n in(-1,)+r:s+=[n][s]

อินพุตคือรายการของสิ่งอันดับ

สิ่งนี้จะจบลงด้วยรหัสทางออก 0สำหรับการสลับเมทริกซ์สัญลักษณ์และรหัสทางออก1มิฉะนั้น นี่คือสิ่งที่จริงและเท็จทำและ - ตามที่ปรากฏในส่วนการตรวจสอบ - มันสามารถนำมาใช้เป็นเงื่อนไขในเช่นสคริปต์ Bash

การตรวจสอบ

ทดสอบ cases.txt

[(1,)]
[(1, 0), (0, 1)]
[(0, 1), (1, 0)]
[(0, 1, 0), (0, 0, 1), (1, 0, 0)]
[(0, 1, 0), (1, -1, 1), (0, 1, 0)]
[(0, 1, 0, 0), (0, 0, 1, 0), (1, 0, 0, 0), (0, 0, 0, 1)]
[(1, 0, 0, 0), (0, 0, 1, 0), (0, 1, -1, 1), (0, 0, 1, 0)]
[(0, 0, 1, 0), (0, 1, -1, 1), (1, -1, 1, 0), (0, 1, 0, 0)]
[(0, 0, 1, 0), (1, 0, -1, 1), (0, 1, 0, 0), (0, 0, 1, 0)]
[(0, 0, 1, 0, 0), (0, 1, -1, 1, 0), (1, -1, 1, 0, 0), (0, 1, 0, -1, 1), (0, 0, 0, 1, 0)]
[(0, 0, 1, 0, 0, 0, 0, 0), (1, 0, -1, 0, 1, 0, 0, 0), (0, 0, 0, 1, -1, 0, 0, 1), (0, 0, 1, -1, 1, 0, 0, 0), (0, 0, 0, 0, 0, 0, 1, 0), (0, 0, 0, 0, 0, 1, 0, 0), (0, 1, -1, 1, 0, 0, 0, 0), (0, 0, 1, 0, 0, 0, 0, 0)]
[(0, 0, 0, 0, 1, 0, 0, 0), (0, 0, 1, 0, -1, 1, 0, 0), (0, 0, 0, 1, 0, 0, 0, 0), (1, 0, 0, -1, 1, -1, 1, 0), (0, 1, -1, 1, -1, 1, 0, 0), (0, 0, 0, 0, 1, 0, 0, 0), (0, 0, 1, 0, 0, 0, 0, 0), (0, 0, 0, 0, 0, 0, 0, 1)]
[(0,)]
[(-1,)]
[(1, 0), (0, 0)]
[(0, 0), (0, 1)]
[(-1, 1), (1, 0)]
[(0, 1), (1, -1)]
[(0, 0, 0), (0, 0, 0), (0, 0, 0)]
[(0, 1, 0), (1, 0, 1), (0, 1, 0)]
[(-1, 1, 1), (1, -1, 1), (1, 1, -1)]
[(0, 0, 1), (1, 0, 0), (0, 1, -1)]
[(0, 1, 0, 0), (0, 0, 0, 1), (1, 0, 0, 0), (0, 0, 1, -1)]
[(0, 0, 1, 0), (0, 0, 1, 0), (1, 0, -1, 1), (0, 1, 0, 0)]
[(0, 0, 0, 1), (1, 0, 0, 0), (-1, 1, 1, 0), (1, 0, 0, 0)]
[(1, 0, 1, 0, -1), (0, 1, 0, 0, 0), (0, 0, 0, 0, 1), (0, 0, 0, 1, 0), (0, 0, 0, 0, 1)]
[(0, 0, 1, 0, 0), (0, 1, -1, 1, 0), (1, -1, 1, 0, 0), (0, 1, 1, -1, 0), (0, 0, -1, 1, 1)]
[(0, -1, 0, 1, 1), (1, -1, 1, -1, 1), (0, 1, 1, 0, -1), (1, 1, -1, 1, -1), (-1, 1, 0, 0, 1)]
[(0, 0, 1, 0, 0, 0, 0, 0), (1, 0, 1, 0, 1, 0, 0, 0), (0, 0, 0, 1, -1, 0, 0, 1), (0, 0, 1, -1, 1, 0, 0, 0), (0, 0, 0, 0, 0, 0, 1, 0), (0, 0, 0, 0, 0, 1, 0, 0), (0, 1, -1, 1, 0, 0, 0, 0), (0, 0, 1, 0, 0, 0, 0, 0)]

test-suite.sh

while read; do
        if python2 asmv.py <<< "$REPLY"; then
                echo "true"
        else
                echo "false"
        fi
done < test-cases.txt 2>&- | uniq -c

เอาท์พุต

$ bash test-suite.sh
     12 true
     17 false

มันทำงานอย่างไร

ไม่คำนึงถึงศูนย์แต่ละแถวและคอลัมน์จะต้องประกอบด้วยรูปแบบ(1, -1) * 1คือการสลับเกิดขึ้นของ1และ-1เริ่มต้นและสิ้นสุดด้วย1 (ดังนั้นผลรวมคือ1 )

ในการตรวจสอบกรณีนี้เราทำการซิป / ย้ายเมทริกซ์อินพุตMต่อท้ายผลลัพธ์ไปที่M (ตอนนี้ประกอบด้วยรายการของแถวและคอลัมน์) และผนวก-1กับแต่ละแถว / คอลัมน์

ตัวอย่างเช่นถ้าMเป็นหนึ่งในเมทริกซ์ต่อไปนี้ (ถูกต้องไม่ถูกต้อง)

     0  1  0         0  0  0
     0  0  1         1  0  0
     1  0  0         0  1 -1

ผลลัพธ์ที่ได้คือ

-1 | 0  1  0    -1 | 0  0  0
-1 | 0  0  1    -1 | 1  0  0
-1 | 1  0  0    -1 | 0  1 -1
------------    ------------
-1 | 0  0  1    -1 | 0  1  0
-1 | 1  0  0    -1 | 0  0  1
-1 | 0  1  0    -1 | 0  0 -1

การอ่านเมทริกซ์แถวที่สร้างขึ้นจะต้องส่งผลตามลำดับที่มีรูปแบบ(-1, 1) * * ในการตรวจสอบกรณีนี้เราจะนำยอดรวมสะสมของรายการทั้งหมดเริ่มต้นด้วยแถวบนสุด

สำหรับเมทริกซ์ตัวอย่างผลลัพธ์นี้จะเป็น

-1 -1  0  0 -1 -1 -1  0 -1  0  0  0 -1 -1 -1  0 -1  0  0  0 -1 -1  0  0
-1 -1 -1 -1 -2 -1 -1 -1 -2 -2 -1 -2 -3 -3 -2 -2 -3 -3 -3 -2 -3 -3 -3 -4

สำหรับเมทริกซ์สัญญาณทางเลือกที่ถูกต้องผลลัพธ์จะประกอบด้วย-1และ0และ - เนื่องจากทุก-1ยกเลิก1ก่อนหน้านี้และในทางกลับกัน - ไม่มีตัวเลขอื่น ๆ

ได้อย่างรวดเร็วก่อนนี้อาจจะล้มเหลวในการตรวจสอบถ้าปลายคอลัมน์สุดท้ายมี1 อย่างไรก็ตามสำหรับเมทริกซ์n × nที่มีk เป็นศูนย์แถวที่ถูกต้องจะมีn + kอยู่ หากคอลัมน์ทั้งหมดยกเว้นคอลัมน์สุดท้ายนั้นใช้ได้เช่นกันจะมีn + k - 1คอลัมน์ในคอลัมน์ซึ่งเป็นไปไม่ได้

เพื่อทดสอบว่าไม่มีหมายเลขอื่น ๆ ที่เราเก็บผลรวมบางส่วนในตัวแปรss+=[n][s]และปรับปรุงพวกเขาสำหรับการเข้ามาของกับเมทริกซ์ที่สร้างด้วยกัน

ถ้า s = 0หรือs = -1 , s+=nนี้คือการเทียบเท่า อย่างไรก็ตามสำหรับค่าอื่น ๆ ของsทั้งหมดจะทำให้เกิดIndexErrorดังนั้น Python จึงยกเลิกด้วย exit code 1ทันที ถ้าเรื่องนี้ไม่ได้เกิดขึ้นที่จุดใดโปรแกรมเสร็จเรียบร้อยด้วยรหัสทางออก0

R, 54 ไบต์

ฟังก์ชั่นนิรนามใช้ตรรกะเดียวกับคำตอบ Python 2, Jelly และ Julia ของ Dennis

function(x)all(abs(cumsum(rbind(-1,cbind(t(x),x))))<2)