Inspiration.

Gegeben (mit allen Mitteln):

• Ein Zwei-Argument (oder einziges Argument , bestehend aus einer Zwei-Element - Liste) Blackbox - Funktion , (Eingang und Ausgang ist 1, 2, 3, ...)f: ℤ+ × ℤ+ → ℤ+
• Eine streng positive Ganzzahlmatrix mit mindestens zwei Zeilen und zwei Spalten

Gibt den Funktions-Trace der Matrix zurück .

Was ist ein Funktionsablauf ?

Eine normale Matrixkurve ist die Summe der Hauptdiagonalen (oben links bis unten rechts) einer Matrix:

[[1,2,3],[4,5,6],[7,8,9]]→ [1,5,9]→ 1+5+9→15

Aber anstatt zu summieren, wollen wir fentlang der Diagonale anwenden :

[[1,2,3],[4,5,6],[7,8,9]]→ [1,5,9]→ f(f(1,5),9)oderf(1,f(5,9))

Bitte geben Sie an, ob Sie von links nach rechts oder von rechts nach links arbeiten.

Die angegebene Matrix und alle Zwischenwerte sind ausschließlich positive Ganzzahlen innerhalb der Ganzzahldomäne Ihrer Sprache. Die Matrix kann nicht quadratisch sein.

Beispiele

f(x,y) = xy, [[1,2,3],[4,5,6],[7,8,9]]→ 1×5×9→45

f(x,y) = xy, [[1,2,3],[4,5,6],[7,8,9]]→ →1591

f(x,y) = x-y, [[4,5,6],[1,2,3]]→ 4-2→2

f(x,y) = (x+y)⁄2, [[2,3,4],[5,6,7],[8,9,10]]→ 5oder7

f(x,y) = x+2y, [[1,2,3],[4,5,6],[7,8,9]]→ 47oder29

f(x,y) = max(x,y), [[1,2,3],[4,5,6],[7,8,9]]→ max(1,5,9)→9

f(x,y) = 2x, [[1,2,3],[4,5,6],[7,8,9]]→ 2oder4

f(x,y) = lcm(x,y), [[2,2,2],[2,2,3],[2,3,3],[4,4,4]]→ lcm(2,2,3)→6

Referenzimplementierung.

R , 40-30 Bytes

function(m,F)Reduce(F,diag(m))

Probieren Sie es online!

Überprüfen Sie die Testfälle.

Fährt die Diagonale entlang, in diesem Fall also von links nach rechts. Für arithmetische Operatoren können Sie "+"oder Backticks um die Operatoren verwenden ( +,*,-,%/%,^,%%)

Ziemlich einfach: Reduceist R a entspricht fold, und die Diagonalen einer Matrix diejenigen Elemente , a_ijwo i==j, dh wo die rowund colUMN Indices gleich. diaghat das passende Verhalten für nicht quadratische Matrizen.

Haskell , 39 Bytes

Vielen Dank an @Laikoni für die Hilfe bei der Behebung der zuvor ungültigen Lösung!

f!m=foldl1 f[h|h:_<-zipWith drop[0..]m]

Associates auf der linken Seite, probieren Sie es online! (Ersetzen foldl1von foldr1für rechtsassoziativ)

Mathematica , 16 Bytes

-1 Byte dank Martin Ender.

#~Tr~Fold[g]@*0&

Probieren Sie es online!

Alternative Lösung, 17 Bytes

Fold[g]@*Diagonal

Probieren Sie es online!

Oktave , 61 57 53 Bytes

function m=g(f,m)for i=diag(m)'(2:end)m=f(m(1),i);end

Probieren Sie es online!

Definiert eine Funktion, gdie ein Funktionshandle fund eine Matrix übernimmt m. Gibt bei der ersten Iteration m(1)das Matrixelement oben links zurück. danach kehrt es einfach zurück m.

Sauber , 56 Bytes

t[[h:_]]f=h
t[[h]:_]f=h
t[[h:_]:r]f=f h(t[t\\[_:t]<-r]f)

Probieren Sie es online! Falten von rechts nach links.

[t\\[_:t]<-r]ist das gleiche wie map tl r, braucht aber nicht import StdEnv.

Haskell , 47 45 42 Bytes

f%((h:t):r)|[]<-t*>r=h|x<-tail<$>r=f h$f%x

Probieren Sie es online! Definiert eine Funktion, (%)die eine Funktion und eine Matrix als Liste von Listen als Eingabe annimmt.

Die Funktion ist von rechts nach links gefaltet:

f % [[1,2,3], -> f 1 ( f % [[5,6],   -> f 1 ( f 5 ( f % [[9]] ) ) -> f 1 ( f 5 ( f 9 ) ) )
     [4,5,6],               [8,9]] )
     [7,8,9]]

f % ((h:t):r)              -- (h:t) is the first row and r the remaining rows
 | [] <- t *> r = h         -- a shorter way of checking wether t==[] or r==[]
 | x<-tail<$>r = f h $ f%x -- apply f to h and the result of recursively calling (%) on
                           -- the remaining matrix with the first column removed

Edit: -2 Bytes dank BMO und -3 Bytes dank Zgarb !

APL (Dyalog Unicode) , 7 Bytes ( Adáms SBCS )

⎕/1 1⍉⎕

Probieren Sie es online!

-3 dank eines Vorschlags, dies von Adám in ein vollständiges Programm umzuwandeln .

Rechts nach links.

Haskell , 44 Bytes

f#m=foldl1 f$zipWith(!!)m[0..length(m!!0)-1]

Probieren Sie es online!

Standard-ML (MLton) , 59 Bytes

fun t[h::_]f=h|t([h]::_)f=h|t((h::_)::r)f=f(h,t(map tl r)f)

Probieren Sie es online! Falten von rechts nach links.

Ungolfed:

fun trace [h::_]      f = h
  | trace ([h]::_)    f = h
  | trace ((h::_)::r) f = f (h, trace (map tl r) f)

Probieren Sie es online!

Python 2 , 61 Bytes

lambda f,m:reduce(f,[l[i]for i,l in enumerate(m)if len(l)>i])

Probieren Sie es online!

Dies funktioniert von links nach rechts.

JavaScript (ES6), 58 56 Byte

g=(f,a,r=a[i=0][0],e=a[++i]&&a[i][i])=>e?g(f,a,f(r,e)):r

Falten von links nach rechts. Bearbeiten: 2 Bytes werden gespeichert, indem die Tatsache verwendet wird, dass das Array streng positiv ist. Alternative Lösung, auch 56 Bytes:

(f,a,g=r=>(e=a[++i]&&a[i][i])?g(f(r,e)):r)=>g(a[i=0][0])

JavaScript, 46 Bytes

f=>a=>a.reduce((p,l,i)=>l[i]?f(p[0]|p,l[i]):p)

Verwenden Sie dank @Shaggy bitweise oder speichern Sie ein Byte. Das ist Magie.

g = f=>a=>a.reduce((p,l,i)=>l[i]?f(p[0]|p,l[i]):p)

c=()=>o.value=g(eval(`(x,y)=>${f.value}`))(m.value.split(/\n/g).map(x=>x.trim().split(/\s+/).filter(v=>v.length).map(v=>+v)).filter(x=>x.length))

<p>a = <textarea id=m>1 2 3
4 5 6
7 8 9</textarea></p>
<p>f = (x, y) => <input id=f type=text value="x + y" /></p>
<p><button onclick=c()>Calc</button></p>
<p>Result = <output id=o></output></p>

Java 8, 88 81 70 Bytes

m->{int r=m[0][0],i=1;try{for(;;)r=f(r,m[i][i++]);}finally{return r;}}

Falten [[1,2,3],[4,5,6],[7,8,9]]zu f(f(1,5),9).

-7 Bytes indirekt dank @KamilDrakari mit einem ähnlichen Trick wie in seiner C # -Antwort : Anstatt eine maximale Grenze für die Schleife basierend auf den Zeilen / Spalten zu haben, versuchen Sie einfach, die zu fangen ArrayIndexOutOfBoundsException.
-11 Bytes ersetzen catch(Exception e)durch finally.

Probieren Sie es online aus.

Alte 88 Bytes Antwort:

m->{int r=m[0][0],i=1;for(;i<Math.min(m.length,m[0].length);)r=f(r,m[i][i++]);return r;}

Probieren Sie es online aus.

Erläuterung:

m->{                   // Method with integer-matrix parameter and integer return-type
  int r=m[0][0],       //  Start the result at the integer of position 0,0 (0-indexed)
      i=1;             //  Start the index at 1 (0-indexed)
  try{for(;;)          //  Loop indefinitely
    r=f(r,m[i][i++]);} //   Call f with the result + next diagonal cell as arguments
                       //   (and increase `i` by 1 with `i++` afterwards)
  finally{             //  If an ArrayIndexOutOfBoundsException occurred we're done,
   return r;}}         //   in which case we return the result-integer

