Ti verrà dato un array 2-D A di numeri interi e una lunghezza N. Il tuo compito è di trovare all'interno dell'array la linea retta (orizzontale, verticale o diagonale) di N elementi che produce la somma totale più alta e restituire quella somma .

Esempio

 N = 3, A = 
 3    3    7    9    3
 2    2   10    4    1
 7    7    2    5    0
 2    1    4    1    3

Questo array ha 34 righe valide, tra cui

 Vertical
 [3]   3    7    9    3
 [2]   2   10    4    1
 [7]   7    2    5    0
  2    1    4    1    3       [3,2,7] = 12
 Horizontal
  3    3    7    9    3
  2    2   10    4    1
  7    7   [2]  [5]  [0]
  2    1    4    1    3       [2,5,0] = 7
 Diagonal
  3    3   [7]   9    3
  2    2   10   [4]   1
  7    7    2    5   [0]
  2    1    4    1    3       [7,4,0] = 11

La linea massima è

 3    3    7   [9]   3
 2    2  [10]   4    1
 7   [7]   2    5    0
 2    1    4    1    3        [7,10,9] = 26

Nota: le linee potrebbero non avvolgere i bordi dell'array.

ingressi

• AX di Y 2-D array A, con X, Y> 0. Ogni elemento dell'array contiene un valore intero che può essere positivo, zero o negativo. Se lo si desidera, è possibile accettare questo array in un formato alternativo (es. Elenco di array 1-D).
• Un singolo numero intero positivo N, non maggiore di max (X, Y).

Produzione

• Un singolo valore che rappresenta la somma massima della riga che è possibile trovare nella matrice. Si noti che non è necessario fornire i singoli elementi di quella linea o dove si trova.

Casi test

N = 4, A = 
-88    4  -26   14  -90
-48   17  -45  -70   85
 22  -52   87  -23   22
-20  -68  -51  -61   41
Output = 58

N = 4, A =
 9    4   14    7
 6   15    1   12
 3   10    8   13
16    5   11    2
Output = 34

N = 1, A = 
 -2
Output = -2

N = 3, A =
1    2    3    4    5
Output = 12

N = 3, A = 
-10   -5    4
 -3    0   -7
-11   -3   -2
Output = -5 

Gelatina , 15 byte

,ZṚ¥;ŒD$+⁹\€€FṀ

Provalo online!

Come funziona

,ZṚ¥;ŒD$+⁹\€€FṀ  Main link. Left argument: M (matrix). Right argument: n (integer)

 ZṚ¥             Zip/transpose and reverse M. This is equivalent to rotating M 90°
                 counterclockwise.
,                Pair M and the result to the right.
    ;ŒD$         Append the diagonals of both matrices to the pair.
        +⁹\€€    Take the sums of length n of each flat array.
             FṀ  Flatten and take the maximum.

Wolfram Language (Mathematica) , 73 byte

