İlham.

Verilen (herhangi bir şekilde):

• İki argüman (veya iki elemanlı listeden oluşan tek argüman) kara kutu işlevi , (giriş ve çıkış 1, 2, 3,…)f: ℤ+ × ℤ+ → ℤ+
• En az iki satır ve iki sütun içeren kesinlikle pozitif bir tam sayı matrisi

matrisin işlev izini döndür .

Bir nedir fonksiyon iz ?

Normal bir matris izi, bir matrisin ana köşegeninin (sol üstten sağ alt) toplamıdır:

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

Ancak toplama yerine f, köşegen boyunca uygulamak istiyoruz :

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

Lütfen soldan sağa mı yoksa sağdan sola mı kullandığınızı belirtin.

Verilen matris ve tüm ara değerler, dilinizin tamsayı alanı içinde kesinlikle pozitif tam sayılar olacaktır. Matris kare olmayabilir.

Örnekler

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]]→ 5veya7

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

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]]→ 2veya4

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

Referans uygulaması.

R , 40 30 bayt

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

Çevrimiçi deneyin!

Test durumlarını doğrulayın.

Köşegen aşağıya iner, bu durumda sola-sağa. Aritmetik operatörler için, "+"operatörleri ( +,*,-,%/%,^,%%) etrafında tekrar kullanabilir veya

Oldukça basit: ReduceR, eşdeğer bir olduğunu foldve bir matrisin köşegen bu unsurlar a_ijburada i==j, diğer bir deyişle rowve colindeksler UMN aynıdır. diagkare olmayan matrisler için uygun davranışa sahiptir.

Haskell , 39 bayt

Daha önce geçersiz olan çözümü düzeltmeme yardım ettiğiniz için teşekkürler @Likonik!

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

Sola ortak, çevrimiçi deneyin! (yerine foldl1göre foldr1sağ birleştirici için)

Mathematica , 16 bayt

Martin Ender sayesinde -1 bayt.

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

Çevrimiçi deneyin!

Alternatif çözüm, 17 bayt

Fold[g]@*Diagonal

Çevrimiçi deneyin!

Octave , 61 57 53 bayt

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

Çevrimiçi deneyin!

gBir işlev tanıtıcısı fve matrisi alan bir işlevi tanımlar m. İlk yinelemede, m(1)sol üst matris öğesini döndürür; Ondan sonra, sadece döner m.

Temiz , 56 bayt

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

Çevrimiçi deneyin! Sağdan sola kıvrılır.

[t\\[_:t]<-r]aynıdır map tl r, ancak buna gerek yoktur import StdEnv.

Haskell , 47 45 42 bayt

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

Çevrimiçi deneyin! (%)Bir fonksiyon ve bir matrisi alan bir fonksiyonu liste olarak girdi listesi olarak tanımlar .

Fonksiyon sağdan sola doğru kıvrılır:

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

Düzenleme: BMO sayesinde -2 bayt ve Zgarb sayesinde -3 bayt !

APL (Dyalog Unicode) , 7 bayt ( Adám's SBCS )

⎕/1 1⍉⎕

Çevrimiçi deneyin!

-3 Bunu, tam programa dönüştürmek için bir öneri bunu Adám .

Sağdan sola.

Haskell , 44 bayt

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

Çevrimiçi deneyin!

Standart ML (MLton) , 59 bayt

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

Çevrimiçi deneyin! Sağdan sola kıvrılır.

Ungolfed:

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

Çevrimiçi deneyin!

Python 2,61 bayt

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

Çevrimiçi deneyin!

Bu soldan sağa çalışıyor.

JavaScript (ES6), 58 56 bayt

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

Soldan sağa katlanır. Düzenleme: Dizi kesinlikle olumlu olduğu gerçeğini kullanarak 2 bayt kaydedildi. Alternatif çözüm, ayrıca 56 bayt:

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

JavaScript, 46 bayt

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

@Shaggy sayesinde, bitsel kullanın veya bir bayt kaydedin. Bu sihir.

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 bayt

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

Kıvrımlar [[1,2,3],[4,5,6],[7,8,9]]için f(f(1,5),9).

-7 byte dolaylı olarak @KamilDrakari sayesinde C # cevabında yaptığı gibi bir numara kullanarak : satırları / sütunları temel alan ilmek için maksimum bir sınır yerine, basitçe deneyin ArrayIndexOutOfBoundsException.
Değiştirilmesi -11 bayt catch(Exception e)ile finally.

Çevrimiçi deneyin.

Eski 88 baytlık cevap:

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

Çevrimiçi deneyin.

Açıklama:

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

Kara kutu giriş formatı:

Bu meta cevabına göreint f(int x,int y) izin verilen adlandırılmış bir fonksiyonun olduğunu varsayar. .

TestVarsayılan işlevi f(x,y)ve yukarıdaki lambda'yı içeren soyut bir sınıfım var :

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

Test durumları için bu fonksiyonun üzerine yazarım f. Örneğin, ilk test durumu şöyle denir:

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

Ataşesi , 14 bayt

Fold#/Diagonal

Çevrimiçi deneyin! Olarak ayarlayın fve arayın f[function, array].

açıklama

Bu iki işlevden oluşan bir çatal: Foldve /Diagonal. Bu, argümanlar için fve aeşdeğerdir:

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

/, bir fonksiyona tek taraflı olarak uygulandığında, son argümanına uygulanan bir fonksiyon döndürür. Yani, bu eşdeğerdir:

Fold[f, Diagonal[a]]

Bu, işlevi f, ana köşegenine katlar a.

AWK , 77 bayt

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}

