बहुआयामी निर्देशांक के सूचकांक का मूल्यांकन करें

9

आयामी निर्देशांक का एक संग्रह प्रदान किया जाता है। एक उदाहरण नीचे है:

{2,3,4}

यह 2x, 3y's और 4z के साथ एक 3 आयामी सरणी के रूप में सोचा जा सकता है; आयामों की कोई संख्या हो सकती है। उदाहरण में, कुल 24 नोड हैं। प्रत्येक नोड को {x, y, z} का उपयोग करके अनुक्रमित किया जा सकता है। 5 वें नोड तक पहुंचने के लिए, नीचे दिए गए तालिका के आधार पर, दिए गए सूचकांक {0, 1, 0} होंगे।

## | x y z
     0 1 2
-----------
0  | 0 0 0
1  | 0 0 1
2  | 0 0 2
3  | 0 0 3
4  | 0 1 0
5  | 0 1 1
6  | 0 1 2
7  | 0 1 3
8  | 0 2 0
...
23 | 1 2 3

यदि नोड संख्या दी गई है, तो एक सूचकांक निर्धारित करने के लिए इस एप्लिकेशन का उद्देश्य पीछे की ओर काम करना है।

यदि 8 वें नोड के "y" इंडेक्स के लिए कहा जाए, तो प्रोग्राम को "2" प्रिंट करना चाहिए।

दिए गए इनपुट के साथ:

{2,3,4}|8|1
<List of Coordinates>|<Node>|<Index>

निम्नलिखित मुद्रित किया जाना चाहिए:

2

आप यह मान सकते हैं कि इनपुट को आपकी पसंद की भाषा में कुछ सुविधाजनक तरीके से प्रदान किया जाएगा और सीमा जाँच की आवश्यकता नहीं है। उदाहरण के लिए आप मान सकते हैं कि प्रदान किए गए निर्देशांक (उदाहरण में "y") दिए गए निर्देशांक के संबंध में मान्य है। आप 0 या 1 आधारित अनुक्रमण का उपयोग कर सकते हैं; उदाहरण 0 आधारित है।

यह इस प्रश्न के रिवर्स की तरह है: एक बहुआयामी सरणी का सूचकांक

code-golf  math  array-manipulation 
— मार्क जॉनसन
स्रोत
1
शायद कुछ परीक्षण मामलों को जोड़ दें
— लुइस मेंडो
1
क्या हम निर्देशांक को 0 से x-1 के बजाय 1 से x तक चलने दे सकते हैं? तो नोड # 0 होगा (1,1,1) और नोड # 23 (2,3,4)।
— nimi
@ निम्मी हां, 1 आधारित अनुक्रमण ठीक है।
— मार्क जॉनसन

जवाबों:

4

MATL , 8 बाइट्स

PiX[vPi)

यह नोड के लिए और आयामों के लिए 1-आधारित अनुक्रमण का उपयोग करता है। तो पहले नोड्स हैं 1, 2आदि; और "x" आयाम है 1, "y" है 2आदि।

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

व्याख्या

