23

दिया (किसी भी तरह से):

एक दो-तर्क (या दो-तत्व सूची से मिलकर एकल तर्क) ब्लैक बॉक्स फ़ंक्शन , (इनपुट और आउटपुट 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) = x^y, [[1,2,3],[4,5,6],[7,8,9]]→ →1^5⁹1

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

संदर्भ कार्यान्वयन।

— एडम
स्रोत

विकर्ण क्या है [[2,2,2],[2,2,3],[2,3,3],[4,4,4]]?

— पूरी तरह से

3

@ टोटलीहुमन:[2,2,3]

— एमिग्ना

1

दमिति, मैंने शीर्षक को "सामान्यीकृत मैट्रिक्स ट्रान्स" के रूप में पढ़ा और पृष्ठ लोड होने पर बहुत निराश हुआ

— टार

9

आर , 40 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

परीक्षण मामलों की जाँच करें।

तिरछा नीचे तिरछे, इसलिए इस मामले में बाएं से दाएं। अंकगणितीय ऑपरेटरों के लिए, आप "+"ऑपरेटरों के आसपास या बैकटिक्स का उपयोग कर सकते हैं ( +,*,-,%/%,^,%%)

बिल्कुल स्पष्ट: Reduceआर के एक के बराबर है fold, और एक मैट्रिक्स के विकर्ण उन तत्वों है a_ijजहां i==j, यानी, जहां rowऔर colसूचकांक umn ही हैं। diagगैर-वर्ग मैट्रिस के लिए उपयुक्त व्यवहार है।

— ग्यूसेप
स्रोत

8

हास्केल , 39 बाइट्स

धन्यवाद @Laikoni मुझे पहले से अमान्य समाधान को ठीक करने में मदद करने के लिए!

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

बाईं ओर सहयोगी, इसे ऑनलाइन आज़माएं! (की जगह foldl1से foldr1सही-साहचर्य के लिए)

— ბიმო
स्रोत

कैसे के बारे में foldl1 f$zipWith(!!)m[0..]?

— गर्वित हैकेलर

@proudhaskeller: यह वही है जो दूसरों ने पहले से ही कोशिश की थी, लेकिन यह गैर-वर्ग

— मैट्रिस

5

गणितज्ञ , 16 बाइट्स

मार्टिन एंडर के लिए -1 बाइट धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

वैकल्पिक समाधान, 17 बाइट्स

Fold[g]@*Diagonal

इसे ऑनलाइन आज़माएं!

— totallyhuman
स्रोत

17 बाइट्स (ब्लैक-बॉक्स फ़ंक्शंस को किसी दिए गए नाम के तहत ग्रहण किया जा सकता है)

— श्री एक्सकोडर

यह @*{}वाक्यविन्यास बहुत मायने नहीं रखता (आप शायद मतलब है @*List), लेकिन यह तथ्य है कि यह वैसे भी काम करता है बहुत अच्छा है। वास्तव में, यह मतलब है कि आप की जगह ले सकता {}है एक साथ 0और एक बाइट बचाने।

— मार्टिन एंडर

@MartinEnder मैं वास्तव में Listपहले किया था, लेकिन मैं {}सिर्फ इसके लिए कोशिश की और बहुत आश्चर्यचकित था कि यह काम किया। समझ में आता है लेकिन कैसे 0काम करता है ? o0

— totallyhuman

1

@totallyhuman वैसा ही जैसा {}। आप वर्तमान {}में फ़ंक्शन के रूप में उपयोग कर रहे हैं (या वास्तव में गणितज्ञ शब्दावली का उपयोग करके "सिर" के रूप में)। यदि आपने fवहाँ एक सामान्य प्रयोग किया है , तो आपको मिलेगाf[1,2,3] (यदि यह विकर्ण है)। लेकिन {}तुम साथ हो {}[1,2,3]। यह एक पूरी तरह से व्यर्थ अभिव्यक्ति है, लेकिन सिर स्वयं मनमाने ढंग से अभिव्यक्ति हो सकते हैं, और अगर गणितज्ञ को यह नहीं पता है कि उनके साथ क्या करना है, तो यह सिर्फ उन्हें छोड़ देता है जैसे वे हैं। मैथेमेटिका की अधिकांश सूची में हेरफेर वास्तव में एक मनमाने ढंग से सिर के साथ काम करते हैं और इस मामले में Fold, सिर को केवल नजरअंदाज कर दिया जाता है। [tbc]

— मार्टिन

तो आप 0इसके बजाय सिर के रूप में उपयोग कर सकते हैं , जो देता है 0[1,2,3]जो अभी भी अर्थहीन है, लेकिन सभी समान काम करता है।

— मार्टिन एंडर

4

ऑक्टेव , 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।

— Sanchises
स्रोत

53 बाइट्स

— ग्यूसेप

@Giuseppe यही मैंने अपने शुरुआती 61-बाइट संस्करण के साथ किया। बेशक, मुझे अपने 57- और 61 बाइट संस्करण के मजबूत बिंदुओं को संयुक्त करना चाहिए, जो वास्तव में 53 बाइट का जवाब देता है। मुझे फिर से देखने के लिए धन्यवाद!

