La matrice cofactorielle est la transposition de la matrice adjointe . Les éléments de cette matrice sont les cofacteurs de la matrice d'origine.

Le cofacteur (c'est-à-dire l'élément de la matrice du cofacteur à la ligne i et à la colonne j) est le déterminant de la sous-matrice formée en supprimant la ième ligne et la jième colonne de la matrice d'origine, multipliée par (-1) ^ (i + j).

Par exemple, pour la matrice

L'élément de la matrice du cofacteur à la ligne 1 et à la colonne 2 est:

Vous pouvez trouver des informations sur le déterminant d'une matrice et comment les calculer ici .

Défi

Votre objectif est de sortir la matrice de cofacteur d'une matrice d'entrée.

Remarque : Les éléments intégrés qui évaluent les matrices de cofacteurs, ou les matrices d'ajustement, ou les déterminants ou quelque chose de similaire sont autorisés .

Contribution

La matrice peut être entrée comme argument de ligne de commande, comme paramètre de fonction, dans STDINou de la manière la plus appropriée pour le langage que vous utilisez.

La matrice sera formatée comme une liste de listes, chaque sous-liste correspondant à une ligne, qui contient des facteurs ordonnés de gauche à droite. Les lignes sont classées de haut en bas dans la liste.

Par exemple, la matrice

a b
c d

sera représenté par [[a,b],[c,d]].

Vous pouvez remplacer les crochets et les virgules par autre chose si cela correspond à votre langue et est raisonnable (par exemple ((a;b);(c;d)))

Les matrices ne contiendront que des entiers (qui peuvent être négatifs) .

Les matrices seront toujours carrées (c'est-à-dire le même nombre de lignes et de colonnes).

Vous pouvez supposer que l'entrée sera toujours correcte (c'est-à-dire pas de problème de formatage, rien d'autre que des entiers, pas de matrice vide).

Production

La matrice de cofacteur résultante peut être sortie STDOUT, renvoyée par une fonction, écrite dans un fichier ou tout autre élément similaire qui convient naturellement à la langue que vous utilisez.

La matrice du cofacteur doit être formatée exactement de la même manière que les matrices d'entrée sont données, par exemple [[d,-c],[-b,a]]. Si vous lisez une chaîne, vous devez retourner / sortir une chaîne dans laquelle la matrice est formatée exactement comme dans l'entrée. Si vous utilisez par exemple une liste de listes comme entrée, vous devez également renvoyer une liste de listes.

Cas de test

• Contribution: [[1]]

Production: [[1]]

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

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

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

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

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

Production:

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

Notation

Il s'agit de code-golf, donc la réponse la plus courte en octets l'emporte.

J, 29 octets

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

Même astuce epsilon / inverse / déterminant. De droite à gauche:

• 1e_9+ ajoute un epsilon,
• (-/ .**%.)est déterminant ( -/ .*) fois inverse ( %.),
• |: transpose,
• <.0.5+ Les manches.

Matlab, 42 33 octets

Utilisation d'une fonction anonyme:

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

L'entrée et la sortie sont des matrices (tableaux numériques 2D).

epsest ajouté au cas où la matrice est singulière. Il est "supprimé" en utilisant round(le vrai résultat est garanti être un entier).

Exemple:

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

Exemple avec matrice singulière:

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

Ou essayez-le en ligne dans Octave.

Mathematica, 27 35 octets

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

R, 121 94 octets

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

Il s'agit d'une fonction absurdement longue qui accepte un objet de classe matrixet renvoie un autre de ces objets. Pour l'appeler, affectez-le à une variable.

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

GAP , 246 octets

Vous pouvez dire que c'est un bon codage par les boucles for imbriquées triples.

C'est assez simple. GAP n'a pas vraiment les mêmes outils pour gérer les matrices que les autres langages orientés mathématiques. La seule chose vraiment utilisée ici est l'opérateur de déterminant intégré.

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;

non 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;

Verbosité v2 , 196 octets

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

Essayez-le en ligne!

_{NB: ne fonctionne pas actuellement sur TIO, en attente d'un pull. Devrait fonctionner hors ligne}

Prend une entrée dans le formulaire ((a b)(c d))pour représenter

En dépit d'avoir une fonction intégrée pour l'adjugate, la verbosité de Verbosity le paralyse toujours. Fonctionnement assez basique, transpose simplement l'adjugate de l'entrée.