प्रत्यावर्तन संकेत मैट्रिक्स सत्यापन

Question

एक बारी संकेत मैट्रिक्स है एक nसे nसंख्या से मिलकर मैट्रिक्स -1, 0, 1, जैसे कि:

• प्रत्येक पंक्ति और स्तंभ का योग 1 है
• साइन में प्रत्येक पंक्ति और कॉलम वैकल्पिक में नॉनज़ेरो प्रविष्टियाँ

ये मैट्रिसेस क्रमपरिवर्तन मैट्रिसेस को सामान्य करते हैं, और nकुछ समय के लिए इस तरह के मैट्रिसेस की संख्या कुछ समय के लिए ब्याज की थी। वे कंप्यूटिंग मैट्रिक्स निर्धारकों के डोड्सन संघनन विधि के दौरान स्वाभाविक रूप से होते हैं (चार्ल्स डोड्सन के नाम पर, जिसे लुईस कैरोल के रूप में जाना जाता है)।

यहां 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 के) truthy मूल्य अगर दिया मैट्रिक्स एक बारी संकेत मैट्रिक्स है एक falsy मूल्य, अन्यथा उत्पादन।

यह कोड-गोल्फ है , इसलिए लक्ष्य उपयोग किए गए बाइट्स की संख्या को कम करना है।

परीक्षण के मामलों

निम्नलिखित परीक्षण मामलों को पायथन जैसे 2D सूची प्रारूप में दिया गया है।

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]]

Comments

संबंधित

— पीटर टेलर

Answer 1

रेटिना , 62 58 56 53 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है, और \tइसे वास्तविक टैब (0x09 जिसे एसई द्वारा अन्यथा रिक्त स्थान में बदल दिया जाएगा) से बदला जाना चाहिए।

$
\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(सत्य)।

परीक्षण सूट। (पहली कुछ पंक्तियाँ इनपुट प्रारूप को रूपांतरित करती हैं और रेटिना को एक साथ कई परीक्षण मामले चलाने देती हैं।)

व्याख्या

शुक्र है कि इनपुट एक चौकोर मैट्रिक्स है: रेटिना में ट्रांसपोज़िंग स्क्वेयर्स केवल करने योग्य है, जबकि आयतों को ट्रांसपोज़ करना एक बहुत बड़ा दर्द है।

$
\t$`¶

हम एक टैब, पूरे इनपुट को फिर से जोड़कर (उपसर्ग का उपयोग करके $`) शुरू करते हैं और फिर अंत में एक लाइनफीड (रेटिना के उपनाम का उपयोग करके ¶) शुरू करते हैं। हम दो प्रतियों को अलग करने के लिए एक टैब का उपयोग कर रहे हैं ताकि हम उनके बीच अंतर कर सकें जब हम उनमें से किसी एक को स्थानांतरित कर रहे हैं, और एक व्हाट्सएप चरित्र का उपयोग करके हम बाद में कुछ बाइट्स बचा सकते हैं।

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

यह ट्रिकिएस्ट बिट है: मैट्रिक्स की पहली कॉपी को ट्रांसपोज़ करना। यह विचार है कि पहली प्रति में कोशिकाओं का मिलान किया जाए और फिर क्षैतिज स्थिति से उन्हें (स्थिर रूप से) छांटा जाए। हम कोशिकाओं के साथ मेल खाते हैं ...(क्योंकि वे हमेशा तीन वर्णों के चौड़े होते हैं) और फिर (.+)लुकबाइंड के अंदर क्षैतिज स्थिति को मापते हैं। फिर, यह सुनिश्चित करने के लिए कि हम केवल पहली प्रति को स्थानांतरित करते हैं, हम जांचते हैं कि हम टैब को पिछले किए बिना स्ट्रिंग की शुरुआत तक पहुंच सकते हैं।

आप देख सकते हैं कि यह दूसरी प्रति की पहली पंक्ति में कुछ तीन-बाइट स्ट्रिंग्स (जो कि कोशिकाओं के साथ भी संरेखित नहीं है) से मेल खाएगा, क्योंकि .+टैब से गुजर सकता है। हालाँकि, यह कोई मुद्दा नहीं है क्योंकि इन मैचों की क्षैतिज स्थिति पहली प्रति के अंदर की तुलना में कड़ाई से अधिक है, इसलिए ये मैच अपनी स्थिति में रहते हैं।

बाकी काफी सरल है:

