पड़ोसियों की सबसे बड़ी राशि के साथ संख्या का पता लगाएं

Question

चुनौती

संख्याओं की एक ग्रिड को देखते हुए (10 <= N <= 99) इसके समीप की चार संख्याओं के उच्चतम योग के साथ वापसी संख्या; यह संख्या के ऊपर, नीचे, दाएं और बाएं नंबर है, लेकिन स्वयं नहीं।

1. संख्या खुद ही नहीं गिनती, केवल उसके चार पड़ोसी।
2. किनारे पर एक संख्या को माना जाना चाहिए जैसे कि लापता संख्या 0 है।
3. मैं संबंधों से बचने के लिए परीक्षा को डिजाइन करूंगा।
4. नंबर नहीं दोहराएंगे।
5. यह कोड-गोल्फ है ।

उदाहरण

दिया हुआ

56 98 32 96
12 64 45 31
94 18 83 71

वापसी

18

एक वास्तविक परीक्षण

दिया हुआ

98 95 67 66 57 16 40 94 84 37
87 14 19 34 83 99 97 78 50 36
18 44 29 47 21 86 24 15 91 61
60 41 51 26 10 58 11 62 55 71
42 85 56 12 46 81 93 65 49 77
89 13 74 39 54 76 92 33 82 90
96 88 70 79 80 28 25 20 75 68
38 63 17 72 53 48 73 30 45 69
64 35 32 31 23 43 22 52 27 59

वापसी

13

दिया हुआ

82 43 79 81 94 36 17 64 58
24 52 13 87 70 18 28 61 69
16 99 75 21 50 44 89 90 51
49 80 63 31 54 65 41 55 38
67 91 76 78 23 86 83 14 73
46 68 62 77 34 48 20 74 10
33 35 26 97 59 66 25 37 32
12 92 84 27 85 56 22 40 45
96 15 98 53 39 30 88 71 29
60 42 11 57 95 19 93 72 47

वापसी

15

Comments

" किनारे पर एक संख्या को माना जा सकता है क्योंकि लापता संख्या एक 0. है " - इसका मतलब है कि हमारे पास एक विकल्प है कि ग्रिड के किनारे पर संख्याओं को कैसे संभालना है। इसलिए हम ग्रिड के दूसरी तरफ घूमने का विकल्प चुन सकते हैं?

— शैगी

@ शगुन नं। जो अपेक्षित परिणाम बदल सकता है। चलो सब इसी तरह करते हैं। पाठ अपडेट किया गया / कर सकते हैं / चाहिए / /

— छाता

अपरिहार्य MATL उत्तर की प्रतीक्षा कर रहा है

— घातक

मुझे लगता है कि अधिकांश समाधान इनपुट को किसी तरह से परिवर्तित करते हैं। क्या वह पारंपरिक है यहां? मेरे (अभी तक पोस्ट किए जाने वाले) समाधान में इनपुट को म्यूट करने के लिए आवश्यक बाइट्स शामिल हैं और मैं सोच रहा हूं कि कई अन्य क्यों नहीं करते हैं।

— छाता

@Umbrella हम आम तौर पर परवाह नहीं करते हैं अगर इनपुट संशोधित हो जाता है। हम शॉर्ट कोड में रुचि रखते हैं, न कि क्लीन कोड में। जब तक आउटपुट सही है, तब तक हम काफी हद तक पारंगत हैं।

Answer 1

MATL , 20 15 13 12 बाइट्स

t1Y6Z+tuX>=)

5 बाइट्स एमिग्ना के लिए धन्यवाद, 2 ग्यूसेप के लिए धन्यवाद, और लुइस मेंडो के लिए एक और धन्यवाद।
इसे ऑनलाइन आज़माएं!

व्याख्या

t1Y6Z+tuX>=)
t                  Duplicate the (implicit) input.
 1Y6               Push the array [0 1 0; 1 0 1; 0 1 0].
    Z+             Convolve with the input.
       uX>         Get the maximum unique element...
      t   =        ... and compare elementwise.
           )       Index into the input.

Answer 2

एपीएल (डायलॉग यूनिकोड) , 31 27 26 24 23 बाइट्स ^{एसबीसीएस}

-2 गायों को धन्यवाद। -1 ngn के लिए धन्यवाद।

