बीच से प्रिंट सरणियाँ

Question

यह एक कोड-गोल्फ प्रश्न है।

पूर्णांक s और n को देखते हुए कार्य लंबाई n के सभी सरणियों को आउटपुट करना है जो मानों को s से s में ले जाता है। एकमात्र ट्विस्ट यह है कि आपको उन्हें निम्न क्रम में आउटपुट करना होगा।

• लंबाई के सभी शून्य सरणी n।
• आपके द्वारा पहले आउटपुट किए गए किसी भी सरणी को छोड़कर, -1 से 1 तक के तत्वों के साथ लंबाई के सभी सरणियाँ।
• लंबाई के सभी सरणियों -2 से तत्वों के साथ 2 से पहले किसी भी सरणी को छोड़कर।
• और इसलिए जब तक कि आप पहले से आउटपुट किए गए किसी भी सरणी को छोड़कर, एस से तत्वों के साथ लंबाई एन के सभी सरणियों तक पहुंचते हैं।

आपको प्रति पंक्ति एक सरणी आउटपुट करना चाहिए। वे अंतरिक्ष या अल्पविराम से अलग हो सकते हैं।

यहाँ कुछ गैर-अनुपालन योग्य अजगर कोड है जो सही क्रम में सरणियों / सूचियों / ट्यूपल्स को आउटपुट करता है।

import itertools

s =  3
n = 2

oldsofar = set()
newsofar = set()
for i in xrange(s):
    for k in itertools.product(range(-i,i+1), repeat = n):
        newsofar.add(k)
    print newsofar - oldsofar
    oldsofar = newsofar.copy()
    print "***"

कोई सेट घटाव या समकक्ष प्रदर्शन करने वाले उत्तरों के लिए अतिरिक्त महिमा (और मुझ से एक अपवोट)।

Comments

क्या हम एक फ़ंक्शन लिख सकते हैं जो परिणाम प्रिंट करता है?

— लीजनमोनमल 978

@ LegionMammal978 मैं एक पूरा कार्यक्रम पसंद करूंगा। यदि इसे गंभीर रूप से विवादास्पद माना जाता है तो मैं निश्चित रूप से :)

क्या आपके प्रत्येक बुलेट बिंदु के भीतर कोई आवश्यक आदेश है?

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

@ मार्टिनबटनर नहीं, बिल्कुल नहीं।

Answer 1

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

NRṗµAṀ€Ụị

इस पद के निर्माण में कोई सूची घटाव का उपयोग नहीं किया गया था। इसे ऑनलाइन आज़माएं!

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

NRṗµAṀ€Ụị  Main link. Arguments: s, n

N          Negate; yield -s.
 R         Range; yield [-s, ..., s].
  ṗ        Cartesian power; push all vectors of length n of those elements.
   µ       Begin a new, monadic link. Argument: L (list of vectors)
    A      Compute the absolute values of all vector components.
     Ṁ€    Get the maximum component of each vector.
       Ụ   Sort the indices of A according to the maximal absolute value of the
           corresponding vector's components.
        ị  Retrieve the vectors of A at those indices.

Comments

अब यह सिर्फ मूर्खतापूर्ण हो रहा है!

"इस पोस्ट के निर्माण में कोई सूची को नुकसान नहीं पहुँचाया गया"

— डेनिस वैन गिल्स

Answer 2

MATL , 18 बाइट्स

_G2$:iZ^t!|X>4#SY)

पहला इनपुट है s, दूसरा हैn

यह भाषा के वर्तमान संस्करण (15.0.0) में काम करता है ।

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

व्याख्या

_      % take input s implicitly. Negate to obtain -s
G      % push input s again
2$:    % inclusive range from -s to s
i      % take input n
Z^     % Cartesian power. Gives 2D array, with each result on a row
t!     % duplicate and transpose
|      % absolute value
X>     % maximum of each column 
4#S    % sort and push the indices of the sorting
Y)     % apply as row indices into the 2D array. Display implicitly

Comments

18 बाइट अपमानजनक है :)

Answer 3

हास्केल, 61 60 बाइट्स

n#s=[c|b<-[0..s],c<-mapM id$[-b..b]<$[1..n],any((b==).abs)c]

प्रयोग उदाहरण: 2#2-> [[0,0],[-1,-1],[-1,0],[-1,1],[0,-1],[0,1],[1,-1],[1,0],[1,1],[-2,-2],[-2,-1],[-2,0],[-2,1],[-2,2],[-1,-2],[-1,2],[0,-2],[0,2],[1,-2],[1,2],[2,-2],[2,-1],[2,0],[2,1],[2,2]]।

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

   b<-[0..s]                           -- loop b through 0 .. s
        c<-mapM id$[-b..b]<$[1..n]     -- loop c through all lists of length n
                                       -- made out of the numbers -b .. b
                                       -- ("[-b..b]<$[1..n]" is "replicate n [-b..b]";
                                       --  "mapM id" is "sequence")
[c|                 ,any((b==).abs)c]  -- keep c if it contains b or -b

संपादित करें: @xnor उठाई बाहर है कि mapM idहै sequence।

Comments

mapM idसे छोटा है sequence।

— xnor

@ एक्सनोर: सच। धन्यवाद!

— नीमी

Answer 4

मैथेमेटिका, 83 बाइट्स

Print/@Select[Range[-#,b=#]~Tuples~a,Abs@#~MemberQ~b&]&/@Range[0,a=Input[];Input[]]

उपयोग करने के लिए, एक स्क्रिप्ट और इनपुट में nफिर sअलग लाइनों पर रखें। प्रत्येक सरणी को एक घुंघराले-कोष्ठक, अल्पविराम-सीमांकित सूची (जैसे, {-1, 0, 1}) के रूप में प्रिंट करता है । यह लंबाई की प्रत्येक सूची को nबीच में संख्याओं के साथ काम करता है [-cur..cur], और उन लोगों को मुद्रित करता है जिनमें या तो शामिल हैं -curया cur। यह फिर सभी के लिए यह दोहराता curहै [0..s]। ^{(इस पोस्ट में 19 `अक्षर शामिल हैं!)}

Answer 5

जावास्क्रिप्ट (स्पाइडरमैन 30+), 134 बाइट्स

(s,n)=>n?[for(a of f(s,n-1))for(i of Array(s*2+1).keys())[i-n,...a]].sort((a,b)=>g(a)-g(b),g=a=>Math.max(...a,-Math.min(...a))):[[]]

कार्टेशियन-पावर-एंड-सॉर्ट दृष्टिकोण का उपयोग करता है, जिसे मैंने अलग से सोचा था, लेकिन मैं उस समय स्पाइडरमॉन्की को पुनः स्थापित कर रहा था, इसलिए मैं @ डेनिस से पहले इसका जवाब देने में असमर्थ था।