एक प्रोग्राम या फ़ंक्शन लिखें, जो पूर्णांक दिया गया है, लंबाई के आयामों के nसाथ एक सरणी का निर्माण करें , जहां प्रत्येक तत्व अपने स्वयं के निर्देशांक का एक पहचानकर्ता है। अर्थात्, एक सरणी से शुरू करके, इसे सरणियों के साथ आबाद करें , जहाँ उनमें से प्रत्येक में अधिक सरणियाँ हों, जिनकी गहराई तक । गहनतम सरणियों के तत्व निर्देशांक का वर्णन करते हैं कि वे पूर्ण सरणी में कहां हैं।nnnnn-1

मेरे स्पष्टीकरण के मामले में कुछ उदाहरण भ्रमित करने वाले थे।

एन = 1

["1"]

n = 2

[
 ["11", "12"],
 ["21", "22"]
]

n = 3

[
  [
    ["111","112","113"],
    ["121","122","123"],
    ["131","132","133"]
  ],
  [
    ["211","212","213"],
    ["221","222","223"],
    ["231","232","233"]
  ],
  [
    ["311","312","313"],
    ["321","322","323"],
    ["331","332","333"]
  ]
]

यहां, "321" का अर्थ है कि यह 3 वें सरणी के 2 तत्व का 1 तत्व है।

नियम:

निर्देशांक और आयाम ( n) 0 या 1 अनुक्रमित हो सकते हैं
nअस्पष्ट मानों को रोकने के लिए दोनों अनुक्रमण विकल्पों के लिए आप मान सकते हैं कि एकल अंक 10 से नीचे है
IO लचीला है।
- विशेष रूप से, निर्देशांक सरणियों, तार आदि हो सकते हैं जब तक कि वे स्पष्ट हों। "321" => [3,2,1]
- आउटपुट प्रमुख शून्य के साथ या बिना बेस 10 में पूर्णांक हो सकता है।
- यदि आप चाहें तो निर्देशांक उल्टे क्रम में हो सकते हैं, जब तक यह सुसंगत है। "321" => "123"
- आउटपुट के लिए आपकी भाषा में एक सरणी संरचना होना आवश्यक नहीं है। जब तक किसी सरणी की शुरुआत, किसी सरणी के अंत और अलग तत्वों के लिए स्पष्ट अलग मार्कर हैं।
- इसके लिए आउटपुट n=1सिर्फ 1 हो सकता है
- यदि आपका आउटपुट एटिपिकल है, तो प्रारूप की व्याख्या करना सुनिश्चित करें।
यह कोड-गोल्फ है इसलिए प्रत्येक भाषा में सबसे छोटा समाधान जीतता है!

code-golf

— मजाक कर रहा है
स्रोत

सैंडबॉक्स (हटाए गए)

— जो किंग

हास्केल में मुझे यह लिखने में परेशानी हो रही थी, इससे पहले कि मुझे एहसास होता कि टाइप सिस्टम इसे असंभव बना देता है।

— गेहूं जादूगर

@CatWizard: आप हमेशा एक नई डेटा संरचना को परिभाषित कर सकते हैं जो कि आसपास हो, जैसे। data L a = L [L a] | E a।

— ბიმო

2

Dyalog एपीएल , 5 3 बाइट्स

⍳⍴⍨

-2 बाइट्स FrownyFrog की बदौलत

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

⍳एक सरणी के आकार को देखते हुए सभी सूचकांक देता है। जैसे २ ३ ।
⍴दायीं आर्ग को आकार देता है बायें आर्ग का आकार। ⍨दोनों ही सही तर्क है।

— dzaima
स्रोत

10

पायथन 3 , 56 बाइट्स

f=lambda n,*l:len(l)//n*l or[f(n,*l,k)for k in range(n)]

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

मिस्टर एक्सकोडर ने 2 बाइट्स को बचाए, जो कि अनकैपिंग के लिए पायथन 3 में बदल गए।

— XNOR
स्रोत

3

यदि आप पायथन .53.5 पर जाते हैं, तो f=lambda n,*l:len(l)//n*l or[f(n,*l,k)for k in range(n)]56 बाइट्स के लिए काम करता है।

— मिस्टर एक्सकोडर

9

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

^{-10 बाइट्स @alephalpha को धन्यवाद}