बेनामी tacit उपसर्ग समारोह। एक मैट्रिक्स को तर्क के रूप में लेता है। मान लिया गया है ⎕IO( मैं ndex हे rigin) होने के लिए 0है, जो कई सिस्टम पर डिफ़ॉल्ट है।

{⊃⍒,(+/--/)⊢∘,⌺3 3⊢⍵}⊃,

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

, ravel (समतल) इनपुट

{… }⊃ निम्नलिखित फ़ंक्शन के परिणाम के अनुसार उसमें से एक तत्व चुनें:

 ⊢⍵ तर्क उपजें (से अलग करता 3 3है ⍵)

 … ⌺3 3 प्रत्येक 3-बाय -3 पड़ोस में निम्नलिखित फ़ंक्शन लागू करें:

  ⊢∘, नेवला (चपटा) पड़ोस के पक्ष में बढ़त-जानकारी की उपेक्षा करें

  (… ) उन लोगों के लिए निम्नलिखित tacit फ़ंक्शन लागू करें

   -/ वैकल्पिक राशि (दाएं-दाएं-साहचर्य में कमी)

   +/- योग से घटाएँ (यह हर दूसरे तत्व का योग देता है)

 , उठाव (समतल) कि (पड़ोस रकम)

 ⍒ ऐसे सूचकांकों का उत्पादन करेंगे जो कि छांटेंगे

 ⊃ पहले उठाओ (यानी उच्चतम राशि का सूचकांक)

Comments

यह तेज़ था। क्या आप तैयार होकर आए थे? ;)

— अम्ब्रेला

@Umbrella नहीं, मैं सिर्फ एक प्रोग्रामिंग भाषा का उपयोग करता हूं जो कि प्रोग्राम के लिए त्वरित है।

— Adám

यह कैसे है {⊃⍒,{+/1↓⍉4 2⍴⍵}⌺3 3⊢⍵}⊃,? संपादित करें: या यहां तक ​​कि{⊃⍒,{⊢/+⌿4 2⍴⍵}⌺3 3⊢⍵}⊃,

— user41805

@ कॉक्सैक मैं हमेशा उस ट्रिक को भूल जाता हूं।

— आरा

-1 बाइट:{⊃⍒,(+/--/)⊢∘,⌺3 3⊢⍵}⊃,

— ngn

Answer 3

जेली , 22 बाइट्स

;€0ZṙØ+SṖ
,ZÇ€Z+$/ŒMœị

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

MATL और Dyalog की तरह बिल्ट-इन इंवोल्यूशन नहीं होने से आपकी भाषा को भूल जाने से कन्वेंशन बिल्ट-इन (थैंक्यू @dylnan) दर्द होता है, लेकिन हम उनके बिना ठीक तरह से कर सकते हैं, आंशिक रूप से धन्यवाद ŒMऔर œị। सबसे पहले, केवल एक दिशा में पड़ोसियों की गणना करने के लिए एक सहायक कार्य, जो संयोगवश इनपुट स्थानांतरित करता है:

;€0Z         Append a zero to each row, then transpose.
    ṙØ+S     Rotate by +1 and −1 (Ø+ = [1,-1]) and sum these.
        Ṗ    Pop the last row.

नेत्रहीन, गणना है:

1 2 3   ;€0   1 2 3 0   Z   1 4 7   ṙØ+     2 5 8   0 0 0     S   2  5  8   Ṗ   2  5  8
4 5 6  ————→  4 5 6 0  ——→  2 5 8  ————→  [ 3 6 9 , 1 4 7 ]  ——→  4 10 16  ——→  4 10 16
7 8 9         7 8 9 0       3 6 9           0 0 0   2 5 8         2  5  8       2  5  8
                            0 0 0           1 4 7   3 6 9         4 10 16

व्याख्या: इस परिणाम का सेल (x, y) सेल (y, x) के क्षैतिज पड़ोसियों का योग है। (उदाहरण के लिए, यहाँ हम देखते हैं कि f (A) [2,3] = 16 = 7 + 9 = A [3,1] + A [3,3] ।)

फिर, मुख्य कार्य:

,ZÇ€            Pair the input with its transpose and apply helper to both.
    Z+$/        Fold by Z+, i.e., turn [X,Y] into transpose(X)+Y.
                Now we've summed the horizontal and vertical neighbors for each cell.
        ŒM      Find the 2D index of the maximal value.
          œị    2D-index (into the original input).

Comments

किस बारे में æc?

— डायलन

ओह, मैं इसके बारे में नहीं जानता था :) मैं बहुत अधिक गोल्फ में व्यस्त हूं इसलिए इसका उपयोग करने के लिए उत्तर लिखने के लिए स्वतंत्र महसूस करता हूं।

— लिन

Answer 4

जेली , 18 बाइट्स

5BæcµḊṖ)
ZÇZ+ÇŒMœị

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

सहायक फ़ंक्शन प्रत्येक पंक्ति में प्रत्येक तत्व के पड़ोसियों को ढूंढता है। मुख्य कार्य यह पंक्तियों और स्तंभों के लिए करता है और फिर उस तत्व को खोजता है जिसमें अधिकतम पड़ोस राशि है।

5BæcµḊṖ)
5B           bin(5): 1,0,1
  æc         Convolve with [[1,2,9],[other rows]] (for example): [[1,2,10,2,9],...]
    µ        New chain.
       )     Apply this to each element:
     Ḋ       Remove the first element.
      Ṗ      Remove the last element.
             Gives [[2,10,2],...]

ZÇZ+ÇŒMœị   
Z            Zip the matrix
 Ç           Apply helper function
  Z          Zip again. Yields the sum of the vertical neighbors of each element.
   +         Add:
    Ç        The sum of each element's horizontal neighbors.
     ŒM      Find the multidimensional index of the maximal element.
       œị    Index back into the original matrix.

Answer 5

वोल्फ्राम भाषा (गणितज्ञ) , 58 बाइट्स

