एक ऐसा फ़ंक्शन लिखें जो सभी मान्य बिंदुओं के चलने योग्य वस्तु को लौटाता है 4-प्रत्यक्ष रूप से (x, y) से सटे हुए

Question

एल्गोरिदम वर्गों और सामान्य रूप से कंप्यूटर विज्ञान में एक बहुत ही सामान्य आवश्यकता एक ग्रिड या मैट्रिक्स (जैसे बीएफएस या डीएफएस) पर 4-प्रत्यक्ष रूप से पुनरावृति करना है। ऐसा लगता है कि अक्सर ढेर सारे अंकगणित और वर्बोज़ कोड के साथ ढेर सारे अंकगणित और लूप के भीतर तुलना का परिणाम है। मैंने इसके लिए कई अलग-अलग दृष्टिकोण देखे हैं, लेकिन मैं यह महसूस नहीं कर सकता कि ऐसा करने के लिए अधिक संक्षिप्त तरीका है।

एक शुद्ध कार्य लिखने की चुनौती है, जो n, mबिंदु पर उत्पन्न होने वाले एक परिमित विमान की चौड़ाई और ऊंचाई को देखते हुए (0,0), और समन्वय करता है (x,y)जो उस विमान के भीतर किसी भी वैध बिंदु का प्रतिनिधित्व कर सकता है, विमान के भीतर सभी बिंदुओं की एक पुन: प्रयोज्य वस्तु देता है जो 4-प्रत्यक्ष हैं के समीप (x,y)।

लक्ष्य उस फ़ंक्शन को यथासंभव कम बाइट्स में परिभाषित करना है।

मान्य इनपुट / आउटपुट को दर्शाने में मदद के लिए कुछ उदाहरण:

n = 5 (y-axis), m = 3 (x-axis) (zero-based)

matrix = [
    [A, B, C],
    [D, E, F],
    [G, H, I],
    [J, K, L],
    [M, N, O],
]

(x, y) => [valid iterable points]

E: (1, 1) => [(1, 0), (2, 1), (1, 2), (0, 1)]
A: (0, 0) => [(1, 0), (0, 1)]
L: (2, 3) => [(2, 2), (2, 4), (1, 3)]
N: (1, 4) => [(1, 3), (2, 4), (0, 4)]

n = 1 (y-axis), m = 1 (x-axis) (zero-based)

matrix = [
    [A],
]

(x, y) => [valid iterable points]

A: (0, 0) => []

n = 2 (y-axis), m = 1 (x-axis) (zero-based)

matrix = [
    [A],
    [B],
]

(x, y) => [valid iterable points]

A: (0, 0) => [(0, 1)]
B: (0, 1) => [(0, 0)]

और यहाँ एक उदाहरण (पायथन में यह एक) एक फ़ंक्शन है जो स्थितियों को संतुष्ट करता है:

def four_directions(x, y, n, m):
    valid_coordinates = []
    for xd, yd in [(1, 0), (0, 1), (-1, 0), (0, -1)]:
        nx, ny = x + xd, y + yd
        if 0 <= nx < m and 0 <= ny < n:
            valid_coordinates.append((nx, ny))
    return valid_coordinates

ऊपर दिया गया उदाहरण एक नामित फ़ंक्शन को परिभाषित करता है, लेकिन अनाम फ़ंक्शन भी स्वीकार्य हैं।

n, m, x, yनिम्नलिखित सीमाओं के भीतर इनपुट सभी अहस्ताक्षरित 32-बिट पूर्णांक हैं:

n > 0
m > 0
0 <= x < m
0 <= y < n

आउटपुट को (x, y) जोड़े के चलने योग्य (हालांकि आपकी पसंद की भाषा को परिभाषित करता है) का रूप लेना चाहिए।

अतिरिक्त स्पष्टीकरण:

जटिल संख्याएँ (और अन्य अभ्यावेदन / क्रमबद्धताएँ) तब तक ठीक हैं जब तक कि चलने-फिरने वाले उपभोक्ता तक पहुँच सकें xऔर yपूर्णांक के रूप में केवल अपना स्थान जान सकें।

