बहुआयामी उलटफेर

Question

गैर-नकारात्मक पूर्णांक के एक एन-आयामी ऑर्थोगोनल (गैर-रैग्ड) सरणी को देखते हुए, और संकेत दिया जाता है कि किस आयाम को उल्टा करना है, सरणी को वापस करें लेकिन उन आयामों के साथ उलट। संकेत को लंबाई N की बूलियन सूची या 0 या 1 से अनुक्रमित पहले N आयामों के सबसेट की सूची के रूप में दिया जा सकता है।

कृपया अपने इनपुट प्रारूप बताएं। कोड स्पष्टीकरण बहुत सराहना की है।

उदाहरण के माध्यम से चला गया

हमें 2-लेयर 3-पंक्ति 4-कॉलम 3 डी-सरणी दी गई है

[[[ 1, 2, 3, 4],
  [ 5, 6, 7, 8],
  [ 9,10,11,12]],

 [[13,14,15,16],
  [17,18,19,20],
  [21,22,23,24]]]

और एक

[true,false,true](बूलियन सूची)
[0,2](0-अनुक्रमित सूची)
[1,3](1-अनुक्रमित सूची)

हमें पहले और अंतिम आयामों के क्रम को उलटने की आवश्यकता है, जो कि परतों और पंक्तियों (स्तंभों) के तत्व हैं, लेकिन प्रत्येक परत की पंक्तियाँ नहीं। पहला (वास्तविक आदेश जो आप ऐसा करते हैं, इससे कोई फर्क नहीं पड़ता) हम परतों के क्रम को उल्टा करते हैं:

[[[13,14,15,16],
  [17,18,19,20],
  [21,22,23,24]],

 [[ 1, 2, 3, 4],
  [ 5, 6, 7, 8],
  [ 9,10,11,12]]]

और फिर हम प्रत्येक पंक्ति के तत्वों के क्रम को उल्टा करते हैं:

[[[16,15,14,13],
  [20,19,18,17],
  [24,23,22,21]],

 [[ 4, 3, 2, 1],
  [ 8, 7, 6, 5],
  [12,11,10, 9]]]

परीक्षण के मामलों

[[[1,2,3,4],[5,6,7,8],[9,10,11,12]],[[13,14,15,16],[17,18,19,20],[21,22,23,24]]]
[true,false,true]/ [0,2]/ [1,3]
 ↓ 
[[[16,15,14,13],[20,19,18,17],[24,23,22,21]],[[4,3,2,1],[8,7,6,5],[12,11,10,9]]]

---

[[1,2,3],[4,5,6]]
[true,false]/[0] / [1]
 ↓
[[4,5,6],[1,2,3]]

---

[[1],[4]]
[true,false]/[0] / [1]
 ↓
[[4],[1]]

---

[[7]]
[true,true]/[0,1] / [1,2]
 ↓
[[7]]

---

[1,2,3,4,5,6,7]
[true]/[0] / [1]
 ↓
[7,6,5,4,3,2,1]

---

[]
[true]/[0] / [1]
 ↓
[]

---

[[],[]]
[false,false]/[] / []
 ↓
[[],[]]

---

[[[[3,1,4,1],[5,9,2,6]],[[5,3,5,8],[9,7,9,3]]],[[[2,3,8,4],[6,2,6,4]],[[3,3,8,3],[2,7,9,5]]]]
[true,false,true,true]/[0,2,3] / [1,3,4]
 ↓
[[[[4,6,2,6],[4,8,3,2]],[[5,9,7,2],[3,8,3,3]]],[[[6,2,9,5],[1,4,1,3]],[[3,9,7,9],[8,5,3,5]]]]

---

[[[[3,1,4,1],[5,9,2,6]],[[5,3,5,8],[9,7,9,3]]],[[[2,3,8,4],[6,2,6,4]],[[3,3,8,3],[2,7,9,5]]]]
[false,true,false,false]/[1] / [2]
 ↓
[[[[5,3,5,8],[9,7,9,3]],[[3,1,4,1],[5,9,2,6]]],[[[3,3,8,3],[2,7,9,5]],[[2,3,8,4],[6,2,6,4]]]]

---

[[[[3,1,4,1],[5,9,2,6]],[[5,3,5,8],[9,7,9,3]]],[[[2,3,8,4],[6,2,6,4]],[[3,3,8,3],[2,7,9,5]]]]
[false,false,false,false]/[] / []
 ↓
