Problem

Erstellen Sie ein Programm oder eine Funktion, die das Ergebnis einer auf die n- ^te Potenz angehobenen Matrix berechnen kann . Ihr Code nimmt eine beliebige quadratische Matrix A und eine nicht negative ganze Zahl n und gibt eine Matrix mit dem Wert A ^{n zurück} .

Beschränkungen

Integrierte Funktionen, die die Matrixleistung und das Matrixprodukt berechnen, sind nicht zulässig.

Es gelten die übrigen Standardregeln für Code-Golf.

Erläuterung

Bei gegebener quadratischer Matrix A ist der Wert von A ⁿ = AA ⋯ A (wiederholtes Matrixprodukt von A mit sich selbst, n- mal). Wenn n positiv ist, wird der gerade erwähnte Standard verwendet. Wenn n Null ist, ist die Identitätsmatrix mit der gleichen Ordnung von A das Ergebnis.

Tor

Dies ist Code-Golf und der kürzeste Code gewinnt.

Testfälle

Hier ist A die Eingabematrix, n ist die Eingabe-Ganzzahl und r ist die Ausgabematrix mit r = A ⁿ .

n = 0
A = 62 72
    10 34
r =  1  0
     0  1

n = 1
A = 23 61 47
    81 11 60
    42  9  0
r = 23 61 47
    81 11 60
    42  9  0

n = 2
A =  12  28 -26  3
     -3 -10 -13  0
     25  41   3 -4
    -20 -14  -4 29
r = -650 -1052  -766 227
    -331  -517   169  43
     332   469 -1158 -53
    -878  -990   574 797

n = 4
A = -42 -19  18 -38
    -33  26 -13  31
    -43  25 -48  28
     34 -26  19 -48
r = -14606833  3168904 -6745178  4491946
      1559282  3713073 -4130758  7251116
      8097114  5970846 -5242241 12543582
     -5844034 -4491274  4274336 -9196467

n = 5
A =  7  0 -3  8 -5  6 -6
     6  7  1  2  6 -3  2
     7  8  0  0 -8  5  2
     3  0  1  2  4 -3  4
     2  4 -1 -7 -4 -1 -8
    -3  8 -9 -2  7 -4 -8
    -4 -5 -1  0  5  5 -1
r =  39557  24398 -75256 131769  50575   14153  -7324
    182127  19109   3586 115176 -23305    9493 -44754
    146840  31906 -23476 190418 -38946   65494  26468
     42010 -21876  41060 -13950 -55148   19290   -406
     44130  34244 -35944  34272  22917  -39987 -54864
      1111  40810 -92324  35831 215711 -117849 -75038
    -70219   8803 -61496   6116  45247   50166   2109

Gelee , 17 16 15 Bytes

Z×'³S€€
LṬ€z0Ç¡

Probieren Sie es online aus!

Permalinks mit Gitterausgabe: Testfall 1 | Testfall 2 | Testfall 3 | Testfall 4 | Testfall 5

Wie es funktioniert

LṬ€z0Ç¡  Main link. Arguments: A (matrix), n (power)

L        Get the length l of A.
 Ṭ€      Turn each k in [1, ..., l] into a Boolean list [0, 0, ..., 1] of length k.
   z0    Zip; transpose the resulting 2D list, padding with 0 for rectangularity.
         This constructs the identity matrix of dimensions k×k.
     Ç¡  Execute the helper link n times.

Z×'³S€€  Helper link. Argument: B (matrix)

Z        Zip; transpose rows and columns of B.
   ³     Yield A.
 ×'      Spawned multiplication; element-wise mutiply each rows of zipped B (i.e.,
         each column of B) with each row of A.
         This is "backwards", but multiplication of powers of A is commutative.
    S€€  Compute the sum of each product of rows.

MATL , 20 Bytes

XJZyXyi:"!J2$1!*s1$e

Probieren Sie es online aus!

Erläuterung

Dies vermeidet die Matrixmultiplikation, indem sie manuell durchgeführt wird, wobei eine elementweise Multiplikation mit Broadcast gefolgt von einer vektorisierten Summe verwendet wird. Insbesondere zum Multiplizieren von Matrizen Mund Nbeiden der Größe s × s :

1. Transponieren M. Rufen Sie die resultierende Matrix auf P.
2. Permutieren Sie die Abmessungen von Nsolchen, die Nmit einer Rotationsachse entlang der ersten Dimension "gedreht" werden, und geben Sie beispielsweise ein s × 1 × s 3D-Array an Q.
3. Multiplizieren Sie jedes Element mit Pjedem Element von Qmit impliziter Übertragung. Dies bedeutet, dass Pautomatisch s- mal entlang der dritten Dimension und s- mal entlang der zweiten Dimension Qrepliziert wird, um beide s × s × s zu machen , bevor die eigentliche elementweise Multiplikation stattfindet.
4. Summiere entlang der ersten Dimension, um ein 1 × s × s- Array zu erhalten.
5. Drücken Sie die führende Singleton-Dimension heraus, um ein s × s- Ergebnis zu erhalten.

Kommentierter Code:

XJ      % take matrix A. Copy to clipboard J
ZyXy    % generate identity matrix of the same size
i:      % take exponent n. Generate range [1 2 ... n] (possibly empty)
"       % for each element in that range
  !     %   transpose matrix with product accumulated up to now (this is step 1)
  J     %   paste A
  2$1!  %   permute dimensions: rotation along first-dimension axis (step 2)
  *     %   element-wise multiplication with broadcast (step 3)
  s     %   sum along first dimension (step 4)
  1$e   %   squeeze out singleton dimension, i.e. first dimension (step 5)
        % end for. Display

