सेल के पड़ोसी खोजें

Question

... या टॉरॉयडल मूर नेबरहुड

सकारात्मक पूर्णांक और एक गैर-नकारात्मक पूर्णांक को देखते हुए h, आसपास के सभी सूचकांकों को लौटाएं ।wii

आप एक मैट्रिक्स को मानने वाले हैं, जिसमें तत्वों की hपंक्तियों से युक्त w, सबसे ऊपर से बाएँ बाएँ कोने में, सबसे ऊपर, नीचे दाएँ हाथ के कोने में, और वापसी, किसी भी उचित प्रारूप में, सूचकांकों की एक सूची होगी। सूचकांक के चारों ओर i। यह मैट्रिक्स एक टोरस (एक अनंत नक्शा है जो प्रत्येक किनारे के चारों ओर लपेटता है)।

उदाहरण के लिए, इनपुट h=4और w=4मैट्रिक्स में परिणाम होगा:

 0  1  2  3 
 4  5  6  7
 8  9 10 11
12 13 14 15

लेकिन अधिक विशेष रूप से:

15 12 13 14 15 12
 3  0  1  2  3  0
 7  4  5  6  7  4
11  8  9 10 11  8
15 12 13 14 15 12
 3  0  1  2  3  0

यदि ऐसा iथा 0, तो आपको वापस लौटना होगा 15, 12, 13, 3, 1, 7, 4, 5(0-आधारित)।

उदाहरण

0-आधारित:

h   w   i       Expected result

4   4   5       0, 1, 2, 4, 6, 8, 9, 10
4   4   0       15, 12, 13, 3, 1, 7, 4, 5
4   5   1       15, 16, 17, 0, 2, 5, 6, 7
1   3   2       1, 2, 0, 1, 0, 1, 2, 0
1   1   0       0, 0, 0, 0, 0, 0, 0, 0

1 के आधार पर:

h   w   i       Expected result

4   4   6       1, 2, 3, 5, 7, 9, 10, 11
4   4   1       16, 13, 14, 4, 2, 8, 5, 6
4   5   2       16, 17, 18, 1, 3, 6, 7, 8
1   3   3       2, 3, 1, 2, 1, 2, 3, 1
1   1   1       1, 1, 1, 1, 1, 1, 1, 1

नियम

• आपका उत्तर 0 या 1-अनुक्रमित हो सकता है, आपकी पसंद, कृपया निर्दिष्ट करें।
• आप ऐसा मान सकते हैं i < h * w(या i <= h * w1-अनुक्रमित उत्तरों के लिए)।
• आप ऐसा मान सकते हैं i >= 0(या i > 01-अनुक्रमित उत्तरों के लिए)।
• लौटाए गए मूल्यों का क्रम तब तक महत्वपूर्ण नहीं है जब तक कि केवल आठ वांछित मूल्य शामिल नहीं किए जाते हैं।
• मानक खामियों को मना किया जाता है ।
• यह कोड-गोल्फ है इसलिए प्रत्येक भाषा में सबसे छोटा उत्तर, जीतता है!

^{के लिए धन्यवाद @Conor ओ ब्रायन लग शीर्षक और अधिक तकनीकी के लिए @ngm अधिक परीक्षण मामलों के लिए!}

Comments

क्या हम पड़ोसियों की 3-बाय -3 मैट्रिक्स वापस कर सकते हैं?

— Adám

@ Adám यदि संभव हो तो केंद्र सेल को शामिल नहीं करने के लिए सूची को पसंद करूंगा। लेकिन सराहना करते हैं कि पहले से ही उत्तर हैं। क्या इसे छानना काफी आसान है?

— डोम हेस्टिंग्स

क्या आदेश देता है?

— रॉबर्ट फ्रेजर

@RobertFraser आदेश महत्वपूर्ण नहीं है। मैं इसे नियमों में जोड़ दूंगा।

— डोम हेस्टिंग्स

@DomHastings मैं उस टिप्पणी की व्याख्या करता हूं: इसे 3 मैट्रिक्स द्वारा 3 वापस करने या केंद्र कक्ष को शामिल करने की अनुमति नहीं है?