— सांचेस

3

साफ , 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 ।

— Laikoni
स्रोत

बहुत सुंदर परिहारStdEnv

— ousurous

3

हास्केल , 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 बाइट्स और ज़र्ब के लिए -3 बाइट्स धन्यवाद !

— Laikoni
स्रोत

1

43 बाइट्स का उपयोग करके $और सशर्त को सरल बनाने के साथ *>।

— जर्गब

@Zgarb उपयोग करने के लिए अच्छा विचार है *>!

— लैकोनी

3

APL (Dyalog Unicode) , 7 बाइट्स ( Adám's SBCS )

⎕/1 1⍉⎕

इसे ऑनलाइन आज़माएं!

-3 Adám द्वारा इसे एक पूर्ण कार्यक्रम में बदलने के लिए एक सुझाव के लिए धन्यवाद ।

दाएं से बाएं।

— आउटगोल्फर को एरिक करें
स्रोत

यहाँ Adám के SBCS का उपयोग करने की आवश्यकता नहीं है: आप बस Dyalog Classic का उपयोग कर सकते हैं।

— जचारि

@ Zacharý बात यह है कि मैं Dyalog यूनिकोड में जवाब दे रहा हूं, क्लासिक समय के साथ पदावनत हो रहा है।

— बजे द एग्रीगेटर

कोडपेज नहीं, हालांकि कोडपेज चालू रहेगा

— Zacharý

@ Zacharý खैर, चलो लगातार सुसंगत हो। : पी

— एरिक आउटगॉल्फ

2

हास्केल , 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— totallyhuman
स्रोत

2

मानक एमएल (एमएलटन) , 59 बाइट्स

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

इसे ऑनलाइन आज़माएं! दाएं-बाएं से सिलवटों।

Ungolfed:

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

इसे ऑनलाइन आज़माएं!

— Laikoni
स्रोत

2

Python 2, 61 bytes

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

Try it online!

This works left-to-right.

— Rod
स्रोत

@AsoneTuhid it can be any way, check the (x+y)⁄2 and x+2yexamples

— Rod

Right, I misread, sorry

— Asone Tuhid

2

JavaScript (ES6), 58 56 bytes

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

Folds left-to-right. Edit: Saved 2 bytes by using the fact that the array is strictly positive. Alternate solution, also 56 bytes:

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

— Neil
स्रोत

It doesn't look like you need the 1/ and you can save another 2 bytes by moving some stuff around: f=>a=>(h=r=>(e=a[++i]&&a[i][i])?h(f(r,e)):r)(a[i=0][0]). TIO

— Shaggy

@Shaggy Oh, it's strictly positive, I hadn't seen that.

— Neil

Apparently we can assume that black-box functions are assigned to a predefined variable so you could save 2 bytes if you want to take advantage of that.

— Shaggy

@Shaggy Actually I think it would save 4 bytes (2x f,) off the first version?

— Neil

You're right; sorry, forgot to count the f, when calling g again.

— Shaggy

2

JavaScript, 46 bytes

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

Thanks to @Shaggy, use bitwise or save one byte. That's magic.

Show code snippet

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>

Expand snippet

— tsh
स्रोत

This doesn't seem to work if the matrix has more rows than columns.

— Shaggy

@Shaggy so sad, 47 bytes now...

— tsh

Yeah, that's what I had originally, too. Was just about to edit the fix into my solution but you beat me too it :( I think you can get one byte back, though, by using bitwise OR, though.

— Shaggy

@Shaggy so magic

— tsh

Forgot to mention: Apparently we can assume that black-box functions are assigned to a predefined variable so you could save 3 bytes if you wanted to take advantage of that.

— Shaggy

2

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

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

-7 bytes indirectly thanks to @KamilDrakari by using a similar trick as he did in his C# answer: instead of having a maximum boundary for the loop based on the rows/columns, simply try-catch the ArrayIndexOutOfBoundsException.
-11 bytes replacing catch(Exception e) with finally.

Try it online.

Old 88 bytes answer:

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

Try it online.

Explanation:

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

Black box input format:

Assumes a named function int f(int x,int y) is present, which is allowed according to this meta answer.

I have an abstract class Test containing the default function f(x,y), as well as the lambda above:

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

For the test cases, I overwrite this function f. For example, the first test case is called like this:

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

— Kevin Cruijssen
स्रोत

2

Attache, 14 bytes

Fold#/Diagonal

Try it online! Set to f and call as f[function, array].

Explanation

This is a fork of two functions: Fold and /Diagonal. This, for arguments f and a, is equivalent to:

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

/, when applied monadically to a function, returns a function that is applied to its last argument. So, this is equivalent to:

Fold[f, Diagonal[a]]

This folds the function f over the main diagonal of a.

— Conor O'Brien
स्रोत

A home-brewed language which is readable‽

— Adám

@Adám ;D yes indeed!

— Conor O'Brien

2

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}

Try it online!

I was curious if AWK could do functional programming at all. I think this counts.

