हर्मिटियन मैट्रिक्स?

18

ध्यान दें कि इस चुनौती को जटिल संख्याओं से निपटने या समझने की आवश्यकता नहीं है।

एक गैर-खाली वर्ग मैट्रिक्स को देखते हुए जहां हर तत्व एक दो-तत्व (Re, Im) पूर्णांक सूची है, यह निर्धारित करता है (किसी भी सत्य / मिथ्या मूल्यों या किसी भी दो सुसंगत मूल्यों को देते हुए) क्या यह एक हर्मिटियन मैट्रिक्स का प्रतिनिधित्व करता है।

ध्यान दें कि इनपुट पूर्णांक का एक 3D सरणी है; जटिल संख्याओं का 2D सरणी नहीं है। यदि आपकी भाषा सीधे 3 डी सरणी नहीं ले सकती है, तो आप एक फ्लैट सूची (और n × n या n × n × 2 आकार में ले सकते हैं यदि आपकी मदद करता है)।

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

चलो-हालांकि उदाहरण

यह उदाहरण पढ़ने में आसानी के लिए शानदार सफेद स्थान वाले JSON का उपयोग करता है:

[[ [2, 0] , [2, 1] , [4, 0] ],
 [ [2,-1] , [3, 0] , [0, 1] ],
 [ [4, 0] , [0,-1] , [1, 0] ]]

स्थानांतरण (NW-SE विकर्ण पर फ्लिप करें):

[[ [2, 0] , [2,-1] , [4, 0] ],
 [ [2, 1] , [3, 0] , [0,-1] ],
 [ [4, 0] , [0, 1] , [1, 0] ]]

पत्ता-सूची के दूसरे तत्वों को हटाएं:

[[ [2, 0] , [2, 1] , [4, 0] ],
 [ [2,-1] , [3, 0] , [0, 1] ],
 [ [4, 0] , [0,-1] , [1, 0] ]]

चूंकि यह इनपुट के समान है, मैट्रिक्स हर्मिटियन है।

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

Hermitian

[[[2,0],[2,1],[4,0]],[[2,-1],[3,0],[0,1]],[[4,0],[0,-1],[1,0]]]

[[[1,0],[2,0]],[[2,0],[1,0]]]

[[[1,0],[2,-3]],[[2,3],[1,0]]]

[[[42,0]]]

गैर Hermitian

[[[2,0],[2,1],[4,0]],[[2,-1],[3,0],[0,1]],[[4,0],[0,-1],[1,-1]]]

[[[0,1],[0,2]],[[0,2],[0,1]]]

[[[1,0],[2,3]],[[2,3],[1,0]]]

[[[3,2]]]

code-golf  math  decision-problem  matrix  complex-numbers 
— एडम
स्रोत
@LuisMendo मैं अभी भी सोच रहा हूँ। कोई विचार?
— Adám
रिकॉर्ड के लिए, एक नया मेटा-पोस्ट । (मैंने बंद करने के लिए मतदान नहीं किया है, लेकिन मुझे लगता है कि किसी के पास है, इसलिए मैं उत्सुक हूं कि समुदाय इस बारे में क्या सोचता है)।
— स्टीवी ग्रिफ़िन
5
@ Adám मैं इसे यथासंभव स्पष्ट कर दूंगा, लेकिन यह आपके ऊपर है। इनपुट और आउटपुट प्रारूपों में लचीलापन आमतौर पर वांछित होता है, लेकिन डिफ़ॉल्ट रूप से अनुमान नहीं लगाया जा सकता है, विशेष रूप से जब आप कहते हैं कि इनपुट वास्तविक संख्याओं का एक 3D सरणी है; जटिल संख्याओं का 2D सरणी नहीं है । यह स्पष्ट नहीं है कि 3 डी सरणी इनपुट प्रारूप की आपकी अवधारणा कितनी व्यापक है
— लुइस मेंडो
3
@ Adám क्या इनपुट के रूप में 2D मैट्रीस (वास्तविक भाग के लिए एक, काल्पनिक भाग के लिए एक जोड़ी) लिया जा सकता है?
— dylnan 16
1
@dylnan No. इनपुट में एक एकल संरचना होनी चाहिए जो किसी प्रकार की 3-आयामीता का प्रतिनिधित्व करती है जहां पत्ती आयाम में री-इम जोड़े होते हैं।
— 16