[[[[3,1,4,1],[5,9,2,6]],[[5,3,5,8],[9,7,9,3]]],[[[2,3,8,4],[6,2,6,4]],[[3,3,8,3],[2,7,9,5]]]]

Comments

मुझे लगता है कि अधिकांश सांख्यिकीय रूप से टाइप की जाने वाली भाषाओं में सबसे कठिन हिस्सा शामिल प्रकार के हस्ताक्षर गोल्फिंग होगा।

— Οसुरेश

@ Arbiturous उन भाषाओं को सामान्य रूप से मनमाने सरणी डेटा के साथ कैसे व्यवहार करते हैं?

— आदम

"सामान्य" उपयोग के लिए तीन मामले हैं जैसा कि मैं इसे देखता हूं: केवल सरणी के एक स्तर के बारे में चिंता करना (जैसे: reverseमनमाना सरणियों पर काम करता है लेकिन केवल पहले स्तर के बारे में परवाह करता है), जेनेरिक, या पुनरावर्ती वर्ग (प्रकार / वस्तु वर्ग कार्यात्मक के आधार पर) या OOP, लेकिन समान उपयोग-मामला)। बाद के दो आमतौर पर अधिक क्रियात्मक होते हैं।

— Οसुरेश

क्या हम मैट्रिक्स को पॉइंटर्स टू पॉइंटर्स टू पॉइंटर्स (C या asm) में स्टोर कर सकते हैं, इसके बजाय उचित मल्टी-डायमेंशनल सरणियों के बजाय जहाँ सब कुछ मेमोरी में सन्निहित है? मुझे पूरा यकीन है कि सूचियों के मनमाने ढंग से घोंसले के शिकार सभी सामान्य उच्च-स्तरीय / गतिशील रूप से टाइप की जाने वाली भाषाएं पहले से ही चीजों को सूचियों की सूची के रूप में मान रही हैं, न कि मैट्रिस, इसलिए मैं यह मानने जा रहा हूं कि यह ठीक है।

— पीटर कॉर्ड्स

@PeterCordes ज़रूर, आगे बढ़ो।

— आदम

Answer 1

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

⊃{⌽[⍺]⍵}/

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

कैसे?

/ - कम करें - इनपुट (सरणी) में सबसे सही तत्व लें और अगले तर्क के साथ फ़ंक्शन को बाएं तर्क के रूप में लागू करें

{⌽[⍺]⍵}- left argument( ⍺) आयाम में उल्टा

⊃ - संलग्न सरणी को समतल करें

Answer 2

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

⊃{⊖[⍺]⍵}⌿

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

ऐसा लगता है कि यूरेल को पहले लगभग समान रूप से संपादित किया गया था , लेकिन मैंने इसे स्वतंत्र रूप से विकसित किया। मुझे लगा कि यह इनपुट प्रारूप अमान्य है।

Answer 3

जावास्क्रिप्ट (Node.js) , 58 55 53 45 बाइट्स

@ बस्ती के लिए 8 बाइट्स को सहेजा गया

इनपुट के रूप में लेता है (indications)(array), जहां संकेत एक बूलियन सूची है।

f=([r,...b])=>a=>1/r?a.sort(_=>r).map(f(b)):a

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

टिप्पणी की गई

f = (                // f is a function taking:
  [r,                //   r = next 'reverse' Boolean flag
      ...b]          //   b = array of remaining flags
) =>                 // and returning an anonymous function taking:
  a =>               //   a = array (or sub-array) to process, or atomic element
    1 / r ?          // if r is defined:
      a.sort(_ => r) //   reverse a if r = 1; leave it unchanged otherwise
      .map(f(b))     //   for each element in the resulting array: do a recursive call,
                     //   using f to generate a new callback function for the next flag
    :                // else:
      a              //   a must be an atomic element and is simply left unchanged

Comments

काम करने के लिए लगता है कि सिर्फ rइनकम का इस्तेमाल r||-1 करना ।

— झबरा

चाहेंगे f=([r,...b])=>a=>1/r?a.sort(_=>r).map(f(b)):aकाम करते हैं? मेरे फोन पर तो ठीक से परीक्षण नहीं कर सकते।

— झबरा

