कई आयामों का एक नृत्य

Question

चुनौती

nपूर्णांक की -dimensional सरणी और पहले nप्राकृतिक संख्या के क्रमांकन को देखते हुए , तदनुसार सरणी आयामों की अनुमति दें।

विवरण

यह चुनौती MATLABs से प्रेरित है permute। ^{_{प्रदर्शन}} क्रमचय को पूर्णांकों की सूची के रूप में दिया गया है, उदाहरण के [1,3,2]लिए 1 का अर्थ 1 से 2 हो जाता है, 2 से 3 की मैपिंग हो जाती है और 3 से 2 की मैपिंग हो जाती है (यहाँ iवें प्रविष्टि का मान iमैप हो जाता है)। लेकिन आप अन्य स्वरूपों का उपयोग कर सकते हैं जो सुविधाजनक हैं, उदाहरण के लिए चक्र या फ़ंक्शन के रूप में। यदि यह अधिक सुविधाजनक है तो आप 0-आधारित अनुक्रमण का भी उपयोग कर सकते हैं।

सरणी को एक पूर्ण "आयताकार" m1 x m2 x ... x mn-अरे माना जा सकता है (यानी आप मान सकते हैं कि यह रैग्ड / दांतेदार नहीं है )।

आप मान सकते हैं कि nबहुत बड़ी नहीं है, क्योंकि कई भाषाओं में एक नेस्टेड सरणी में आयामों की संख्या की सीमा होती है।

यदि आपकी भाषा बहुआयामी सरणियों का समर्थन नहीं करती है, तो आप एक स्ट्रिंग भी ले सकते हैं जो इनपुट के रूप में सरणी का प्रतिनिधित्व करती है।

उदाहरण

• nपहचान की अनुमति के साथ किसी भी आयामी सरणी को [1,2,3,...,n]अपरिवर्तित किया जाएगा।
• [[10,20,30],[40,50,60]]क्रमपरिवर्तन के साथ सरणी [2,1]मैप हो जाती है [[10,40],[20,50],[30,60]]।
• [[[1,2],[3,4]],[[5,6],[7,8]]]क्रमपरिवर्तन के साथ सरणी [2,3,1]मैप हो जाती है [[[1,3],[5,7]],[[2,4],[6,8]]]।

Answer 1

अंतर्निहित समाधान वाली भाषाएं

xnor द्वारा इस प्रस्ताव के आधार पर

एपीएल (डायलॉग यूनिकोड) , 1 बाइट

⍉

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

जे , 2 बाइट्स

|:

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

आर , 5 बाइट्स

aperm

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

ऑक्टेव / MATLAB, 8 बाइट्स

@permute

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

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

Transpose

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

जूलिया , 11 बाइट्स

permutedims

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

Answer 2

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

pएक प्रकार (बहुरूप वर्ग बहुरूपिक) फ़ंक्शन है जो Intएस की एक सूची के रूप में क्रमपरिवर्तन ले रहा है , और एक नेस्टेड सूची Intएस के बहुआयामी सरणी का प्रतिनिधित्व करता है ।

p [2,1] [[10,20,30],[40,50,60]]वैसे भी कॉल करें , यदि टाइप करने में चूक सफल नहीं होती है, तो आपको :: [[Int]]परिणाम का प्रकार देते हुए एक प्रकार का एनोटेशन जोड़ना होगा ( जैसे नेस्टेडली)।

import Data.List
class P a where p::[Int]->[a]->[a]
instance P Int where p _=id
instance P a=>P[a]where p(x:r)m|n<-p r<$>m,y:z<-sort r=last$n:[p(x:z)<$>transpose n|x>y]

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

मनमानी गहराई के नेस्टेड सरणियों के साथ गोल्फिंग चुनौतियां हास्केल में थोड़ी अजीब हैं, क्योंकि स्थिर टाइपिंग रास्ते में मिल जाती है। जबकि हास्केल सूचियों (चुनौती विवरण में सटीक सिंटैक्स के साथ) को केवल ठीक से घोंसला बनाया जा सकता है, विभिन्न घोंसले की गहराई की सूची असंगत प्रकार की होती है। इसके अलावा, मानक हास्केल पार्सिंग फ़ंक्शन को उस मूल्य के प्रकार को जानने की आवश्यकता होती है जिसे आप पार्स करने की कोशिश कर रहे हैं।

नतीजतन, यह अपरिहार्य लगता है कि कार्यक्रम में टाइप-संबंधित घोषणाओं को शामिल करने की आवश्यकता है, जो अपेक्षाकृत क्रिया हैं। गोल्फ वाले हिस्से के लिए, मैं एक प्रकार के वर्ग को परिभाषित करने पर बस गया P, जैसे कि pसरणी के प्रकार पर बहुरूपी हो सकता है।

इस बीच, TIO की टेस्टिंग हार्नेस पार्सिंग समस्या के आसपास आने का रास्ता दिखाती है।

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