Max[Tr/@Join[#,#,{#,Reverse@#}]&/@Join@@Partition[#2,{#,#},1,1,-∞]]&

Provalo online!

Come funziona

Prende prima Nla matrice e poi l' Ainput.

Join@@Partition[#2,{#,#},1,1,-∞]trova ogni Nper Nmatrice di matrice della matrice A, imbottita -∞dove necessario per garantire che le linee che si esauriscono dalla griglia saranno fuori servizio.

Per ciascuno di quei blocchi calcoliamo Tr/@Join[#,#,{#,Reverse@#}]: la traccia (cioè la somma) di ogni riga, la traccia (cioè la somma) di ogni colonna, la traccia (in realtà la traccia, per la prima volta nella storia del golf del codice Mathematica) del blocco e la traccia del blocco è stata invertita. #lo è Transpose@#.

Quindi troviamo il Maxtutto.

Mathematica, 135 123 byte

Max[(s=#;r=#2;Max[Tr/@Partition[#,r,1]&/@Join[s,s~Diagonal~#&/@Range[-(t=Tr[1^#&@@s])+2,t-1]]])&@@@{#|#2,Reverse@#|#2}]&

Provalo online!

Gelatina , 16 byte

µ;Z;Uµ;ŒDðṡ€ẎS€Ṁ

Provalo online!

JavaScript, 151 129 byte

a=>n=>a.map((l,x)=>l.map((v,y)=>[...'01235678'].map(d=>m=(g=i=>i--&&g(i)+(a[x+d%3*i-i]||[])[y+i*~-(d/3)])(n)>m?g(n):m)),m=-1/0)|m

La funzione Curry accetta due argomenti, il primo è un array di array di numeri, il secondo è un numero.

Grazie ad Arnauld , risparmia oltre 20 byte.

f=

a=>n=>a.map((l,x)=>l.map((v,y)=>[...'01235678'].map(d=>m=(g=i=>i--&&g(i)+(a[x+d%3*i-i]||[])[y+i*~-(d/3)])(n)>m?g(n):m)),m=-1/0)|m

<p><label>N = <input id="N" type="number" min="1" value="3" /></label></p>
<p><label>A = <textarea id="A" style="width: 400px; height: 200px;"> 3    3    7    9    3
 2    2   10    4    1
 7    7    2    5    0
 2    1    4    1    3
</textarea></label></p>
<input value="Run" type="button" onclick="O.value=f(A.value.split('\n').filter(x=>x.trim()).map(x=>x.trim().split(/\s+/).map(Number)))(+N.value)" />
<p>Result = <output id="O"></output></p>

Jq 1,5 , 211 byte

def R:reverse;def U:[range(length)as$j|.[$j][$j:]]|transpose|map(map(select(.))|select(length>=N));def D:U+([R[]|R]|U|map(R)[1:]);[A|.,transpose,D,(map(R)|D)|.[]|range(length-N+1)as$i|.[$i:$i+N]]|max_by(add)|add

Si aspetta input Ne A, ad esempio:

def N: 3;
def A: [
  [ 3, 3,  7, 9, 3 ],
  [ 2, 2, 10, 4, 1 ],
  [ 7, 7,  2, 5, 0 ],
  [ 2, 1,  4, 1, 3 ]
];

allargato

def chunks:      .[] | range(length-N+1) as $i | .[$i:$i+N] ;
def flip:        [ reverse[] | reverse ] ;
def upperdiag:   [ range(length) as $j | .[$j][$j:] ] | transpose | map(map(select(.))|select(length>=N)) ;
def lowerdiag:   flip | upperdiag | map(reverse)[1:] ;
def diag:        upperdiag + lowerdiag ;
def allchunks:   A | ., transpose, diag, (map(reverse)|diag) | chunks ;

[allchunks]|max_by(add)|add

Nota che questa sfida è sostanzialmente la stessa del problema del Project Euler 11

Provalo online!

Python 2 , 208 184 183 176 byte

• 24 byte salvati utilizzando -float("inf")per indicare che la linea selezionata ha raggiunto al di fuori della matrice anziché calcolare la somma negativa di tutti gli elementi della matrice.
• Salvato un byte definendo R,L=range,len di abbreviare le funzioni integrate e usando y in R(L(A))...R(L(A[y]))invece di y,Y in e(A)...x,_ in e(Y).
• Salvato sette byte giocando float("inf")a golf 9e999.

lambda N,A:max(sum(A[y+q*j][x+p*j]if-1<x+p*j<L(A[y])>-1<y+q*j<L(A)else-9e999for j in R(N))for y in R(L(A))for x in R(L(A[y]))for p,q in[(1,0),(0,1),(1,1),(1,-1)]);R,L=range,len

Provalo online!

Spiegazione

lambda N,A:                                                                                                                                                       ;R,L=range,len # lambda function, golfed built-ins
           max(                                                                                                                                                  )               # return the maximum line sum
                                                                                          for y in R(L(A))                                                                       # loop through matrix rows
                                                                                                          for x in R(L(A[y]))                                                    # loop through matrix columns
                                                                                                                             for p,q in[(1,0),(0,1),(1,1),(1,-1)]                # loop through four directions; east, south, south-east, north-east
               sum(                                                                      )                                                                                       # matrix line sum
                                                                            for j in R(N)                                                                                        # loop through line indices
                                  if-1<x+p*j<L(A[y])>-1<y+q*j<L(A)                                                                                                               # coordinates inside the matrix?
                   A[y+q*j][x+p*j]                                                                                                                                               # true; look at the matrix element
                                                                  else-9e999                                                                                                     # false; this line cannot be counted, max(...) will not return this line

R , 199 byte

function(m,n,i=1,j=1){y=1:n-1
x=j-y;x[x<1]=NA
y=i-y;y[y<1]=NA
'if'(i>nrow(m)|j>ncol(m),NA,max(c(v(m[i,x]),v(m[y,j]),v(m[b(y,x)]),v(m[b(y,rev(x))]),f(m,n,i+1,j),f(m,n,i,j+1)), na.rm=T))}
v=sum
b=cbind

Provalo online!

Una soluzione ricorsiva. Per ogni elemento (i, j) della matrice restituisce il massimo tra la somma lungo la riga, la somma lungo la colonna, la somma lungo entrambe le diagonali e il risultato della funzione applicata a (i + 1, j) e (i, j + 1). I risultati per i casi di test sono mostrati nel TIO.

Buccia , 14 byte

▲mΣṁX⁰ṁëIT∂(∂↔

Provalo online!

Grazie ai nuovi anti∂iagonali integrati, questa è una risposta abbastanza breve :)

JavaScript 170 byte

ancora pulire la parte golf ha aggiunto altri 4 caratteri perché non ho gestito un caso in cui il massimo è negativo e N è maggiore di 1

M=-1e9
G=(A,N)=>eval(`for(y in m=M,A)
for(x in R=A[y])
{for(a=b=c=d=j=0;j<N;d+=Y[x-j++])
{a+=R[X=+x+j]
b+=(Y=A[+y+j]||[])[x]
c+=Y[X]}
m=Math.max(m,a||M,b||M,c||M,d||M)}`)

console.log(G([ [3,3,7,9,3],
 [2,2,10,4,1],
 [7,7,2,5,0],
 [2,1,4,1,3]],3)==26)
 
 console.log(G([[-88,4,-26,14,-90],
[-48,17,-45,-70,85],
[22,-52,87,-23,22],
[-20,-68,-51,-61,41]],4)==58)

console.log(G([[9,4,14,7],[6,15,1,12],[3,10,8,13],[16,5,11,2]],4)==34)

console.log(G([[-2]],1)==-2)
console.log(G([[1,2,3,4,5]],3) ==12)

Python 2 , 222 218 byte

n,a=input()
W=len(a[0]);Q=['']*W;R=range;a+=[Q]*n
for l in a:l+=Q
print max(sum(x)for y in[zip(*[(a[j][i+k],a[j+k][i],a[j+k][i+k],a[j+k][i+n+~k])for k in R(n)])for j in R(len(a)-n)for i in R(W)]for x in y if''not in x)

Provalo online!