T` 0

हम इनपुट से रिक्त स्थान और शून्य हटाते हैं।

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

और अंत में हम जांचते हैं कि पूरे इनपुट में फॉर्म की व्हाट्सएप-टर्मिनेटेड पंक्तियाँ हैं 1(-11)*, यानी एक वैकल्पिक अनुक्रम 1और -1जो शुरू होता है और इसके साथ समाप्त होता है 1(क्योंकि अन्यथा यह इसके लिए योग्‍य नहीं है 1)।

Answer 2

जेली, 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.

Answer 3

पायथ, 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

Answer 4

जेली , 11 बाइट्स

;Zj-+\ṚQḄ=2

प्रत्यावर्तन चिह्न के लिए 1 रिटर्न , 0 अन्यथा। इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

पृष्ठभूमि

शून्य की अवहेलना करते हुए, प्रत्येक पंक्ति और स्तंभ में प्रतिमान (1, -1) * 1 , अर्थात 1 और -1 की बारी-बारी से घटित होती है। , शुरू करने और एक के साथ समाप्त 1 (ताकि योग है 1 )।

सत्यापित करने के लिए यह मामला है, हम सभी पंक्तियों और स्तंभों की सरणी लेते हैं, और -1 का उपयोग करके उनमें शामिल होते हैं विभाजक के रूप में जोड़ते हैं। चूंकि सभी समापन बिंदु 1 के हैं , परिणामी फ्लैट सरणी पैटर्न को संतुष्ट करती है (1, -1) * 1 अगर और केवल अगर पंक्तियां और कॉलम करते हैं।

वास्तविक परीक्षण के लिए, हम सरणी के संचयी योग की गणना करते हैं। एक प्रत्यावर्ती संकेत मैट्रिक्स के लिए, परिणाम 0 की सरणी होगी और 1 जो 1 के साथ समाप्त होती है ।

हम संचयी योग को उल्टा करते हैं और सभी अद्वितीय तत्वों की प्रारंभिक घटनाओं के क्रम को बनाए रखते हुए इसे काट लेते हैं। एक सत्य इनपुट के लिए, परिणाम सूची [1, 0] होगी ।

संबंधित बूलियन का उत्पादन करने के लिए, हम द्विआधारी से पूर्णांक तक दोहराए गए संचयी योगों को परिवर्तित करते हैं और यदि परिणाम 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.

Answer 5

MATL, 18 16 15 13 बाइट्स

3 बाइट्स @Luis की बदौलत बच गईं

t!h"@s1=@Xzdv

यह समाधान इनपुट के रूप में एक 2 डी सरणी को स्वीकार करता है और एक सत्य या गलत सरणी का उत्पादन करेगा । यह ध्यान रखना महत्वपूर्ण है कि MATL में, एक सत्य सरणी सभी गैर-शून्य तत्वों से बनी होती है जबकि एक गलत परिणाम में कम से कम शून्य तत्व होता है। यहाँ सत्य / असत्य सरणियों का एक और प्रदर्शन है ।

इसे ऑनलाइन आज़माएं

सभी परीक्षण मामलों को दिखाने के लिए संशोधित संस्करण

व्याख्या

        % 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

Answer 6

जूलिया, 36 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 7

जावास्क्रिप्ट (ईएस 6), 112 100 बाइट्स

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

सरणी और इसके प्रवाह को स्ट्रिंग्स में समतल करता है, फिर 0पैटर्न के लिए ( एस की अनदेखी ) जाँच करता है1-11...1-11 प्रत्येक स्ट्रिंग में ।

संपादित करें: @PeterTaylor के लिए धन्यवाद 12 बाइट्स सहेजे गए।

Comments

आपको पैटर्न की जांच करने की आवश्यकता नहीं है -11-1...-11-1क्योंकि चूंकि प्रविष्टियां वैकल्पिक हैं और सकारात्मक राशि 1है -1, इसलिए एक से अधिक होना चाहिए , इसलिए पैटर्न होना चाहिए 1-11...1-11।

— पीटर टेलर

@PeterTaylor Ugh, यह दूसरी बार है जब मैंने प्रश्न गलत किया है। (पहली बार से संबंधित टिप्पणियां हटा दी गई हैं।)

— नील

हेडर 110 बाइट्स कहता है, लेकिन यह केवल 100 है

— पीटर टेलर

@PeterTaylor कम से कम "सेव्ड 12 बाइट्स टू @PeterTaylor" धन्यवाद सही था।

— नील

Answer 8

पायथन 2, 63 60 बाइट्स

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

इनपुट tuples की एक सूची है।

यह बारी बारी से साइन मैट्रिसेस और एग्ज़िट कोड 1 के लिए एक्ज़िट कोड 0 के साथ समाप्त होता है । यह वही है जो सत्य और असत्य है, और - जैसा कि सत्यापन अनुभाग में दिखाया गया है - यह वास्तव में एक शर्त के रूप में इस्तेमाल किया जा सकता है, जैसे, एक बैश स्क्रिप्ट।

सत्यापन

परीक्षण 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 को zip / transpose करते हैं , परिणाम को 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 's और 0 ' s और - के बाद से प्रत्येक -1 को पिछले 1 से रद्द कर देता है और इसके विपरीत - कोई अन्य संख्या नहीं।

पहली नज़र में, यह जाँच करने में विफल हो सकता है कि क्या अंतिम कॉलम 1 के साथ समाप्त होता है । हालाँकि, k zeroes वाले n × n मैट्रिक्स के लिए , मान्य पंक्तियों में n + k वाले होंगे। यदि अंतिम को छोड़कर सभी कॉलम मान्य थे, तो कॉलम में n + k - 1 वाले होंगे, जो कि असंभव है।

यह जांचने के लिए कि अन्य संख्याएँ नहीं हैं, हम आंशिक रकमों को एक चर s में संग्रहीत करते हैं और उन्हें उत्पन्न मैट्रिक्स के साथ प्रत्येक प्रविष्टि के लिए अद्यतन करते हैं s+=[n][s]।

यदि s = 0 या s = -1 , यह इसके बराबर है s+=n। हालांकि, s के अन्य सभी मूल्यों के लिए , यह एक IndexError का कारण बनता है , इसलिए पायथन तुरंत निकास कोड 1 के साथ समाप्त हो जाता है । यदि यह किसी भी बिंदु पर नहीं होता है, तो प्रोग्राम एक्जिट कोड 0 के साथ सफाई से समाप्त हो जाता है ।

Answer 9

आर, 54 बाइट्स

अनाम फ़ंक्शन, डेनिस के पाइथन 2, जेली और जूलिया के उत्तर के समान तर्क का उपयोग करता है।

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