APL, 32 31 Zeichen

{⍺=0:(⍴⍵)⍴1⍨1+≢⍵⋄+.×⍨⍣(⍺-1)⊣⍵}

Linkes Argument die Macht zu erheben, rechtes Argument die Matrix. Das schwierigste (platzsparendste) Bit ist das Erstellen der Identitätsmatrix für den Fall, dass der gewünschte Exponent 0 ist. Die tatsächliche Berechnung basiert auf der Tatsache, dass das verallgemeinerte innere Produkt ( .) mit +und ×als Operanden effektiv das Matrixprodukt ist. Dies bildet zusammen mit dem Power ⍣Operator ("Repeat") das Fleisch der Lösung.

Salbei, 112 Bytes

lambda A,n:reduce(lambda A,B:[[sum(map(mul,zip(a,b)))for b in zip(*B)]for a in A],[A]*n,identity_matrix(len(A)))

Probieren Sie es online aus

Erläuterung:

Das innere Lambda ( lambda A,B:[[sum(map(mul,zip(a,b)))for b in zip(*B)]for a in A]) ist eine einfache Implementierung der Matrixmultiplikation. Das äußere Lambda ( lambda A,n:reduce(...,[A]*n,identity_matrix(len(A)))) reduceberechnet die Matrixleistung durch iterierte Matrixmultiplikation (unter Verwendung der oben genannten hausgemachten Matrixmultiplikationsfunktion), wobei die Identitätsmatrix als zu unterstützender Anfangswert verwendet wird n=0.

Julia, 90 86 68 Bytes

f(A,n)=n<1?eye(A):[A[i,:][:]⋅f(A,n-1)[:,j]for i=m=1:size(A,1),j=m]

Dies ist eine rekursive Funktion, die eine Matrix ( Array{Int,2}) und eine Ganzzahl akzeptiert und eine Matrix zurückgibt.

Ungolfed:

function f(A, n)
    if n < 1
        # Identity matrix with the same type and dimensions as the input
        eye(A)
    else
        # Compute the dot product of the ith row of A and the jth column
        # of f called on A with n decremented
        [dot(A[i,:][:], f(A, n-1)[:,j]) for i = (m = 1:size(A,1)), j = m]
    end
end

Probieren Sie es online aus! (Beinhaltet alle bis auf den letzten Testfall, der für die Site zu langsam ist)

18 Bytes dank Dennis gespart!

Python 2.7, 158 145 Bytes

Die schlechteste Antwort hier, aber mein bisher bestes Golf in Python. Zumindest hat es Spaß gemacht zu lernen, wie man Matrixmultiplikation macht.

Golf:

def q(m,p):
 r=range(len(m))
 if p<1:return[[x==y for x in r]for y in r]
 o=q(m,p-1)
 return[[sum([m[c][y]*o[x][c]for c in r])for y in r]for x in r]

Erläuterung:

#accepts 2 arguments, matrix, and power to raise to
def power(matrix,exponent):
 #get the range object beforehand
 length=range(len(matrix))
 #if we are at 0, return the identity
 if exponent<1:
  #the Boolean statement works because Python supports multiplying ints by bools
  return [[x==y for x in length] for y in length]
 #otherwise, recur
 lower=power(matrix,exponent-1)
 #and return the product
 return [[sum([matrix[c][y]*lower[x][c] for c in length]) for y in length] for x in length]

JavaScript (ES6), 123 Byte

(n,a)=>[...Array(n)].map(_=>r=m(i=>m(j=>m(k=>s+=a[i][k]*r[k][j],s=0)&&s)),m=g=>a.map((_,n)=>g(n)),r=m(i=>m(j=>+!(i^j))))&&r

Ich hatte eine 132-Byte-Version mit, reduceaber ich habe nur aso oft zugeordnet, dass es 9 Bytes kürzer war, eine Hilfsfunktion zu schreiben, um dies für mich zu tun. Funktioniert, indem die Identitätsmatrix erstellt und mit alangen nZeiten multipliziert wird . Es gibt eine Reihe von Ausdrücken, die zurückgeben 0oder 1für, i == jaber alle scheinen 7 Bytes lang zu sein.

Python 3 , 147 Bytes

def f(a,n):
 r=range(len(a));r=[[i==j for j in r]for i in r]
 for i in range(n):r=[[sum(map(int.__mul__,x,y))for y in zip(*a)]for x in r]
 return r

Probieren Sie es online aus!

R, 49 Bytes

f=function(m,n)`if`(n,m%*%f(m,n-1),diag(nrow(m)))

Rekursive Funktion, die eine mAtrix und die Kraft benötigt n, sie zu erhöhen. Rekursive Aufrufe %*%, die das Punktprodukt berechnen. Der Anfangswert für die Rekursion ist die Identitätsmatrix mit der gleichen Größe wie m. Da m %*% m = m %*% m %*% Ifunktioniert das ganz gut.

Python 2 , 131 Bytes

f=lambda M,n:n and[[sum(map(int.__mul__,r,c))for c in zip(*f(M,n-1))]for r in M]or[[0]*i+[1]+[0]*(len(M)+~i)for i in range(len(M))]

Probieren Sie es online aus!