Натхнення.

Дано (будь-якими способами):

• Двоаргумент (або один аргумент, що складається з двоелементного списку) функція чорного поля , (вхід і вихід - 1, 2, 3,…)f: ℤ+ × ℤ+ → ℤ+
• Суворопозитивна ціла матриця з принаймні двома рядками та двома стовпцями

повернути слід функції матриці .

Що таке слід функцій ?

Нормальний матричний слід - це сума основної діагоналі (зверху ліворуч донизу праворуч) матриці:

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

Але замість підсумовування ми хочемо застосувати fпо діагоналі:

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

Будь ласка, вкажіть, чи використовуєте ви зліва направо чи справа наліво.

Дана матриця та всі проміжні значення будуть суто позитивними цілими числами в цілому домені вашої мови. Матриця може бути не квадратною.

Приклади

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]]→ 5або7

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

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]]→ 2або4

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

Довідкова реалізація.

R , 40 30 байт

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

Спробуйте в Інтернеті!

Перевірте тестові випадки.

Проходить по діагоналі, тому в цьому випадку зліва направо. Для арифметичних операторів можна використовувати "+"або зворотні посилання навколо операторів (+,*,-,%/%,^,%% )

Досить прямо: ReduceR еквівалентно a fold, а діагональ матриці - це ті елементи, a_ijде i==j, тобто, де показники rowі column однакові. diagмає відповідну поведінку для неквадратичних матриць.

Хаскелл , 39 байт

Дякую @Laikoni за допомогу мені виправити раніше недійсне рішення!

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

Асоціатори зліва, спробуйте це в Інтернеті! (Замінити foldl1на foldr1для правоассоціатівной)

Математика , 16 байт

-1 байт завдяки Мартіну Ендеру.

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

Спробуйте в Інтернеті!

Черговий розчин, 17 байт

Fold[g]@*Diagonal

Спробуйте в Інтернеті!

Октава , 61 57 53 байт

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

Спробуйте в Інтернеті!

Визначає функцію, gяка приймає функціональну ручку fта матрицю m. Під час першої ітерації m(1)повертає верхній лівий елемент матриці; після цього воно просто повертається m.

Чисто , 56 байт

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

Спробуйте в Інтернеті! Складки справа наліво.

[t\\[_:t]<-r]те саме map tl r, що і не потрібно import StdEnv.

Haskell , 47 45 42 байт

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

Спробуйте в Інтернеті! Визначає функцію(%) яка приймає функцію та матрицю як список списків у якості вхідних даних.

Функція - складки справа наліво:

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

Редагувати: -2 байти завдяки BMO та -3 байти завдяки Zgarb !

APL (Dyalog Unicode) , 7 байт ( SBCS Адама )

⎕/1 1⍉⎕

Спробуйте в Інтернеті!

-3 завдяки пропозиції перетворити це на повну програму від Adám .

Праворуч наліво.

Haskell , 44 байти

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

Спробуйте в Інтернеті!

Стандартний ML (MLton) , 59 байт

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

Спробуйте в Інтернеті! Складки справа наліво.

Безголівки:

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

Спробуйте в Інтернеті!

Python 2 , 61 байт

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

Спробуйте в Інтернеті!

Це працює зліва направо.

JavaScript (ES6), 58 56 байт

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

Складається зліва направо. Редагувати: збережено 2 байти, використовуючи той факт, що масив суворо позитивний. Альтернативне рішення, також 56 байт:

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

JavaScript, 46 байт

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

Завдяки @Shaggy, використовуйте побіжно або збережіть один байт. Це магія.

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 байт

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

Складки [[1,2,3],[4,5,6],[7,8,9]]до f(f(1,5),9).

-7 байт опосередковано завдяки @KamilDrakari , використовуючи аналогічний трюк, який він робив у своїй відповіді C # : замість того, щоб мати максимальну межу для циклу на основі рядків / стовпців, просто спробуйте вловити ArrayIndexOutOfBoundsException.
-11 байт заміни catch(Exception e)наfinally .

Спробуйте в Інтернеті.

Старі 88 байт відповідають:

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

Спробуйте в Інтернеті.

Пояснення:

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

Формат введення чорного поля:

Припускаємо, що присвоєна названа функція int f(int x,int y), яка дозволена відповідно до цього метавідповіді .

У мене абстрактний клас, Testщо містить функцію за замовчуванням f(x,y), а також лямбда вище:

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. Наприклад, перший тестовий виклик називається так:

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 байт

Fold#/Diagonal

Спробуйте в Інтернеті! Встановіть fта дзвоніть як f[function, array].

Пояснення

Це виделка двох функцій: Foldі /Diagonal. Це, для аргументів fі a, еквівалентно:

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

/, при застосуванні монадично до функції повертає функцію, застосовану до останнього аргументу. Отже, це рівнозначно:

Fold[f, Diagonal[a]]

Це згортає функцію fнад головною діагоналлю a.

AWK , 77 байт

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}

Спробуйте в Інтернеті!

Мені було цікаво, якщо AWK можна взагалі займатися функціональним програмуванням. Я думаю, що це має значення.

"Матриця" визначається як стандартний асоціативний масив з додатковими полями M[1]=#rowsта M[2]=#columns. Ім'я функції передається у вигляді рядка, який оцінюється за допомогою @F(...)синтаксису. Оцінювання проводиться зліва направо. rПараметр є заповнювачем для запобігання перезапису існуючого rзмінного і уникнути необхідності повторної ініціалізації для кожного виклику. Зазвичай для позначення таких заповнювачів додається додатковий простір AWK, але це кодовий гольф, тому кожен байт рахується. :)

Посилання TIO реалізує всі тестові випадки.

05AB1E , 15 10 байт

Згинання справа наліво
Збережено 5 байтів за допомогою нового вбудованого, як запропонував Кевін Крейсейссен

Å\`[.g#I.V

Пояснення

Працює так само, як і стару версію, за винятком того, що Å\це новий вбудований для висунення основної діагоналі.

Спробуйте в Інтернеті! або як тестовий набір

Стара версія

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

Спробуйте в Інтернеті! або як тестовий набір

Пояснення

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

Лушпиння , 7 байт

Дякую @Zgarb, що виправив моє подання!

Ḟ₁§z!Tŀ

Асоціатори зліва, спробуйте в Інтернеті! (для право-асоціативної версії просто замініть Ḟна F)

Пояснення

На жаль, не існує простого способу отримати діагональ матриці, тому більшість байтів призначені для цього:

Ḟ₁§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 байт

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

Спробуйте в Інтернеті!

Визначає функцію T(для TRACE), яка приймає ARRAYі рядокF що називає функцію. Складається зліва направо.

Використання непрямих посилань ( $) не працює з функціями. Тому використання EVALта передавання рядка до імені здається єдиним способом отримати функцію чорного поля в SNOBOL.

Крім того, визначити масиви досить болісно; однак, оскільки невірні посилання на масив викликають FAILURE, це працює для неквадратичних масивів - якщо вони Iє поза межами будь-якого виміру, F(RETURN)примушує функцію повертатися.

Редагувати:

Можливо, виходячи з цього мета-повідомлення , я можу припустити, що функція чорного поля Fвизначена під іменем F, що знизить це до 75 байт (видалити використання EVALта ,Fу визначенні функції). Однак я віддаю перевагу цій версії, оскільки вона ближче до передачі посилання на функцію.

C, 76 байт

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

Зліва направо.

Спробуйте в Інтернеті!

тинілісп , 79 байт

(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

Останній рядок - це неназвана лямбда-функція, яка приймає функцію та матрицю та повертає матричний слід. Слід ліво-асоціативний (тобто f(f(1,5),9)). Спробуйте в Інтернеті!

Безумовно

Ми визначаємо хелперну функцію для обчислення діагоналі; то generalized-traceце лише невелика обгортка навколо бібліотечної функції 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))))

(head matrix)Обчислюючи діагоналі рекурсивно, ми перевіряємо, чи правда. Якщо матриця поза рядками, це буде порожній список (нуль), а headнуль - нуль - фальси. Або, якщо матриця поза стовпцями, її першим рядком (головою) буде порожній список (нуль) - фальси. Інакше вийде непорожній перший ряд, який є тризубним.

Отже, якщо перший рядок не існує або порожній, повертаємо нуль. В іншому випадку, якщо є непорожній перший рядок, ми беремо (head (head matrix))- перший елемент першого ряду - і cons(додаємо) його до результату рекурсивного виклику. Аргумент рекурсивного виклику (map tail (tail matrix))- це, візьміть усі рядки, окрім першого, і візьміть усі, крім першого елемента кожного рядка.

Парі / GP , 42 байти

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

Спробуйте в Інтернеті!

C # (Visual C # компілятор) , 72 69 60 байт

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

Спробуйте в Інтернеті!

try/catch дозволяє правильно дістатись діагоналі, просто пройшовшись по ній і закінчившись поза межами.

3 байти збережено, тому що, як вказував Кевін Круїссен, функції чорної скриньки можна припустити існувати під певним іменем .

9 байт збережено шляхом повернення за допомогою зміни аргументу .

Таким чином, функція викликається, зберігаючи потрібну функцію під іменем f, викликаючи trace(matrix), і результат зберігається в matrix[0][0].

Крім того, якщо вам дуже подобається багатослівність,

C # (Visual C # компілятор) , 97 + 13 = 110 78 69 байт

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

Спробуйте в Інтернеті!

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!