फ़ंक्शन का उपयोग करने के लिए है X[( ind2subMatlab या ऑक्टेव में इसी ), जो एक रैखिक सूचकांक को बहुआयामी सूचकांक में परिवर्तित करता है। हालाँकि, आयामों का क्रम यदि चुनौती के रूप में परिभाषित किया गया है, तो P( flip) फ़ंक्शन को कॉल करने से पहले, और फिर से vअपने ouputs को बदलने के बाद की जरूरत है।

P    % Implicit input: size as a row vector. Flip
i    % Input: node (linear) index
X[   % Convert from linear index to multidimensional indices. Produces
     % as many outputs as entries there are in the size vector
v    % Concatenate all outputs into a column vector
P    % Flip
i    % Input: dimension
)    % Index: select result for that dimension. Implicitly display
— लुइस मेंडो
स्रोत
3

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

(#)तीन तर्क लेता है और पूर्णांक देता है, के रूप में उपयोग करें [2,3,4]#8$1।

l#n=(zipWith mod(scanr(flip div)n$tail l)l!!)

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

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

  • lनिर्देशांक की सूची है, nनोड संख्या। l#nएक ऐसा कार्य है जो अंतिम सूचकांक लेता है i।
  • उदाहरण सूची [2,3,4]और नोड को देखते हुए 8, पहले सूची की पूंछ ली जाती है, दे रही है [3,4]। फिर इसे ight scanसे ned किया जाता है, लिस्ट देते हुए प्रत्येक एलिमेंट द्वारा नोड नंबर को आईडी करते हुए ।rdiv[0,2,8]
  • तब सूची [0,2,8]और मूल l=[2,3,4]रहे हैं zipped ULUS ऑपरेटर, दे रही है ।withmod[0,2,0]
  • अंत में !!सूची अनुक्रमण ऑपरेटर को आंशिक रूप से लागू किया जाता है, जिसके परिणामस्वरूप फ़ंक्शन अंतिम सूचकांक देने के लिए तैयार होता है।
— अर्जन जोहान्सन
स्रोत
3

APL (Dyalog Classic) , 5 बाइट्स

⎕⌷⎕⊤⎕

नहीं, आप एक फ़ॉन्ट याद नहीं कर रहे हैं। यह कैसे दिखना है।

यह एक REPL प्रोग्राम है जो STDIN से इनपुट लेता है: नोड संख्या, आयाम और सूचकांक (उस क्रम में)। उत्तरार्द्ध 0- या 1-आधारित हो सकता है, जिसके मूल्य के आधार पर ⎕IO।

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

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

बहुआयामी सरणी अनुक्रमण अनिवार्य रूप से मिश्रित आधार रूपांतरण है, इसलिए ⊤चुनौती का पहला भाग क्या पूछता है। प्रत्येक घटना ⎕एसटीडीआईएन से एक पंक्ति को पढ़ती और निकालती है, इसलिए

      ⎕ ⊤ ⎕
⎕:
      8
⎕:
      2 3 4
0 2 0

अंत में, ⌷तत्व को निर्दिष्ट सूचकांक पर ले जाता है। बाईं ओर ⎕STDIN से तीसरा और अंतिम इनपुट पढ़ता है और

      ⎕ ⌷ (0 2 0)
⎕:
      1
2
— डेनिस
स्रोत
मिश्रित आधार रूपांतरण फिर से!
— एडम
3

हास्केल, 38 30 29 28 बाइट्स

l#n=(mapM(\x->[1..x])l!!n!!)

यह 0-आधारित सूचकांकों का उपयोग करता है और 1 से शुरू होने वाला निर्देशांक है। इसे ऑनलाइन आज़माएं!

xइनपुट के प्रत्येक आयाम को सूची में बदलें [1..x], जैसे [2,3,4]-> [[1,2],[1,2,3],[1,2,3,4]]। mapMउन सभी संभावित n-tuples की सूची बनाता है जहां पहला तत्व पहली सूची से लिया गया है, आदि !!n-tuple और आयाम को अनुक्रमित करने के लिए दो बार ।

संपादित करें: @ Johanrjan जोहानसन ने 8 9 बाइट्स बचाए । धन्यवाद!

— nimi
स्रोत
ऊह, चतुर! लेकिन mapM id.map f=mapM f। और (`take`[0..])छोटा है।
— अर्जन जोहान्सन
@ ,RjanJohansen: 8 बाइट्स, यह बड़े पैमाने पर है! आपका बहुत बहुत धन्यवाद! 1-आधारित निर्देशांक की अनुमति होने पर भी ओपी के उत्तर की प्रतीक्षा की जा रही है।
— nimi
इसके अलावा, l#n=(mapM(`take`[0..])l!!n!!)कम है। (संयोग से आपको ज़रूरत नहीं थी f=, फ़ंक्शंस गुमनाम हो सकते हैं। ओह, मुझे लगता है कि आप इसे गिन नहीं रहे हैं।)
— भजन जोहान्स
@ .RjanJohansen: फिर से धन्यवाद। f=एक प्रति था और TIO से त्रुटि पेस्ट करें।
— nimi
2

ब्रेकीलॉग , 25 23 बाइट्स

tT&bhH&h{>ℕ}ᵐ:H≜ᶠ⁾t:T∋₎

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

दूसरा तर्क 1-अनुक्रमित है, अन्य 2 0 अनुक्रमित हैं।

व्याख्या

tT                          Input = [_, _, T]
  &bhH                      Input = [_, H, T]
      &h{>ℕ}ᵐ               Create a list where each element is between 0 and the
                              corresponding element in the first element of the Input
             :H≜ᶠ⁾          Find the first H possible labelings of that list
                  t         Take the last one
                   :T∋₎     Output is the T'th element
— Fatalize
स्रोत
1

गणितज्ञ, २६ २३ बाइट्स

Array[f,#,0,Or][[##2]]&

इनपुट के लिए 1-आधारित इंडेक्सिंग, और आउटपुट के लिए 0-आधारित इंडेक्सिंग का उपयोग करना।

क्यों Or? क्योंकि यह विशेषता के साथ सबसे छोटा बिल्ट-इन फ़ंक्शन है Flat।

उदाहरण:

In[1]:= Array[f,#,0,Or][[##2]]&[{2,3,4},9,2]

Out[1]= 2
— alephalpha
स्रोत
1

एपीएल (डायलॉग) , 6 बाइट्स

0-आधारित इंडेक्सिंग प्राप्त करने के लिए ⎕IO←0, जो कई प्रणालियों पर डिफ़ॉल्ट है। आयामों के लिए संकेत, फिर (नोड, समन्वय) की संलग्न सूची।

⎕⊃↑,⍳⎕

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

⎕ आयामों के लिए संकेत

⍳उस आइटम के लिए i ndices  होने के साथ प्रत्येक आइटम के साथ उस आकृति का एक सरणी उत्पन्न करें

, ravel (सूचकांकों की सूची में शामिल करें)

↑ गहराई के एक स्तर को रैंक के एक अतिरिक्त स्तर में परिवर्तित करें

⎕⊃ (नोड, समन्वय) की संलग्न सूची के लिए संकेत और उस से एक तत्व लेने के लिए उपयोग करें

— एडम
स्रोत
1

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

Œp⁴ị⁵ị

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

यह इनपुट और आउटपुट के लिए 1-इंडेक्सिंग का उपयोग करता है।

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

Œp⁴ị⁵ị
Œp      Cartesian product of the first input
        numbers are converted to 1-based ranges
  ⁴ị    index specified by second input
    ⁵ị  index specified by third input
— लीक नन
स्रोत
0

आर, 52 बाइट्स

function(x,y,z,n,i)expand.grid(1:z,1:y,1:x)[n,4-i]-1

एक अनाम फ़ंक्शन देता है, 1-अनुक्रमित।

उदाहरण के लिए। expand.gridसूची बनाता है, लेकिन पहला तर्क सबसे तेज़ बदलता है, इसलिए हमें उन्हें रिवर्स ऑर्डर में इनपुट करना होगा, अर्थात z,y,x। फिर हम बस इंडेक्स कर सकते हैं [n,4-i], जहां 4-iउलट क्रम के लिए आवश्यक है, और यह सुनिश्चित करने के लिए 1 से घटाएं कि वे कहां से चलते हैं0:(x-1) आदि ।

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

— ग्यूसेप
स्रोत
0

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

(a,n,i,g=j=>a[++j]?g(j)/a[j]|0:n)=>g(i)%a[i]

Ungolfed:

(a,n,i)=>a.reduceRight(([n,...a],e)=>[n/e|0,n%e,...a],[n])[i+1]

अफसोस reduceकी बात है दो बाइट्स लंबा है:

(a,n,i)=>a.reduce((r,d,j)=>j>i?r/d|0:r,n)%a[i]
— नील
स्रोत
लगता है कि हम एक ही विचार के साथ आए थे /
— लीक नून
@LeakyNun खैर, यह वास्तव में आश्चर्यजनक नहीं है, यह देखते हुए कि अनुक्रमण कैसे काम करता है।
— नील
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.