Se le dará una matriz A de números enteros en 2-D, y una longitud N. Su tarea es encontrar dentro de la matriz la línea recta (horizontal, vertical o diagonal) de N elementos que produce la suma total más alta, y devolver esa suma .

Ejemplo

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

Esta matriz tiene 34 líneas válidas, incluidas

 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 línea máxima es

 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: las líneas pueden no ajustarse alrededor de los bordes de la matriz.

Entradas

• AX por Y matriz 2D A, con X, Y> 0. Cada elemento de la matriz contiene un valor entero que puede ser positivo, cero o negativo. Puede aceptar esta matriz en un formato alternativo (por ejemplo, una lista de matrices 1-D) si lo desea.
• Un solo entero positivo N, no mayor que max (X, Y).

Salida

• Un valor único que representa la suma máxima de líneas que se puede encontrar en la matriz. Tenga en cuenta que no necesita proporcionar los elementos individuales de esa línea o dónde se encuentra.

Casos de prueba

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 

Jalea , 15 bytes

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

Pruébalo en línea!

Cómo funciona

,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 bytes

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

Pruébalo en línea!

Cómo funciona

Primero toma Ny luego la matrizA como entrada.

Join@@Partition[#2,{#,#},1,1,-∞]Busca todos Npor Nsubmatriz de la matrizA , acolchado con-∞ cuando sea necesario para asegurar que las líneas corriendo de la rejilla será fuera de la carrera.

Para cada uno de esos bloques calculamos Tr/@Join[#,#,{#,Reverse@#}]: la traza (es decir, la suma) de cada fila, la traza (es decir, la suma) de cada columna, la traza (en realidad, la traza, por primera vez en la historia del golf de código de Mathematica) del bloque , y el rastro del bloque se invirtió. #es Transpose@#.

Luego encontramos el Maxde todos estos.

Mathematica, 135 123 bytes

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

Pruébalo en línea!

Jalea , 16 bytes

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

Pruébalo en línea!

JavaScript 151 129 bytes

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 función Curry toma dos argumentos, el primero es un conjunto de números, el segundo es un número.

Gracias a Arnauld , ahorre más de 20 bytes.

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 bytes

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

Espera entrada Ny A, por ejemplo:

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

Expandido

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

Tenga en cuenta que este desafío es básicamente el mismo que el problema 11 del Proyecto Euler

Pruébalo en línea!

Python 2 , 208 184 183 176 bytes

• Se guardaron 24 bytes al usar -float("inf")para representar que la línea marcada alcanzó fuera de la matriz en lugar de calcular la suma negativa de todos los elementos de la matriz.
• Se guardó un byte definiendo R,L=range,lenpara acortar las funciones integradas y utilizando en y in R(L(A))...R(L(A[y]))lugar de y,Y in e(A)...x,_ in e(Y).
• Ahorró siete bytes jugando float("inf")al 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

Pruébalo en línea!

Explicación

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 bytes

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

Pruébalo en línea!

Una solución recursiva. Para cada elemento (i, j) de la matriz, devuelve el máximo entre la suma a lo largo de la fila, la suma a lo largo de la columna, la suma a lo largo de cualquier diagonal y el resultado de la función aplicada a (i + 1, j) y (i, j + 1) Los resultados para los casos de prueba se muestran en el TIO.

Casco , 14 bytes

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

Pruébalo en línea!

Gracias a los nuevos anti∂iagonals incorporados, esta es una respuesta bastante corta :)

JavaScript 170 bytes

Todavía wip en la parte de golf agregó 4 caracteres más porque no logré un caso donde el máximo es negativo y N es mayor que 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 bytes

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)

Pruébalo en línea!