Im@Last[Union@@ListConvolve[{a={0,1,0},{1,I,1},a},#,2,0]]&

$\left( \begin{smallmatrix} 0 & 1 & 0 \\ 1 & i & 1 \\ 0 & 1 & 0 \end{smallmatrix} \right)$ , तत्व को सबसे बड़े वास्तविक भाग के साथ लें, और उसके काल्पनिक भाग को लें।

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

Answer 6

पायथन 2 , 127 बाइट्स

def f(a):n=len(a[0]);b=sum(a,[])+[0]*n;print b[max(range(len(b)-n),key=lambda i:b[i-1]*(i%n>0)+b[i+1]*(i%n<n-1)+b[i-n]+b[i+n])]

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

Answer 7

स्टैंसिल , 1 + 10 = 11 बाइट्स (गैर-प्रतिस्पर्धात्मक)

कमांड-लाइन विकल्प:  1 1 पीढ़ी की गणना करें

y⊃⍨⊃⍒,
+/N

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

y चपटा मूल इनपुट  से पहले  चपटा के  अवरोही क्रम में
⊃⍨ उठाओ
⊃
⍒
,

+/
N सॉन के बिना वॉन न्यूमनन पड़ोस  की रकम

Comments

बेशक वहाँ पड़ोसियों के लिए निर्मित एक चरित्र के साथ एक भाषा है।

— छाता

निष्पक्ष होना, इसका एकमात्र उद्देश्य इस प्रकार की समस्याओं को हल करना है ।

— अदाम

यह गैर-प्रतिस्पर्धा क्यों है?

— केविन क्रूज़सेन

@KevinCruijssen मैंने y भाषा में जोड़ा जब मैंने देखा कि इसे मूल इनपुट तक आसान पहुँच की आवश्यकता है। इससे पहले, आपको (,⍎'input')इसके बजाय लिखना था y।

— आदम

@ एडम आह ठीक है, हाँ, तो यह वास्तव में गैर-प्रतिस्पर्धात्मक है। ध्यान नहीं दिया गया था कि चुनौती कल पोस्ट की गई थी। यदि यह एक पुरानी चुनौती थी, गैर-प्रतिस्पर्धात्मक क्योंकि भाषा (या भाषा संस्करण) नया है, तो यह वर्तमान मेटा में अब गैर-प्रतिस्पर्धा नहीं करता है ।

— केविन क्रूज़सेन

Answer 8

जावास्क्रिप्ट (ईएस 6), 94 बाइट्स

a=>a.map(p=m=(r,y)=>p=r.map((v,x)=>(s=~r[x-1]+~p[x]+~(a[y+1]||0)[x]+~r[x+1])>m?v:(m=s,o=v)))|o

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

कैसे?

इसके बजाय 4 पड़ोसियों की राशि की अधिकतम की तलाश की, हम कम से कम देखने के मीटर राशि का है उनकी एक पूरक की। यह हमें शून्य मानों की तरह अपरिभाषित मूल्यों को संसाधित करने की अनुमति देता है, क्योंकि:

~undefined === -1
~0 === -1

आंतरिक मानचित्र () इस तरह से लिखा गया है कि यह पंक्ति आर की सामग्री को परिवर्तित नहीं करता है । इसलिए, हम अगले पुनरावृत्ति में शीर्ष पड़ोसियों का परीक्षण करने के लिए पी में इसके परिणाम को बचा सकते हैं ।

हम प्रयोग करते हैं:

• ~r[x-1] बाएं सेल के लिए
• ~r[x+1] सही सेल के लिए
• ~p[x] शीर्ष सेल के लिए
• ~(a[y+1]||0)[x] नीचे सेल के लिए

Answer 9

के (ngn / k) , ४३ ४० बाइट्स

{(,/x)@*>,/(+g@+x)+(g:{(+':x)-|-':|x})x}

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

Answer 10

जावा 8, 187 बाइट्स

m->{int r=0,l=m.length,i=l,L,j,S=0,s;for(;i-->0;)for(L=j=m[i].length;j-->0;)if((s=(i<1?0:m[i-1][j])+(i<l-1?m[i+1][j]:0)+(j<1?0:m[i][j-1])+(j<L-1?m[i][j+1]:0))>S){S=s;r=m[i][j];}return r;}

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

स्पष्टीकरण:

m->{                           // Method with integer-matrix parameter and integer return
  int r=0,                     //  Result-integer, starting at 0
      l=m.length,              //  Amount of rows
      i=l,                     //  Rows index integer
      L,                       //  Amount of columns
      j,                       //  Column index integer
      S=0,                     //  Largest sum of four cells
      s;                       //  Current sum of four cells
  for(;i-->0;)                 //  Loop over the rows
    for(L=j=m[i].length;j-->0;)//   Inner loop over the columns
      if((s=                   //    Set the current sum to: the sum of:
           (i<1?0:m[i-1][j])   //     Value of the cell to the left, or 0 if out of bounds
          +(i<l-1?m[i+1][j]:0) //     Value of the cell to the right, or 0 if out of bounds
          +(j<1?0:m[i][j-1])   //     Value of the cell down, or 0 if out of bounds
          +(j<L-1?m[i][j+1]:0))//     Value of the cell up, or 0 if out of bounds
         >S){                  //    If this current sum is larger than the largest sum:
        S=s;                   //     Replace the largest sum with this current sum
        r=m[i][j];}            //     And set the result to the current cell
  return r;}                   //  Return the result

Answer 11

जावास्क्रिप्ट ईएस 6, 170 बाइट्स

c=g=>{s=0;n=0;f=m=>m||[];for(i=0;i<g.length;i++)for(j=0;j<g[i].length;j++){s=~~f(g[i-1])[j]+~~f(g[i+1])[j]+~~f(g[i])[j-1]+~~f(g[i])[j+1];b=s>n?g[i][j]+!(n=s):b;}return b}

Comments

PPCG में आपका स्वागत है! आपका कोड मान लेता है कि इनपुट g नाम के एक चर में संग्रहीत है , जिसकी अनुमति नहीं है । आपको या तो एक पूरा कार्यक्रम लिखना चाहिए जो इनपुट या एक फ़ंक्शन (जो आमतौर पर और जेएस में पसंदीदा तरीका है) पढ़ता है।

— अरनुलद

@Arnauld धन्यवाद! मैंने कोड निर्धारित किया

— जीन-फिलिप लेक्लर्क

आप परीक्षण को आसान बनाने के लिए TIO लिंक जोड़ने पर विचार कर सकते हैं । (मैं एक टिप्पणी में लिंक फिट करने के लिए 2 के परीक्षण के मामले को हटा दिया।)

— अरनौल्ड