— जुंगह्वान मिन

Answer 1

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

सहेजे गए 2 बाइट @KevinCruijssen को धन्यवाद

0-आधारित सूचकांक की अपेक्षा करता है।

(h,w,i)=>[...'12221000'].map((k,j,a)=>(i+w+~-k)%w+~~(i/w+h+~-a[j+2&7])%h*w)

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

आसपास के सूचकांकों को निम्नलिखित क्रम में लौटाया जाता है:

$$\begin{matrix}5&4&3\\6&\cdot&2\\7&0&1\end{matrix}$$

कैसे?

सूचकांक पर प्रत्येक आसपास के सेल की ( एक्स + घ एक्स , वाई + घ y ) द्वारा दिया जाता है:$I_{dx,dy}$$(x+dx,y+dy)$

$$\begin{align}I_{dx,dy}&=((x+dx) \bmod w)+w((y+dy) \bmod h)\\&=((N+dx) \bmod w)+w((\left\lfloor\frac{N}{w}\right\rfloor+dy) \bmod h)\end{align}$$

जहाँ लक्ष्य सेल का सूचकांक है।$N=wy+x$

हम सूची के माध्यम से चलना और घटाना 1 का मान प्राप्त करने के लिए डी एक्स , जो देता है:$[1,2,2,2,1,0,0,0]$$1$$dx$

$$[0,1,1,1,0,-1,-1,-1]$$

के संबंधित मानों के लिए , हम उसी स्थान का उपयोग करते हैं जिसे 2 स्थितियों द्वारा स्थानांतरित किया गया है, जो देता है:$dy$

$$[1,1,0,-1,-1,-1,0,1]$$

Comments

w*(~~(i/w+h+~-a[j+2&7])%h)करने के लिए ~~(a[j+2&7]-1+i/w+h)%h*wकोष्ठक की एक जोड़ी से छुटकारा हो रही द्वारा 2 बाइट्स बचाता है।

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

@KevinCruijssen अच्छा कैच। धन्यवाद!

— अरनुलद

Answer 2

APL (Dyalog Classic) , 27 बाइट्स

{(⍺⊥⍺|(⍺⊤⍵)-⊢)¨1-1↓4⌽,⍳3 3}

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

{ }तर्क ⍺(आयाम h w) और ⍵(सूचकांक i) के साथ एक समारोह है

⍳3 3सभी 2 अंकों त्रिगुट नंबर की एक मैट्रिक्स है: 0 0, 0 1, ...,2 2

, मैट्रिक्स को वेक्टर के रूप में लागू करता है

1↓4⌽केंद्र तत्व को हटा 1 1बाएं (4 घूर्णन द्वारा 4⌽() और एक छोड़ने 1↓)

1- 1 से घटाकर, सभी 8 पड़ोसी ऑफ़सेट देते हैं

( )¨ प्रत्येक ऑफसेट के लिए कोष्ठक में फ़ंक्शन ट्रेन लागू करता है

⍺⊤⍵मैट्रिक्स का बेस- ⍺इनकोडिंग है ⍵- निर्देशांक⍵

(⍺⊤⍵)-⊢ एक पड़ोसी के निर्देशांक देते हुए, वर्तमान ऑफसेट को घटाता है

⍺|aनिर्देशांक के चारों ओर लपेटने और मैट्रिक्स के भीतर रहने के लिए मॉड है

⍺⊥ आधार से डीकोड ⍺

Answer 3

एपीएल (Dyalog यूनिकोड) , 40 बाइट्स ^SBCS

अनाम शिशु फ़ंक्शन। h wबाएं तर्क के iरूप में और सही तर्क के रूप में लेता है।

{1↓4⌽,3 3↑,⍨⍣2⍪⍨⍣2⊃⊖∘⍉/(¯1+⍺⊤⍵),⊂⍺⍴⍳×/⍺}

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