@ सुग्गी नाइस! मुझे यह असामान्य प्रसंस्करण प्रवाह पसंद है।

— अरनुलद

Answer 4

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

f=lambda a,t:t and[f(l,t[1:])for l in a][::1|-t[0]]or a

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

Answer 5

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

”€ẋ”ṚpFv

आयामों की 0-अनुक्रमित सूची लेता है।

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

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

”€ẋ”ṚpFv  Main link. Left arg: D (dimensions, 0-based), Right arg: A (array)

”€ẋ       Repeat '€' d times, for each d in D.
   ”Ṛp    Perform Cartesian product of ['Ṛ'] and each string of '€'s, prepending a
          'Ṛ' to each string of '€'s.
      F   Flatten the result.
          If, e.g., D = [0,2,4], we build the string "ṚṚ€€Ṛ€€€€".
       v  Eval the resulting string, using A as left argument.

Comments

यह खराब है। बहुत अच्छा!

— 17

Answer 6

आर , 80 78 77 बाइट्स

[जहां संकेत दिया गया है, वहां अनुक्रमों की एक सूची बनाकर आर के एक्सट्रैक्टर को कॉल करें । उनमें वास्तव में शून्य होते हैं, जिन्हें चुपचाप अनदेखा कर दिया जाता है। drop=Fआयामों के अनुसंधान के डिफ़ॉल्ट छोड़ने को रोकने के लिए की जरूरत है। revजिस तरह से आर सरणियों को भरता है, हमें डायमेंशन रिवर्स इंडिकेटर के लिए कॉल की आवश्यकता होती है ।

-2 धन्यवाद @ गिउसेप्पे

-1 इन-लाइन असाइनमेंट का उपयोग करना।

function(x,a,d=dim(x))do.call("[",c(list(x),Map(seq,r<-d*rev(a),d-r),drop=F))

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

@JayCe का सम्माननीय उल्लेख जो एक ही लंबाई में एक ही परिणाम प्राप्त करने वाले भिन्नता के साथ आया:

function(x,a,d=dim(x))array(x[t(t(expand.grid(Map(seq,r<-d*rev(a),d-r))))],d)

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

Comments

78 बाइट्स बहुत अच्छा जवाब!

— ग्यूसेप

बहुत गहरा जवाब। इसे पूरी तरह समझने में मुझे थोड़ा वक्त लगा। मैंने इसका उपयोग किए बिना इसे दोहराने की कोशिश की do.call- यह 83 बाइट्स पर लंबा है, फिर भी इसे संदर्भ के लिए एक टिप्पणी के रूप में यहां पोस्ट कर रहा हूं : TIO

— JayCe

वास्तव में, @JayCe, आपका शानदार उत्तर भी 78 बाइट्स के

— जे। सेप 4'18

Answer 7

हास्केल, 120 119 बाइट्स

फ़ंक्शन f, एन-आयामी सूची और इनपुट के रूप में बूल की एक सूची लेता है

class F r where f::[Bool]->r->r
instance F Int where f=seq
instance F r=>F[r]where f(a:y)=last(id:[reverse|a]).map(f y)

Comments

आपको चारों ओर कोष्ठक की आवश्यकता नहीं है F r।

— अर्जन जोहान्सन

परीक्षण मामलों और OJ के 1-बाइट गोल्फ के साथ TIO लिंक ।

— खुल्द्रेशेथ ना'बरिया

Answer 8

05AB1E , 23 11 10 बाइट्स

'€s×'R«J.V

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

-12 बाइट्स @ Mr.Xcoder का धन्यवाद ।

इनपुट के रूप में 0-अनुक्रमित सत्य-मान (यानी [0,2,3]), जो पहला इनपुट है।

स्पष्टीकरण:

'€s×           # Repeat "€" the indices amount of times
               #  i.e. [0,2,3] → ["","€€","€€€"]
    'R«        # Append each with "R"
               #  i.e. ["","€€","€€€"] → ["R","€€R","€€€R"]
        J      # Join them all together
               #  i.e. ["R","€€R","€€€R"] → R€€R€€€R
         .V    # Execute string as 05AB1E code

उदाहरण के लिए: यदि सूचकांक इनपुट-सूची है [0,2,3], तो यह निम्नलिखित स्ट्रिंग बनाएगा:

R€€R€€€R

जो होगा:

    €€€R    # Reverse the items in the most inner (4th level) lists
 €€R        # Reverse the most inner (3rd level) lists themselves
            # Do nothing with the inner (2nd level) lists 
R           # Reverse the entire outer (1st level) list

---

मूल 23 बाइट उत्तर:

ćURvy„ RèJ…εÿ}}„ RXèJ.V

