Introducción

Deje que un campo sea un rectángulo lleno solo con los caracteres -y [0-9]. Un ejemplo de un campo es:

11-011123
111-010--
0010---01
111-01234

Verá que este campo se ha separado en tres áreas más pequeñas:

Para calcular la puntuación de un área más pequeña, solo sumamos todos los números. Por ejemplo:

11
111
0010
111

1 + 1 + 1 + 1 + 1 + 0 + 0 + 1 + 0 + 1 + 1 + 1 = 9

El puntaje total para esta área es 9 . Ahora hacemos lo mismo para la segunda área:

   011123
    010

0 + 1 + 1 + 1 + 2 + 3 + 0 + 1 + 0 = 9

La puntuación total también es 9 . Ahora tenemos que examinar la última área:

       01
    01234

0 + 1 + 0 + 1 + 2 + 3 + 4 = 11

Esto tiene un puntaje total de 11 . El puntaje más alto en el campo es 11, así que esto es lo que necesitamos para generar.

La tarea

Dado un campo (en forma de una cadena 2D, una matriz, etc.), genera la puntuación más alta en el campo. Puede suponer que los campos dados siempre contendrán al menos 1 dígito. Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes.

Casos de prueba

Caso de prueba 1:

Input:
1

Output:
1

Caso de prueba 2:

Input:
1-1-1-1
-1-1-1-
2-1-1-1
-1-1-1-

Output:
2

Caso de prueba 3:

Input:
12-45-
4-65-9
87-654
12-487
45----
684764

Output:
69

Caso de prueba 4:

Input:
111-12
------
21--10

Output:
3

MATL , 54 51 49 bytes

n:"G~1@(2Y6Z+leG45>1e*5M@)*]vtz:"otY*g]G48-X:*sX>

La entrada es una matriz de caracteres 2D en formato MATL (AB), con un ;separador de filas. Las entradas en el ejemplo y en los casos de prueba son respectivamente:

['11-011123';'111-010--';'0010---01';'111-01234']
['1']
['1-1-1-1';'-1-1-1-';'2-1-1-1';'-1-1-1-']
['12-45-';'4-65-9';'87-654';'12-487';'45----';'684764']
['111-12';'------';'21--10']

Pruébalo en línea!

Explicación

Esto funciona construyendo una matriz de adyacencia del gráfico definido por la relación "estar conectado". Como ejemplo, considere el campo 3 × 4

52-4
15-8
3-72

Las entradas en una matriz 2D se describen fácilmente en MATL utilizando la indexación lineal (columna mayor). En el caso 3 × 4, el índice lineal de cada entrada se da como

1  4  7 10
2  5  8 11
3  6  9 12

La matriz de adyacencia se construye en pasos usando la multiplicación de matrices. En el primer paso, se consideran vecinos inmediatos . Por ejemplo, el punto indexado 3 es vecino de sí mismo y de eso con el índice 2. No es vecino de 6 porque ese punto no contiene un número de acuerdo con el campo. En este ejemplo, la matriz de adyacencia de la relación "vecino inmediato" es la matriz L 12 × 12 dada como

1 1 0 1 0 0 0 0 0 0 0 0
1 1 1 0 1 0 0 0 0 0 0 0
0 1 1 0 0 0 0 0 0 0 0 0
1 0 0 1 1 0 0 0 0 0 0 0
0 1 0 1 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 1
0 0 0 0 0 0 0 0 0 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1
0 0 0 0 0 0 0 0 1 0 1 1

(Se puede ver que la columna 3 tiene un valor 1en las filas 2 y 3.) Esta matriz siempre es simétrica y su diagonal tiene valor 1para los puntos que no contienen -.

El siguiente paso sería la matriz de adyacencia de la relación "conectada como máximo con un punto intermedio ". Para obtenerlo, basta con multiplicar L por sí mismo y establecer entradas distintas de cero en 1. En general, la matriz de adyacencia de la relación "conectada por algún camino", M , se obtiene elevando L a un exponente (en sentido matricial) que representa la longitud máxima posible del camino. Un límite superior de la longitud de trayectoria máxima es el número de entradas en distintos de cero L .

Calcular la potencia de la matriz directamente puede causar un desbordamiento, ya que se producen grandes cantidades rápidamente. Por lo tanto, es mejor multiplicar gradualmente por la misma matriz, convirtiendo las entradas distintas de cero en 1 después de cada paso para evitar que se acumulen grandes cantidades.

La columna i de M representa los puntos que están conectados (por cualquier ruta) con el punto i . Ahora, el campo de nivel se puede reducir a un vector de columna c en orden lineal, donde cada entrada contiene el número correspondiente o un valor indefinido para -. Entonces, en este caso, c sería

5
1
3
2
5
-
-
-
7
4
8
2

Mutiplying cada columna de M por c elemento a elemento y el cálculo de la suma de cada columna proporciona, para cada punto i , la puntuación total del punto de área i pertenece. Un área se define por todos los puntos que están conectados entre sí. Tenga en cuenta que muchas columnas darán el mismo resultado; a saber, las columnas i y j darán la misma suma si los puntos i y j están conectados (pertenecen a la misma área). El resultado final es el máximo de esas sumas.

        % Implicitly take input: 2D char array