{... } "dfn"; ⍺बाएं तर्क (आयाम) है और ⍵सही तर्क (इंडेक्स) है।

 ×/⍺ आयामों का उत्पाद (गुणन-कमी)

 ⍳ पहले कई सूचकांकों

 ⍺⍴ आयामों का उपयोग r rhape कि

 ⊂ इसे संलग्न करें (इसे एक एकल तत्व के रूप में मानें)

 (… ), निम्नलिखित को प्रस्तुत करें:

  ⍺⊤⍵ मिश्रित-मूलांक में सूचकांक को सांकेतिक शब्दों में बदलना h w(यह हमें सूचकांक के निर्देशांक देता है)

  ¯1+ उन निर्देशांक में नकारात्मक जोड़ें

 ⊖∘⍉/ घुमा-फिराकर कम
  ^{करें यह इसके बराबर है y⊖⍉x⊖⍉... जो इसके बराबर है y⊖x⌽... जो बाएं चरणों को iदाएं (कम एक) तक iऑफसेट करता है , और नीचे की ओर कई चरणों के रूप में घूमता है जो ऑफसेट (कम एक) है, जिसके कारण 3-बाय -3 मैट्रिक्स हम शीर्ष बाएं कोने में होना चाहते हैं}

 ⊃ खुलासा (क्योंकि कमी ने वेक्टर को स्केलर से कम कर दिया है)

 ⍪⍨⍣2 दो बार अपने आप से ऊपर ढेर (हमें केवल एकल-पंक्ति मैट्रिस के लिए तीन बार चाहिए)

 ,⍨⍣2 खुद को दो बार अपील करें (हमें केवल एकल-कॉलम मैट्रिस के लिए तीन बार चाहिए)

 3 3↑ पहले तीन कॉलम की पहली तीन पंक्तियों को लें

यदि 3-बाय -3 मैट्रिक्स लौटना स्वीकार्य है तो अगले दो चरणों को छोड़ दिया जा सकता है:

 , उठाव (चपटा)

 4⌽ बाएं चार चरणों को घुमाएं (केंद्र तत्व को सामने लाते हैं)

 1↓ पहला तत्व छोड़ो

Comments

@ Adám ऊपर को ठीक करें और इसे छोटा करें: {,(⍺⊥⍺|(⍺⊤⍵)-⊢)¨1-⍳3 3}मुझे यकीन नहीं है कि अगर आपको मध्य तत्व को भी हटा देना चाहिए: {4⌽1↓4⌽...}

— nn

@ उह, यह काफी मूल है। आप उस पोस्ट!

— एडम जूल 18'18

@ Adám ok

— ngn

मुझे नहीं लगता कि आउटपुट में केंद्र तत्व होने की उम्मीद है।

— जुंगह्वान मिन

पिछले परीक्षण मामले में अभी भी 8 तत्व हैं। मुझे लगता है कि अपेक्षित उत्पादन पड़ोसियों को सापेक्ष पदों पर मुद्रित करना है[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]

— जुंगह्वान मिन

Answer 4

पायथन 2 , 79 69 66 बाइट्स

lambda h,w,i:[(i+q%3-1)%w+(i/w+q/3-1)%h*w for q in range(9)if q-4]

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

3 बाइट्स द्वारा उपहार में नील यह देखते हुए कि (x*w)%(h*w)==((x)%h)*w==(x)%h*w।

0-अनुक्रमित समाधान।

Comments

%h*w 3 बाइट्स बचाता है *w%(h*w)।

— नील

Answer 5

आर , 125 111 108 बाइट्स

function(x,i,m=array(1:prod(x),x),n=rbind(m,m,m),o=cbind(n,n,n),p=which(m==i,T)+x-1)o[p[1]+0:2,p[2]+0:2][-5]

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

14 और 8 बाइट्स @JayCe और @ मर्क द्वारा गॉकेटेड हैं।

इनपुट [w, h], iइसलिए है क्योंकि R पहले कॉलम में एरेज़ को पॉप्युलेट करता है।

