11

ठीक है, एक कोड गोल्फ में मेरा दूसरा प्रयास, आइए देखें कि यह कैसे होता है।

बहाना आप 9 मूल्यों की एक सरणी है। अब एक 3x3 ग्रिड में उस सरणी की कल्पना करें।

आपको उन पड़ोसियों को वापस करने की आवश्यकता है जिनकी संख्या सरणी के अनुक्रमित के रूप में है।

0 | 1 | 2

3 | 4 | 5

6 | 7 | 8

नियम:

यह कोड गोल्फ है, इसलिए सबसे कम उत्तर जीतता है।
प्रिटेंड सरणी का सूचकांक 0 या 1 से शुरू हो सकता है (सभी उदाहरण 0 का उपयोग करते हैं)
बस मानों को वापस लौटाना मानों पर आधारित (जैसे if 3: return 046)
सबमिशन सिर्फ एक प्रक्रिया / कार्य / विधि हो सकती है, लेकिन एक उदाहरण अच्छा होगा
लौटाया गया मान किसी भी क्रम में हो सकता है (जैसे यदि इनपुट 0 है तो यह 13 या 31 हो सकता है)
यदि आप चाहें, तो आउटपुट संख्याओं की एक सूची हो सकती है, जैसे कि [0,4,6]इसके बजाय046
विकर्णों की गणना नहीं की जाती है, जैसा कि उदाहरणों द्वारा देखा जाता है।

उदाहरण:

इनपुट:

0

उत्पादन:

13

इनपुट:

3

उत्पादन:

046

इनपुट:

4

उत्पादन:

1357

code-golf grid

— hcorion
स्रोत

4

ऐसा लगता है कि यह चुनौती सैंडबॉक्स में कुछ समय तक लाभ दे सकती है । आप अपनी चुनौती को वहां पोस्ट कर सकते हैं ताकि अन्य लोग इसकी समीक्षा कर सकें और इसे पोस्ट करने से पहले इसमें आपकी मदद कर सकें। आपके उदाहरणों से मैं अनुमान लगा रहा हूँ कि आप विकर्णों की गिनती नहीं कर रहे हैं। आप इसे स्वयं प्रश्न में जोड़ना चाह सकते हैं। आप उस सरणी के अनुक्रमित को आउटपुट करने की आवश्यकता का भी उल्लेख करते हैं जो पड़ोसी हैं। मुझे लगता है कि यह सिर्फ 3x3 ग्रिड के लिए हार्डकोड किया जा सकता है। क्या यह बेहतर हो सकता है कि पड़ोसियों को खुद आउटपुट दें?

— प्रहार

7

जैसा कि आप जानते, सिकोड़ी पर वास्तव में कुछ हम यहाँ ऐसा नहीं है; हार्डकॉडिंग आउटपुट या तो अनुमति है या यह नहीं है। चूंकि यह आमतौर पर यह परिभाषित करने के लिए बहुत कठिन है कि हार्डकोडिंग के रूप में वास्तव में क्या मायने रखता है, मैं व्यक्तिगत रूप से इसे अनुमति देता हूं या एक अतिरिक्त इनपुट के रूप में ग्रिड आकार दे सकता हूं।

— डेनिस

1

क्या आउटपुट संख्याओं की एक सूची हो सकती है, जैसे [0,4,6]इसके बजाय 046?

— लकोनी

@ लिकोनी हां, थोड़ा बहुत देर हो चुकी है क्योंकि आप पहले ही इसका जवाब दे चुके हैं।

— h

@ डेनिस हां, मुझे पूरा यकीन नहीं था कि इसे कैसे रखा जाए। मुझे पसंद है कि कैसे सी और अजगर के जवाब दोनों ने प्रदान किए, लेकिन अंतिम के रूप में गैर-कठिन कोडित उत्तर होने से। मैं हार्ड-कोडिंग के बजाय एल्गोरिदम को प्रोत्साहित करना चाहता था, लेकिन मुझे यकीन नहीं था कि अगर यह भी संभव था (बिना लंबे उत्तर के), और मैं अपने सवाल का कोई जवाब नहीं देना चाहता था।

— हॉर्सियन

2

जेली , 16 13 बाइट्स

9Ḷ,d3ạ/S€=1T’

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

यह काम किस प्रकार करता है

9Ḷ,d3ạ/S€=1T’  Main link. Argument: n (0, ..., 8)

