18

कोफ़ेक्टर मैट्रिक्स एडजुगेट मैट्रिक्स का संक्रमण है । इस मैट्रिक्स के तत्व मूल मैट्रिक्स के cofactors हैं ।

कॉफ़ेक्टर (यानी रो और कॉलम j पर कॉफ़ेक्टर मैट्रिक्स का तत्व) मूल मैट्रिक्स से आईआईटी पंक्ति और जेथ कॉलम को हटाने के द्वारा गठित सबमेट्रिक्स का निर्धारक है (-1 (^ + i) से गुणा)।

उदाहरण के लिए, मैट्रिक्स के लिए

पंक्ति 1 और स्तंभ 2 पर कोफ़ेक्टर मैट्रिक्स का तत्व है:

आप इस बात की जानकारी प्राप्त कर सकते हैं कि मैट्रिक्स का निर्धारक क्या है और यहां उनकी गणना कैसे करें ।

चुनौती

आपका लक्ष्य इनपुट मैट्रिक्स के कोफ़ेक्टर मैट्रिक्स का उत्पादन करना है।

नोट : अंतर्निहित इंसुलेशन जो कॉफ़ेक्टर मैट्रिसेस, या आसन्न मैट्रिसेस, या निर्धारक या कुछ इसी तरह के मूल्यांकन की अनुमति है ।

इनपुट

मैट्रिक्स को कमांड लाइन तर्क के रूप में इनपुट किया जा सकता है, फ़ंक्शन पैरामीटर के रूप में, STDINया किसी भी तरह से जो आपके द्वारा उपयोग की जाने वाली भाषा के लिए सबसे उपयुक्त है।

मैट्रिक्स को सूचियों की एक सूची के रूप में स्वरूपित किया जाएगा, प्रत्येक पंक्ति एक पंक्ति के अनुरूप है, जिसमें बाएं से दाएं के आदेश दिए गए कारक हैं। सूची में ऊपर से नीचे तक पंक्तियों का आदेश दिया गया है।

उदाहरण के लिए, मैट्रिक्स

a b
c d

द्वारा प्रतिनिधित्व किया जाएगा [[a,b],[c,d]]।

आप वर्ग कोष्ठक और अल्पविराम को किसी अन्य चीज़ से प्रतिस्थापित कर सकते हैं यदि यह आपकी भाषा के अनुकूल हो और समझदार हो (जैसे ((a;b);(c;d)))

मैट्रिक्स में केवल पूर्णांक होंगे (जो नकारात्मक हो सकते हैं) ।

मैट्रिसेस हमेशा वर्गाकार होंगे (यानी समान संख्या में पंक्तियाँ और स्तंभ)।

आप मान सकते हैं कि इनपुट हमेशा सही होगा (यानी कोई स्वरूपण समस्या, पूर्णांक के अलावा कुछ नहीं, कोई खाली मैट्रिक्स नहीं)।

उत्पादन

परिणामस्वरूप कोफ़ेक्टर मैट्रिक्स को आउटपुट किया जा सकता है STDOUT, एक फ़ंक्शन से लौटाया जाता है, एक फ़ाइल पर लिखा जाता है, या कुछ भी ऐसा ही होता है जो स्वाभाविक रूप से आपके द्वारा उपयोग की जाने वाली भाषा के अनुरूप होता है।

कॉफ़ेक्टर मैट्रिक्स को उसी तरीके से स्वरूपित किया जाना चाहिए जिस तरह से इनपुट मैट्रिसेस दिए गए हैं, जैसे [[d,-c],[-b,a]]। यदि आप एक स्ट्रिंग पढ़ते हैं, तो आपको एक स्ट्रिंग लौटना / आउटपुट करना होगा जिसमें मैट्रिक्स बिल्कुल इनपुट की तरह स्वरूपित होता है। यदि आप किसी चीज़ का उपयोग करते हैं जैसे इनपुट के रूप में सूचियों की एक सूची, तो आपको सूचियों की एक सूची भी वापस करनी होगी।

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

इनपुट: [[1]]

आउटपुट: [[1]]

इनपुट: [[1,2],[3,4]]

आउटपुट: [[4,-3],[-2,1]]

इनपुट: [[-3,2,-5],[-1,0,-2],[3,-4,1]]

आउटपुट: [[-8,-5,4],[18,12,-6],[-4,-1,2]]

इनपुट: [[3,-2,7,5,0],[1,-1,42,12,-10],[7,7,7,7,7],[1,2,3,4,5],[-3,14,-1,5,-9]]

आउटपुट:

[[9044,-13580,-9709,23982,-9737],[-1981,1330,3689,-3444,406],[14727,7113,2715,-9792,414],[-28448,-2674,-707,16989,14840],[-2149,2569,-2380,5649,-3689]]