सरणी बनाता है और फिर "triples" यह पंक्ति और स्तंभ-वार। फिर iमूल सरणी में ढूंढें और खोजें कि यह पड़ोस है। बिना उत्पादन i।

Comments

आप 14 बाइट्स बचा सकते हैं । मुझे नहीं पता था कि जिसके पास एक गिरफ्तारी का तर्क था, उसने आज कुछ सीखा!

— JayCe

आप को बचा सकता है 8 बाइट्स की जगह seq()के साथ1:

— मार्क

Answer 6

PHP , 165 बाइट्स

यह "0-आधारित" है। PHP में एक बेहतर समाधान होना चाहिए, लेकिन यह एक प्रारंभिक बिंदु है!

<?list(,$h,$w,$i)=$argv;for($r=-2;$r++<1;)for($c=-2;$c++<1;)$r||$c?print(($k=(int)($i/$w)+$r)<0?$h-1:($k>=$h?0:$k))*$w+(($l=$i%$w+$c)<0?$w-1:($l>=$w?0:$l))%$w.' ':0;

इसे चलाने के लिए:

php -n <filename> <h> <w> <i>

उदाहरण:

php -n cell_neighbours.php 4 5 1

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

Answer 7

के (ngn / k) , 27 24 बाइट्स

{x/x!''(x\y)-1-3\(!9)^4}

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

{ }तर्क x(आयाम h w) और y(सूचकांक i) के साथ एक समारोह है

(!9)^4के 0 1 2 3 4 5 6 7 8बिना है4

3\ त्रिगुट में एनकोड: (0 0;0 1;0 2;1 0;1 2;2 0;2 1;2 2)

1-1पड़ोसी को देने से घटाव :(1 1;1 0;1 -1;0 1;0 -1;-1 1;-1 0;-1 -1)

x\yमैट्रिक्स का बेस- xइनकोडिंग है y- निर्देशांकy

- प्रत्येक ऑफसेट को घटाता है, जिससे हमें पड़ोसी निर्देशांक के 8 जोड़े मिलते हैं

x!''xप्रत्येक के लिए आधुनिक है - मैट्रिक्स के भीतर रहने के लिए चारों ओर से निर्देशांक लपेटें

x/आधार से डीकोड x- निर्देशांक के जोड़े को एकल पूर्णांक में बदल देता है

Comments

जिज्ञासा से बाहर, क्या आपके K के वैरिएंट में J "की तरह" रिवर्स तर्क "क्रिया विशेषण है ~?

— कॉनर ओ'ब्रायन

@ ConorO'Brien ks में से कोई भी मैं नहीं जानता (Kx का K, Kona, oK, और मेरा) इसके पास है, जो कि गोल्फ के लिए दुर्भाग्यपूर्ण है। केवल 6 बिल्ट-इन क्रियाविशेषण हैं: / \ '/: \:': और उपयोगकर्ता-परिभाषित के लिए कोई तंत्र नहीं है।

— ngn

बेशक मैं एक सेल्फी एडवर्ब जोड़ सकता था, लेकिन ngn / k के लिए गोल्फिंग अपने आप में एक अंत नहीं है, केवल परीक्षण के मामलों और अनुभव को संचित करने का एक साधन है।

— ngn 19'18

ये उचित है। बेशक, आप इसे भाषा की संभावित कमी के रूप में देख सकते हैं। मैंने Attache को विकसित करने में मदद करने के लिए PPCG का उपयोग किया है, और महसूस किया है कि Attache में कुछ बहुत ही उपयोगी फ़ंक्शंस की कमी है, जिन्हें मैंने अन्यथा शामिल नहीं किया है। मैं K का उपयोग नहीं करता, लेकिन शायद अन्य यूज़ेस हैं जो उस प्रकार की क्रिया विशेषण को वारंट कर सकते हैं?

— कॉनर ओ'ब्रायन

