जानकारी

1 से 9 की संख्या प्रत्येक मूर के पड़ोस में एक सेल का प्रतिनिधित्व करती है , जिसमें 5 केंद्रीय सेल हैं। इसलिए:

123
456
789

1={-1,-1} 2={-1, 0} 3={-1, 1}
4={ 0,-1} 5={ 0, 0} 6={ 0, 1} 
7={ 1,-1} 8={ 1, 0} 9={ 1, 1}

चुनौती

आप STDIN, ARGV या फ़ंक्शन तर्क के माध्यम से इनपुट ले सकते हैं और परिणाम को वापस कर सकते हैं या इसे STDOUT में प्रिंट कर सकते हैं। इनपुट एक एन एक्स एन ग्रिड (टोरस टोपोलॉजी है, जिसका अर्थ है कि x या y <1 है तो x या y = N, और यदि x या y> N तो x या y = 1), और आपके प्रोग्राम का एक अंतर आउटपुट होना चाहिए अपने मूर की नेबरहुड सेल में मूल्य के साथ प्रत्येक सेल को प्रतिस्थापित करके ग्रिड।

उदाहरण इनपुट ग्रिड (2 x 2):

13
79

आउटपुट:

97
31

स्पष्टीकरण:

1,1 पद पर शुरू करके हमारे पास 1 मूल्य है, क्योंकि मूल्य 1 = {- 1, -1} हमें 1 + (- 1), 1 + (- 1) = 0,0 प्राप्त करना है। और क्योंकि यह 0,0 का एक टोरस है जिसे हम एन के चारों ओर लपेटते हैं। इसलिए हम सेल वैल्यू को 1,1 (1) की स्थिति में सेल वैल्यू 2,2 (9) पर पुनः प्राप्त करते हैं।

अगले सेल 1,2 के लिए हमारे पास मूल्य 3 (= -1, 1) है इसलिए 1 + (- 1), 2 + (1) = 0,3। 2,1 के आसपास लपेटता है जिसका मूल्य 7 है।

2,1 पर अगली सेल वैल्यू 7 (= 1, -1) है इसलिए 2+ (1), 1 + (- 1) = 3,0। 1,2 के आसपास लपेटता है जिसका मूल्य 3 है।

2,2 पर अगली सेल वैल्यू 9 (= 1, 1) है इसलिए 2+ (1), 2 + (1) = 3,3। 1,1 के चारों ओर लपेटता है जिसका मूल्य 1 है।

और ज्यादा उदाहरण

इनपुट ग्रिड (3 x 3):

123
456
789

अपेक्षित उत्पादन:

987
654
321

इनपुट ग्रिड (5 x 5):

अपेक्षित उत्पादन:

अंतिम नोट्स

यदि आपके कोई प्रश्न हैं, तो टिप्पणी करने में संकोच न करें। यह एक कोड गोल्फ चुनौती है, सबसे छोटा कोड जीतता है!

code-golf

— AndoDaan
स्रोत

आप किसी तत्व की स्थिति को कैसे परिभाषित करते हैं? मुझे समझ नहीं आया कि कोशिकाओं के इनपुट सेट को कैसे अनुक्रमित किया जाता है।

— रेनबोल्ट

@Rainbolt इनपुट पंक्तियों द्वारा अनुक्रमित किया जाता है फिर कॉलम। इसलिए अंतिम उदाहरण (इनपुट) में सेल वैल्यू 2,3 पर 9. पंक्ति 2 = 81982 है, और उस का तीसरा कॉलम 9. है

— एंडोएडैन

1

संबंधित: codegolf.stackexchange.com/q/36839/15599

— लेवल रिवर सेंट

4

मदद नहीं कर सका लेकिन "मूर उदाहरण" पढ़ा।

— 21

9

एपीएल (33)

इसके लिए एपीएल बनाया गया था । यह एक फ़ंक्शन है जो इनपुट ग्रिड को एन-बाय-एन मैट्रिक्स के रूप में लेता है और आउटपुट ग्रिड को एन-बाय-एन मैट्रिक्स के रूप में लौटाता है।

{(⍳⍴⍵)⌷¨(,∆∘.⊖(∆←2-⌽⍳3)∘.⌽⊂⍵)[⍵]}

परीक्षा:

      ⍝ define input matrices
      ∆1 ← ↑(1 3)(7 9)
      ∆2 ← ↑(1 2 3)(4 5 6)(7 8 9)
      ∆3 ← ↑(7 7 4 9 7)(8 1 9 8 2)(3 2 2 3 6)(9 6 3 3 6)(6 7 8 1 1)
      ⍝ show input matrices
      ∆1 ∆2 ∆3
 1 3  1 2 3  7 7 4 9 7 
 7 9  4 5 6  8 1 9 8 2 
      7 8 9  3 2 2 3 6 
             9 6 3 3 6 
             6 7 8 1 1 
      ⍝ apply function to input matrices giving output matrices
      {(⍳⍴⍵)⌷¨(,∆∘.⊖(∆←2-⌽⍳3)∘.⌽⊂⍵)[⍵]} ¨ ∆1 ∆2 ∆3
 9 7  9 8 7  2 8 7 2 8 
 3 1  6 5 4  3 7 3 3 7 
      3 2 1  1 1 9 2 3 
             7 3 3 6 9 
             7 7 4 3 3

— मारीनस
स्रोत

5

पायथन, 174

def t(b):b=b.split("\n");E=enumerate;C=[-1]*3+[0]*3+[1]*3+[-1,0,1]*3;print"\n".join("".join(b[(i+C[int(x)-1])%len(b)][(j+C[int(x)+8])%len(y)]for j,x in E(y))for i,y in E(b))

अजगर इसके लिए नहीं बना था ... एपीएल था!

— मर्जी
स्रोत

3

अजगर, १०५

सूचियों की सूची लेता है और लौटाता है:

def f(a):e=enumerate;n=len(a);return[[a[(y+(v-1)/3-1)%n][(x+(v-1)%3-1)%n]for x,v in e(u)]for y,u in e(a)]

लेता है और एक स्ट्रिंग लौटाता है (148 अक्षर):

def f(s):
 a=[map(int,l)for l in s.split()];n=len(a);e=enumerate
 for y,u in e(a):print''.join(`a[(y+(v-1)/3-1)%n][(x+(v-1)%3-1)%n]`for x,v in e(u))

— gRC
स्रोत

2

MATLAB - 121 बाइट्स

function O=X(I),m=size(I,1);n=3*m;o=-1:1;c=o<2;M=c'*o+n*o'*c;D=repmat(I,3);C=D;C(:)=1:n*n;t=m+(1:m);O=C+M(D);O=D(O(t,t));

MATLAB एपीएल की तुलना में इसके लिए थोड़ा कम बनाया गया था, लेकिन पायथन की तुलना में इसके लिए थोड़ा अधिक बनाया गया था। ;)

टेस्ट आउटपुट

X( [1 2 3; 4 5 6; 7 8 9] )

ans =

     9     8     7
     6     5     4
     3     2     1

X( [7 7 4 9 7; 8 1 9 8 2; 3 2 2 3 6; 9 6 3 3 6; 6 7 8 1 1] )

ans =

     2     8     7     2     8
     3     7     3     3     7
     1     1     9     2     3
     7     3     3     6     9
     7     7     4     3     3

— COTO
स्रोत

मूर Iteration