Blackbox-Eingabeformat:

Nimmt an, dass eine benannte Funktion int f(int x,int y)vorhanden ist, die gemäß dieser Meta-Antwort zulässig ist .

Ich habe eine abstrakte Klasse, Testdie die Standardfunktion f(x,y)sowie das obige Lambda enthält:

abstract class Test{
  int f(int x,int y){
    return x+y;
  }

  public java.util.function.Function<int[][],Integer>c=
    m->{int r=m[0][0],i=1;for(;i<Math.min(m.length,m[0].length);)r=f(r,m[i][i++]);return r;}
  ;
}

Für die Testfälle überschreibe ich diese Funktion f. Zum Beispiel heißt der erste Testfall so:

System.out.println(new Test(){
  @Override
  int f(int x,int y){
    return x*y;
  }
}.c.apply(new int[][]{
  new int[]{1,2,3},
  new int[]{4,5,6},
  new int[]{7,8,9}
}));

Attache , 14 Bytes

Fold#/Diagonal

Probieren Sie es online! Festlegen auf fund anrufen als f[function, array].

Erläuterung

Dies ist eine Gabelung mit zwei Funktionen: Foldund /Diagonal. Dies ist für Argumente fund aäquivalent zu:

Fold[f, (/Diagonal)[f, a]]

/Bei monadischer Anwendung auf eine Funktion wird eine Funktion zurückgegeben, die auf ihr letztes Argument angewendet wird. Das entspricht also:

Fold[f, Diagonal[a]]

Dies faltet die Funktion füber die Hauptdiagonale von a.

AWK , 77 Bytes

func z(F,M,r){for(e=1;e<M[1]&&e<M[2];)r=@F(r==""?M[1,1]:r,M[++e,e])
return r}

Probieren Sie es online!

Ich war neugierig, ob AWKich überhaupt funktionale Programmierung machen kann. Ich denke das zählt.

Die "Matrix" ist als standardmäßiges assoziatives Array mit zusätzlichen Feldern M[1]=#rowsund definiert M[2]=#columns. Der Funktionsname wird als String übergeben, der über die @F(...)Syntax ausgewertet wird . Die Auswertung erfolgt von links nach rechts. Der rParameter ist ein Platzhalter, um das Überschreiben einer vorhandenen rVariablen und die Neuinitialisierung bei jedem Aufruf zu vermeiden. In der Regel wird zusätzlicher Speicherplatz hinzugefügt, um solche Platzhalter festzulegen. AWKDies ist jedoch Codegolf, sodass jedes Byte zählt. :)

Der TIO-Link implementiert alle Testfälle.

05AB1E , 15 10 Bytes

Falten von rechts nach links
Gespeicherte 5 Bytes mit einer neuen integrierten Funktion, wie von Kevin Cruijssen vorgeschlagen