बुलियन-सूची के रूप में इनपुट (यानी [1,0,1,1] ) के , जो पहला इनपुट है।

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

स्पष्टीकरण:

ćU                 # Pop and save the first boolean in variable `X`
  R                # Reverse the remaining boolean-list
   v    }          # Loop `y` over each of them:
    „ Rè           #  Take the string "R ", and index the current boolean (0 or 1) in it
    J              #  Join it together with the string of the previous iteration
    …εÿ}           #  Surround it with "ε" and "}"
         „ RXè     # Index variable `X` also in "R "
              J    # Join it together with the rest
.V                 # Execute string as 05AB1E code

उदाहरण के लिए: यदि बूलियन इनपुट-सूची है [1,0,1,1], तो यह निम्नलिखित स्ट्रिंग बनाएगा:

εεεR}R} }R

जो होगा:

  εR}         # Reverse the items in the most inner (4th level) lists
 ε   R}       # Reverse the most inner (3rd level) lists themselves
ε       }     # Do nothing with the inner (2nd level) lists 
         R    # Reverse the entire outer (1st level) list

Comments

अच्छा जवाब है, लेकिन ... उह ... क्या यह 11 काम करेगा?

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

@ Mr.Xcoder धन्यवाद! यह वास्तव में बहुत आसान है। और प्रत्येक को जोड़कर और फिर उलटने के बजाय 1 और बाइट गोल्फ में सक्षम किया गया है।

— केविन क्रूज़सेन

@ Mr.Xcoder Btw, बिना किसी वैप का उपयोग किए बार-बार n की मात्रा 'x*को दोहराने के लिए काम क्यों करता है , लेकिन यह समय पर काम नहीं करता है ! .. संपादित करें: केवल विरासत में हालांकि ..xs'€*

— केविन क्रूज़सेन

विरासत संस्करण काफी छोटी है, यह इस तथ्य के कारण हो सकता है कि €यह अभी भी एक ऑपरेटर के रूप में पार्स किया गया है, भले ही यह एक चारकोल में हो? ईमानदार होना निश्चित नहीं है। नए संस्करण में, *फिर भी उसी तरह व्यवहार नहीं करता है।

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

Answer 9

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

एक अलग (पुनरावर्ती) दृष्टिकोण। Arnauld के जवाब को हरा नहीं ... अभी तक ...

इनपुट के रूप में लेता है array, boolean list

f=(a,r)=>r>[]?(r[0]?a.reverse():a).map(c=>f(c,r.slice(1))):a

f=(a,r)=>r>[]?(r[0]?a.reverse():a).map(c=>f(c,r.slice(1))):a

console.log(f([[[[3,1,4,1],[5,9,2,6]],[[5,3,5,8],[9,7,9,3]]],[[[2,3,8,4],[6,2,6,4]],[[3,3,8,3],[2,7,9,5]]]],[true,false,true,true]))

Answer 10

अजगर , 15 बाइट्स

.v+jk.n*\_*L\ME

यहाँ यह कोशिश करो!

अनायास, खाली आयाम सूची मामले को संभालने के लिए 2 बाइट्स से कम नहीं होता है ... लेकिन मैं इसके ssस्थान पर उपयोग करना चाहता हूं jk.n: | मान लें कि परिवर्तित की जाने वाली सूची को मूल स्ट्रिंग के रूप में मूल Pyth सिंटैक्स में दिया जा सकता है। मैंने परीक्षण को आसान बनाने के लिए पायथ सिंटैक्स के लिए एक कनवर्टर लिखा है। दुर्भाग्यपूर्ण मामले में कि ओपी इसे अनुमति नहीं देने का विकल्प चुनता है, एक 17-बायटर इसे "ठीक" करेगा:

.v+jk.n*\_*L\ME\E

Answer 11

जाप , 15 14 बाइट्स

अरनुलद के हल से कुछ प्रेरणा लेकर ।

पहले इनपुट के रूप में संकेत लेता है, 1एस और 0एस के बूलियन सरणी के रूप में ।

