मैदान पर उच्चतम स्कोर

Question

परिचय

एक फ़ील्ड को केवल वर्णों से भरा एक आयत बनाते हैं -और [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

Comments

वाह ... अच्छी चुनौती।

— आर। काप

"0010 --- 01" इसके बजाय ["0010", "", "", "01"] नहीं है?

— शुक्र

"111-01234" भी, ऐसा क्यों नहीं है ["111", "01234"]?

— शुक्र

मुझे समझ नहीं आ रहा है। मैंने सोचा कि -क्षेत्रों को अलग किया जाए? क्या आप "क्या एक क्षेत्र को परिभाषित करता है" भाग को स्पष्ट कर सकते हैं, कृपया?

— शुक्र

क्या आप यह समझाने की चुनौती दे सकते हैं?

— शुक्र

Answer 1

MATL , 54 51 49 बाइट्स

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

इनपुट MATL (AB) प्रारूप में एक 2 डी चार सरणी है, जिसमें ;पंक्ति विभाजक है। उदाहरण और परीक्षण मामलों में इनपुट क्रमशः हैं:

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

इसे ऑनलाइन आज़माएं!

व्याख्या

यह संबंध से परिभाषित ग्राफ के एक आसन्न मैट्रिक्स के निर्माण से काम करता है "जुड़ा हुआ है"। एक उदाहरण के रूप में, 3 × 4 क्षेत्र पर विचार करें

52-4
15-8
3-72

एक 2D सरणी में प्रविष्टियां MATL (स्तंभ-प्रमुख) रैखिक अनुक्रमण का उपयोग करके आसानी से वर्णित हैं। 3 × 4 मामले में, प्रत्येक प्रविष्टि के रैखिक सूचकांक के रूप में दिया गया है

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

आसन्न मैट्रिक्स मैट्रिक्स गुणन का उपयोग करके चरणों में बनाया गया है। पहले चरण में, तत्काल पड़ोसियों पर विचार किया जाता है। उदाहरण के लिए, अंक 3 अनुक्रमित के साथ स्वयं का और उसी का पड़ोसी है। यह 6 का पड़ोसी नहीं है क्योंकि उस बिंदु में फ़ील्ड के अनुसार कोई संख्या नहीं है। इस उदाहरण में "तत्काल-पड़ोसी" संबंध के आसन्न मैट्रिक्स 12 × 12 मैट्रिक्स एल के रूप में दिया गया है

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उन बिंदुओं के लिए मूल्य है जो शामिल नहीं हैं -।

अगला कदम संबंध के आसन्न मैट्रिक्स होगा " बीच में सबसे अधिक एक बिंदु पर जुड़ा हुआ है "। इसे प्राप्त करने के लिए, यह एल को खुद से गुणा करने और नॉनजेरो प्रविष्टियों को सेट करने के लिए पर्याप्त है 1। सामान्य तौर पर, संबंध के आसन्न मैट्रिक्स " कुछ पथ द्वारा जुड़ा हुआ है ", एम , एल को एक संभावित (मैट्रिक्स अर्थ में) बढ़ाकर प्राप्त किया जाता है जो अधिकतम संभव पथ की लंबाई का प्रतिनिधित्व करता है। अधिकतम पथ लंबाई की एक ऊपरी सीमा एल में नॉनज़ेरो प्रविष्टियों की संख्या है ।

मैट्रिक्स पावर की गणना करने से सीधे अतिप्रवाह हो सकता है, क्योंकि बड़ी संख्या में जल्दी होते हैं। इसलिए बड़ी संख्या में निर्माण को रोकने के लिए प्रत्येक चरण के बाद नॉनज़ेरो प्रविष्टियों को 1 में परिवर्तित करना, एक ही मैट्रिक्स द्वारा धीरे-धीरे गुणा करना बेहतर होता है।

कॉलम मैं के एम अंक उस बिंदु के साथ (किसी भी मार्ग से) से जुड़े हुए हैं का प्रतिनिधित्व करता है मैं । अब, लेवल फ़ील्ड को रैखिक क्रम में एक कॉलम वेक्टर सी में घटाया जा सकता है , जहां प्रत्येक प्रविष्टि में संबंधित संख्या या इसके लिए एक अपरिभाषित मान होता है -। तो इस मामले में सी होगा

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

के प्रत्येक स्तंभ Mutiplying एम द्वारा ग तत्व के लिहाज से और प्रत्येक स्तंभ का योग कंप्यूटिंग देता है, प्रत्येक बिंदु के लिए मैं , क्षेत्र बिंदु के कुल स्कोर मैं के अंतर्गत आता है। एक क्षेत्र को सभी बिंदुओं द्वारा परिभाषित किया गया है जो पारस्परिक रूप से जुड़े हुए हैं। ध्यान दें कि कई कॉलम समान परिणाम देंगे; अर्थात्, कॉलम मैं और जे एक ही राशि है, तो अंक दे देंगे मैं और जे (एक ही क्षेत्र से संबंधित) से जुड़े हुए हैं। अंतिम परिणाम उन रकमों का अधिकतम है।

        % 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

Answer 2

जावास्क्रिप्ट (ईएस 6), 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>

Answer 3

पायथ, 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.