9              Set the return value to 9.
 Ḷ             Unlength; yield [0, ..., 8].
  ,            Pair; yield [[0, ..., 8], n].
   d3          Divmod 3; yield [[[0, 0], ..., [2, 2]], [n:3, n%3]]].
     ạ/        Reduce by absolute difference, yielding
               [[|0 - n:3|, |0 - n%3|], ..., [[|2 - n:3|, |2 - n%3|]].
       S€      Sum each, yielding
               [|0 - n:3| + |0 - n%3|, ..., [|2 - n:3| + |2 - n%3|].
         =1    Compare the sums with 1.
           T   Truth; yield all 1-based indices of 1.
            ’  Decrement to yield all 0-based indices of 1.

— डेनिस
स्रोत

नियम बताते हैं: "प्रिटेंड सरणी का सूचकांक 0 या 1. पर शुरू हो सकता है" - आप अंत में गिरावट को छोड़ सकते हैं।

— स्टेटबर्घ

@steenbergh मुझे लगता है कि मुझे 1-आधारित इनपुट तब भी लेना होगा, जिसकी लागत कई बाइट्स के रूप में बचती है।

— डेनिस

9

MATL , 17 16 बाइट्स

9:qWIe1Y6Z+i)BPf

सरणी 1 आधारित है, वह यह है कि से संख्या शामिल 1करने के लिए 9।

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

व्याख्या

2उदाहरण के रूप में इनपुट पर विचार करें ।

9:q  % Push [0 1 2 ... 8]
     % STACK: [0 1 2 ... 8]
W    % Rise to 2, element-wise
     % STACK: [1 2 4 ... 256]
Ie   % Reshape as 3-row matrix (column-major order)
     % STACK: [1   8  64;
               2  16 128;
               4  32 256]
1Y6  % Push [0 1 0; 1 0 1; 0 1 0]
     % STACK: [1   8  64;
               2  16 128;
               4  32 256],
              [0   1   0;
               1   0   1;
               0   1   0]
Z+   % Convolution, maintaining size
     % STACK: [10  81 136;
               21 170 336;
               34 276 160]
i    % Take input, n
     % STACK: [10  81 136;
               21 170 336;
               34 276 160],
               2
 )   % Get n-th entry (1-based; column-major order)
     % STACK: 21
B    % Convert to binary
     % STACK: [1 0 1 0 1]
P    % Flip
     % STACK: [1 0 1 0 1]
f    % Find: gives indices of nonzeros. Implicitly display
     % STACK: [1 3 5]

— लुइस मेंडो
स्रोत

1

वाट? आप इसके साथ कैसे आए?

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

1

@RobertFraser पड़ोसियों को खोजने के बारे में ये चुनौतियां हमेशा मुझे एक दृढ़ संकल्प दृष्टिकोण का सुझाव देती हैं। लेकिन दृढ़ विश्वास स्वाभाविक रूप से पड़ोसियों के मूल्यों को जोड़ता है, इसलिए मुझे उन्हें अंत में अलग करने में सक्षम होने की आवश्यकता है --- यह दो और द्विआधारी विस्तार भागों की शक्ति है

— लुइस मेंडो

5

गणितज्ञ, 32 बाइट्स

GridGraph@{3,3}~AdjacencyList~#&

एक सरणी के बजाय एक ग्राफ का उपयोग करता है। GridGraph@{3,3}नीचे दिखाए गए एक 3x3 ग्रिड के आकार के ग्राफ का निर्माण करता है, जो गणितज्ञ डिफ़ॉल्ट रूप से कोने के लिए 1-9 की संख्या के साथ सहायक लेबल करता है। फिर ~AdjacencyList~#&आपको एक शीर्ष के पड़ोसियों को बताता है।

— पेड़ नहीं
स्रोत

उन बिल्डरों से प्यार करेंगे ...

— नील

4

गणितज्ञ, 40 बाइट्स