Ê?Vn@ÎãßUÅX:V

कोशिश करो

---

व्याख्या

                   :Implicit input of boolean array U=indications and multi-dimensional integer array V
Ê                  :Get the length of U
 ?                 :If truthy (i.e., >0)
  Vn               :  Sort V
    @ÎÃ            :   Function that gets the first element of U; 0 will leave the array untouched, 1 will reverse it.
       £           :  Map each X
        ß          :  Run the programme again with the following inputs
         UÅ        :   U with the first element removed
           X       :   X will serve as the new value of V
            :      :Else
             V     :  Just return V

Answer 12

क्लीन , 122 112 बाइट्स

import StdEnv
class$r::[Bool]->r->r
instance$r where$_=id
instance$[r]| $r where$[a:y]=if(a)reverse id o map($y)

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

डेमियन हैस्केल का एक संस्करण क्लीन के गोल्फर प्रकार प्रणाली का उपयोग करके उत्तर देता है। वास्तव में दो भाषाओं के बीच व्यापक समानता को दर्शाता है।

व्याख्या की:

import StdEnv                 // import basic stuff
class $ r :: [Bool] -> r -> r // $ takes a boolean list and returns a function on r to r
instance $ r                  // instance on all types, taken when no more specific instances exist
    where $ _ = id            // return the identity function for all arguments
instance $ [r] | $ r          // instance for lists of a type which has an instance itself
    where $ [a: y]
        = if(a) reverse id    // reverse if the head of the argument is true
            o map ($ y)       // composed with the map function acting on $ applied to the tail

Answer 13

रूबी , 54 बाइट्स

f=->a,d{r,*z=d;r&&a.reverse!;d==[]?a:a.map{|w|f[w,z]}}

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

Answer 14

(अप्रयुक्त लेकिन मुझे सही लगता है। कंपाइलर एसएसएम आउटपुट जैसा मैं उम्मीद करता हूं वैसा ही दिखता है। अगर मुझे इस डेटा संरचना को बनाने और प्रिंट करने वाले परीक्षण दोहन को लिखने के लिए समय मिलता है तो मैं अपडेट करूंगा।)

GNU C ++ (पोर्टेबल) 148 बाइट्स

#include<algorithm>
#include<cstdint>
struct m{intptr_t d,l,a[];void R(int*r){if(*r)std::reverse(a,a+l);for(int i=0;d&&i<l;((m*)a[i++])->R(r+1));}};

GNU C ++ (int = सूचक) और एक गैर-शून्य फ़ंक्शन UB से गिरता है 120 बाइट्स

#include<algorithm>
struct m{int d,l,a[],R(int*r){if(*r)std::reverse(a,a+l);for(int i=0;d&&i<l;((m*)a[i++])->R(r+1));}};

यह गहराई काउंटर, लंबाई, सरणी की एक संरचना {पूर्णांक या संकेत} है। इस गैर-बाइनरी ट्री के निचले स्तर ( depth==0) में, intptr_tपूर्णांक का एक सरणी है। उच्च स्तरों में, यह एक struct m*संग्रहित है intptr_t। ट्रैवर्सल एक कास्ट लेता है।

R()रिवर्स समारोह एक सदस्य समारोह है कि क्योंकि एक आर्ग की घोषणा बचाता है, और का एक बहुत बचाता है p->बनाम निहित struct सदस्यों को संदर्भित करने के वाक्य रचना thisसूचक।

केवल GNU एक्सटेंशन एक चर-आकार की संरचना बनाने के लिए C99 लचीला सरणी सदस्य है , जो GNU एक्सटेंशन के रूप में C ++ में समर्थित है। मैं *aएक अलग से आवंटित सरणी की ओर इशारा करते हुए एक सदस्य का उपयोग कर सकता था और यह सादा ISO C ++ हो सकता है। (और यह वास्तव में किसी भी अन्य परिवर्तनों की आवश्यकता के बिना एक बाइट को बचाएगा)। मैंने इसे asm संस्करण के लिए मॉकअप / संदर्भ कार्यान्वयन के रूप में लिखा था।

---

बस के साथ छोटा संस्करण intभी बदले के R()रूप में लौटने की घोषणा करता intहैvoid । हैकरी के ये दो बिट्स असंबंधित हैं; यह सिर्फ "कम से कम एक कार्यान्वयन पर काम करता है" संस्करण है।