गैर-शून्य-आधारित अनुक्रमणिका स्वीकार्य हैं, लेकिन केवल अगर पसंद की भाषा एक गैर-शून्य-अनुक्रमित भाषा है। यदि भाषा नंबरिंग सिस्टम के मिश्रण का उपयोग करती है, तो मैट्रिक्स का प्रतिनिधित्व करने के लिए आमतौर पर उपयोग किए जाने वाले डेटा संरचना की नंबरिंग प्रणाली के लिए डिफ़ॉल्ट। यदि ये दी गई भाषा में अभी भी सभी विदेशी अवधारणाएं हैं, तो कोई भी शुरुआती सूचकांक स्वीकार्य है।

Comments

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

— पोस्ट रॉक गार्फ हंटर

हम गारंटी देते हैं कि (x,y)खुद आयत में है, है ना?

— xnor

डिफ़ॉल्ट रूप से, CGCC पूर्ण कार्यक्रमों के साथ-साथ प्रस्तुतियाँ भी करने की अनुमति देता है। यह उन भाषाओं को अनुमति देने में मदद करता है जो आवश्यक रूप से प्रतिस्पर्धा करने के लिए कार्यों की अवधारणा नहीं है

— जो किंग

एक कोड ऑब्जेक्ट के बजाय एक आउटपुट STDOUT को होगा। यह आम तौर पर स्पष्ट सीमांकक के साथ कोई भी उत्पादन हो सकता है इसलिए यह स्पष्ट नहीं है और डिफ़ॉल्ट मानक आउटपुट स्वरूपों

— जो किंग

क्या पूर्णांक ट्यूपल्स के बजाय जटिल संख्याओं के रूप में निर्देशांक का प्रतिनिधित्व करने की अनुमति है?

— जोएल

Answer 1

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

lambda m,n,x,y:[(x-1,y),(x+1,y)][~x:m-x]+[(x,y-1),(x,y+1)][~y:n-y]

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

चार पड़ोसियों को सूचीबद्ध करता है, फिर उन लोगों को हटाने के लिए सूची स्लाइसिंग का उपयोग करता है जो आउट-ऑफ-बाउंड हैं।

---

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

lambda m,n,x,y:[(k/n,k%n)for k in range(m*n)if(k/n-x)**2+(k%n-y)**2==1]

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

चार पड़ोसियों में से कौन-से सीमा में हैं, इसकी जाँच करने के बजाय, हम इसे उन पड़ोसियों के लिए सभी-सीमा बिंदुओं की जाँच करने का धीमा तरीका बताते हैं, जो कि यूक्लिडियन दूरी से ठीक 1 की दूरी पर हैं (x,y)। हम एक ग्रिड पर पुनरावृति करने के लिए क्लासिक डिव-मॉड ट्रिक का भी उपयोग करते हैं , जैसे दो लूप लिखने की आवश्यकता को बचाते हैं for i in range(m)for j in range(n)।

मैंने दूरी की स्थिति लिखने के लिए जटिल अंकगणित का उपयोग करने की कोशिश की, लेकिन यह लिखने में अधिक समय लगा abs((k/n-x)*1j+k%n-y)==1।

---

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

lambda m,n,x,y:[(x+t/3,y+t%3-1)for t in-2,0,2,4if m>x+t/3>=0<y+t%3<=n]

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

Comments

100k पर बधाई!

— अरनुलद

Answer 2

ऑक्टेव , 90 बाइट्स

यह एक ज्यामितीय दृष्टिकोण का उपयोग करता है: पहले हम वांछित आकार के शून्य का एक मैट्रिक्स बनाते हैं, और 1वांछित स्थान पर सेट करते हैं । फिर हम कर्नेल के साथ बातचीत करते हैं

[0, 1, 0]
[1, 0, 1]
[0, 1, 0]