The "Matrix" is defined as a standard associative array, with extra fields M[1]=#rows and M[2]=#columns. The function name is passed in as a string which is evaluated via the @F(...) syntax. Evaluation is performed left to right. The r parameter is a placeholder to prevent overwriting an existing r variable and to avoid the need to reinitialize for each call. Typically extra space is added to designate such placeholders in AWK, but this is code golf, so every byte counts. :)

The TIO link implements all the test cases.

— Robert Benson
स्रोत

2

05AB1E, 15 10 bytes

Folds from right-to-left
Saved 5 bytes using a new built-in as suggested by Kevin Cruijssen

Å\`[.g#I.V

Explanation

Works the same as the old version, except that Å\ is a new built-in for pushing the main diagonal.

Try it online! or as a Test Suite

Old Version

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

Try it online! or as a Test suite

Explanation

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

— Emigna
स्रोत

1

¬g£vyNè}[ can be Å\`[ now, saving 5 bytes.

— Kevin Cruijssen

1

Husk, 7 bytes

Thanks @Zgarb for fixing my submission!

Ḟ₁§z!Tŀ

Associates to the left, Try it online! (for a right-associative version simply replace Ḟ by F)

Explanation

Unfortunately there's no easy way to get the diagonal of a matrix, so most the bytes are for that:

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

— ბიმო
स्रोत

Huh, built-in for anti-diagonals, but not for diagonals‽

— Adám

2

@Adám I assume that's because you can compute antidiagonals of infinite matrices but not diagonals.

— Martin Ender

1

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

Try it online!

Defines a function T (for TRACE) that takes an ARRAY and a string F that's the name of a function. Folds left-to-right.

Using indirect reference ($) doesn't work with functions. So using EVAL and passing a string to the name seems to be the only way to get a black-box function in SNOBOL.

Also, it's quite painful to define arrays; however, because invalid array references cause FAILURE, this works for non-square arrays -- if I is out-of-bounds in either dimension, the F(RETURN) forces the function to return.

Edit:

Possibly, based on this meta post, I may assume that the black-box function F is defined under the name F, which would drop this to 75 bytes (remove use of EVAL and ,F in the function definition). However, I prefer this version since it's closer to passing a reference to a function.

— Giuseppe
स्रोत

1

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!

— Steadybox
स्रोत

1

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.

— DLosc
स्रोत

1

Pari/GP, 42 bytes

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

Try it online!

— alephalpha
स्रोत

1

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.

— Kamil Drakari
स्रोत

Nice trick with the try-catch. I've been able to golf 7 bytes on my Java 8 answer (even though I have to use catch(Exception e) instead of catch. :) EDIT: Oh, been able to replace the catch(Exception e) with finally to save more bytes. Thanks again. +1 from me.

— Kevin Cruijssen

@KevinCruijssen you may also be able to benefit from my newest improvement (though I don't remember for sure whether Java is amenable to modifying arguments)

— Kamil Drakari

Thanks for letting me know. Although it is possible in Java, it means I'll have to change the finally into catch(Exception e), because I'm not returning inside the finally anymore. So m->{try{for(int i=1;;m[0][0]=f(m[0][0],m[i][i++]));}catch(Exception e){}} (73 bytes) is unfortunately longer for me in comparison to my current answer m->{int r=m[0][0],i=1;try{for(;;)r=f(r,m[i][i++]);}finally{return r;}} (70 bytes) But indeed a nice way to save bytes in your answer! :) Too bad I can only +1 your answer once.

— Kevin Cruijssen

1

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>

Expand snippet

— Shaggy
स्रोत

1

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

— RosLuP
स्रोत

Good job. While I think you arrive to this on you own, it happens to be identical to Erik the Outgolfer's original solution.

— Adám

0

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.

— Mr. Xcoder
स्रोत

0

Clojure, 30 bytes

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

Reduces "from the left".

— NikoNyrh
स्रोत

0

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!

— Asone Tuhid
स्रोत

सामान्यीकृत मैट्रिक्स ट्रेस

उदाहरण

आर , 40 30 बाइट्स

हास्केल , 39 बाइट्स

गणितज्ञ , 16 बाइट्स

वैकल्पिक समाधान, 17 बाइट्स

ऑक्टेव , 61 57 53 बाइट्स

साफ , 56 बाइट्स

हास्केल , 47 45 42 बाइट्स

APL (Dyalog Unicode) , 7 बाइट्स ( Adám's SBCS )

हास्केल , 44 बाइट्स

मानक एमएल (एमएलटन) , 59 बाइट्स

Ungolfed:

Python 2, 61 bytes

JavaScript (ES6), 58 56 bytes

JavaScript, 46 bytes

Java 8, 88 81 70 bytes

Attache, 14 bytes

Explanation

AWK, 77 bytes

05AB1E, 15 10 bytes

Husk, 7 bytes

Explanation

SNOBOL4 (CSNOBOL4), 86 bytes

Edit:

C, 76 bytes

tinylisp, 79 bytes

Ungolfed

Pari/GP, 42 bytes

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

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

JavaScript, 61 57 56 52 50 44 42 bytes

Test Cases

APL NARS, 20 bytes, 10 chars

Jelly, 5 bytes

Clojure, 30 bytes

Ruby, 55 53 bytes