La matriz de cofactor es la transposición de la matriz adjugada . Los elementos de esta matriz son los cofactores de la matriz original.

El cofactor (es decir, el elemento de la matriz de cofactor en la fila i y la columna j) es el determinante de la submatriz formada al eliminar la i-ésima fila y la columna jth de la matriz original, multiplicada por (-1) ^ (i + j).

Por ejemplo, para la matriz

El elemento de la matriz de cofactores en la fila 1 y la columna 2 es:

Puede encontrar información sobre cuál es el determinante de una matriz y cómo calcularlos aquí .

Desafío

Su objetivo es generar la matriz de cofactor de una matriz de entrada.

Nota : Están permitidos los elementos integrados que evalúan las matrices de cofactores, o las matrices adyuvantes, o los determinantes o cualquier cosa similar .

Entrada

La matriz se puede incorporar como un argumento de línea de comando, como un parámetro de función, de la STDINmanera más apropiada para el idioma que utilice.

La matriz se formateará como una lista de listas, cada sublista correspondiente a una fila, que contiene factores ordenados de izquierda a derecha. Las filas se ordenan de arriba a abajo en la lista.

Por ejemplo, la matriz

a b
c d

será representado por [[a,b],[c,d]].

Puede reemplazar los corchetes y las comas con algo más si se ajusta a su idioma y es razonable (por ejemplo ((a;b);(c;d)))

Las matrices solo contendrán enteros (que pueden ser negativos) .

Las matrices siempre serán cuadradas (es decir, el mismo número de filas y columnas).

Puede suponer que la entrada siempre será correcta (es decir, sin problemas de formato, nada más que enteros, sin matriz vacía).

Salida

La matriz de cofactor resultante puede ser expulsada STDOUT, devuelta desde una función, escrita en un archivo o algo similar que naturalmente se adapte al lenguaje que utiliza.

La matriz de cofactor debe formatearse exactamente de la misma manera que se dan las matrices de entrada, por ejemplo [[d,-c],[-b,a]]. Si lee una cadena, debe devolver / generar una cadena en la que la matriz esté formateada exactamente como en la entrada. Si utiliza algo como, por ejemplo, una lista de listas como entrada, también debe devolver una lista de listas.

Casos de prueba

• Entrada: [[1]]

Salida: [[1]]

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

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

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

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

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

Salida:

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

Puntuación

Este es el código de golf, por lo que gana la respuesta más corta en bytes.

J, 29 bytes

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

El mismo truco épsilon / inverso / determinante. De derecha a izquierda:

• 1e_9+ agrega un épsilon,
• (-/ .**%.)es determinante ( -/ .*) veces inverso ( %.),
• |: transpone,
• <.0.5+ rondas

Matlab, 42 33 bytes

Usando una función anónima:

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

La entrada y la salida son matrices (matrices numéricas 2D).

epsse agrega en caso de que la matriz sea singular. Se "elimina" usandoround (se garantiza que el verdadero resultado sea un entero).

Ejemplo:

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

Ejemplo con matriz singular:

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

O pruébelo en línea en 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]))))

Esta es una función absurdamente larga que acepta un objeto de clase. matrix y devuelve otro objeto. Para llamarlo, asígnelo a una variable.

Sin golf:

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

BRECHA , 246 bytes

Se puede decir que esta es una buena codificación por los bucles for anidados triples.

Es bastante sencillo. GAP realmente no tiene las mismas herramientas para manejar matrices que otros lenguajes orientados a las matemáticas. Lo único que realmente se usa aquí es el operador determinante incorporado.

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;

sin golf:

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;

Verbosidad v2 , 196 bytes

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

Pruébalo en línea!

_{NB: Actualmente no funciona en TIO, a la espera de un tirón. Debería funcionar sin conexión}

Toma entrada en el formulario ((a b)(c d))para representar

A pesar de tener un incorporado para el adyuvante, la verbosidad de Verbosity todavía lo paraliza. Bastante básico de cómo funciona, solo transpone el adjunto de la entrada.