Array[List,#~Table~#]&

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

— जंगहवान मिन
स्रोत

6

जे , 18 बाइट्स

,"1/^:(]{:)~@,.@i.

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

Iterative समाधान, कोई अंतर्निर्मित कार्टेशियन उत्पाद नहीं। यह शिखर जे जैसा दिखता है।

                       input                                    2
                i.     range                                 0, 1
             ,.@       reshape each element
                       into a one-dimensional array        [0],[1]   (A)
    ^:(]{:)            (input−1) times...             (1 iteration)
,"1/       ~@             prepend the contents of each 1d array in A    |
                          to every 1d array from the previous iteration,|  
                          assembling the results for each A[n] into     |!CANTEXPLAINTHIS!
                          a larger array                                |
                                                         [ [0,0],       |
                                                           [0,1] ],     |
                                                         [ [1,0],       |
                                                           [1,1] ]      |

— FrownyFrog
स्रोत

सबसे पहले उच्च बाइट गिनती मुझे बंद कर दिया है, लेकिन इस सच में सुंदर जम्मू है

— योना

6

जेली , 8 7 बाइट्स

ṗ³s³$³¡

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

व्याख्या

उदाहरण के रूप में तर्क 2 का उपयोग करें।

ṗ³s³$³¡   
ṗ        Cartesian power with power
 ³       2 (the argument). Autoranges the left arg.
         Yields [[1,1],[1,2],[2,1],[2,2]]
    $³¡  Do 2 times:
  s³     Split into segments of length 2. 
         This last step molds the array of indices into the proper shape.

यदि ¡यह डायड के पुनरावृत्तियों पर सही तर्क से भिन्न नहीं है, तो यह 4 बाइट होगा:ṗs³¡

— dylnan
स्रोत

यह मेरे लिए एक पूर्ण कार्यक्रम की तरह दिखता है। क्या आप सुनिश्चित हैं कि आउटपुट (STDOUT) 1वैध है?

— एर्ग आउटफोलर जूल

@EriktheOutgolfer मैं आउटपुट के साथ ठीक हूं

— जो किंग

@JoKing लेकिन, इस मामले में, "किसी सरणी की शुरुआत के लिए स्पष्ट मार्कर नहीं हैं, किसी सरणी का अंत"। क्या आप प्रश्न संपादित करना चाहते हैं? (बहुत सारे जवाब वास्तव में उन्हें शामिल नहीं करते हैं)

— एरिक आउटगोल्फर

5

जे, 13 बाइट्स

[:{[;/@$,:@i.

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

दिलचस्प है कि यह एपीएल उत्तर की तुलना में बहुत लंबा है (हालांकि यह एक बेहतर अनुवाद देखने में मेरी अक्षमता हो सकती है)

व्याख्या

[: { [ ;/@$ ,:@i.


     [                NB. the argument
            ,:@i.     NB. range 0..arg, considered as one item: ,: is "itemize" 
          $           NB. repeat the right range the left number of times
       ;/@            NB. and then put boxes around them. so, eg, if we had
                      NB. an arg of 3, now we have the list of boxes 
                      NB. [0 1 2][0 1 2][0 1 2]
[: {                  NB. { is "Catalog", it creates the cartesian product
                      NB. in exactly the format we desire.

— जोनाह
स्रोत

1

एक बेहतर (?) अनुवाद

— FrownyFrog

@FrownyFrog बचने के लिए एक हुक का उपयोग करना #.invबहुत चालाक है, +1।

— कोल

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

— योना

जोनाह, @cole आपका धन्यवाद

— FrownyFrog

5

MATLAB, 92 89 55 बाइट्स

मेरे पास चुनौती के नियमों को फिर से पढ़ने का एक अलग उत्तर है, लेकिन मैं पिछले प्रयास को नीचे छोड़ दूंगा क्योंकि यह देखने में अलग और अभी भी मजेदार है।

reshape(string(dec2base(0:n^n-1,n+(n<2))),[~(1:n)+n 1])

व्याख्या

                        0:n^n-1                        % [0,1,...,n^n-1]
               dec2base(       ,n+(n<2))               % Put into base n (base 2 if n=1)
        string(                         )              % Convert to strings
                                          [~(1:n)+n 1] % Dimension array [n,n,...,n] (length n)
reshape(                                 ,            )% Use dim array to reshape

यह स्ट्रिंग्स के एक n- आयामी सरणी को आउटपुट करता है जो 0 अनुक्रमित हैं।

पिछला उत्तर (89 बाइट्स)

मेरा पहला गोल्फ! यह संभवतया कम हो सकता है, लेकिन मुझे लगा कि मुझे जो मिला है, वह पोस्ट करूँगा।

x=(1:n)';for d=2:n;y=((1:n)*10^(d-1));o=[];for p=1:nnz(y);o=cat(d,o,(x+y(p)));end;x=o end

व्याख्या

x=(1:n)';                       % Create array x=[1,2,...n]'
for d=2:n                       % d for dimension
    y=((1:n)*10^(d-1));         % Creates an array for each d where
                                %   y=[10,20,30,...] for n=2
                                %   y=[100,200,...] for n=3 etc.
    o=[];                       % o for output
    for p=1:nnz(y)              % For each value of y
        o=cat(d,...             % Concatenate in the dth dimension:
            o,...               % - The current output
            x+y(p));            % - The sum of
                                %   - The array from the last dimension
                                %   - The current value in y (e.g. 100)
    end
    x=o                         % Send the output to x for the next loop
end

समाधान देने के लिए अंत में आउटपुट x

अन्य MATLAB पोस्ट की तरह, आउटपुट एक एन-आयामी सरणी है, सिवाय इसके कि निर्देशांक प्रदर्शित करने के लिए संख्याओं का उपयोग किया जाता है। यह किसी भी मूल्य के लिए काम करता है, हालांकि क्योंकि MATLAB में लूप खराब हैं, यह n = 8 के आसपास काफी धीमा होने लगता है।

संपादित करें: लुइस मेंडो के लिए -2 बाइट्स धन्यवाद। आउटपुट को प्रिंट करने के लिए अंतिम अर्धविराम को भी हटा दिया।

— जैकब वॉटसन
स्रोत

4

PPCG में आपका स्वागत है!

— झबरा

मुझे लगता है कि आप की जगह ले सकता lengthसे nnzकुछ बाइट्स को बचाने के लिए। पीपीसीजी नियमों के अनुसार, कोड को कुछ वास्तविक आउटपुट का उत्पादन करना होता है, आमतौर पर इसे STDOUT में प्रदर्शित करके (यह एक चर में संग्रहीत आउटपुट के लिए पर्याप्त नहीं है), या इसे एक फ़ंक्शन होना चाहिए जो आउटपुट लौटाता है

— लुइस मेंडो

5

जंग ,201 176 167 166 154 बाइट्स

enum L{S(String),L(Vec<L>)}fn
h(n:u8,d:u8,s:&str)->L{if
d<1{L::S(s.into())}else{L::L((0..n).map(|i|h(n,d-1,&format!("{}{}",s,i))).collect())}}|n|h(n,n,"")

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

आउटपुट प्रकार दो प्रकार के साथ एक योग प्रकार है क्योंकि भाषा सख्ती से टाइप की जाती है। यह या तो हो सकता है L, जो एक सूची प्रकार है जिसमें यह राशि प्रकार है या Sजो एक परिणाम प्रकार (एक स्ट्रिंग) है। परिणाम इस तरह दिख सकता है।

L::L([
 L::L([ L::S("00"), L::S("01") ]),
 L::L([ L::S("10"), L::S("11") ]),
])

इसके अलावा, सुधारित का उपयोग कर rustfmt:

enum L {
    S(String),
    L(Vec<L>),
}
fn h(n: u8, d: u8, s: &str) -> L {
    if d < 1 {
        L::S(s.into())
    } else {
        L::L(
            (0..n)
                .map(|i| h(n, d - 1, &format!("{}{}", s, i)))
                .collect(),
        )
    }
}
|n| h(n, n, "")

— कोनराड बोरोस्की
स्रोत

4

आर , 102 बाइट्स

function(n,m=array(T,rep(n,n)))`if`(n<2,'1',{m[]=apply(which(m,T)[,`[<-`(1:n,1:2,2:1)],1,toString);m})

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

1-अनुक्रमित, उलट
दुर्भाग्य से R मैट्रिक्स को कॉलम द्वारा संग्रहीत करता है, अन्यथा हम 73 बाइट्स तक जा सकते हैं
-9 बाइट्स ने whichसरणी अनुक्रमण का उपयोग करने के लिए @Giuseppe सुझाव के लिए धन्यवाद बचाया

— digEmAll
स्रोत

आपका 76 बाइट का उत्तर 73 बाइट्स हो सकता है जो कि मैंने यह देखने के लिए जाँचने से पहले लागू किया है कि क्या पहले से ही एक आर उत्तर था। आप कुछ दृष्टिकोण को बदलने में सक्षम हो सकते हैं, हालांकि? पूरी तरह से निश्चित नहीं।

— Giuseppe

1

@Giuseppe: सरणी अनुक्रमण वह whichहै जिसकी मैं तलाश कर रहा था, धन्यवाद! सहेजे गए 9 बाइट्स

— digEmAll

4

जावा 10, 144 बाइट्स

समाधान विधि है f। यह सरणी का एक स्ट्रिंग प्रतिनिधित्व पैदा करता है।

String h(int n,int d,String s){if(d<1)return s;var r="[";for(int i=0;i++<n;)r+=h(n,d-1,s+i)+",";return r+"]";}String f(int n){return h(n,n,"");}

यह ऑनलाइन की कोशिश करो

Ungolfed

String h(int n, int d, String s) {
    if (d < 1)
        return s;
    var r = "[";
    for (int i = 0; i++ < n;)
        r += h(n, d - 1, s + i) + ",";
    return r + "]";
}
String f(int n) {
    return h(n, n, "");
}

स्वीकृतियाँ

बाइट बचत कोनराड बोरोस्की को धन्यवाद

— जेकब
स्रोत

1

जावा 10 में, आप के Object[]साथ बदल सकते हैं var। इसके अलावा, मुझे लगता है कि इस elseब्लॉक अनावश्यक है, के रूप में आप returnमें ifब्लॉक।

— कोनराड बोरोवस्की

3

05AB1E , 7 बाइट्स

LsãsGsô

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

व्याख्या

L          # push range [1 ... input]
 sã        # input repeated cartesian products of the list
   sG      # input - 1 times do:
     sô    # split into input parts

— Emigna
स्रोत

3

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

f=(n,i=n,s='')=>i?[...Array(n)].map((_,j)=>f(n,i-1,s+j)):s

इसे ऑनलाइन आज़माएं! आउटपुट 0-अनुक्रमित है। संपादित करें: @JoKing के लिए 2 बाइट्स धन्यवाद और @Arnauld के लिए एक और 2 बाइट्स धन्यवाद।

— नील
स्रोत

3

MATLAB, 116 108 104 बाइट्स

मुझे ऐसा लगता है कि ऐसा करने के लिए एक छोटा तरीका होना चाहिए, MATLAB की आत्मीयता को बहुआयामी परिपक्वता की ओर देखते हुए ... लुइस को कुछ शॉर्ट-हैंडिंग से 4 बाइट्स के लिए धन्यवाद

a=~(1:n)+n;c=cell(1,n);[c{:}]=ind2sub(a,1:n^n);reshape(arrayfun(@(varargin)[varargin{:}],c{:},'un',0),a)

व्याख्या

% For using twice, define the array of dimension sizes [n, n, .., n]
a=~(1:n)+n;
% To group variable number of outputs from ind2sub into a cell array
c=cell(1,n);   
% Convert linear indices to self-describing coordinates
[c{:}]=ind2sub(a,1:n^n);     
% reshape to make it the n-dimensional array
% arrayfun to loop over the numerous ind2sub outputs simultaneously
% varargin and {:} usage to account for various numbers of inputs
reshape(arrayfun(@(varargin)[varargin{:}],c{:},'uni',0),a)

आउटपुट एक एन-डायमेंशनल सेल सरणी है, जहां प्रत्येक तत्व समन्वय मूल्यों का एक सरणी है। nसंख्यात्मक सरणी आउटपुट के कारण अस्पष्टता के बिना किसी के लिए काम करता है , इसलिए जब तक एक n^(n+1)तत्व सरणी को रैम में संग्रहीत किया जा सकता है!

— Wolfie
स्रोत

3

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

Ｎθ≔ＥＸθθ⪫⪪◧⍘ιθθ ¦0υＦθ≔⪪υθυυ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｎθ

इनपुट n।

≔ＥＸθθ⪫⪪◧⍘ιθθ ¦0υ

nⁿ nआधार में सभी -digit संख्या उत्पन्न करें n।

Ｆθ≔⪪υθυ

उन्हें nएक n-आयामी आयाम में विभाजित करें जहां प्रत्येक आयाम आकार का है n।

υ

सरणी मुद्रित करें। डिफ़ॉल्ट आउटपुट स्वरूप प्रत्येक तत्व की अपनी लाइन पर होता है, फिर nलाइनों के प्रत्येक ब्लॉक को एक खाली लाइन द्वारा समाप्त किया जाता है, फिर लाइनों के nब्लॉक के प्रत्येक ब्लॉक को nदूसरी खाली लाइन द्वारा समाप्त किया जाता है, और इसलिए n-1शीर्ष स्तर पर रिक्त लाइनों तक ।

— नील
स्रोत

2

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

ṗṁẋ`ŒṬ$

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

— आउटग्रॉफर को एरिक करें
स्रोत

स्वयं की पहचान करने वाले निर्देशांक

एन = 1

n = 2

n = 3

नियम:

Dyalog एपीएल , 5 3 बाइट्स

पायथन 3 , 56 बाइट्स

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

जे , 18 बाइट्स

जेली , 8 7 बाइट्स

जे, 13 बाइट्स

व्याख्या

MATLAB, 92 89 55 बाइट्स

जंग ,201 176 167 166 154 बाइट्स

आर , 102 बाइट्स

जावा 10, 144 बाइट्स

Ungolfed

स्वीकृतियाँ

05AB1E , 7 बाइट्स

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

MATLAB, 116 108 104 बाइट्स

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

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