@ ConorO'Brien मैं ⍨एपीएल से परिचित हूं जो ~जे की तरह है और मैं इसकी उपयोगिता के बारे में आश्वस्त हूं, लेकिन, आप देखते हैं, कश्मीर मुद्रण योग्य ASCII तक सीमित है और (लगभग) कोई डिग्राफ नहीं है, इसलिए, एक नया क्रिया विशेषण मतलब होगा कार्यान्वयन के बीच कुछ अन्य उपयोगी आदिम और साथ ही अधिक असंगति का बलिदान। मैं यह नहीं देख सकता कि मैं इसे अंदर लाने के लिए क्या कर सकता हूं।

— ngn

Answer 8

MATL , 24 बाइट्स

*:2Geti=&fh3Y6&fh2-+!Z{)

इनपुट हैं h, w, i। आउटपुट संख्याओं के साथ एक पंक्ति वेक्टर या स्तंभ वेक्टर है।

इनपुट iऔर आउटपुट 1-आधारित हैं।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

*     % Take two inputs implicitly. Multiply
      % STACK: 16
:     % Range
      % STACK: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
2G    % Push second input again
      % STACK: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16], 4
e     % Reshape with that number of rows, in column-major order
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16]
t     % Duplicate
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16],
      %        [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16]
i=    % Take third input and compare, element-wise
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16],
      %        [0 0 0 0; 0 1 0 0; 0 0 0 0; 0 0 0 0]
&f    % Row and column indices of nonzeros (1-based)
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16], 2, 2,
h     % Concatenate horizontally
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16], [2 2]
3Y6   % Push Moore mask
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16], [2 2],
      %        [1 1 1; 1 0 1; 1 1 1]
&f    % Row and column indices of nonzeros (1-based)
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16], [2 2],
      %        [1; 2; 3; 1; 3; 1; 2; 3], [1; 1; 1; 2; 2; 3; 3; 3] 
h     % Concatenate horizontally
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16], [2 2],
      %        [1 1; 2 1; 3 1; 1 2; 3 2; 1 3; 2 3; 3 3] 
2-    % Subtract 2, element-wise
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16], [2 2],
      %        [-1 -1; 0 -1; 1 -1; -1 0; -1 0; -1 1; 0 1; 1 1] 
+     % Add, element-wise with broadcast
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16],
      %        [1 1; 2 1; 3 1; 1 2; 3 2; 1 3; 2 3; 3 3]
!     % Transpose
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16],
      %        [1 2 3 1 3 1 2 3; 1 1 1 2 2 3 3 3]
Z{    % Convert into a cell array of rows
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16],
      %        {[1 2 3 1 3 1 2 3], [1 1 1 2 2 3 3 3]}
)     % Index. A cell array acts as an element-wise (linear-like) index
      % STACK: [1 2 3 5 7 9 10 11]

Answer 9

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