Å\`[.g#I.V

Erläuterung

Funktioniert genauso wie die alte Version, mit der Ausnahme, dass Å\eine neue Funktion zum Drücken der Hauptdiagonale eingebaut ist.

Probieren Sie es online! oder als Test Suite

Alte Version

¬g£vyNè}[.g#I.V

Probieren Sie es online! oder als Testsuite

Erläuterung

¬                 # get the head of the input (first row)
 g                # get its length (number of columns)
  £               # take that many rows from input
   v              # for each row_index, row (N,y) do:
    y             # push the row
     Nè           # get the nth element of the row
       }          # end loop
        [.g#      # loop until one value remain on the stack
            I.V   # run the input function

Schale , 7 Bytes

Vielen Dank an @Zgarb für die Korrektur meiner Einsendung!

Ḟ₁§z!Tŀ

Associates auf der linken Seite, versuchen Sie es online! (für eine rechtsassoziative Version einfach ersetzen Ḟdurch F)

Erläuterung

Leider gibt es keine einfache Möglichkeit, die Diagonale einer Matrix zu ermitteln. Die meisten Bytes sind dafür:

Ḟ₁§z!Tŀ  -- function ₁ is the function and matrix A implicit, example: 
  §      -- fork A
     T   -- | transpose A: [[1,4,7],[2,5,8],[3,6,9]]
      ŀ  -- | enumerate A: [1,2,3]
   z!    -- and zipWith index: [1,5,9]
Ḟ₁       -- right fold function

SNOBOL4 (CSNOBOL4) , 86 Bytes

T	I =1
	T =M<1,1>
I	I =I + 1
	T =EVAL(F '(T,M<I,I>)')	:S(I)F(RETURN)
	DEFINE('T(M,F)')

Probieren Sie es online!

Definiert eine Funktion T(für TRACE), die eine ARRAYund eine Zeichenfolge akzeptiert F, die der Name einer Funktion ist. Falten von links nach rechts.

Die Verwendung von indirect reference ( $) funktioniert nicht mit Funktionen. Die Verwendung EVALund Übergabe eines Strings an den Namen scheint daher die einzige Möglichkeit zu sein, eine Black-Box-Funktion in SNOBOL zu erhalten.

Es ist auch ziemlich schmerzhaft, Arrays zu definieren. Da ungültige Array-Referenzen jedoch dazu führen FAILURE, funktioniert dies für nicht quadratische Arrays. Wenn Isie in einer der beiden Dimensionen außerhalb der Grenzen liegen, F(RETURN)wird die Funktion zur Rückgabe gezwungen.

Bearbeiten:

Möglicherweise kann ich aufgrund dieses Meta- Posts davon ausgehen, dass die Black-Box-Funktion Funter dem Namen definiert ist F, wodurch diese auf 75 Byte reduziert wird (Verwendung von EVALund ,Fin der Funktionsdefinition entfernen ). Ich bevorzuge diese Version jedoch, da sie näher an der Übergabe eines Verweises auf eine Funktion liegt.

C 76 Bytes

i,t;f(g,A,n,m)int*A,(*g)();{for(t=*A,i=m+1;--n*--m;t=g(t,*A))A+=i;return t;}

Links nach rechts.

Probieren Sie es online!

tinylisp , 79 bytes

(load library
(d D(q((M)(i(h M)(c(h(h M))(D(map t(t M))))(
(q((F M)(foldl F(D M

Die letzte Zeile ist eine unbenannte Lambda-Funktion, die eine Funktion und eine Matrix aufnimmt und den Matrix-Trace zurückgibt. Die Spur ist linksassoziativ (dh f(f(1,5),9)). Probieren Sie es online!

Ungolfed

Wir definieren eine Hilfsfunktion zur Berechnung der Diagonale; dann generalized-traceist nur ein kleiner Wrapper um die Bibliotheksfunktion foldl.

(load library)

(def diagonal
 (lambda (matrix)
  (if (head matrix)
   (cons
    (head (head matrix))
    (diagonal (map tail (tail matrix))))
   nil)))

(def generalized-trace
 (lambda (func matrix)
  (foldl func (diagonal matrix))))

Wenn wir die Diagonale rekursiv berechnen, prüfen wir, ob sie (head matrix)wahr ist. Wenn die Matrix keine Zeilen enthält, ist dies die leere Liste (nil) und headvon nil ist nil - falsey. Wenn die Matrix keine Spalten mehr enthält, ist die erste Zeile (Kopf) die leere Liste (Null) - Falsey. Andernfalls wird es eine nicht leere erste Zeile geben, was wahr ist.

Wenn also die erste Zeile nicht existiert oder leer ist, geben wir nil zurück. Andernfalls nehmen wir, wenn es eine nicht leere erste Zeile gibt, das (head (head matrix))erste Element der ersten Zeile und cons(stellen) es dem Ergebnis des rekursiven Aufrufs voran . Das Argument für den rekursiven Aufruf lautet (map tail (tail matrix))--das heißt, alle Zeilen bis auf die erste und alle bis auf das erste Element jeder Zeile.

Pari / GP , 42 Bytes

f->a->fold(f,[a[i,i]|i<-[1..min(#a,#a~)]])

Probieren Sie es online!

C # (Visual C # -Compiler) , 72 69 60 Byte

m=>{try{for(int i=1;;m[0][0]=f(m[0][0],m[i][i++]));}catch{}}

Probieren Sie es online!

try/catch Ermöglicht das korrekte Erreichen der Diagonale, indem Sie einfach daran entlang gehen und außerhalb der Grenzen enden.

3 Bytes gespart, weil, wie von Kevin Cruijssen hervorgehoben, angenommen werden kann , dass Black-Box-Funktionen unter einem bestimmten Namen existieren .

9 Bytes gespart durch Rückgabe durch Ändern eines Arguments .

Somit wird die Funktion aufgerufen, indem die gewünschte Funktion unter dem Namen f, dem Aufruf trace(matrix)und dem Ergebnis gespeichert wird matrix[0][0].

Alternativ, wenn Sie wirklich Ausführlichkeit mögen,

C # (Visual C # -Compiler) , 97 + 13 = 110 78 69 Byte

(int[][]m)=>{try{for(int i=1;;m[0][0]=f(m[0][0],m[i][i++]));}catch{}}

Probieren Sie es online!

32 Byte, die mit einer vordefinierten Funktion gespeichert wurden, da der SystemImport und der lange Funcgenerische Typ entfernt werden konnten, wenn die Funktion nicht als Parameter verwendet wurde.

JavaScript, 61 57 56 52 50 44 42 Bytes

Verkleinert von links nach rechts. Es wird davon ausgegangen, dass die Funktion der Variable zugewiesen ist f, wie in diesem Meta-Post beschrieben , auf den ich von Herrn Xcoder & Totalhuman aufmerksam gemacht wurde. Kann nicht sagen, da ich damit einverstanden bin, da dies unserem bestehenden Konsens direkt widerspricht, dass wir möglicherweise nicht davon ausgehen, dass die Eingabe einer vordefinierten Variablen zugewiesen ist, aber ich nehme die wenigen Bytes, die vorerst gespart werden.

a=>a.map((y,z)=>x=(n=y[z])?z?f(x,n):n:x)|x

Testfälle

g=
a=>a.map((y,z)=>x=(n=y[z])?z?f(x,n):n:x)|x
o.innerHTML=[[`f(x,y) = xy`,[[1,2,3],[4,5,6],[7,8,9]],(x,y)=>x*y,45],[`f(x,y) = x<sup>y</sup>`,[[1,2,3],[4,5,6],[7,8,9]],(x,y)=>x**y,1],[`f(x,y) = x-y`,[[4,5,6],[1,2,3]],(x,y)=>x-y,2],[`f(x,y) = <sup>(x+y)</sup>⁄<sub>2</sub>`,[[2,3,4],[5,6,7],[8,9,10]],(x,y)=>(x+y)/2,7],[`f(x,y) = x+2y`,[[1,2,3],[4,5,6],[7,8,9]],(x,y)=>x+2*y,29],[`f(x,y) = max(x,y)`,[[1,2,3],[4,5,6],[7,8,9]],(x,y)=>Math.max(x,y),9],[`f(x,y) = 2x`,[[1,2,3],[4,5,6],[7,8,9]],(x,y)=>2*x,4],[`f(x,y) = lcm(x,y)`,[[2,2,2],[2,2,3],[2,3,3],[4,4,4]],(x,y)=>-~[...Array(x*y).keys()].find(z=>!(++z%x|z%y)),6]].map(([a,b,c,d],e)=>`Test #${++e}:  ${a}\nMatrix:   ${JSON.stringify(b)}\nFunction: ${f=c}\nResult:   ${g(b)}\nExpected: ${d}`).join`\n\n`

