क्या मेरा मैट्रिक्स एरोहेड है?

33

परिभाषा

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

* * * * * *
* * 0 0 0 0
* ० * ० ०
* ० ० * ० ०
* ० ० ० * ०
* 0 0 0 0 *

जहां प्रत्येक * कोई गैर-शून्य प्रविष्टि है।

कार्य

गैर-नकारात्मक पूर्णांक के एक वर्ग मैट्रिक्स को देखते हुए, जांचें कि क्या यह ऊपर की परिभाषा के अनुसार एरोहेड है।

आप मैट्रिक्स का आकार इनपुट के रूप में नहीं ले सकते , जब तक कि आपकी भाषा किसी सरणी के समतुल्य न हो, एक सूचक और लंबाई (जैसे)। यह हमेशा कम से कम 3 x 3 होगा।

प्रत्येक भाषा में बाइट्स में सबसे छोटा कोड जीतता है।

इनपुट और आउटपुट

इनपुट प्राप्त करने के लिए आप निम्नलिखित में से किसी भी प्रारूप को चुन सकते हैं:

  • मूल मैट्रिक्स प्रकार में एक मैट्रिक्स (यदि आपकी भाषा में एक है)
  • एक 2D सरणी 1 (1D सरणियों का एक सरणी, प्रत्येक एक पंक्ति के अनुरूप)
  • 1D सरणी (चूंकि मैट्रिक्स हमेशा चौकोर होता है)
  • एक स्ट्रिंग (आपने रिक्ति को चुना, लेकिन कृपया इसे किसी भी तरह से दुरुपयोग न करें)।

जब आउटपुट प्रदान करने की बात आती है, तो आप या तो मानक निर्णय-समस्या की परिभाषा के बाद एक सत्य / मिथ्या मूल्य की रिपोर्ट कर सकते हैं , या किसी दो अलग और सुसंगत मूल्यों का चयन कर सकते हैं।

इसके अलावा, आप इनपुट ले सकते हैं और किसी भी मानक भाषा के माध्यम से किसी भी प्रोग्रामिंग भाषा में आउटपुट दे सकते हैं , जबकि ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है। यदि आप किसी अन्य प्रारूप को चुनना चाहते हैं या किसी चीज़ के बारे में अनिश्चित हैं, तो कृपया टिप्पणियों में पूछें।

1: या आपकी भाषा के समकक्ष (सूची, वेक्टर, आदि)

उदाहरण

आइए निम्नलिखित उदाहरण देखें:

१ २ २ २
२ १ ० ०
३ ० १ ०
४ ० ० १

यह एक एरोहाइड मैट्रिक्स है (आपके कार्यक्रमों को एक सत्य मूल्य की रिपोर्ट करनी चाहिए), क्योंकि मुख्य विकर्ण पर तत्व हैं 1 1 1 1, शीर्ष पंक्ति 1 2 2 2पर वे हैं और बाएं स्तंभ पर वे हैं 1 2 3 4। अन्य सभी प्रविष्टियाँ 0 हैं , इसलिए यह सभी शर्तों को पूरा करती है।

३ ५ ६
१ ०
० ०

यह मैट्रिक्स एरोहेड नहीं है क्योंकि मुख्य विकर्ण पर 0 है ।

९ ० ९ १ ९
९ ९ ० ०
९ 9 ९ ०
९ ० ० ९

यह एक है नहीं तो Arrowhead, क्योंकि यह एक में शामिल 7 एक के स्थान पर 0 ।

अधिक परीक्षण के मामले

Truthy:

[[१, १, १], [१, १, ०], [१, ०, १]]
[[१, २, ३, ४], [१, १, ०, ०], [१, ०, १, ०], [१, ०, ०, १]]
[[१, २, २, २], [२, १, ०, ०], [३, ०, १, ०], [४, ०, ०, १]]
[[३४, ११, ३५, ५,], ५६, ५६ 0, ०, ०], [५,, ०, ६, ९, ०], [४०, ०, ०,]]]

Falsy:

[[३, ५, ६], [,, १, ०], [,, ०, ०]]
[[९, ९, ९, ९], [९, ९, ०, ०], [९,,, ९, ०], [९, ०, ०, ९]]
[[१, ०, ३, ४], [१, १, ०, ०], [१, ०, १, ०], [१, ०, ०, १]]
[[१, ६, ३, ४], [१३, २, ०, ६], [२ ९, ०, १, ०], [२, ०, ०, ४]]
code-golf  array-manipulation  decision-problem  matrix 
— मिस्टर एक्सकोडर
स्रोत
1
क्या यह संभव है कि मैट्रिक्स में ऋणात्मक संख्याएँ हो सकती हैं
— Zacharý
2
@ Zacharý नहीं आप मान सकते हैं कि वे सभी गैर-नकारात्मक हैं ।
— श्री एक्सकोडर
पेडेंट: एक दो आयामी सरणी और एक मैट्रिक्स एक ही बात नहीं है, और न ही यह सरणी के सरणी के समान है। क्या इनपुट एक दो आयामी सरणी के रूप में स्वीकार्य है अगर आपकी पसंद की भाषा बहुआयामी सरणियों का समर्थन करने के लिए पर्याप्त सभ्य है?
— इयान बुश
@IBBush हाँ, एक 2D सरणी पूरी तरह से ठीक है।
— श्री एक्सकोडर
9
@ Mr.Xcoder यह एक पर्याप्त रूप से अलग और दिलचस्प चुनौती होगी यदि तीर किसी भी दिशा में इंगित कर सकता है
— dylnan

जवाबों:

15

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

Edc65 के लिए 1 बाइट का धन्यवाद सहेजा गया

m=>m.some((r,y)=>r.some((c,x)=>(x*y&&x!=y)^!c))