जवाबों:

10

आर, 71 48 47 बाइट्स

function(A)all(Conj(t(B<-A[,,1]+A[,,2]*1i))==B)

वास्तविक संख्याओं का एक 3D सरणी लेता है, काल्पनिक संख्याओं का 2 डी सरणी बनाता है, स्थानांतरित करता है, संयुग्म करता है और तुलना करता है।

के लिए धन्यवाद @Giuseppe 23 बाइट्स, और करने के लिए एक अद्भुत द्वारा बाइट गिनती कम करने के लिए @Vlo अंतिम 1 के लिए!

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

उदाहरण:

> A <- array(c(2,2,4,2,3,0,4,0,1,0,-1,0,1,0,-1,0,1,0),dim=c(3,3,2))
> A
, , 1

     [,1] [,2] [,3]
[1,]    2    2    4
[2,]    2    3    0
[3,]    4    0    1

, , 2

     [,1] [,2] [,3]
[1,]    0    1    0
[2,]   -1    0    1
[3,]    0   -1    0

> f <- function(A)all(Conj(t(B<-A[,,1]+A[,,2]*1i))==B)
> f(A)
[1] TRUE
— plannapus
स्रोत
1
B=A[,,1]+A[,,2]*1iकुछ बाइट्स बचाना चाहिए।
— ग्यूसेप
@GIuseppe arf मुझे लगा कि मैंने कोशिश की है लेकिन स्पष्ट रूप से नहीं। धन्यवाद!
— प्लेनैपस
1
इसके अलावा, isSymmetricमौजूद है और हर्मिटियन कॉम्प्लेक्स मैट्रिस के लिए काम करता है, लेकिन 1x1मामला बहुत ही पेचीदा है क्योंकि [यह बूंदों की विशेषता है और इसके परिणामस्वरूप complexएकmatrix
— Giuseppe
2
function(A)all(Conj(t(B<-A[,,1]+A[,,2]*1i))==B)इन-लाइन असाइनमेंट सेव करता है 1.
— Vlo
7

अष्टक , ३ ९ 34 31 बाइट्स

@(x)(y=x(:,:,1)+j*x(:,:,2))==y'

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

लुइस मेंडो के लिए 3 बाइट्स का धन्यवाद, जिन्होंने मुझे चुनौती पाठ में स्पष्टीकरण के बारे में बताया।

स्पष्टीकरण:

MATLAB और ऑक्टेव में, ' संयुग्म जटिल संक्रमण है, न कि "नियमित" स्थानान्तरण।

हम एक वैरिएबल yइनलाइन बनाते हैं जो 3 डी मैट्रिक्स की पहली परत है और दूसरी परत जटिल इकाई के साथ गुणा हैj , यानी एक जटिल मैट्रिक्स जहां वास्तविक शब्द पहली "परत" है, और काल्पनिक दूसरी "परत" है। हम तब जांचते हैं कि क्या यह खुद को जटिल संयुग्मित ट्रांसलॉग्ड के बराबर है।

यह एक मैट्रिक्स को आउटपुट देगा 1यदि केवल सही है, और एक मैट्रिक्स जिसमें कम से कम एक है, 0यदि गलत है। इन्हें ऑक्टेव (प्रूफ) में सही और गलत माना जाता है ।

— स्टीवी ग्रिफिन
स्रोत
5

एपीएल (डायलॉग यूनिकोड) , 22 15 9 7 बाइट्स

⍉≡⊢∘-\¨

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

टैसिट उपसर्ग फ़ंक्शन।

Dfn पर 7 बाइट्स के लिए Adám के लिए और Adám और ErikTheOutgolfer दोनों के लिए धन्यवाद मेरी मूर्खता के साथ मुझे tacit संस्करण खोजने में मदद करने के लिए।

टैसिट संस्करण पर 2 बाइट्स के लिए ngn के लिए धन्यवाद।

कैसे?

⍉≡⊢∘-\¨ ⍝ Anonymous tacit function.
      ¨ ⍝ Apply to each element of the argument:
     \  ⍝ Cumulative reduction, using
  ⊢∘-   ⍝ Ignore the first element, then negate the second
 ≡      ⍝ And match
⍉       ⍝ To the argument's transposition.
— जे। सल्ल
स्रोत
5

वोल्फ्राम लैंग्वेज (मैथमेटिका) , 45 34 33 26 21 18 बाइट्स

#==#&[#.{1,I}]&

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

— जोनाथन फ्रेच
स्रोत
— जुंगह्वान मिन
@alephalpha बहुत बहुत धन्यवाद; मुझे पता है कि 0xf3c7ट्रांसपोट ऑपरेटर है, लेकिन क्या है 0xf3c8?
— जोनाथन फ्रीच
1
— जोनाथन फ्रीच
4

जावा 8, 137 136 134 126 119 116 बाइट्स

m->{int r=1,l=m.length,i=l*l,j,k;for(;i-->0;)r=m[j=i/l][k=i%l][0]!=m[k][j][0]|m[j][k][1]!=-m[k][j][1]?0:r;return r;}

-3 बाइट्स @ceilingcat की बदौलत ।

रिटर्न 1अगर Hermitian, 0अन्यथा।

स्पष्टीकरण:

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

m->{                 // Method with 3D integer-array as parameter and boolean return-type
  int r=1,           //  Flag-integer `r`, starting at 1
      l=m.length,    //  The size of the 3D input array
      i=l*l,j,k;     //  Index-integers
  for(;i-->0;)       //  Loop over the rows and columns
    r=m[j=i/l][k=i%l][0]!=m[k][j][0]
                     //   If the first numbers diagonally aren't equal,
      |m[j][k][1]!=-m[k][j][1]?
                     //   or the second numbers aren't negatives of each other:
       0             //    Set the flag `r` to 0
      :              //   Else:
       r;            //    Leave the flag `r` the same
  return r;}         //  Return the flag `r`
— केविन क्रूज़सेन
स्रोत
3

जेली ,  6  5 बाइट्स

Z×Ø+⁼

एक मोनोडिक लिंक 1एक हर्मिटियन इनपुट के लिए लौट रहा है और 0अन्यथा।

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

कैसे?

Z×Ø+⁼ - Link: list of lists of lists, M
Z     - transpose
  Ø+  - literal = [1,-1]
 ×    - multiply (vectorises)
    ⁼ - equal to M?
— जोनाथन एलन
स्रोत
मेरा मानना ​​है कि आधुनिक जेली है Ø+।
— lirtosiast
@lirtosiast वास्तव में आप सही हैं, इसका उपयोग करने के लिए अपडेट किया गया; धन्यवाद!
— जोनाथन एलन
1

पर्ल 5 , -a0 48 बाइट्स

पुरानी गिनती: 50 बाइट्स (के +2लिए a0)। ऐसी भाषा के लिए बुरा नहीं है, जिसमें कोई बिलिन ट्रांसजेंड नहीं है (मैं बिल्कुल भी ईर्ष्या नहीं कर रहा हूं, कोई साड़ी नहीं)

,वास्तविक और काल्पनिक भाग के बीच STDIN पर इनपुट मैट्रिक्स दें , जैसे:

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

1हेर्मिटियन के लिए प्रिंट करेंगे , अन्यथा कुछ भी नहीं

#!/usr/bin/perl -a0
say@F~~[map/(\S+,)(\S+)/gc?$1.-$2:(),(/.+/g)x@F]

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

— टन हास्पेल
स्रोत
1

भूसी , 7 बाइट्स

=¹mmṀ_T

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

कैसे?

ध्यान दें कि †इसके बजाय काम करना चाहिए mm , लेकिन एक कष्टप्रद बग है जो मुझे इसका उपयोग करने से रोकता है :(

= =mm¹_T - पूर्ण कार्यक्रम। टुपल्स की सूची की सूची के रूप में कमांड लाइन आर्ग्स से इनपुट लेता है।
  मी टी - इनपुट के प्रस्ताव में प्रत्येक सूची के लिए ...
   m_ - ... प्रत्येक टपल के अंतिम मान को उनके द्वारा अलग करें।
= Whether - जांचें कि क्या यह इनपुट के समान है।
— मिस्टर एक्सकोडर
स्रोत
1

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

@ बाइल के लिए 2 बाइट्स का धन्यवाद

falseहरमिटियन के लिए या trueगैर-हर्मिटियन के लिए रिटर्न ।

m=>m.some((r,y)=>r.some(([a,b],x)=>m[x][y]!=a+[,-b]))

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

— Arnauld
स्रोत
Codegolf.stackexchange.com/a/156714 पर 3 बाइट्स सहेजें - f=([c,...s],p='')=>c?p+c+f(s,p+'🍹'):p।
— नील
1

सी (जीसीसी) , 107 103 100 बाइट्स

j,k,r;f(A,s)int***A;{for(r=0,j=s;j--;)for(k=s;k--;)r|=*A[j][k]-*A[k][j]|A[j][k][1]+A[k][j][1];A=!r;}

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

— जोनाथन फ्रेच
स्रोत
— स्टेडीबॉक्स
@Steadybox बहुत बहुत धन्यवाद। मजेदार ... कुछ घंटे पहले मेरे दिमाग में यह गोल्फ था - अनुक्रमण के बजाय डेरेफ़रिंग - लेकिन बस भूल गया ...
— जोनाथन फ्रीच
@ceilingcat धन्यवाद।
— जोनाथन फ्रेच
0

वास्तव में , 13 बाइट्स

┬⌠⌠Çá╫k⌡M⌡Mß=

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

यह काम किस प्रकार करता है?

यह सबमिशन वास्तव में जटिल संख्याओं का उपयोग करता है। यदि जटिल प्रविष्टियों के मैट्रिक्स के रूप में इनपुट लेने की अनुमति थी, तो यह 8 बाइट्स होगा ।

┬⌠⌠Çá╫k⌡M⌡Mß=  –> Full program.
┬              –> Transpose.
 ⌠       ⌡M    –> For each list in the input's transpose do the following:
  ⌠    ⌡M         –> For each two-element list of the form [a, b]...
   Ç              –> Turn it into a complex number (a+bi).
    á             –> Find its complex conjugate: Push (a-bi).
     ╫k           –> Push [Re(N), Im(N)], so [a, -b].
           ß=  –> Check whether the result equals the input.
— मिस्टर एक्सकोडर
स्रोत
0

अजगर, 9 बाइट्स

qCmm,hk_e

स्पष्टीकरण:

qCmm,hk_ekdQQ  Autofill variables
    ,hk_ek     [a,-b]...
  mm      dQ    ...for each [a,b] in the input (m...Q)'s rows (m...d).
 C             Transpose.
q           Q  Is this result equal to the original?

टेस्ट सूट ।

— स्टीवन एच।
स्रोत
आपका जवाब वास्तव में 9 बाइट्स है ... एक 9-बाइट विकल्प qCmm*V_B1:।
— मिस्टर एक्सकोडर
जैसा कि मैं प्रस्तुत कर रहा था, मैंने एक बाइट को गोल्फ से बाहर कर दिया qCmm.e_Fbk... जाहिरा तौर पर मैं अंतिम प्रस्तुत में बाइट गिनती को संपादित करना भूल गया। @ Mr.Xcoder मैंने इसे परवाह किए बिना तय किया, पकड़ने के लिए धन्यवाद!
— स्टीवन एच।
0

सी,  111   110  108 बाइट्स

@ बाइट को बचाने के लिए @ जोनाथन फ्रीच और दो बाइट्स बचाने के लिए @ceilingcat को धन्यवाद!

i,j,r;f(A,n)int*A;{for(r=i=0;i<n*2;i+=2)for(j=n*2;j;r|=A[i*n+j]-A[j*n+i]|A[i*n-~j]+A[j*n-~i])j-=2;return!r;}

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

सी (जीसीसी) ,  106  104 बाइट्स

i,j,r;f(A,n)int*A;{for(r=i=0;i<n*2;i+=2)for(j=n*2;j;r|=A[i*n+j]-A[j*n+i]|A[i*n-~j]+A[j*n-~i])j-=2;A=!r;}

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

— Steadybox
स्रोत
मुझे लगता है r|=...|... काम करता है r+=...||...।
— जोनाथन फ्रीच
@JonathanFrech हाँ, यह करता है। धन्यवाद!
— स्टेडीबॉक्स
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.