Çevrimiçi deneyin!

Merak ettim eğer AWKİşlevsel programlama yapabilir . Bence bu önemli.

"Matrix", standart bir ilişkisel dizi olarak tanımlanmıştır, fazladan alanlar M[1]=#rowsve M[2]=#columns. İşlev adı, @F(...)sözdizimi aracılığıyla değerlendirilen bir dize olarak geçirilir . Değerlendirme soldan sağa yapılır. rParametresi varolan üzerine yazılmasını önlemek için bir yer tutucudur rdeğişken ve her çağrı için yeniden başlatmak ihtiyacını önlemek için. AWKBu tür yer tutucuları belirtmek için tipik olarak fazladan boşluk eklenir , ancak bu kod golf, yani her bayt sayılır. :)

TIO linki tüm test durumlarını uygular.

05AB1E , 15 10 bayt

Sağdan sola kıvrımlar Kevin Cruijssen
tarafından önerildiği gibi yeni bir yerleşik kullanarak 5 bayt kurtardı

Å\`[.g#I.V

açıklama

Å\Ana köşegeni itmek için yeni bir yerleşik olması dışında eski sürümle aynı şekilde çalışır .

Çevrimiçi deneyin! veya Test Paketi olarak

Eski versiyon

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

Çevrimiçi deneyin! veya Test paketi olarak

açıklama

¬                 # 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

Kabuğu , 7 bayt

Gönderimi düzelttiği için @ Zgarb'a teşekkürler!

Ḟ₁§z!Tŀ

Sola ortak, çevrimiçi deneyin! (sağ ilişkisel sürümü için basitçe yerine Ḟgöre F)

açıklama

Ne yazık ki, bir matrisin köşegenini elde etmenin kolay bir yolu yoktur, bu nedenle çoğu bayt bunun içindir:

Ḟ₁§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 bayt

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

Çevrimiçi deneyin!

Alan bir işlevi T(için TRACE) tanımlar.ARRAY ve bir dizeF that's the name of a function. Folds left-to-right.

Dolaylı reference ( $) kullanmak işlevlerle çalışmaz. Yani kullanarakEVAL and passing a string to the name seems to be the only way to get a black-box function in SNOBOL.

Ayrıca, dizileri tanımlamak oldukça acı vericidir; Ancak, geçersiz dizi başvuruları nedenFAILURE , kare olmayan diziler için işe yarar I- her iki boyutta da sınırlar dışındaysa, F(RETURN) forces the function to return.

Düzenle:

Muhtemelen, göre bu meta yazı , bir kara kutu işlevi olduğunu varsayalım Fadı altında tanımlandığı F75 bayt (kaldırılmasının kullanımı bu düşeceği, EVALve ,Fişlev tanımında). Ancak, bu fonksiyonu tercih ediyorum, çünkü bir fonksiyona referans vermek daha yakın.

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

Left-to-right.

Try it 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

The last line is an unnamed lambda function that takes a function and matrix and returns the matrix trace. The trace is left-associative (i.e. f(f(1,5),9)). Try it online!

Ungolfed

We define a helper function to compute the diagonal; then generalized-trace is merely a small wrapper around the library function 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))))

When computing the diagonal recursively, we check whether (head matrix) is truthy. If the matrix is out of rows, it will be the empty list (nil), and head of nil is nil--falsey. Or, if the matrix is out of columns, its first row (head) will be the empty list (nil)--falsey. Otherwise, there will be a nonempty first row, which is truthy.

So, if the first row doesn't exist or is empty, we return nil. Otherwise, if there is a nonempty first row, we take (head (head matrix))--the first element of the first row--and cons (prepend) it to the result of the recursive call. The argument to the recursive call is (map tail (tail matrix))--that is, take all rows but the first, and take all but the first element of each row.

Pari/GP, 42 bytes

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

Try it online!

C# (Visual C# Compiler), 72 69 60 bytes

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

Try it online!

try/catch allows the diagonal to be correctly reached by simply going along it and terminating when out of bounds.

3 bytes saved because, as pointed out by Kevin Cruijssen, black-box functions can be assumed to exist under a specific name.

9 bytes saved by returning via modifying an argument.

Thus, the function is called by storing the desired function under the name f, calling trace(matrix), and the result is stored in matrix[0][0].

Alternatively, if you really like verbosity,

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

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

Try it online!

32 bytes saved by using a predefined function, because not taking the function as a parameter allowed removing the System import and the long Func generic type.

JavaScript, 61 57 56 52 50 44 42 bytes

Reduces left to right. Assumes the function is assigned to variable f, as per this meta post brought to my attention by Mr. Xcoder & totallyhuman. Can't say as I agree with it as it directly contradicts our existing consensus that we may not assume input is assigned to a pre-defined variable, but I'll take the few bytes saving for now.

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

Test Cases

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 chars

{⍺⍺/1 1⍉⍵}

test:

  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

Jelly, 5 bytes

Left-to-right.

ŒDḢç/

Try it online!

Disclaimer: I do not know if this an acceptable input method for black-box functions. This assumes that the function is implemented in the link above, and is thus "named" (that is, it's callable with) ç, but otherwise I have no way to assign it to ç. If anyone has more experience with Jelly + black box functions, I would appreciate thoughts. After spending some time in chat, we figured that using ç might indeed be valid.

Clojure, 30 bytes

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

Reduces "from the left".

Ruby, 55 53 bytes

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

Try it online!