n:      % Range [1,...,N], where N is number of entries in the input
"       % For loop. Each iteration builds a row of matrix L
  G     %   Push input again
  ~     %   Logical negate: transform into matrix of zeros
  1     %   Push 1, to be written into a matrix entry
  @     %   Iteration index. Ranges from 1 to N
  (     %   Write that 1 into the N-th entry (linear order)
  2Y6   %   Push array [0 1 0; 1 1 1; 0 1 0]: mask of immediate neighbours
  Z+    %   Convolve and keep same-size result
  le    %   Linearize into row array
  G45>  %   Array of same size as the input that contains 1 for numbers, 0 for '-'
  1e    %   Linearize into row array
  *     %   Multiply element-wise
  5M    %   Push last array again: 1 for numbers, 0 for '-'
  @)    %   Get 0 or 1 value of that array corresponding to current iteration
  *     %   Multiply. This is to give a row of zeros for non-numbers
]       % End. We have all rows of L in the stack
v       % Concatenate all rows into a matrix: L.
tz:     % Duplicate. Range [1,...,K], where K is the number of nonzeros in L
"       % For loop. Repear K times. This loop computes the 0/1 matrix power
  o     %   Convert matrix entries to double
  tY*   %   Duplicate and matrix-multiply
  g     %   Convert to logical values, that is, nonzero values become 1
]       % End. We have matrix M
G48-    % Convert input chars to the corresponding numbers by subtractig 48
X:      % Linearize into column array. This is vector c
*       % Element-wise multiplication with broadcast (implicit repetition)
s       % Sum of each column. Gives a row array
X>      % Maximum of that row array
        % Implicitly display

JavaScript (ES6), 157 bytes

s=>[...o=s].map((n,i)=>o=n<'.'|(a=[...s]).map(_=>a.map((c,j)=>c>'-'&c<10&(a[j+1]|a[j-1]|a[j+l]|a[j-l])>90?a[n-=-c,j]=99:0),a[i]=99)|o>n?o:n,l=~s.search`
`)|o

Explicación

Toma un campo de entrada como una cadena. Para cada número en el campo, suma todos los números en el área. Lo hace iterando sobre cada número en el campo varias veces, agregando el número a la puntuación si una celda adyacente contiene un número previamente contado. Los números contados que forman parte del área se representan estableciéndolos en 99 para que no se vuelvan a contar. Produce el puntaje más alto como un número.

var solution =

s=>
  [...o=s].map((n,i)=>o=n<'.'|             // for each number on the field
                                           // n = area score
      (a=[...s])                           // a = array of each field character
      .map(_=>                             // loop to ensure whole area is found
        a.map((c,j)=>                      // for each cell c at index j
          c>'-'&c<10&                      // if the current cell is a number
          (a[j+1]|a[j-1]|a[j+l]|a[j-l])>90 // and an adjacent cells is in the area
          ?a[n-=-c,j]=99:0                 // add the cell to the area
        ),                                 // and the number to the score
        a[i]=99                            // mark the starting cell as counted
      )
      |o>n?o:n,                            // o = output (max of o and n)
    l=~s.search`
`                                          // l = line length of field
  )
  |o                                       // return o

<textarea id="input" rows="6" cols="40">12-45-
4-65-9
87-654
12-487
45----
684764</textarea><br />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

Pyth, 93 bytes

A,hlh.zjJ\-.zKsm?qdJd\#HD'b=KXKbJR+i@HbTsm?&&gd0<dlKq@Kd\#'d0[tbhb-bG+bG;Wh=NxK\#=+Y'N)h.MZY

Pruébalo en línea!

Cómo funciona

Primer paso: leer la entrada

A,hlh.zjJ\-.zKsm?qdJd\#H
A,                           Assign the following to G and H:
  hlh.z                          G = increment(length(first(all_input())))
       jJ\-.z                    H = join(J="-",all_input())
                m       H    for d in H:
                 ?qdJ            if equal(d,J):
                     d               add d to the list
                                 else:
                      \#             add "#" to the list
                             end
               s             sum the list
              K              assign to K

Sample input:
11-011123
111-010--
0010---01
111-01234

G = 10
H = "11-011123-111-010---0010---01-111-01234" (note the extra dashes connecting each line)
J = "-"
K = "##-######-###-###---####---##-###-#####"

Segundo paso: definir una función para evaluar un área

D'b=KXKbJR+i@HbTsm?&&gd0<dlKq@Kd\#'d0[tbhb-bG+bG;
D'b                                             ;  def quote(b):
   =KXKbJ                                              K[b] = J
         R+                                            return the sum of A and B, where:
           i@HbT                                         A = to_integer(H[b],10)

                 m                   [tbhb-bG+bG         for d in {dec(b), inc(b), minus(b,G), add(b,G)}:
                  ?&&                                      if .... and ........ and ............... :
                     gd0                                      d>=0
                        <dlK                                           d<len(K)
                            q@Kd\#                                                  equal(K[d],"#")
                                  'd                           add quote(d) to temp_list
                                                           else:
                                    0                          add 0 to temp_list
                s                                        B = sum(temp_list)

Basically, this function (quote) is given a starting
point (b), and then recursively find its neighbour and
add their values to the output.

Tercer paso: lea todas las áreas y encuentre el máximo requerido

Wh=NxK\#=+Y'N)h.MZY
Wh=NxK\#     )         while inc(N=find(K,"#")):   --while K still has "#"
        =+Y'N              Y+= quote(N)
               .MZY    find the maximum of Y,
              h        then print the first.