falseएरोहेड मैट्रिस के लिए और trueनॉन-एरोहेड मैट्रिस के लिए रिटर्न (अनुमति दी जाती है क्योंकि किसी भी दो अलग-अलग मूल्यों का प्रतिनिधित्व करने के लिए और गुस्से में इस्तेमाल किया जा सकता है)

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

कोड स्निपेट दिखाएं

— हरमन एल
स्रोत
अब यह वास्तव में चतुर दृष्टिकोण है!
— श्री Xcoder
1
क्या यह काम कर सकता है? f=m=>m.some((r,y)=>r.some((c,x)=>(x*y&&x!=y)^!c))
— edc65
@ edc65 f=पाठ्यक्रम के बिना;-)
— नील 1
11

जे , 21 20 19 17 15 बाइट्स

-4 बाइट्स @GalenIvanov को धन्यवाद।

*-:1,1,.=&/:@}.

मैट्रिक्स के रूप में इनपुट लेता है (रैंक 2 सरणी)।

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

व्याख्या

इतिहास को संपादित करने के लिए आप को सबक दें कि आप उसे गोल्फ में न लिखें और एक ही समय में एक स्पष्टीकरण लिखें।

* -: 1, 1,. = & /: @ }.  Let m be the input matrix.
            = & /: @ }.  Identity matrix 1 smaller than m.
                     }.    Behead (m without its first row).
                   @       Composed with.
                /:         Grade up (get len(m) - 1 unique elements)
              &            Composed with.
            =              Self-classify (compare equality with
                           unique elements)
        1,.              Prepend a column of 1s
     1,                  Prepend a row of 1s
*                        Signum (0 becomes 0, n > 0 becomes 1)
  -:                     Does it match the generated arrowhead matrix?

दृश्य व्याख्या

ध्यान दें कि यह आरईपीएल पर किया जाता है (इनपुट तीन स्थानों से शुरू किया जाता है और आउटपुट बिना किसी प्रमुख स्थान के दिया जाता है)। उसके कारण, मैं कभी-कभी रचना कार्यों को छोड़ देता हूं, @और &चूंकि आरईपीएल पर चीजों का मूल्यांकन दाएं-बाएं किया जाता है (कार्य अधिक जटिल होते हैं)।

मान लें कि आपके पास निम्नलिखित नमूना मैट्रिक्स है:

   ] m =. 4 4 $ 1 2 3 4 1 1 0 0 1 0 1 0 1 0 0 1
1 2 3 4
1 1 0 0
1 0 1 0
1 0 0 1

सबसे पहले, मैं स्पष्टीकरण देना चाहता हूं (और एक चिल्लाहट को) @ GalenIvanov की पहचान मैट्रिक्स उत्पन्न करने का बहुत चालाक तरीका है, जो निम्नलिखित है =&/:@}.।

सबसे पहले, हम इनपुट मैट्रिक्स ( }.) को हेड करते हैं ।

   }. m
1 1 0 0
1 0 1 0
1 0 0 1

तब हमें संकेत मिलते हैं कि प्रत्येक पंक्ति /:क्रमिक-अप का उपयोग करके छांटे गए थे ।

   /: }. m
2 1 0

ध्यान दें कि परिणामी सूचकांक अद्वितीय हैं : सूची में कोई डुप्लिकेट तत्व नहीं हैं (और यह क्यों होगा? एक सरणी में दो तत्वों को एक ही स्थिति में रखने का कोई तरीका नहीं है)।

अंत में, हम आला का उपयोग करते हैं, लेकिन सहायक =-स्वयं-वर्गीकृत करते हैं। यह मोनाड एक सरणी में अन्य तत्वों के लिए प्रत्येक अद्वितीय तत्व की तुलना करता है। याद रखें कि मैंने कैसे उल्लेख किया कि यह महत्वपूर्ण था कि परिणामी संकेत अद्वितीय हैं? चूंकि =स्वयं-वर्गीकृत इस क्रम में तुलना करता है कि अद्वितीय तत्व सूची में दिखाई देते हैं, जिसके परिणामस्वरूप आउटपुट एक अद्वितीय इनपुट के लिए पहचान मैट्रिक्स होगा (यही कारण =@i.है कि आप किसी दिए गए लंबाई की पहचान मैट्रिक्स बना सकते हैं)।

   = /: }. m
1 0 0
0 1 0
0 0 1
   NB. This is what is happening
   (2 = 2 1 0) , (1 = 2 1 0) ,: (0 = 2 1 0)
1 0 0
0 1 0
0 0 1

एक बार जब हमारे पास पहचान मैट्रिक्स होती है, तो यह लोगों की एक पंक्ति और लोगों के एक कॉलम को जोड़ने की बात है, जो बहुत ही सरलता से किया जाता है (यदि एक परमाणु दिया जाता है - अर्थात एक एकल तत्व - ,परिवार इसे भरने के लिए दोहराएगा) :

   1,. (=&/:@}. m)
1 1 0 0
1 0 1 0
1 0 0 1
   1, (1,. =&/:@}. m)
1 1 1 1
1 1 0 0
1 0 1 0
1 0 0 1

तब हम केवल इनपुट मैट्रिक्स के सिग्नम में जेनरेट किए गए एरोहेड मैट्रिक्स की तुलना करते हैं।

   * m
1 1 1 1
1 1 0 0
1 0 1 0
1 0 0 1
   (* m) -: (1, 1,. =&/:@}. m)