Mod[i=#;w=#2;Mod[i+#2,w]+i~Floor~w+w#&@@@{-1,0,1}~Tuples~2~Delete~5,1##2]&

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

रिवर्स में इनपुट लेता है (i, w, h ), 0-आधारित।

इसमें केंद्र सेल के साथ 3x3 मैट्रिक्स, (60 बाइट्स)

(Join@@(p=Partition)[Range[#2#]~p~#,a={1,1};3a,a,2a])[[#3]]&

लेता है (w, h, i ), 1-आधारित।

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

Answer 10

बैच, 105 बाइट्स

@for /l %%c in (0,1,8)do @if %%c neq 4 cmd/cset/a(%3/%2+%1+%%c/3-1)%%%1*%2+(%3%%%2+%2+%%c%%3-1)%%%2&echo.

0 अनुक्रमित। @ चासब्रोन की मॉडुलो 3 ट्रिक चोरी करके 23 बाइट्स बचाए।

Answer 11

MATL, 24 बाइट्स

X[h3Y6&fh2-+1GX\1Gw!Z}X]

इसे MATL ऑनलाइन पर आज़माएं

आदानों लेता है [w h]और i। इस के 8 बाइट्स बेशर्मी से लुइस मेंडोस के जवाब से प्रेरित होकर चुराए गए थे , हालांकि समग्र दृष्टिकोण अलग है।

Answer 12

क्लीन , 85 83 बाइट्स

import StdEnv
r=(rem)
$h w i=tl[r(n+i/w)h*w+r(r(m+i)w)w\\n<-[0,1,h-1],m<-[0,1,w-1]]

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

iएक समन्वय के रूप में व्यवहार करता है (0 <= p < h, 0 <= q < w), और आसन्न तत्वों के मूल्यों को उत्पन्न करता है जहां मूल्य है p'w + q'।

Answer 13

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

PRs©Ṫ{œi+€Ø-Ż¤ŒpḊœị®

बाईं ओर के आयामों की एक सूची को स्वीकार करने वाला डियाडिक लिंक [h,w], और दाईं ओर एक पूर्णांक के रूप में सेल i, जो पड़ोस की एक सूची देता है।

^{नोट: ओपी में अनुमति दी गई उदाहरणों में यह आदेश अलग है}

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

कैसे?

PRs©Ṫ{œi+€Ø-Ż¤ŒpḊœị® - Link: [h,w], i
P                    - product -> h*w
 R                   - range -> [1,2,3,...,h*w]
    Ṫ{               - tail of left -> w
  s                  - split into chunks -> [[1,2,3,...w],[w+1,...,2*w],[(h-1)*w+1,...,h*w]]
   ©                 - ...and copy that result to the register
      œi             - multi-dimensional index of (i) in that list of lists, say [r,c]
             ¤       - nilad followed by link(s) as a nilad:
          Ø-         -   literal list -> [-1,1]
            Ż        -   prepend a zero -> [0,-1,1]
        +€           - addition (vectorises) for €ach -> [[r,r-1,r+1],[c,c-1,c+1]]
              Œp     - Cartesian product -> [[r,c],[r,c-1],[r,c+1],[r-1,c],[r-1,c-1],[r-1,c+1],[r+1,c],[r+1,c-1],[r+1,c+1]]
                Ḋ    - dequeue -> [[r,c-1],[r,c+1],[r-1,c],[r-1,c-1],[r-1,c+1],[r+1,c],[r+1,c-1],[r+1,c+1]]
                   ® - recall (the table) from the register
                 œị  - multi-dimensional index into (1-indexed & modular)

Answer 14

अटैच , 66 बाइट्स

{a.=[]Moore[Integers@@__2,{Push[a,_]},cycle->1]Flat[a@_][0:3'5:8]}

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

मुझे अभी भी लागू करने की आवश्यकता है Mooresऔर NMoore, लेकिन मेरे पास अभी भी है Mooreजो एक पुनरावृत्ति कार्य के रूप में कार्य करता है। अनिवार्य रूप से, Integers@@__2पूर्णांक के आकार का एक पूर्णांक सरणी __2(अंतिम दो तर्क) बनाता है Prod[__2]। यह हमें लक्ष्य सरणी देता है। फिर, प्रत्येक तत्व को चक्र करने के विकल्प के साथ आकार (निहित तर्क) के प्रत्येक मूर पड़ोस पर Mooreफ़ंक्शन {Push[a,_]}को प्रसारित करता है 1(cycle->1 ) । यह प्रत्येक पड़ोस को सरणी में जोड़ता है a। फिर, Flat[a@_]के _वें सदस्य को समतल करता है a, अर्थात, मूर पड़ोस आस-पास _(पहला तर्क)। [0:3'5:8]इस चपटा सरणी से केंद्र को छोड़कर सभी सदस्यों को प्राप्त करता है।

भाषा के अपडेट के साथ यह समाधान कुछ इस तरह दिखेगा (49 बाइट्स):

{Flat[NMoore[Integers@@__2,_,cycle->1]][0:3'5:8]}

Answer 15

Kotlin , 88 बाइट्स

शून्य आधारित अनुक्रमित का उपयोग करता है और एक 8 तत्व सूची आउटपुट करता है।

{h:Int,w:Int,i:Int->List(9){(w+i+it%3-1)%w+(h+i/w+it/3-1)%h*w}.filterIndexed{i,v->i!=4}}

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