Matryca kofaktora jest transpozycją macierzy adiuwatu . Elementy tej matrycy są kofaktorami oryginalnej matrycy.

Kofaktor (tj. Element macierzy kofaktora w rzędzie i i kolumnie j) jest wyznacznikiem submatrix utworzonej przez usunięcie i-tego rzędu i j-tej kolumny z oryginalnej macierzy, pomnożonej przez (-1) ^ (i + j).

Na przykład dla matrycy

Element macierzy kofaktora w wierszu 1 i kolumnie 2 to:

Informacje na temat wyznacznika macierzy i sposobu ich obliczania można znaleźć tutaj .

Wyzwanie

Twoim celem jest wyprowadzenie macierzy kofaktora macierzy wejściowej.

Uwaga : Dozwolone są wbudowane, które oceniają matryce kofaktorów lub macierze przyległe, wyznaczniki lub cokolwiek podobnego .

Wejście

Macierz może być wprowadzona jako argument wiersza poleceń, jako parametr funkcji, STDINw dowolny sposób lub w sposób najbardziej odpowiedni dla używanego języka.

Macierz zostanie sformatowana jako lista list, a każda lista podrzędna odpowiada jednemu wierszowi, który zawiera czynniki uporządkowane od lewej do prawej. Rzędy są uporządkowane od góry do dołu na liście.

Na przykład macierz

a b
c d

będzie reprezentowany przez [[a,b],[c,d]].

Możesz zamienić nawiasy kwadratowe i przecinki na coś innego, jeśli pasuje do twojego języka i jest sensowny (np. ((a;b);(c;d)))

Macierze będą zawierać tylko liczby całkowite (które mogą być ujemne) .

Macierze zawsze będą kwadratowe (tj. Ta sama liczba wierszy i kolumn).

Możesz założyć, że dane wejściowe zawsze będą poprawne (tj. Nie będzie problemu z formatowaniem, nic poza liczbami całkowitymi, brak pustej macierzy).

Wynik

Otrzymana macierz kofaktora może zostać wyprowadzona STDOUT, zwrócona z funkcji, zapisana do pliku lub w dowolny podobny sposób, który naturalnie pasuje do używanego języka.

Macierz kofaktora należy sformatować dokładnie w taki sam sposób, jak podane są macierze wejściowe, np [[d,-c],[-b,a]]. Jeśli czytasz ciąg, musisz zwrócić / wyprowadzić ciąg, w którym macierz jest sformatowana dokładnie tak, jak na wejściu. Jeśli używasz czegoś takiego jak np. Lista list jako danych wejściowych, musisz również zwrócić listę list.

Przypadki testowe

• Wejście: [[1]]

Wynik: [[1]]

• Wejście: [[1,2],[3,4]]

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

• Wejście: [[-3,2,-5],[-1,0,-2],[3,-4,1]]

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

• Wejście: [[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]]

Wynik:

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

Punktacja

To jest golf golfowy, więc wygrywa najkrótsza odpowiedź w bajtach.

J, 29 bajtów

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

Ta sama sztuczka epsilon / inverse / determinant. Z prawej do lewej:

• 1e_9+ dodaje epsilon,
• (-/ .**%.)jest wyznacznikiem ( -/ .*) razy inverse ( %.),
• |: transponuje,
• <.0.5+ rundy.

Matlab, 42 33 bajty

Korzystanie z anonimowej funkcji:

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

Dane wejściowe i wyjściowe są macierzami (tablice numeryczne 2D).

epsjest dodawany w przypadku, gdy macierz jest pojedyncza. Jest „usuwany” za pomocą round(z pewnością prawdziwy wynik jest liczbą całkowitą).

Przykład:

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

Przykład z macierzą pojedynczą:

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

Lub wypróbuj online w Octave.

Mathematica, 27 35 bajtów

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

R, 121 94 bajtów

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

Jest to absurdalnie długa funkcja, która przyjmuje obiekt klasy matrixi zwraca inny taki obiekt. Aby go wywołać, przypisz go do zmiennej.

Nie golfowany:

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 bajtów

Możesz powiedzieć, że jest to dobre kodowanie dzięki potrójnie zagnieżdżonym pętlom for.

To całkiem proste. GAP nie ma tak naprawdę takich samych narzędzi do radzenia sobie z macierzami, jakie mają inne języki zorientowane na matematykę. Jedyne, co tak naprawdę tutaj zastosowano, to wbudowany operator wyznacznika.

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;

bez golfa:

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;

Verbosity v2 , 196 bajtów

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

Wypróbuj online!

_{Uwaga: obecnie nie działa w TIO, oczekuje na ściągnięcie. Powinien działać w trybie offline}

Pobiera dane wejściowe w formularzu ((a b)(c d))do przedstawienia

Pomimo posiadania wbudowanej funkcji dla jednostki zależnej, gadatliwość wciąż ją osłabia. Dość podstawowe, jak to działa, po prostu transponuje odpowiednik wejścia.