यह 32-बिट लक्ष्य (जहां intएक पॉइंटर पकड़ सकता है) पर ठीक काम करना चाहिए , जब तक आप gcc7 या पुराने के साथ संकलन करते हैं, या अनुकूलन को अक्षम करते हैं। ( gcc8 -O3मानता है कि निष्पादन एक गैर- voidसमारोह के निचले हिस्से तक नहीं पहुंच सकता है क्योंकि यह यूबी होगा।) x86 gcc -m32 -O3को gcc7 के साथ ठीक काम करना चाहिए, जैसे Godbolt जहां मैंने दोनों संस्करणों (विभिन्न नामस्थानों में) और एक गैर-सदस्य-फ़ंक्शन संस्करण को शामिल किया है ।

Ungolfed

फ़ंक्शन arg, int r[]0 / गैर-शून्य पूर्णांक का एक सरणी है जो इंगित करता है कि क्या किसी दी गई गहराई को स्वैप किया जाना चाहिए, बाहरी-सबसे स्तर से शुरू होता है।

#include<algorithm>  // for std::reverse
#include<cstdint>    // for intptr_t.  GNU C defines __intptr_t, so we could use that...

struct m{
    __intptr_t d,l,a[];    // depth = 0 means values, >0 means pointers.
    // l = length
    //__intptr_t a[];  // flexible array member: array contiguous with the struct

    void R(int r[]) {
        if(*r)
            std::reverse(a, a+l);   // *r && std::reverse() doesn't work because it returns void.

        if(d) // recurse if this isn't the bottom depth
            for(int i=0 ; i<l ; i++)  // tree traversal
                ((m*)a[i])->R(r+1);   // with the rest of the depth list
    }

}; // struct m

जब हम पुनरावृत्ति करते हैं r+1, तो हम गुजरते हैं , इसलिए वर्तमान गहराई की जांच हमेशा होती है*r ।

एक पूर्व संस्करण बस rअपरिवर्तित पारित हुआ , और जाँच की गई r[d]। एक लचीली सरणी के सदस्य के साथ, मुझे किसी प्रकार के अंतिम-स्तरीय संकेतक को संग्रहीत करने की आवश्यकता थी क्योंकि a[]कोई संकेतक नहीं है, यह एक सच्चा सरणी है जिसमें कोई अप्रत्यक्षता नहीं है। लेकिन एक intptr_t *aसदस्य के साथ , मैं सिर्फ nullptrपत्ते के स्तर के लिए नहीं हो सकता , क्योंकि मैं चाहता हूं कि यह मूल्य हो।

ट्री ट्रैवर्सल के पहले या बाद के वर्तमान स्तर को उलट देना कोई मायने नहीं रखता। मैं इसे करने की कोशिश नहीं की थी दौरान ।

मुझे यकीन नहीं है कि std::reverseबाइट काउंट बनाम एक मैनुअल लूप के लायक है, खासकर अगर मैं R()उस लूप के अंदर कहीं एक बार प्रत्येक सूचक पर कॉल करने में काम कर सकता हूं । लेकिन केवल यदिd!=0

Comments

वाह, प्रभावशाली।

— आदम

@ Adám: धन्यवाद, यह आश्चर्यजनक रूप से स्वाभाविक रूप से और अच्छी तरह से लिखने के बाद मैंने इसे लिखा है। मैं यह देखने के लिए उत्सुक हूं कि मैं x86 मशीन कोड में क्या कर सकता हूं: पी

— पीटर कॉर्ड्स

Answer 15

गणितज्ञ, 7 बाइट्स

Reverse

समारोह। पहले तर्क के रूप में इसे नेस्टेड सूची दें, और दूसरे तर्क के रूप में उलटने के लिए स्तरों / आयामों की 1-आधारित सूची। इसे ऑनलाइन आज़माएं!

^{अंत में, एक और चुनौती जहां मैथेमेटिका में एक बिलिन है!}

Comments

परतों को उलटने के लिए ? TIO लिंक हो सकता है?

— आदम

@ Adám वह है, आयामों की सूची को उलटने के लिए, जिसे आम तौर पर गणितज्ञ के स्तर के रूप में संदर्भित किया जाता है ।

— लीजनमोनमाल 978