• इस एल्गोरिथ्म के सार को सारांशित करने के लिए: यह क्रमबद्धता सूचकांकों की अदला-बदली होने पर पड़ोसी आयामों को स्थानांतरित करते हुए, क्रमचय सूची पर एक बुलबुला छाँट देता है।

• जैसा कि class P aघोषणा द्वारा दिया गया है , किसी भी उदाहरण में, pदो तर्क, एक क्रमपरिवर्तन (हमेशा प्रकार [Int]) और एक सरणी लेता है ।

• क्रमबद्धता को चुनौती के विवरण के रूप में दिया जा सकता है, हालांकि एल्गोरिथ्म के काम करने का तरीका, सूचकांकों का चुनाव मनमाना है, सिवाय उनके सापेक्ष क्रम के। (तो दोनों 0- और 1- आधारित काम।)
• आधार instance P Intआयाम 1 के सरणियों को संभालता है, जो pकेवल अपरिवर्तित रिटर्न देता है, क्योंकि एक आयाम केवल खुद को मैप किया जा सकता है।
• दूसरे instance P a => P [a]को पुनरावर्ती रूप से परिभाषित किया गया है, आयाम n + 1 सरणियों के लिए इसे परिभाषित करने के लिए pआयाम n सबरेज़ के साथ कॉल करना ।
  • p(x:r)mपहले p rप्रत्येक तत्व पर पुनरावर्ती कॉल करता है m, एक परिणाम सरणी nदेता है जिसमें पहले को छोड़कर सभी आयाम एक दूसरे के लिए अपेक्षाकृत सही ढंग से अनुमत होते हैं।
  • शेष क्रमपरिवर्तन जिसे करने की आवश्यकता nहै, द्वारा दिया जाता है x:y:z = x:sort r।
  • यदि x<yतब पहले आयाम को nसही ढंग से रखा गया है, और nबस वापस आ गया है।
  • यदि x>y, तब पहले और दूसरे आयाम की nआवश्यकता होती है, जिसे स्वैप किया जाता है, जो transposeफ़ंक्शन के साथ किया जाता है । अंत p(x:z)में परिणाम के प्रत्येक तत्व के लिए पुनरावर्ती रूप से लागू किया जाता है, यह सुनिश्चित करते हुए कि मूल पहले आयाम को सही स्थिति में स्थानांतरित किया जाता है।

Answer 3

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

यह क्रमपरिवर्तन के लिए 0-इंडेक्सिंग का उपयोग करता है

from numpy import*
from itertools import*
z=range
def f(i,r):
	l=array(i).shape;R={b:a for a,b in enumerate(r)};r=len(r);m=eval('['*r+'0'+q('for k in z(l[R[%s]])]',r-1,-1,-1))
	for d in product(*[z(p) for p in l]):exec'm'+q('[d[R[%s]]]',r)+'=i'+q('[d[%s]]',r)
	return m
q=lambda s,*j:''.join(s%(j)for j in z(*j))

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

-2 बाइट्स थैंक्स टू @ जोनाथन फ्रेच।

Comments

आपको कॉल करने के लिए कोष्ठकों की आवश्यकता नहीं है exec (दो बाइट्स को बचाने के लिए ) , क्योंकि यह पायथन 2 में एक बयान है

— जोनाथन फ्रीच

में भी एक शानदार जगह है z(p) for।

— जोनाथन फ्रीच

इस्तेमाल किया map(z,l), s%jऔर print301 बाइट्स के लिए- ऑनलाइन यह कोशिश करो!

— श्री एक्सकोडर

Answer 4

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

import numpy
numpy.einsum

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

पर्मुटेशन वेक्टर pको अक्षरों की एक स्ट्रिंग के रूप में दिया जाता है। तो के [2,3,1]रूप में दिया जा सकता है 'bca'।

@EriktheOutgolfer की बदौलत 16 बाइट बच गईं!

Comments

क्या यह 26 से अधिक आयामों का समर्थन करता है?

— आउटगॉल्फ

वास्तव में 52 से अधिक आयाम नहीं: अपरकेस + लोअरकेस।

— rahnema1

Answer 5

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

(a,p,v=[],r=[],g=(a,[d,...p],_,h=(r,[i,...v])=>1/v[0]?h(r[i]=r[i]||[],v):r[i]=a)=>1/d?a.map((e,i)=>g(e,p,v[d]=i)):h(r,v))=>g(a,p)&&r

0 अनुक्रमित। स्पष्टीकरण: gपुनरावर्ती का उपयोग करके पुन : क्रमबद्ध सूचकांकों की aएक सरणी vके निर्माण पर पुनरावर्ती पुनरावृत्त होता है p। एक बार जब pसमाप्त हो जाता है, hतो पुनरावर्ती rसूचकांकों का उपयोग करके तत्व को परिणाम सरणी में सम्मिलित करता है ।