जो मूल बिंदु के 4-पड़ोसियों पर समान आकार के एक नए मैट्रिक्स का उत्पादन करता है। फिर हम find()इस नई मैट्रिक्स की नॉनज़रो प्रविष्टियों के सूचकांक।

function [i,j]=f(s,a,b);z=zeros(s);z(a,b)=1;[i,j]=find(conv2(z,(v=[1;-1;1])*v'<0,'same'));

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

^{_{दृढ़ संकल्प सफलता की कुंजी है।}}

Comments

वास्तव में, यह कितना भी छोटा क्यों न हो

— लुइस मेंडो

Answer 3

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

Cases[List~Array~#2,a_/;Norm[a-#]==1,{2}]&

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

1-अनुक्रमित (जो अनुक्रमण के लिए गणितज्ञ के सम्मेलन का अनुसरण करता है)। के रूप में इनपुट लेता है {x,y}, {m,n}।

---

0-अनुक्रमित I / O के लिए, 45 बाइट्स :

Cases[Array[List,#2,0],a_/;Norm[a-#]==1,{2}]&

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

Answer 4

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

बोरिंग दृष्टिकोण।

(h,w,x,y)=>[x&&[x-1,y],~x+w&&[x+1,y],y&&[x,y-1],++y-h&&[x,y]].filter(_=>_)

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

---

जावास्क्रिप्ट (Node.js) , 74 बाइट्स

कम उबाऊ लेकिन सिर्फ लंबे समय के रूप में। के रूप में इनपुट लेता है ([h,w,x,y])।

a=>a.flatMap((_,d,[h,w,x,y])=>~(x+=--d%2)*~(y+=--d%2)&&x<w&y<h?[[x,y]]:[])

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

---

जावास्क्रिप्ट (V8) , 67 बाइट्स

यदि सभी मानक आउटपुट विधियों की अनुमति थी, तो हम केवल इसके साथ मान्य निर्देशांक प्रिंट कर सकते हैं:

(h,w,x,y)=>{for(;h--;)for(X=w;X--;)(x-X)**2+(y-h)**2^1||print(X,h)}

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

Answer 5

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

2ḶṚƬNƬẎ+⁸%ƑƇ

एक dyadic लिंक बाईं तरफ के दो (0-अनुक्रमित) पूर्णांकों की एक सूची को स्वीकार करने, [row, column], और सही, पर दो पूर्णांकों [height, width], जो पूर्णांकों की सूची की एक सूची पैदावार, [[adjacent_row_1, adjacent_column_1], ...]।

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

कैसे?

2ḶṚƬNƬẎ+⁸%ƑƇ - Link: [row, column]; [height, width]   e.g. [3,2]; [5,3] (the "L" example)
2            - literal 2                                   2
 Ḷ           - lowered range                               [0,1]
   Ƭ         - collect up while distinct, applying:
  Ṛ          -   reverse                                   [[0,1],[1,0]]
     Ƭ       - collect up while distinct, applying:
    N        -   negate                                    [[[0,1],[1,0]],[[0,-1],[-1,0]]]
      Ẏ      - tighten                                     [[0,1],[1,0],[0,-1],[-1,0]]
        ⁸    - chain's left argument ([row, column])       [3,2]
       +     - add (vectorises)                            [[3,3],[4,2],[3,1],[2,2]]
           Ƈ - filter keep if:
          Ƒ  -   is invariant under:
         %   -     modulo ([height, width]) (vectorises)    [3,0] [4,2] [3,1] [2,2]
             - (...and [3,0] is not equal to [3,3] so ->)  [[4,2],[3,1],[2,2]]

Comments

आप बदल सकते हैं ḶṚƬके साथ Ṭ€। 2ḶṚƬNƬẎरिटर्न [[0, 1], [1, 0], [0, -1], [-1, 0]], जबकि 2Ṭ€NƬẎरिटर्न [[1], [0, 1], [-1], [0, -1]], और, चूंकि सिंगलटन लपेटे जाते हैं, +केवल ⁸उन लोगों के पहले तत्व के साथ वेक्टर होता है , इसलिए वे ऐसे कार्य करते हैं जैसे कि उनका दूसरा तत्व 0(एडिटिव आइडेंटिटी) हो। परिणामस्वरूप, केवल आउटपुट का क्रम बदल सकता है।

— को आउटगॉल्फ

Answer 6

पर्ल 6 , 56 49 बाइट्स

-7 बाइट्स nwellnhof के लिए धन्यवाद!

{grep 1>(*.reals Z/@^b).all>=0,($^a X+1,-1,i,-i)}

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

यदि यह सीमा 0 से 1 के बीच विभाजित है, तो यह जाँचने से सीमा तत्वों को हटा दिया जाता है कि यह 1 और 1 है। इनपुट और आउटपुट को जटिल संख्याओं के माध्यम से लेता है जहाँ वास्तविक भाग xसमन्वय है और काल्पनिक भाग है y। आप इन .imऔर .reकार्यों के माध्यम से निकाल सकते हैं ।

Comments

49 बाइट्स

— nwellnhof

@nwellnhof बहुत अच्छा! मैं इस तरह से कुछ करने के लिए इसका निर्माण करूँगा , लेकिन divNum

— जो किंग

(*.reals>>.Int Zdiv@^b).noneया (*.reals Z/@^b)>>.Int.noneकाम करेगा, लेकिन इंट-कास्ट बहुत महंगा लगता है।

— nwellnhof

Answer 7

जे , ^{30 29} 28 बाइट्स

(([+.@#~&,1=|@-)j./)~j./&i./

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

किस तरह:

• दाहिने हाथ mx narg को जटिल संख्याओं के ग्रिड में बदल देंj./&i./
• बाएँ आर्ग के लिए भी (हमारी बात) j./
• एक मास्क बनाएँ, जहाँ हमारे बिंदु और ग्रिड के बीच की दूरी ठीक 1 हो 1=|@-
• दोनों को समतल करने के बाद, ग्रिड को फ़िल्टर करने के लिए उपयोग करें #~&,
• परिणाम को वास्तविक बिंदुओं में बदल दें +.@

Answer 8

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 91 बाइट्स

(a,b,x,y)=>new[]{(x+1,y),(x-1,y),(x,y+1),(x,y-1)}.Where(d=>((x,y)=d,p:x>=0&x<a&y>=0&y<b).p)

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

वैकल्पिक रूप से:

(a,b,x,y)=>new[]{(x+1,y),(x-1,y),(x,y+1),(x,y-1)}.Where(d=>((x,y)=d).Item1>=0&x<a&y>=0&y<b)

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

Answer 9

चारकोल , 29 बाइट्स

Ｊθη#ＦＩζＦＩε«Ｊικ¿№ＫＶ#⊞υ⟦ικ⟧»⎚Ｉυ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। आदेश x, y, चौड़ाई, ऊंचाई में इनपुट लेता है। स्पष्टीकरण:

Ｊθη#

#प्रदान की गई स्थिति में प्रिंट करें ।

ＦＩζＦＩε«

दिए गए आयत पर लूप करें।

Ｊικ

वर्तमान स्थिति के लिए कूदो।

¿№ＫＶ#⊞υ⟦ικ⟧

यदि आसन्न है #तो स्थिति को बचाएं।

»⎚Ｉυ

लूप के अंत में खोजे गए पदों को आउटपुट करें।

बोरिंग जवाब:

ＦＩζＦＩε¿⁼¹⁺↔⁻ιＩθ↔⁻κＩηＩ⟦ικ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। आसन्न पदों को गणितीय रूप से पाकर काम करता है।

Answer 10

हास्केल, 62 बाइट्स

का उपयोग करते हुए

f m n a b = [(x,y)|x<-[0..m-1],y<-[0..n-1],(x-a)^2+(y-b)^2==1]

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

बोरिंग दृष्टिकोण: 81 बाइट्स

f m n x y=filter (\(x,y)->x>=0&&y>=0&&x<m&&y<n) [(x-1,y),(x+1,y),(x,y-1),(x,y+1)]