{24,135,26,157,2468,359,48,579,68}[[#]]&

1 अनुक्रमित। बस जवाब दिखता है। क्या कोई गणितज्ञ में बेहतर कर सकता है?

— ग्रेग मार्टिन
स्रोत

3

मुझे आश्चर्य है कि इसके लिए कोई बेसिन नहीं है। जैसे मुझे उम्मीद है कि एक 2D सरणी में एक तत्व के सभी पड़ोसियों को खोजने के लिए एक बेसिन होना चाहिए, लेकिन मुझे यकीन नहीं है, मुझे इस तथ्य के अलावा कि अन्य बहुत सारे बिल्डिंग्स हैं, मैथमेटिका के बारे में कुछ भी नहीं पता है।

— हाइपरएन्यूट्रीनो

2

आप 0-इंडेक्सिंग का उपयोग करके एक बाइट को बचा सकते हैं और 31[420,51,...,75][[#]]&।

— मार्टिन एंडर

1

आप GridGraph@{3,3}~AdjacencyList~#&1-अनुक्रमण के साथ 32 बाइट्स के लिए उपयोग कर सकते हैं ।

— पेड़ नहीं

@ lanlock4 बहुत बढ़िया! कृपया इसका उत्तर दें ताकि मैं इसे उखाड़ सकूं!

— ग्रेग मार्टिन

4

ऑक्टेव, 42 40 39 बाइट्स

@(n,x=~e(3),y=x(n)=1)find(bwdist(x)==1)

1-आधारित सूचकांक।

सभी परीक्षण मामलों की जाँच करें।

स्पष्टीकरण:

x=~e(3);         % create a 3*3 matrix of zeros
x(n)=1;          % set the element with index n to 1
d=bwdist(x);     % compute the distance transform of the matrix
find(d == 1)     % find where the distance is 1.

उदाहरण: n = 2

(ऑक्टेव डेटा में संग्रहित कॉलम-वार है।)

d =

   1.00000   1.41421   2.23607
   0.00000   1.00000   2.00000
   1.00000   1.41421   2.23607

तार्किक सूचकांक जहां दूरी 1 है:

d == 1

 1   0   0
 0   1   0
 1   0   0

find(d ==1)

 1
 3
 5

— rahnema1
स्रोत

3

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

lambda n:filter(abs,[(n-3)*(n>3),(n+3)*(n<7),~-n*(n%3!=1),-~n*(n%3>0)])

1-अनुक्रमित
इसे ऑनलाइन आज़माएं!

परिणामों की पूर्वनिर्धारित सूची से परिणाम प्राप्त करना कम है (46 बाइट्स):

[13,204,15,406,1357,248,37,468,57].__getitem__

0-अनुक्रमित
इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

2

हास्केल , 74 71 68 बाइट्स

f n=[x|x<-[n-3,n-1..n+3],0<x,x<10,gcd 3x<2||n-1/=x,gcd 3n<2||n+1/=x]

इसे ऑनलाइन आज़माएं! 1-अनुक्रमित ग्रिड का उपयोग करता है। उदाहरण उपयोग: f 3रिटर्न [2,6]।

संपादित करें: : rjan जोहान्सन के लिए 3 6 बाइट्स सहेजे गए !

के लिए 77 75 बाइट्स, निम्नलिखित समारोह #एक मनमाना ग्रिड आकार के लिए काम करता है m:

n#m=[x|x<-[n-m,n-1,n+1,n+m],0<x,x<=m*m,gcd x m<m||n-1/=x,gcd n m<m||n+1/=x]

इसे ऑनलाइन आज़माएं! प्रत्येक nसूची [n-m,n-1,n+1,n+m]में सभी चार पड़ोसी शामिल हैं। xइस सूची में प्रत्येक प्रविष्टि के लिए हम जाँच करते हैं -1<xऔर x<m*mयह सुनिश्चित करने के लिए कि xग्रिड के ऊपर या नीचे नहीं है, mod n 3>0||n-1/=xबाईं ग्रिड सीमा को लागू करने के लिए औरmod(n+1)m>0||n+1/=x लिए और बाईं सीमा के लिए।

— Laikoni
स्रोत

1

आप उपयोग कर सकते हैं [n-3,n-1..n+3]और gcd 3n>1।

— अर्जन जोहानसन

उफ़, कभी उस gcdहिस्से को बुरा मत मानना । यह होना चाहिए था <3, और फिर के लिए टूट जाता है n==0। आप हो सकता है कि चाल का उपयोग करने के लिए यदि आप के लिए सब कुछ बदल में सक्षम हो 1-indexed।

— अर्जन जोहानसन

ओह, और n/=2&&n/=5द्वारा प्रतिस्थापित किया जा सकता है mod x 3>0। (या gcdरीइन्डेक्सिंग वाला संस्करण, जो अब दो बार उपयोग किया जा सकता है।)

— अर्जन जोहान्सन

2

रूबी , 51 48 45 बाइट्स

->a{[a+3,a-3][a/6..a/3]+[a+1,a-1][a%-3..a%3]}

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

ऊर्ध्वाधर और क्षैतिज पड़ोसियों के साथ 2 सरणियां बनाएं, फिर उनमें से एक या अधिक का चयन करें।

रूबी हार्डकोड, 44 बाइट्स

->a{%w(13 024 15 046 1357 248 37 468 57)[a]}

... इसके लायक नहीं।

— जीबी
स्रोत

2

सी, 100 92 91 83 78 74 बाइट्स

p(n){putchar(n+48);}f(n){n>3&&p(n-3);n<7&&p(n+3);n%3&&p(n+1);--n%3&&p(n);}

1 अनुक्रमित। 4 बाइट बचाने के लिए @ निएल को धन्यवाद।

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

हार्डकोड संस्करण, 56 बाइट्स

l[]={13,204,15,406,1357,248,37,468,57};
#define L(n)l[n]

0 अनुक्रमित

— Steadybox
स्रोत

2

पहले संस्करण में, आप n>3&&p(n-3)4 बाइट्स को बचाने के लिए आदि नहीं लिख सकते हैं ? दूसरे संस्करण में, क्या आप l[]=एक बाइट को बचाने के लिए नहीं लिख सकते हैं ?

— नील

@ नील मैं कर सकता हूँ। धन्यवाद!

— स्टेडीबॉक्स

क्या आप सुनिश्चित हैं कि वर्तमान में आपका कोड सही है? जब मैं परीक्षण के मामलों की कोशिश करता हूं तो यह तीनों के लिए विफल हो जाता है ..: एस यहां कोशिश करें। क्या आप शायद एक काम कर रहे TIO- लिंक प्रदान कर सकते हैं, शायद मैं कुछ गलत कर रहा हूं?

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

1

@KevinCruijssen TIO लिंक जोड़ा गया, और ऐसा लगता है कि मैं पिछले कोड पर वास्तविक कोड को संपादित करना भूल गया ... ओह, ठीक है। आपका लिंक सही तरीके से काम कर रहा है, लेकिन ध्यान दें कि मेरा उत्तर 1-अनुक्रमित है जबकि उदाहरण परीक्षण के मामले 0-अनुक्रमित हैं।

— स्टेडीबॉक्स

@Steadybox आह, आप वास्तव में सही हैं। मुझे 1-अनुक्रमित भाग याद आया, मेरा बुरा। TIO को जोड़ने के लिए धन्यवाद। +1

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

1

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

lambda x:[x+3,x-3][x/6:x/3+1]+[x+1,x-1][x%-3:x%3+1]

मेरे रूबी जवाब के पिछले संस्करण के आधार पर , मैंने इसे दिलचस्प पाया क्योंकि यह ज्यादातर एक ही कोड था, एक अलग चाल का उपयोग करके, और एक ही परिणाम पैदा करता है। यह एक सही होने से मुझे माणिक जवाब थोड़ा और अधिक गोल्फ में मदद मिली।

मूल रूप से, माणिक यह छोटा होता है क्योंकि सरणी टुकड़ा सूचकांक समावेशी होता है, अजगर को इसकी आवश्यकता होती है +1 को क्षतिपूर्ति करने की ।

व्याख्या

2 सरणियां (ऊर्ध्वाधर और क्षैतिज पड़ोसी) प्राप्त करें, फिर कुछ गणनाओं के आधार पर एक या दोनों का चयन करें।

— जीबी
स्रोत

1

जावा 7, 63 बाइट्स (हार्डकोड)

int c(int i){return new int[]{31,420,51,640,7531,842,73,864,75}[i];}

0 से इंडैक्स
(उलट क्रम उत्पादन क्योंकि 024और 046मान्य पूर्णांक नहीं हैं।)
~~फिर भी एक गैर हार्डकोडेड संस्करण पर काम कर रहा है, लेकिन~~ मैं आपको विश्वास दिलाता कर सकते हैं इसे कम नहीं होगा ..

इसे यहाँ आज़माएँ।

82 बाइट्स

String c(int n){return""+(n>3?n-3:"")+(n<7?n+3:"")+(n%3>0?n+1:"")+(--n%3>0?n:"");}

1-अनुक्रमित @Steadybox C उत्तर के
आधार पर

इसे यहाँ आज़माएँ।

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

0

जावास्क्रिप्ट + लॉश, 71 बाइट्स

f=a=>_.range(9).filter(b=>a>b?f(b).includes(a):[,1,,1][b-a]&&b%3|a%3<2)

— ब्रायन मैककिनटन
स्रोत

0

बैच, 116 बाइट्स

@set c=cmd/cset/a%1
@set/ar=%1%%3
@if %1 gtr 2 %c%-3
@if %r% gtr 0 %c%-1
@if %r% lss 2 %c%+1
@if %1 lss 6 %c%+3

0 अनुक्रमित।

— नील
स्रोत

पड़ोसियों के सूचकांक को एक 3x3 ग्रिड में लौटाएं

जेली , 16 13 बाइट्स

यह काम किस प्रकार करता है

MATL , 17 16 बाइट्स

व्याख्या

गणितज्ञ, 32 बाइट्स

गणितज्ञ, 40 बाइट्स

ऑक्टेव, 42 40 39 बाइट्स

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

हास्केल , 74 71 68 बाइट्स

रूबी , 51 48 45 बाइट्स

रूबी हार्डकोड, 44 बाइट्स

सी, 100 92 91 83 78 74 बाइट्स

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

व्याख्या

जावा 7, 63 बाइट्स (हार्डकोड)

जावास्क्रिप्ट + लॉश, 71 बाइट्स

बैच, 116 बाइट्स