<pre id=o></pre>

APL NARS, 20 Bytes, 10 Zeichen

{⍺⍺/1 1⍉⍵}

Prüfung:

  f←{⍺⍺/1 1⍉⍵}
  ⎕←q←3 3⍴⍳10    
1 2 3
4 5 6
7 8 9
  ×f q
45
  *f q
1
  {⍺+2×⍵}f q
47
  ⌈f q
9
  {2×⍺+0×⍵}f q
2
  -f ⊃(4 5 6)(1 2 3)
2
  {(⍺+⍵)÷2}f ⊃(2 3 4)(5 6 7)(8 9 10)
5
  ∧f ⊃(2 2 2)(2 2 3)(2 3 3)(4 4 4)
6

Gelee , 5 Bytes

Links nach rechts.

ŒDḢç/

Probieren Sie es online!

Haftungsausschluss: Ich weiß nicht, ob dies eine akzeptable Eingabemethode für Black-Box-Funktionen ist. Dies setzt voraus, dass die Funktion in dem obigen Link implementiert ist und daher "benannt" ist (das heißt, sie ist mit aufrufbar) ç, aber ansonsten habe ich keine Möglichkeit, sie zuzuweisen ç. Wenn jemand mehr Erfahrung mit Jelly + Blackbox-Funktionen hat, würde ich mich über Gedanken freuen. Nachdem wir einige Zeit im Chat verbracht hatten, stellten wir fest, dass die Verwendung çtatsächlich gültig sein könnte.

Clojure, 30 Bytes

#(reduce %2(map nth %(range)))

Verkleinert "von links".

Ruby , 55 53 Bytes

->f,m,n=m[i=0][0]{(k=m[i+=1]&.[]i)?(n=f[n,k];redo):n}

Probieren Sie es online!