บทนำ

ให้สนามเป็นรูปสี่เหลี่ยมผืนผ้าที่เต็มไปด้วยเพียงตัวละครและ- [0-9]ตัวอย่างของฟิลด์คือ:

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

คุณเห็นว่าฟิลด์นี้ถูกแยกออกเป็นสามส่วนเล็ก ๆ :

ในการคำนวณคะแนนของพื้นที่ที่เล็กกว่าเราเพียงแค่เพิ่มตัวเลขทั้งหมด ตัวอย่างเช่น:

11
111
0010
111

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

คะแนนรวมสำหรับพื้นที่นี้เป็น9 ตอนนี้เราทำสิ่งเดียวกันสำหรับพื้นที่ที่สอง:

   011123
    010

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

คะแนนรวมยังเป็น9 ตอนนี้เราต้องตรวจสอบพื้นที่สุดท้าย:

       01
    01234

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

นี้มีคะแนนรวม11 คะแนนสูงสุดในสนามคือ 11 ดังนั้นนี่คือสิ่งที่เราต้องการออก

งาน

รับสนาม (ในรูปแบบของสตริง 2D, อาเรย์, ฯลฯ ) ส่งออกคะแนนสูงสุดในสนาม คุณอาจจะคิดว่าช่องที่ระบุจะเสมอมีอย่างน้อย 1 บาท นี่คือโค้ดกอล์ฟดังนั้นการส่งที่มีจำนวนไบต์น้อยที่สุดจะชนะ!

กรณีทดสอบ

กรณีทดสอบ 1:

Input:
1

Output:
1

กรณีทดสอบ 2:

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

Output:
2

กรณีทดสอบ 3:

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

Output:
69

กรณีทดสอบ 4:

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

Output:
3

MATL , 54 51 49 ไบต์

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

อินพุตเป็นอาร์เรย์ถ่าน 2 มิติในรูปแบบ MATL (AB) โดยมี;ตัวคั่นแถว อินพุตในตัวอย่างและในกรณีทดสอบตามลำดับ:

['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']

ลองออนไลน์!

คำอธิบาย

สิ่งนี้ทำงานได้โดยการสร้างเมทริกซ์ adjacency ของกราฟที่กำหนดโดยความสัมพันธ์ "กำลังเชื่อมต่อ" ยกตัวอย่างเช่นพิจารณาฟิลด์ 3 × 4

52-4
15-8
3-72

รายการในอาร์เรย์ 2D อธิบายได้ง่ายใน MATL โดยใช้การจัดทำดัชนีเชิงเส้น ในกรณี 3 × 4 ดัชนีเชิงเส้นของแต่ละรายการจะได้รับเป็น

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

adjacency matrix ถูกสร้างขึ้นในขั้นตอนโดยใช้การคูณเมทริกซ์ ในขั้นตอนแรกจะพิจารณาประเทศเพื่อนบ้านทันที ตัวอย่างเช่นจุดที่จัดทำดัชนี 3 คือเพื่อนบ้านของตัวเองและของที่มีดัชนี 2 มันไม่ใช่เพื่อนบ้านของ 6 เพราะจุดนั้นไม่ได้มีตัวเลขตามเขตข้อมูล ในตัวอย่างนี้เมทริกซ์ adjacency ของความสัมพันธ์ "เพื่อนบ้านทันที" คือ 12 × 12 เมทริกซ์Lให้เป็น

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

(มันสามารถเห็นได้ว่าคอลัมน์ที่ 3 มีค่า1ในแถวที่ 2 และ 3) เมทริกซ์นี้อยู่เสมอสมมาตรและเส้นทแยงมุมของมีค่าสำหรับจุดที่ไม่ได้มี1-

ขั้นตอนต่อไปคือเมทริกซ์ adjacency ของความสัมพันธ์ "เชื่อมโยงกับจุดหนึ่งมากที่สุดระหว่าง " ที่จะได้รับมันพอเพียงที่จะคูณL1ด้วยตัวเองและชุดภัณฑ์รายการไป โดยทั่วไปเมทริกซ์ adjacency ของความสัมพันธ์ "เชื่อมต่อโดยบางเส้นทาง", M , ได้มาจากการเพิ่มLให้เป็นเลขชี้กำลัง (ในความหมายของเมทริกซ์) ที่แสดงถึงความยาวเส้นทางที่เป็นไปได้สูงสุด ผูกพันบนของความยาวเส้นทางสูงสุดคือจำนวนของรายการภัณฑ์ในL

การคำนวณพลังงานเมทริกซ์โดยตรงอาจทำให้เกิดการล้นเนื่องจากจำนวนมากจะเกิดขึ้นอย่างรวดเร็ว ดังนั้นจึงเป็นการดีที่จะค่อยๆคูณเมทริกซ์เดียวกันโดยแปลงรายการที่ไม่ใช่ศูนย์เป็น 1 หลังจากแต่ละขั้นตอนเพื่อป้องกันไม่ให้มีจำนวนมากขึ้น

คอลัมน์ฉันของMหมายถึงจุดที่มีการเชื่อมต่อ (โดยเส้นทางใด ๆ ) ที่มีจุดฉัน ตอนนี้ข้อมูลระดับจะลดลงคอลัมน์เวกเตอร์ค-ในการสั่งซื้อเชิงเส้นซึ่งแต่ละรายการมีตัวเลขที่สอดคล้องกันหรือไม่ได้กำหนดค่าสำหรับ ดังนั้นในกรณีนี้คจะเป็น

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

Mutiplying คอลัมน์ของแต่ละMโดยคองค์ประกอบที่ชาญฉลาดและการคำนวณผลรวมของแต่ละคอลัมน์จะช่วยให้สำหรับแต่ละจุดผม , คะแนนรวมของจุดพื้นที่ที่ฉันเป็น พื้นที่ถูกกำหนดโดยทุกจุดที่เชื่อมต่อกัน โปรดทราบว่าคอลัมน์จำนวนมากจะให้ผลลัพธ์เดียวกัน กล่าวคือคอลัมน์iและjจะให้ผลรวมเท่ากันถ้าคะแนน iและjเชื่อมต่อกัน (อยู่ในพื้นที่เดียวกัน) ผลสุดท้ายคือผลรวมสูงสุด

        % 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 ไบต์

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

คำอธิบาย

ใช้ฟิลด์อินพุตเป็นสตริง สำหรับแต่ละหมายเลขในฟิลด์จะสรุปตัวเลขทั้งหมดในพื้นที่ มันทำเช่นนี้โดยวนซ้ำในแต่ละหมายเลขในฟิลด์หลาย ๆ ครั้งโดยเพิ่มจำนวนลงในคะแนนหากเซลล์ที่อยู่ติดกันมีจำนวนที่นับก่อนหน้านี้ ตัวเลขที่นับที่เป็นส่วนหนึ่งของพื้นที่จะถูกแสดงด้วยการตั้งค่าเป็น 99 เพื่อที่จะไม่ถูกนับอีกครั้ง ส่งออกคะแนนสูงสุดเป็นตัวเลข

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 ไบต์

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

ลองออนไลน์!

มันทำงานอย่างไร

ขั้นตอนแรก: อ่านอินพุต

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 = "##-######-###-###---####---##-###-#####"

ขั้นตอนที่สอง: กำหนดฟังก์ชั่นเพื่อประเมินพื้นที่หนึ่ง

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.

ขั้นตอนที่สาม: อ่านพื้นที่ทั้งหมดและค้นหาค่า rqeuired สูงสุด

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.