La matrice cofattore è la trasposizione della matrice adiugata . Gli elementi di questa matrice sono i cofattori della matrice originale.

Il cofattore (cioè l'elemento della matrice cofattore nella riga i e nella colonna j) è il determinante della sottostruttura formata eliminando l'ottava riga e la jesima colonna dalla matrice originale, moltiplicata per (-1) ^ (i + j).

Ad esempio, per la matrice

L'elemento della matrice cofattore nella riga 1 e nella colonna 2 è:

Puoi trovare informazioni su ciò che è determinante di una matrice e su come calcolarle qui .

Sfida

Il tuo obiettivo è produrre la matrice cofattore di una matrice di input.

Nota : sono consentiti incorporati che valutano matrici di cofattori o matrici corrugate, determinanti o simili .

Ingresso

La matrice può essere inserita come argomento della riga di comando, come parametro di funzione, in STDINo in qualsiasi modo più appropriato per la lingua utilizzata.

La matrice verrà formattata come un elenco di elenchi, ogni sottoelenco corrispondente a una riga, che contiene i fattori ordinati da sinistra a destra. Le righe sono ordinate dall'alto verso il basso nell'elenco.

Ad esempio, la matrice

a b
c d

sarà rappresentato da [[a,b],[c,d]].

Puoi sostituire le parentesi quadre e le virgole con qualcos'altro se si adatta alla tua lingua ed è ragionevole (ad es. ((a;b);(c;d)))

Le matrici conterranno solo numeri interi (che possono essere negativi) .

Le matrici saranno sempre quadrate (cioè lo stesso numero di righe e colonne).

Si può presumere che l'input sia sempre corretto (ovvero nessun problema di formattazione, nient'altro che numeri interi, nessuna matrice vuota).

Produzione

La matrice cofattore risultante può essere trasmessa a STDOUT , restituita da una funzione, scritta in un file o qualcosa di simile che si adatta naturalmente alla lingua che si utilizza.

La matrice cofattore deve essere formattata esattamente allo stesso modo delle matrici di input, ad es [[d,-c],[-b,a]]. Se leggi una stringa, devi restituire / generare una stringa in cui la matrice è formattata esattamente come nell'input. Se si utilizza qualcosa come ad esempio un elenco di elenchi come input, è necessario restituire anche un elenco di elenchi.

Casi test

• Ingresso: [[1]]

Produzione: [[1]]

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

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

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

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

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

Produzione:

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

punteggio

Questo è code-golf, quindi vince la risposta più breve in byte.

J, 29 byte

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

Stesso trucco epsilon / inverso / determinante. Da destra a sinistra:

• 1e_9+ aggiunge un epsilon,
• (-/ .**%.) è determinante ( -/ .*) volte inverso ( %.),
• |: traspone,
• <.0.5+ turni.

Matlab, 42 33 byte

Utilizzando una funzione anonima:

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

Input e output sono matrici (array numerici 2D).

epsviene aggiunto nel caso in cui la matrice sia singolare. Viene "rimosso" utilizzandoround (il risultato reale è garantito per essere un numero intero).

Esempio:

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

Esempio con matrice singolare:

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

Oppure provalo online in Octave.

Mathematica, 27 35 byte

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

R, 121 94 byte

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

Questa è una funzione assurdamente lunga che accetta un oggetto di classe matrixe restituisce un altro oggetto del genere. Per chiamarlo, assegnarlo a una variabile.

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 byte

Si può dire che questa è una buona codifica da parte dei tripli cicli nidificati.

È abbastanza semplice. GAP non ha davvero gli stessi strumenti per gestire le matrici di altre lingue orientate alla matematica. L'unica cosa veramente usata qui è l'operatore determinante incorporato.

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;

Verbosity v2 , 196 byte

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

Provalo online!

_{NB: Al momento non funziona su TIO, in attesa di un pull. Dovrebbe funzionare offline}

Accetta input nel modulo ((a b)(c d))per rappresentare

Nonostante abbia un built-in per l'aggiustato, la verbosità di Verbosity lo paralizza ancora. Abbastanza semplice come funziona, traspone semplicemente l'aggiustato dell'input.