Vous obtiendrez un tableau 2-D A d'entiers et une longueur N. Votre tâche est de trouver dans le tableau la ligne droite (horizontale, verticale ou diagonale) de N éléments qui donne la somme totale la plus élevée, et de renvoyer cette somme .

Exemple

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

Ce tableau contient 34 lignes valides, y compris

 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 ligne maximale est

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

Remarque: les lignes peuvent ne pas entourer les bords du tableau.

Contributions

• AX par Y 2-D tableau A, avec X, Y> 0. Chaque élément du tableau contient une valeur entière qui peut être positive, nulle ou négative. Vous pouvez accepter ce tableau dans un autre format (par exemple une liste de tableaux 1-D) si vous le souhaitez.
• Un seul entier positif N, non supérieur à max (X, Y).

Production

• Une seule valeur représentant la somme de lignes maximale qui peut être trouvée dans le tableau. Notez que vous n'avez pas besoin de fournir les éléments individuels de cette ligne ou où elle se trouve.

Cas de 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 

Gelée , 15 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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

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

Essayez-le en ligne!

Comment ça fonctionne

Prend d'abord Npuis la matrice Aen entrée.

Join@@Partition[#2,{#,#},1,1,-∞]trouve tous Npar Nsous - matrice de la matrice A, rembourré avec -∞si nécessaire pour faire en sorte que les lignes à court de la grille sera hors de la course.

Pour chacun de ces blocs, nous calculons Tr/@Join[#,#,{#,Reverse@#}]: la trace (c'est-à-dire la somme) de chaque ligne, la trace (c'est-à-dire la somme) de chaque colonne, la trace (en fait la trace, pour la première fois dans l'histoire du golf avec le code Mathematica) du bloc et la trace du bloc inversée. #est Transpose@#.

Ensuite, nous trouvons le Maxde tous ces éléments.

Mathematica, 135 123 octets

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

Essayez-le en ligne!

Gelée , 16 octets

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

Essayez-le en ligne!

JavaScript, 151 129 octets

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 fonction Curry prend deux arguments, le premier est un tableau de tableaux de nombres, le second est un nombre.

Grâce à Arnauld , économisez plus de 20 octets.

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 octets

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

Attend une entrée dans Net A, par exemple:

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

Étendu

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

Notez que ce défi est fondamentalement le même que le problème Project Euler 11

Essayez-le en ligne!

Python 2 , 208 184 184 183 176 octets

• Enregistré 24 octets en utilisant -float("inf")pour représenter que la ligne vérifiée a atteint en dehors de la matrice au lieu de calculer la somme négative de tous les éléments de la matrice.
• Enregistré un octet en définissant R,L=range,lenpour raccourcir les fonctions intégrées et en utilisant y in R(L(A))...R(L(A[y]))au lieu de y,Y in e(A)...x,_ in e(Y).
• Sauvegardé sept octets en jouant float("inf")au 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

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Une solution récursive. Pour chaque élément (i, j) de la matrice, il renvoie le maximum entre la somme le long de la ligne, la somme le long de la colonne, la somme le long de l'une ou l'autre diagonale et le résultat de la fonction appliquée à (i + 1, j) et (i, j + 1). Les résultats des cas de test sont présentés dans le TIO.

Husk , 14 octets

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

Essayez-le en ligne!

Grâce aux nouveaux anti∂iagonaux intégrés, c'est une réponse assez courte :)

JavaScript 170 octets

essuyez toujours la partie golf a ajouté 4 caractères supplémentaires parce que je n'ai pas réussi un cas où le max est négatif et N est supérieur à 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 octets

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)

Essayez-le en ligne!