1
— गोभी
स्रोत
2
(17 बाइट्स के लिए) के *बजाय पर्याप्त नहीं है 0@<? इसे आज़माएं
— गैलन इवानोव
1
@GalenIvanov अच्छी पकड़ है, मुझे ऐसा लगता है। धन्यवाद! स्पष्टीकरण लोल को फिर से संपादित करने का समय।
— कोल
1
मुझे लगता है कि मुझे पहचान मैट्रिक्स उत्पन्न करने का एक नया तरीका मिल गया है : =&/:जब मैंने इसे संयुक्त किया }., तो मुझे यह *-:1,1,.=&/:@}.15 बाइट्स के लिए मिला था इसे ऑनलाइन आज़माएं!
— गैलेन इवानोव
1
@GalenIvanov शानदार दृष्टिकोण ( -ग्रेड /:और }.-हेड के उपयोग दोनों ), फिर से धन्यवाद! मैं इसे संपादित करता हूँ।
— कोल
हम्म, वास्तव में *-:1,1,.=@}.ठीक काम करता है - पहचान मैट्रिक्स को खोजने के लिए फैंसी तरीके की कोई आवश्यकता नहीं है। आप केवल वर्ग मैट्रिक्स से एक पहचान मैट्रिक्स उत्पन्न कर सकते हैं =। तो एक पंक्ति को इसके साथ छोड़ें }., पहचान मैट्रिक्स के साथ बनाएं = , एक पंक्ति और एक स्तंभ जोड़ें 1और इसी तरह।
— गेलन इवानोव
9

वोल्फ्राम भाषा (गणितज्ञ) , 47 बाइट्स

Clip@#==Array[If[1<#!=#2>1,0,1]&,{1,1}Tr[1^#]]&

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

स्पष्टीकरण: Clip@#1s के साथ मैट्रिक्स में सभी गैर-शून्य संख्याओं को प्रतिस्थापित करता है, फिर हम इसकी तुलना आयामों के साथ सरणी से करते हैं {1,1}Tr[1^#]= जब {Length@#, Length@#}स्थिति में 0 के साथ , और 1 अन्यथा।i,j1 < i != j > 1

(मोटे तौर पर यूरिल के उत्तर पर आधारित है ।)

यहाँ एक और विचार है जो 16 बाइट्स लंबा है - यदि आप इसे नीचे गोल्फ कर सकते हैं तो इसे चोरी करने के लिए स्वतंत्र महसूस करें:

Union@@Array[{1,#}~Tuples~2&,Length@#]==Most@Keys@ArrayRules@#&

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

— पेड़ नहीं
स्रोत
8

APL (Dyalog Classic) , 19 16 15 13 बाइट्स

-1 बाइट @ErikTheOutgolfer के लिए धन्यवाद

( ⎕IO←0)

×≡(∧=⌊)/¨∘⍳∘⍴

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

-2 बाइट्स के लिए धन्यवाद @ngn और @ H.PWiz

कैसे?

(2 डी इनपुट मैट्रिक्स एस )

  • ×≡जांचें कि क्या S केवल पर सकारात्मक है ...
  • (∧=⌊ ... विकर्ण या शीर्ष पंक्ति और बाएं स्तंभ ...
  • )/¨∘⍳∘⍴... एस का ।
— जाकारी
स्रोत
⍳∘⍴कार्टेशियन उत्पाद के लिए अच्छा उपयोग ।
— ऊरीएल
×≡(=/∨1∊⊢)¨∘⍳∘⍴
— एरिक आउटोलॉफ़र
1
(=/∨1∊⊢)->(~≠⌊⌊)/
— ngn
2
@ और भी बेहतर: (∧=⌊)/बेशक, दोनों की आवश्यकता है⎕IO←0
— H.PWiz
7

पॉवरशेल , 112 108 बाइट्स

param($a)$o=+!(0-in$a[0]);1..($x=$a.count-1)|%{$i=$_;0..$x|%{$o*=(!($y=$a[$i][$_]),$y)[!$_-or$_-eq$i]}};!!$o

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

इनपुट लेता है और सरणी-ए-सरणियों के रूप में हेरफेर करता है, क्योंकि पावरशेल मैट्रिसेस का समर्थन नहीं करता है (.NET Direct3D ट्रांसफॉर्म मैट्रिसेस सपोर्ट के बाहर, जो कुछ पूरी तरह से अलग है)।

संपूर्ण एल्गोरिथ्म इस तथ्य पर आधारित है कि गैर-शून्य संख्याएं सत्य हैं और शून्य, पावरशेल में गलत है और उन सत्य / गलत मूल्यों को निर्धारित करने के लिए गुणा का उपयोग कर रहा है।

हम पहले पहली पंक्ति, ले $a[0], और जाँच करें कि क्या 0है -in, की दुकान है कि हमारे में है कि सरणी $output चर। यदि उस पंक्ति में कुछ भी शून्य है, तो $oवह भी शून्य है, अन्यथा यह एक है, जिसके साथ एक त्वरित कास्ट-टू-इंट द्वारा किया गया है +।

अगला हम 1ऊपर से लूप करते हैं $a.count-1, $xरास्ते में सेटिंग करते हैं - हम एक बार में प्रत्येक पंक्ति के माध्यम से लूपिंग करते जा रहे हैं।

प्रत्येक पुनरावृत्ति हम सहायक $iपंक्ति को निर्धारित करते हैं कि हम किस पंक्ति पर नज़र रखते हैं, फिर इस पंक्ति में प्रत्येक तत्व को पुनरावृत्त 0करने के $xलिए लूप करें। इनर लूप के अंदर, हम फिर से गुणा कर रहे हैं $o, इस बार छद्म-टर्नरी ऑपरेटर के रूप में एक ट्यूपल सेटअप से चयन करके।

टपल की स्थिति, !$_-or$_-eq$iकहती है "जब हम 0 वें स्तंभ पर होते हैं, या स्तंभ पंक्ति (यानी, मुख्य विकर्ण)" से मेल खाता है, तो सत्य होने पर टपल के दूसरे छमाही का चयन करने के लिए या जब फर्स्ट हाफ़ होता है। टपल से बना है !($y=$a[$i][$_]), $y। $yदूसरे हाफ को गोल करने के लिए पहला हाफ सेट , लेकिन या तो हम वर्तमान तत्व का चयन कर रहे हैं। पहला हाफ उस पर बूलियन नकार देता है, जबकि दूसरा हाफ तत्व को जैसा लेता है। इस प्रकार, यदि हम 0 वें कॉलम पर नहीं हैं और न ही मुख्य विकर्ण हैं, तो हम यह सुनिश्चित करते हैं कि तत्व बूलियन को लेकर शून्य है। इसी तरह, हम यह सुनिश्चित करते हैं कि 0 कॉलम या मुख्य विकर्ण केवल इसे लेने से गैर-शून्य है।

इसलिए अब जब हमने मैट्रिक्स में प्रत्येक तत्व के माध्यम से पुनरावृत्त किया है, $oया तो यह होने जा रहा है 0यदि कुछ तत्व गलत था, या कुछ गैर-शून्य पूर्णांक है अगर यह एक एरोहेड मैट्रिक्स है। हम डबल-बूलियन-नहीं है कि Falseया तो Trueक्रमशः प्राप्त करने के लिए , हमारे उत्पादन को सुसंगत बनाने के लिए, और वह पाइपलाइन पर छोड़ दिया जाता है जहां मुद्रण निहित है।

— AdmBorkBork
स्रोत
+= [int]? यह अच्छा है।
— रूट
— AdmBorkBork
7

जेली , 14 12 बाइट्स

ŒDµḢ;Ḣ€Ȧ>FẸ$

Pietu1998 से -2 बाइट्स

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

व्याख्या

[[9,7,1],
 [7,1,0],
 [7,0,1]]

एक उदाहरण इनपुट के रूप में उपरोक्त मैट्रिक्स का उपयोग करें।

ŒDµḢ;Ḣ€Ȧ>FẸ$
ŒD              Diagonals → [[9, 1, 1], [7, 0], [1], [7], [7, 0]]
  µ             New monadic link
   Ḣ            Head → [9, 1, 1]. Alters diagonals list.
    ;Ḣ€         Append with the head of each of the other diagonals → [9, 1, 1, 7, 1, 7, 7]
       Ȧ        Logical all → 1
         FẸ$    Flatten what's left in diagonals then take logical any → [[0],[],[],[0]] → [0,0] → 0
        >       Matrix is an arrowhead iff result of Ȧ > result of Ẹ
— dylnan
स्रोत
@ wizzwizz4 मुझे यकीन नहीं है कि आपका क्या मतलब है
— dylnan
@ wizzwizz4 इस कोड से पता चलता है कि मैट्रिक्स के तत्वों को कैसे फिर से इकट्ठा किया जाता है। यह शीर्ष, बाएँ और मुख्य विकर्ण लेता है। क्या यही आपका मतलब है?
— डायलन
मेरा आशय उस कोड के वास्तविक दृश्य प्रतिनिधित्व से था जो आपने अपने स्पष्टीकरण में प्रदान किया था। मैं मजाकिया होने की कोशिश कर रहा था लेकिन यह स्पष्ट रूप से काम नहीं कर रहा था। मैं इन टिप्पणियों को साफ करूंगा।
— wizzwizz4
7

APL (Dyalog) , 21 18 17 बाइट्स

×≡1⍪1,(=/¨∘⍳1-⍨⍴)

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

कैसे?

यह एक रास्ता जाता है -

=/¨∘⍳ - पहचान मैट्रिक्स बनाता है

1-⍨⍴ - के लिये n - 1

1⍪1, - एक कॉलम और 1s की एक पंक्ति तैयार करता है

≡ - से तुलना करता है

× - मूल मैट्रिक्स, इसके बाद एक तत्व-वार साइनग-इंग चला गया है

— Uriel
स्रोत
6

MATL , 15 बाइट्स

gtZyXy,!llY(]X=

इनपुट एक मैट्रिक्स है ( ;पंक्ति विभाजक के रूप में उपयोग )। आउटपुट 1एरोहेड के लिए है, 0अन्यथा।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

g        % Implicit input. Convert to logical values (nonzero becomes true and
         % zero becomes false)
t        % Duplicate
Zy       % Size
Xy       % Identity matrix of that size
,        % Do twice
  !      %   Transpose
  ll     %   Push 1 twice
  Y(     %   Write 1 at all entries of row 1
]        % End
X=       % Are the two matrices (input and constructed) equal? Implicit display
— लुइस मेंडो
स्रोत
1
वास्तव में Indeity मैट्रिक्स क्या है ?
— १g
13
@EriktheOutgolfer स्पष्ट रूप से एक मैट्रिक्स जिसमें एक देवता होता है।
— कोल
5
@cole शायद Elysian फ़ील्ड पर एक मैट्रिक्स से संबंधित है
— jld
5

सी (जीसीसी) ,80 75 बाइट्स

i;f(A,n)int*A;{for(i=0;i<n*n;i++)n=A[i]>0^(i<n||i%n<1||i/n==i%n)?0:n;n=!n;}

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

स्कूटिनैट के लिए 5 बाइट्स धन्यवाद!

इस उत्तर से परीक्षा कोड का पुन: उपयोग किया ।

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

2 डी सरणी की जानकारी को एक आयाम में एन्कोड करने से परिस्थितियों का काफी सरल सेट होता है। यदि हम iअपने 0-आधारित इंडेक्स को nआयामी सरणी में रखते हैं, तो i<nपहली पंक्ति का वर्णन करते हैं। इसी तरह, i%n==0पहले कॉलम का i/n==i%nवर्णन करता है और विकर्ण का वर्णन करता है।

रिटर्न को संभालने के लिए मैंने जो सबसे अच्छी चाल पाई, वह यह है कि त्रुटि का सामना करते समय आयाम को शून्य पर सेट करें। यह लूप को तुरंत समाप्त करने का कारण बनता है, फिर आयाम के तार्किक निषेध को वापस करने से हमें दो अलग-अलग मूल्यों में से एक मिलेगा। स्कॉचनेट ने जीसीसी को इसे और अधिक अच्छी तरह से वापस करने का तरीका पाया।

— FryAmTheEggman
स्रोत
कुछ और गोल्फिंग के साथ -2 बाइट्स
— स्कूटिनैट
और मानों लौटने के gcc के तरीके का दुरुपयोग करके एक अतिरिक्त -4 बाइट
— स्कैटिनेट
@scottinet धन्यवाद! मुझे यह पता लगाने में कठिनाई हो रही थी कि मुझे उस चाल का उपयोग करने के लिए कौन सा मूल्य निर्धारित करना चाहिए।
— FryAmTheEggman
वास्तव में, मुझे विश्वास नहीं है कि आपका पहला गोल्फ काम करता है। इसने परीक्षण मामलों को पारित कर दिया क्योंकि पहली स्थिति में कभी भी शून्य नहीं था। एक मामला जोड़ा और उस परिवर्तन को वापस कर दिया।
— FryAmTheEggman
int test0 [] = {0, 1, 1, 1, 1, 0, 1, 0, 1}; प्रिंटफ ("% d \ n", f (test0, 3)); 0 नहीं 1 लौटना है (यदि 3x3 matrx 011 110 101 है) क्योंकि एक [0,0] 0 है
— RosLuP
5

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

lambda m,E=enumerate:all((x[j]>0)-(i>0<j!=i)for i,x in E(m)for j,y in E(m))

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

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

सरणी को 1D मैट्रिक्स के रूप में लेना:

def f(m):s=len(m)**.5;print all((v<1)^(0in(p>s,p%s,p//s-p%s))for p,v in enumerate(m))

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

— FlipTack
स्रोत
क्या आपको शीर्ष समाधान में "1D मैट्रिक्स" का मतलब था?
— निकोनिराह
@NikoNyrh उफ़, तय
— पलटें
5

आर , 78 70 69 68 54 53 बाइट्स

function(m){d=diag(nrow(m))
d[1,]=d[,1]=1
all(d!=!m)}

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

पोर्टिंग लुइस मेंडो का उत्तर मेरे पूर्व दृष्टिकोण की तुलना में बहुत छोटा है।

एक बग को इंगित करने के लिए rturnbull के लिए धन्यवाद , और एक बाइट नीचे गोल्फिंग!

पुराना उत्तर, 68 बाइट्स:

function(m,i=which(!m,T))all(i[,1]-i[,2],i!=1,sum(m>0)==3*nrow(m)-2)

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

duckmayr का उत्तर परीक्षण करता है कि मुख्य विकर्ण और पहली पंक्ति / स्तंभ ( m[i]) पर सभी प्रविष्टियाँ नॉनज़ेरो हैं और बाकी ( m[-i]) शून्य हैं, विकर्ण और पहली पंक्ति को प्राप्त करने के लिए कुछ अच्छे अंकगणित का उपयोग करते हैं।

यह उत्तर, हालांकि, यह सुनिश्चित करने के लिए परीक्षण करता है कि (1) शून्य प्रविष्टियाँ मुख्य विकर्ण या पहली पंक्ति / स्तंभ पर नहीं हैं, और (2) कि n x nमैट्रिक्स, 3*n-2नॉनजेरो प्रविष्टियाँ दी गई हैं।

whichउन सूचकांकों को लौटाता है जहां इसका इनपुट है TRUE, और वैकल्पिक के साथ arr.ind=T, प्रत्येक सरणी आयाम के लिए सूचक का एक सरणी देता है, इस मामले में, दो।

इसलिए जब any(i[,1]==i[,2]), विकर्ण पर एक शून्य मौजूद होता है, और जब any(i==1), पहली पंक्ति या पहले कॉलम में एक शून्य मौजूद होता है।

अंत में, एक छोटे से गणित से पता चलता है कि अशून्य प्रविष्टियों की संख्या में होना चाहिए 3*n-2, nपहले कॉलम से, n-1विकर्ण से, और n-1पहली पंक्ति से।

— ग्यूसेप
स्रोत
यह एरो मैट्रेस के लिए काम नहीं करता है जहाँ मान नहीं हैं। 1. क्या आपका मतलब all(!m==!d)अंतिम पंक्ति में है?
— rturnbull
@ आर्टर्नबुल आह! धन्यवाद। आर ऑपरेटर सिंटैक्स बहुत अजीब है। मेरा वास्तव में मतलब था (!!m)==dलेकिन !पहले की तुलना में कम है ==। मुझे लगता है कि d==!!mहालांकि यह चाल चलनी चाहिए।
— ग्यूसेप
ऐसा लगता d!=!mहै कि एक बाइट कम के लिए भी ऐसा ही है। आप pryr::fसिंटैक्स का उपयोग करके functionभी एक और बाइट बचा सकते हैं।
— rturnbull
मैंने इसे गोल्फ करने की कोशिश की लेकिन सबसे अच्छा मैं अभी भी 53 कर सकता हूं ।
— JayCe
@JayCe nah आपके उत्तर और मेरा, दोनों को 52 तक पहुंचाया जा सकता है, और मुझे यकीन नहीं है कि यह मेरे लिए पहले क्यों नहीं हुआ ... मैं तुम्हारा अलग पोस्ट करूँगा; एक-लाइन का दृष्टिकोण काफी अच्छा है और मुझे संदेह है कि आपके सुधार के लिए कुछ और कमरे हो सकते हैं
— Giuseppe
3

हास्केल , 62 बाइट्स

-3 बाइट्स मिस्टर एक्सकोडर की बदौलत। -13 बाइट्स उपयोगकर्ता28667 के लिए धन्यवाद। -5 बाइट्स जर्ब के लिए धन्यवाद।

z=zip[0..]
f m=and[(i==j||i*j<1)==(a>0)|(i,r)<-z m,(j,a)<-z r]

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

— totallyhuman
स्रोत
1
80 बाइट्स .... आप लगभग हमेशा <1इस तरह के और चाल के बारे में भूल जाते हैं ? : पी
— श्री एक्सकोडर
1
(x==y||x==0||y==0)==(m!!y!!x/=0)कम होना चाहिए
— user28667
1
अनुक्रमण के बजाय ज़िप करके 62 बाइट्स , और कर रहे हैं x*y<1।
— ज़गरब
3

पायथन 3 , 72 71 बाइट्स

lambda x,e=enumerate:any(0**n^(0<i!=j>0)for i,r in e(x)for j,n in e(r))

1 बाइट को बंद करने के लिए @xnor को धन्यवाद!

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

— डेनिस
स्रोत
मुझे लगता 0<i!=j>0है कि एक बाइट बचाता है,
— xnor
@xnor धन्यवाद! मुझे नहीं लगता कि मैंने कभी किसी संख्या का तुलना श्रृंखला में पुनः उपयोग किया है ...
— डेनिस
2

पायथ, 22 21 बाइट्स

यह निश्चित रूप से मैट्रिक्स हेरफेर के लिए भाषा नहीं है।

.As.e+!MWk.Db,0k,@bkh

मैट्रिक्स में प्रत्येक पंक्ति bऔर इसके सूचकांक kके लिए .e, पहले और kवें प्रविष्टियों (बाईं ओर और विकर्ण) के साथ ,@bkhऔर ( +) के साथ अन्य सभी प्रविष्टियों को पकड़ लेता है .Db,0k। यदि k0 पहली पंक्ति (के अनुरूप नहीं है Wk), तो !नहीं Mउन सभी प्रविष्टियों की। एक बार उन सभी का चयन हो जाने के बाद, सुनिश्चित करें कि वे सभी सत्य हैं। ( .As) अगर वहाँ 0 है जहाँ नहीं होना चाहिए, तो इसी स्थान को पकड़ा जाएगा और गड़बड़ किया जाएगा और, और अगर वहाँ एक !नॉनज़रो है जहाँ नहीं होना चाहिए, तो यह 0 तक नहीं होगा, जो कि है असत्य भी।

परीक्षण सूट।

आदेशों की अदला-बदली के लिए -1 बाइट्स।

— स्टीवन एच।
स्रोत
1
वाह यह समाधान वास्तव में अच्छा है कि पायथ मैट्रिक्स हेरफेर के साथ काफी समानांतर है। संभवतः कल एक और पायथ द्वंद्वयुद्ध के लिए: पी
— श्री एक्सकोडर
आप इसे @VQUQया तो .DVQUQ विकर्णों के लिए उपयोग कर सकते हैं या विकर्णों को हटाने में सक्षम हो सकते हैं । लेकिन इसके लिए पूरी तरह से अलग दृष्टिकोण की आवश्यकता होगी। हालांकि यकीन नहीं ... (BTW लिंक अपडेट करना भूल गया?)
— श्री एक्सकोडर
@ Mr.Xcoder फिक्स्ड लिंक, मैं कल अन्य रणनीतियों के साथ गड़बड़ करने की कोशिश करूंगा।
— स्टीवन एच।
मैं अपने VQUQविचार का उपयोग करके एक वैकल्पिक 21-बटर पर पहुंचा >.A++hCQhQ.(VQUQsstCt:। यह अत्यधिक बेमानी लगता है, हालांकि। आप कुछ बाइट्स को बचाने के लिए इसे ट्विक करने में सक्षम हो सकते हैं।
— श्री Xcoder
2

पिप , 31 23 22 बाइट्स

{0<_!=B>0MC#a==0=_MMa}

यह एक फ़ंक्शन है जो संख्याओं की 2 डी नेस्टेड सूची लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

यहाँ तुलना की जा रही है। पता करने के लिए पहली बात यह है कि पिप में तुलना ऑपरेटरों को एक साथ श्रृंखलित जा सकता है, पायथन में की तरह है: 5>4>3है 5>4 and 4>3(सही) नहीं, (5>4)>3(गलत)। दूसरा यह है कि यह =="बिल्कुल बराबर" ऑपरेटर पर लागू नहीं होता है । एक और अंतर यह: नियमित रूप से तुलना मानचित्रण ऑपरेटरों की तुलना में अधिक पूर्वता है MCऔर MMऔर, लैम्ब्डा भाव में इस्तेमाल किया जा सकता है, जबकि ==कम पूर्वता है और नहीं कर सकता।

{                    }  Define a function with argument a:
 0<_!=B>0MC#a            Generate a matrix (as nested lists) that has 0 on the first row,
                          first column, and main diagonal, and 1 elsewhere (see below for
                          details)
               0=_MMa    Map the function 0=_ to the elements of the elements of a,
                          generating a matrix that is 0 where a is nonzero and vice versa
             ==          Test if the two matrices are equal, returning 0 or 1 accordingly

पहला मैट्रिक्स उत्पन्न करने के लिए, हम MC"मैप-कोर्डर्स" का उपयोग करते हैं । यह ऑपरेटर एक संख्या लेता है, उस आकार का एक वर्ग समन्वित ग्रिड बनाता है, और परिणामों के सूचियों की एक सूची को लौटाते हुए प्रत्येक (x, y) समन्वित जोड़ी के लिए एक फ़ंक्शन मैप करता है। उदाहरण के लिए, {a+b} MC 3परिणाम देगा [[0; 1; 2]; [1; 2; 3]; [2; 3; 4]]।

यहां, ग्रिड का #aआकार, हमारे मूल तर्क का आकार है। फ़ंक्शन है 0<_!=B>0, जो लिखने का एक छोटा तरीका है {0 < a != b > 0}:

{        }  Function; a and b are the arguments (in our case, row and column)
 0<a        Return 1 (truthy) if a is greater than 0
    !=b     and a is not equal to b
       >0   and b is greater than 0

यह पहली पंक्ति / स्तंभ और मुख्य विकर्ण के लिए 0 देता है, और 1 अन्य जगहों पर।

— DLosc
स्रोत
2

भूसी , 12 11 बाइट्स

S≡ȯ´Ṫ§^*=ŀL

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

व्याख्या

S≡ȯ´Ṫ§^*=ŀL  Input is a k×k array A.
          L  The length, k.
         ŀ   The range [0,1..k-1].
  ȯ´Ṫ        Outer product with itself by this function:
              Arguments are two numbers x and y.
        =     Equality of x and y
     §^       to the power of
       *      x times y.
S≡           Does the result have the same shape and distribution of truthy values as A?

विचार यह है कि हस्क 0 की शक्ति को 0 के रूप में 1 के रूप में परिभाषित करता है, इसलिए बाहरी उत्पाद में पहली पंक्ति और स्तंभ पर 1s है। इसके अलावा, किसी भी संख्या की शक्ति 1 है, इसलिए बाहरी उत्पाद में विकर्ण पर 1s है। कुछ सकारात्मक संख्या की शक्ति के लिए अन्य प्रविष्टियां 0 हैं, जो 0. है। यह एक बाइनरी एरोहेड मैट्रिक्स देता है, जिसकी तुलना हम इनपुट से करते हैं ≡।

— Zgarb
स्रोत
2

एपीएल + विन, 36 33 बाइट्स

(↑⍴m)=+/(+⌿m)=+/m←×m×n∘.×n←⍳↑⍴m←⎕

एपीएल 2 डी मैट्रिक्स के स्क्रीन इनपुट के लिए संकेत।

— ग्राहम
स्रोत
2

क्लोजर, 128 95 92 85 बाइट्स

#(every? neg?(for[R[(range(count %))]i R j R]((if((set[i(- i j)j])0)- dec)((% i)j))))

दो लगातार खुलने वाले कोष्ठक देखना हमेशा रोमांचक होता है।

मूल संस्करण:

#(and(apply =(map assoc(for[i(rest %)](subvec i 1))(range)(repeat 0)))(every? pos?(concat(map nth %(range))(% 0)(map first %))))

पहला भाग assocउप-मैट्रिक्स के विकर्ण तत्वों द्वारा शून्य पर काम करता है , और जाँच रहा है कि सभी पंक्तियाँ समान हैं :) मैंने याकूब की विधि पर एक समान चाल का उपयोग किया ।

लैटर भाग concatविकर्ण + प्रथम पंक्ति और स्तंभ को जोड़ता है और जाँचता है कि वे सकारात्मक हैं।

— NikoNyrh
स्रोत
2

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

जावास्क्रिप्ट के लिए मेरा समाधान:

m=>m.some((r,i)=>m[0][i]*r[0]*r[i]==0|r.filter(c=>i*c)[2])

हर्मन के उत्तर के रूप में चतुर नहीं है , लेकिन मुझे बस ऐसा महसूस हुआ कि मुझे यहां भी पोस्ट करना चाहिए।

कोड स्निपेट दिखाएं

— पेड्रो कोरसो
स्रोत
3
PPCG में आपका स्वागत है!
— स्टेडीबॉक्स
2

क्लोजर, 212 206 188 बाइट्स

-6 बाइट्स कुछ छूटे हुए रिक्त स्थान को हटाकर, और शॉर्टकट करके range। मुझे यह बैठने देना पड़ सकता है इसलिए मैं बेहतर तरीके से सोच सकता हूं।

-18 बाइट्स @NikoNyrh के लिए धन्यवाद, और के लिए शॉर्टकट बनाना map।

(fn[m](let[r range a map z zero?](and(every? #(not(z %))(concat(m 0)(rest(a #(% 0)m))(a get m(r))))(every? z(apply concat(into(a #(take(dec %)%2)(r)(a rest m))(a take-last(r)(reverse(rest m)))))))))

भयानक, बस भयानक। मुझे नहीं पता कि मैं एक उचित समाधान के चारों ओर अपना सिर क्यों नहीं लपेट सकता।

एक नेस्टेड वेक्टर को इनपुट के रूप में लेता है।

(defn arrowhead? [matrix]
  (let [; Get the 0th cell of the 0th row, then the 1st cell of the 1st row...
        main-diagonal (map get matrix (range))

        ; Get the 0th cell of each row
        first-col (rest (map #(% 0) matrix))
        arrowhead (concat (matrix 0) first-col main-diagonal)

        ;
        right-rest (map take-last (range) (reverse (rest matrix)))
        left-rest (map #(take (dec %) %2) (range) (map rest matrix))
        rest-matrix (apply concat (into left-rest right-rest))]

    ; And check them
    (and (every? pos? %) arrowhead
         (every? zero? rest-matrix))))

मैंने इसे एक अलग विधि का उपयोग करके खरोंच से फिर से लिखने की कोशिश की, और यह लंबे समय तक समाप्त हो गया। मैट्रिक्स के "आराम" अनुभागों को मैन्युअल रूप से बाहर करने के बजाय, मैंने इसके बजाय मैट्रिक्स में सभी निर्देशांक उत्पन्न करने का प्रयास करने का निर्णय लिया, तीर के निर्देशांक को उत्पन्न करने के बाद, फिर clojure.set/differenceगैर-तीरहेड कोशिकाओं को प्राप्त करने के लिए उपयोग करें। दुर्भाग्य से, उस अंतर्निहित में कॉल महंगा है:

223 बाइट्स

(fn[m](let[l(range(count m))g #(get-in m(reverse %))e every? a(for[y l x l][x y])k #(map % l)r(concat(k #(do[% %]))(k #(do[0%]))(k #(do[% 0])))](and(e #(zero?(g %))(clojure.set/difference(set a)(set r)))(e #(pos?(g %)))r)))

(defn arrowhead? [matrix]
  (let [length-range (range (count matrix))
        get-cell #(get-in matrix (reverse %))
        all-coords (for [y length-range
                         x length-range]
                     [x y])

        k #(map % length-range)

        diag (k #(do[% %]))
        top-side (k #(do [0 %]))
        left-side (k #(do [% 0]))
        arrowhead (concat diag top-side left-side)

                   ; 22 bytes! Ouch
        rest-cells (clojure.set/difference (set all-coords) (set arrowhead))]

    (and (every? #(zero? (get-cell %)) rest-cells)
         (every? #(pos? (get-cell %)) arrowhead))))
— Carcigenicate
स्रोत
वहाँ सुधार की गुंजाइश काफी बहुत है, उदाहरण के लिए #(drop 1 %)के रूप में ही है restऔर #(not(zero? %))रूप में ही है pos?(जैसा कि हम गैर-ऋणात्मक संख्याओं है)। आप मेरे 128-बाइट के उत्तर पर एक नज़र डालना चाह सकते हैं, जो इस तरह का दृष्टिकोण है। लागू करने के बाद मुझे एहसास हुआ कि इंडेक्स-आधारित पहुंच से निपटने के लिए यह बहुत छोटा है।
— निकोनिराह
@NikoNyrh हां, मैं उस दिन बहुत अच्छी नाली में नहीं था। मैं नहीं जानता कि मैं कैसे भूल गया rest। मुझे शायद बस इस कोशिश को विफल करना चाहिए और फिर से प्रयास करना चाहिए।
— कैरिजनेट
2

स्टेक्स , 11 बाइट्स CP437

ä¢⌠┐xⁿtH↔BU

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

13 बाइट्स के साथ अनपैक्ड संस्करण:

B|AsF:10i^\=*

अंत में हस्क बंधे और जेली द्वारा सिर्फ एक बाइट से पीटा ...

व्याख्या

B                Push tail (all except 1st row) of the input array, then push the head (1st row)
 |A              All elements in the head are truthy
                 This will be used as an accumulator
   sF            For each element in the tail, execute the rest of the program
     :1          All truthy indices
       0i^\      Expected truthy indices (0 and the current row number)
           =     The truthy indices are as expected
            *    Perform logical "and" with the accumulator
                 Implicit output of the final accumulator
— वीजुन झोउ
स्रोत
1

आर , 81 79 बाइट्स

function(x){n=nrow(x);i=c(seq(1,n^2,n+1),1:n,seq(1,n^2,n));all(x[i]>0,x[-i]<1)}

-2 बाइट्स मिस्टर एक्सकोडर की बदौलत

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

— duckmayr
स्रोत
— श्री एक्सकोडर
बहुत अच्छा; मैं एक 78 बटर को खोजने में कामयाब रहा जो कुछ बहुत ही अजीब कर रहा है लेकिन मुझे आपका एक 76 बाइट गोल्फ भी मिला ।
— ग्यूसेप
69 बाइट्स लेकिन मैंने खान को 68 में सुधार दिया!
— ग्यूसेप
1

पॉवरशेल , 186 बाइट्स

$a=$($args);if($a[0]-contains0){0;exit};0..($a.Length-1)|%{if($a[$_][0]-eq0-or$a[$_][$_]-eq0){0;exit};$r=$a[$_];$d=$_;if($_-ne0){1..($r.Length-1)|%{if($r[$_]-ne0-and$_-ne$d){0;exit}}}};1

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

— जड़
स्रोत
2
कुछ गोल्फ - param($a)इनपुट लेने के लिए उपयोग करते हैं, के -containsलिए स्वैप किया जा सकता है -inऔर सभी के लिए -eq0स्वैप किया जा सकता है !। अंत में, आप लूप बॉडी से लूप 1अप $a.lengthऔर छुटकारा पा सकते हैं if($_-ne0)।
— AdmBorkBork
1

के (ओके) , 27 30 बाइट्स

समाधान:

x~a*x|a:a|+(a:1,(#1_x)#0)|=#x:

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

स्पष्टीकरण:

मैं कुछ गूंगा होना चाहिए क्योंकि एपीएल समाधान आधे बाइट की संख्या से कम हैं ...

एरोहेड बनाने में 24 बाइट्स खर्च हुए। orएक साथ निम्नलिखित तीन मैट्रिसेस:

/ assume 4x4 matrix
=#x
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1

+(a:1,(#1_x)#0)
1 0 0 0
1 0 0 0
1 0 0 0
1 0 0 0

a
1 1 1 1
0 0 0 0
0 0 0 0
0 0 0 0

पूर्ण विराम: 

x~a*x|a:a|+(a:1,(#1_x)#0)|=#x: / the solution
                            x: / save input as x
                           #   / count length
                          =    / identity matrix
                         |     / or with
           (            )      / do this together
                      #0       / take from 0
                ( 1_x)         / drop first of x
                 #             / count
              1,               / prepend 1
            a:                 / save as a
          +                    / flip rows/cols
         |                     / or with
        a                      / a
      a:                       / save as a
     |                         / or with
    x                          / x
  a*                           / multiply by arrowhead
x~                             / matches input?
— streetster
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.