स्कोरिंग

यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा जवाब है।

— Fatalize
स्रोत

2

मुझे यकीन नहीं है कि कॉफ़ेक्टर मैट्रिक्स की व्याख्या कैसे की जाए , ठीक उसी तरह से फॉर्मेट किया जाना चाहिए जिस तरह से इनपुट मेट्रिक्स फ़ंक्शन सबमिशन के लिए दिए जाते हैं जो तर्कों से इनपुट प्राप्त करते हैं और एक मूल्य वापस करते हैं। क्या हम वास्तविक मैट्रिस या उनके स्ट्रिंग अभ्यावेदन को पढ़ते / वापस करते हैं?

— डेनिस

1

संक्षेप में: यदि आप एक स्ट्रिंग पढ़ते हैं, तो आपको एक स्ट्रिंग लौटना / आउटपुट करना होगा जिसमें मैट्रिक्स इनपुट में बिल्कुल स्वरूपित होता है। यदि आप किसी सूची की सूची जैसे कुछ का उपयोग करते हैं, तो आपको सूचियों की एक सूची भी वापस करनी होगी।

— घातक

क्या 1x1 मैट्रिक्स में वास्तव में एक कॉफ़ेक्टर मैट्रिक्स है?

— लियाम

जब तक मैं गलत नहीं हूँ, तब भी आपके परीक्षण के मामले में आसन्न मैट्रिक्स (यह क्या होना चाहिए का स्थानान्तरण) लगता है।

— लियाम

@ICHHHHats सही, मैंने इसे ठीक किया, धन्यवाद।

— घातक

1

जे, 29 बाइट्स

3 :'<.0.5+|:(-/ .**%.)1e_9+y'

एक ही एप्सिलॉन / व्युत्क्रम / निर्धारक चाल। दांये से बांये तक:

1e_9+ एक एप्सिलॉन जोड़ता है,
(-/ .**%.)है निर्धारक ( -/ .*) बार उलटा ( %.),
|: transposes,
<.0.5+ राउंड।

— लिन
स्रोत

5

मतलाब, 42 33 बाइट्स

एक अनाम फ़ंक्शन का उपयोग करना:

@(A)round(inv(A+eps)'*det(A+eps))

इनपुट और आउटपुट मैट्रिसेस (2 डी न्यूमेरिकल एरे) हैं।

epsमैट्रिक्स विलक्षण होने की स्थिति में जोड़ा जाता है। इसका उपयोग करके "हटा दिया गया" round(सही परिणाम पूर्णांक होने की गारंटी है)।

उदाहरण:

>> @(A)round(inv(A+eps)'*det(A+eps))
ans = 
    @(A)round(inv(A+eps)'*det(A+eps))
>> ans([-3,2,-5; -1,0,-2; 3,-4,1])
ans =
-8    -5     4
18    12    -6
-4    -1     2

एकवचन मैट्रिक्स के साथ उदाहरण:

>> @(A)round(inv(A+eps)'*det(A+eps))
ans = 
    @(A)round(inv(A+eps)*det(A+eps)')
>> ans([1,0 ; 0,0])
ans =
     0     0
     0     1

या इसे ऑक्टेव में ऑनलाइन आज़माएं ।

— लुइस मेंडो
स्रोत

2

हालाँकि, मुझे चिंता है कि मैंने चुनौती के बारे में बात नहीं की है: यह उत्तर मानता है कि इनपुट मैट्रिक्स उल्टा है। [1,0 ; 0,0]जब यह आउटपुट होना चाहिए, तो आपके कोड का उपयोग करना एक त्रुटि देता है[0,0 ; 0,1]

— 14

1

जब से आप एक फ़ंक्शन से लौट रहे हैं, मुझे नहीं लगता कि आपको इसकी आवश्यकता होनी चाहिए mat2str: "परिणामस्वरूप कॉफ़ेक्टर मैट्रिक्स हो सकता है ... एक फ़ंक्शन से वापस लौटा"

— FryAmTheEggman

1

@FryAmTheEggman धन्यवाद! लेकिन " कोफ़ेक्टर मैट्रिक्स को उसी तरीके से स्वरूपित किया जाना चाहिए जिस तरह से इनपुट मैट्रिसेस दिए गए हैं "। इसलिए मुझे लगता है कि मुझे जरूरत हैmat2str

— लुइस मेंडू

1

@Fatalize हाँ, यह है कि। eps1e-16 के बारे में है। तो यह मैट्रिक्स को गैर-विलक्षण (लेकिन बहुत ही बीमार) बनाता है। परिणाम बिल्कुल पूर्णांक नहीं है; इसलिए fix(शून्य की ओर गोल) इसे ठीक करता है। यह काम करता है बशर्ते त्रुटि अधिक न हो .5। मुझे डर है कि कोई गारंटी नहीं है। बहुत बड़े पूर्णांकों के लिए यह विफल हो सकता है। मैंने कहा कि यह एक गंदी चाल थी :-P

— लुइस मेंडो

1

@ स्पष्टता के लिए निर्धारित करें, क्या आप कह सकते हैं कि क्या mat2strयहां जरूरत है? मेरे लिए ऐसा लगता है कि चूंकि यह एक फ़ंक्शन है, वास्तव में इनपुट अनमैटेड मैट्रिक्स है। जैसे अगर आप कोशिश करते हैं f=...तो f(f(...))यह काम नहीं करेगा, लेकिन हटाने mat2strसे वह काम ठीक हो जाता है।

— FryAmTheEggman

4

गणितज्ञ, 27 35 बाइट्स

Thread[Det[#+x]Inverse[#+x]]/.x->0&

— alephalpha
स्रोत

क्या यह नॉन-इनवर्टेबल मैट्रिस के लिए काम करता है, जैसे [[1,0],[0,0]]?

— 15

@FryAmTheEggman कि काम करने के लिए प्रतीत नहीं होता है।

— लीजनमोनमाल 978

3

आर, 121 94 बाइट्स

function(A)t(outer(1:(n=NROW(A)),1:n,Vectorize(function(i,j)(-1)^(i+j)*det(A[-i,-j,drop=F]))))

यह एक बेतुका लंबा कार्य है जो कक्षा की एक वस्तु को स्वीकार करता matrixहै और इस तरह की दूसरी वस्तु लौटाता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

Ungolfed:

cofactor <- function(A) {
    # Get the number of rows (and columns, since A is guaranteed to
    # be square) of the input matrix A
    n <- NROW(A)

    # Define a function that accepts two indices i,j and returns the
    # i,j cofactor
    C <- function(i, j) {
        # Since R loves to drop things into lower dimensions whenever
        # possible, ensure that the minor obtained by column deletion
        # is still a matrix object by adding the drop = FALSE option
        a <- A[-i, -j, drop = FALSE]

        (-1)^(i+j) * det(a)
    }

    # Obtain the adjugate matrix by vectorizing the function C over
    # the indices of A
    adj <- outer(1:n, 1:n, Vectorize(C))

    # Transpose to obtain the cofactor matrix
    t(adj)
}

— एलेक्स ए।
स्रोत

केmapply बजाय 80 बाइट्स का उपयोग करें outerऔरVectorize

— Giuseppe

2

जीएपी , 246 बाइट्स

आप बता सकते हैं कि यह ट्रिपल नेस्टेड फॉर-लूप्स द्वारा अच्छा कोडिंग है।

यह बहुत सीधा है। जीएपी के पास वास्तव में मैट्रिस से निपटने के लिए समान उपकरण नहीं हैं जो अन्य गणित उन्मुख भाषाएं करते हैं। केवल एक चीज जो वास्तव में यहां उपयोग की जाती है, वह निर्धारक ऑपरेटर में निर्मित है।

f:=function(M)local A,B,i,j,v;A:=StructuralCopy(M);if not Size(M)=1 then for i in [1..Size(M)] do for j in [1..Size(M)] do B:=StructuralCopy(M);for v in B do Remove(v,j);od;Remove(B,i);A[i][j]:= (-1)^(i+j)*DeterminantMat(B);od;od;fi;Print(A);end;

ungolfed:

f:=function(M)
    local A,B,i,j,v;
    A:=StructuralCopy(M);
    if not Size(M)=1 then
        for i in [1..Size(M)] do
            for j in [1..Size(M)] do
                B:=StructuralCopy(M);
                for v in B do
                    Remove(v,j);
                od;
                Remove(B,i);
                 A[i][j]:= (-1)^(i+j)*DeterminantMat(B);
            od;
        od;
    fi;
    Print(A);
end;

— लियाम
स्रोत

1

वर्बोसिटी v2 , 196 बाइट्स

IncludeTypePackage<Matrix>
IncludeTypePackage<OutputSystem>
print=OutputSystem:NewOutput<DEFAULT>
input=Matrix:Adjugate<ARGV0>
input=Matrix:Transpose<input>
OutputSystem:DisplayAsText<print;input>

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

_{NB: वर्तमान में TIO पर काम नहीं करता है, एक पुल का इंतजार कर रहा है। ऑफ़लाइन काम करना चाहिए}

((a b)(c d))प्रतिनिधित्व करने के लिए फार्म में इनपुट लेता है

[\begin{matrix} ए ख \\ सी घ \end{matrix}]

$\bigg[ \begin{matrix} a \: b \\ c \: d \end{matrix} \bigg]$

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

— केर्ड सिक्काहिरिंग
स्रोत

कोफ़ेक्टर मैट्रिस