Die Cofaktormatrix ist die Transponierte der Adjugatmatrix . Die Elemente dieser Matrix sind die Cofaktoren der ursprünglichen Matrix.

Der Cofaktor (dh das Element der Cofaktormatrix in Zeile i und Spalte j) ist die Determinante der Submatrix, die durch Löschen der i-ten Zeile und j-ten Spalte aus der ursprünglichen Matrix gebildet wird, multipliziert mit (-1) ^ (i + j).

Zum Beispiel für die Matrix

Das Element der Cofaktormatrix in Zeile 1 und Spalte 2 ist:

Informationen zur Determinante einer Matrix und zu deren Berechnung finden Sie hier .

Herausforderung

Ihr Ziel ist es, die Cofaktormatrix einer Eingabematrix auszugeben.

Hinweis : Es sind integrierte Funktionen zulässig , die Cofaktormatrizen oder adjugierte Matrizen oder Determinanten oder ähnliches auswerten .

Eingang

Die Matrix kann als Befehlszeilenargument, als Funktionsparameter STDINoder auf eine Weise eingegeben werden, die für die von Ihnen verwendete Sprache am besten geeignet ist.

Die Matrix wird als Liste von Listen formatiert, wobei jede Unterliste einer Zeile entspricht, die die von links nach rechts geordneten Faktoren enthält. Die Zeilen werden in der Liste von oben nach unten sortiert.

Zum Beispiel die Matrix

a b
c d

wird vertreten durch [[a,b],[c,d]].

Sie können die eckigen Klammern und Kommas durch etwas anderes ersetzen, wenn es zu Ihrer Sprache passt und sinnvoll ist (z. B. ((a;b);(c;d))).

Matrizen enthalten nur Ganzzahlen (die negativ sein können) .

Matrizen sind immer quadratisch (dh die gleiche Anzahl von Zeilen und Spalten).

Sie können davon ausgehen, dass die Eingabe immer korrekt ist (dh kein Formatierungsproblem, nichts anderes als Ganzzahlen, keine leere Matrix).

Ausgabe

Die resultierende Cofaktormatrix kann ausgegeben STDOUT, von einer Funktion zurückgegeben, in eine Datei geschrieben oder in eine ähnliche Form gebracht werden , die der von Ihnen verwendeten Sprache entspricht.

Die Cofaktormatrix muss genauso formatiert sein, wie die Eingabematrizen angegeben sind, z [[d,-c],[-b,a]]. Wenn Sie eine Zeichenfolge lesen, müssen Sie eine Zeichenfolge zurückgeben / ausgeben, in der die Matrix genau wie in der Eingabe formatiert ist. Wenn Sie beispielsweise eine Liste von Listen als Eingabe verwenden, müssen Sie auch eine Liste von Listen zurückgeben.

Testfälle

• Eingang: [[1]]

Ausgabe: [[1]]

• Eingang: [[1,2],[3,4]]

Ausgabe: [[4,-3],[-2,1]]

• Eingang: [[-3,2,-5],[-1,0,-2],[3,-4,1]]

Ausgabe: [[-8,-5,4],[18,12,-6],[-4,-1,2]]

• Eingang: [[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]]

Ausgabe:

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

Wertung

Das ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes.

J, 29 Bytes

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

Gleicher epsilon / inverser / determinanter Trick. Von rechts nach links:

• 1e_9+ fügt ein epsilon hinzu,
• (-/ .**%.)ist determinant ( -/ .*) mal invers ( %.),
• |: transponiert,
• <.0.5+ Runden.

Matlab, 42 33 Bytes

Verwenden einer anonymen Funktion:

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

Eingabe und Ausgabe sind Matrizen (numerische 2D-Arrays).

epswird hinzugefügt, falls die Matrix singulär ist. Es wird mit "entfernt" round(das wahre Ergebnis ist garantiert eine ganze Zahl).

Beispiel:

>> @(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

Beispiel mit singulärer Matrix:

>> @(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

Oder versuchen Sie es online in Octave.

Mathematica, 27 35 Bytes

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

R 121 94 Bytes

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

Dies ist eine absurd lange Funktion, die ein Objekt der Klasse akzeptiert matrixund ein anderes solches Objekt zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

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)
}

GAP , 246 Bytes

Sie erkennen dies an den dreifach verschachtelten for-Schleifen.

Es ist ziemlich einfach. GAP verfügt nicht über die gleichen Tools für den Umgang mit Matrizen wie andere mathematisch orientierte Sprachen. Das einzige, was hier wirklich verwendet wird, ist der eingebaute Determinantenoperator.

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;

Ausführlichkeit v2 , 196 Bytes

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

Probieren Sie es online!

_{NB: Funktioniert derzeit nicht mit TIO, wartet auf einen Pull. Sollte offline funktionieren}

Nimmt Eingaben in das Formular ((a b)(c d))zur Darstellung

Obwohl für das Adjugat eine Funktion eingebaut ist, wird es durch die Ausführlichkeit von Verbosity immer noch lahmgelegt. Ziemlich einfach, wie es funktioniert, transponiert nur das Adjugat der Eingabe.