รับอาร์เรย์ N-Dim orthogonal (ไม่มอมแมม) ของจำนวนเต็มไม่เป็นลบและบ่งชี้ว่ามิติใดที่จะย้อนกลับส่งคืนอาร์เรย์ แต่กลับตามมิติเหล่านั้น การบ่งชี้อาจถูกกำหนดเป็นรายการบูลีนที่มีความยาว N หรือรายการของเซ็ตย่อยของมิติ N แรกที่จัดทำดัชนีจาก 0 หรือ 1

โปรดระบุรูปแบบการป้อนข้อมูลของคุณ คำอธิบายรหัสชื่นชมมาก

ตัวอย่างแบบ walk-through

เราได้รับอาร์เรย์ 3 มิติ 4 แถว 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]]]]

APL (Dyalog) , 20 9 ไบต์

⊃{⌽[⍺]⍵}/

ลองออนไลน์!

อย่างไร?

/ - ลด - ใช้องค์ประกอบที่เหมาะสมที่สุดในการป้อนข้อมูล (อาร์เรย์) และใช้ฟังก์ชั่นที่มีองค์ประกอบซ้ายถัดไปเป็นอาร์กิวเมนต์ซ้าย

{⌽[⍺]⍵}- ย้อนกลับในมิติleft argument( ⍺)

⊃ - แผ่อาร์เรย์ที่ล้อมรอบ

APL (Dyalog Unicode) ขนาด 9 ไบต์

⊃{⊖[⍺]⍵}⌿

ลองออนไลน์!

ดูเหมือนว่าUriel จะแก้ไขเป็นสิ่งที่เกือบจะเหมือนกันเสียก่อน แต่ฉันพัฒนาขึ้นมาเอง ฉันคิดว่ารูปแบบอินพุตนี้ไม่ถูกต้อง

JavaScript (Node.js) , 58 55 53 45 ไบต์

บันทึก 8 ไบต์ด้วย @Shaggy

รับอินพุตเป็น(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

Python 2 , 56 55 ไบต์

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

ลองออนไลน์!

เยลลี่ขนาด 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.

R , 80 78 77 ไบต์

สร้างการเรียกไปยังตัวแยกของ R [โดยสร้างรายการลำดับที่กลับด้านตามที่ระบุ จริง ๆ แล้วมันมีศูนย์ซึ่งจะถูกละเว้นอย่างเงียบ ๆ drop=Fเป็นสิ่งจำเป็นเพื่อป้องกันไม่ให้ลดลงเริ่มต้นของ R มิติ เราต้องการการrevเรียกไปยังตัวบ่งชี้การย้อนกลับมิติเนื่องจากวิธีการเติมอาร์เรย์ R

-2 ขอบคุณ @Giuseppe

-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)

ลองออนไลน์!

Haskell, 120 119 ไบต์

ฟังก์ชั่น f ใช้รายการ N- มิติและรายการบูลเป็นอินพุต

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)

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

ตัวอย่างเช่น: ถ้าบูลีน input-list [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

JavaScript (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]))

Pyth , 15 ไบต์

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

ลองที่นี่!

น่ารำคาญการจัดการรายการมิติที่ว่างเปล่าจะต้องไม่น้อยกว่า 2 ไบต์ ... ฉันควรใช้ssแทนjk.nแต่: | สมมติว่ารายการที่จะถูกแปลงสามารถให้ในไวยากรณ์ Pyth ดั้งเดิมเป็นสตริง ฉันเขียนตัวแปลงเป็นไวยากรณ์ Pythเพื่อให้การทดสอบง่ายขึ้น ในกรณีที่โชคร้ายที่ OP เลือกที่จะไม่ยอมให้สิ่งนี้ 17-byter จะ "แก้ไข" มัน:

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

Japt , 15 14 ไบต์

ด้วยแรงบันดาลใจจากการแก้ปัญหาของ Arnauld

ใช้การบ่งชี้ว่าเป็นอินพุตแรกเป็นอาร์เรย์บูลีนของ1s และ0s

Ê?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

ทำความสะอาด , 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

Ruby , 54 ไบต์

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

ลองออนไลน์!

(ยังไม่ทดลอง แต่ฉันคิดว่าถูกต้องคอมไพเลอร์ asm เอาท์พุตดูเหมือนสิ่งที่ฉันคาดหวังจะปรับปรุงถ้า / เมื่อฉันหาเวลาที่จะเขียนเทียมทดสอบที่สร้างและพิมพ์โครงสร้างข้อมูลนี้)

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เพื่อสร้างโครงสร้างขนาดตัวแปรซึ่งได้รับการสนับสนุนใน C ++ เป็นส่วนขยาย GNU ฉันอาจใช้*aสมาชิกที่ชี้ไปยังอาเรย์ที่ถูกจัดสรรแยกต่างหากและให้นี่เป็น ISO C ++ แบบธรรมดา (และนั่นจะช่วยประหยัดไบต์โดยไม่ต้องมีการเปลี่ยนแปลงอื่น ๆ ) ฉันเขียนสิ่งนี้เป็นการใช้งาน mockup / การอ้างอิงสำหรับรุ่น asm

รุ่นที่สั้นกว่าพร้อมintประกาศเพียงR()ว่ากลับมาintแทนvoidแทนการแฮกเกอร์สองบิตเหล่านี้ไม่เกี่ยวข้องกัน นี่เป็นเพียงรุ่น "ใช้งานได้กับการใช้งานอย่างน้อยหนึ่งรุ่น"

ควรทำงานได้ดีกับเป้าหมายแบบ 32 บิต (ซึ่งintสามารถถือตัวชี้) ได้ตราบใดที่คุณคอมไพล์ด้วย gcc7 หรือเก่ากว่าหรือปิดใช้งานการปรับให้เหมาะสม ( gcc8 -O3สมมติว่าการประมวลผลไม่สามารถเข้าถึงด้านล่างของvoidฟังก์ชันที่ไม่ใช่เพราะจะเป็น UB) x86 gcc -m32 -O3ควรทำงานได้ดีกับ gcc7เช่น Godboltที่ฉันรวมทั้งรุ่น (ในเนมสเปซที่แตกต่างกัน) และรุ่นที่ไม่ใช่สมาชิก .

Ungolfed

ฟังก์ชั่นหาเรื่อง, 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

เมื่อเรา recurse เราผ่านดังนั้นการตรวจสอบความลึกปัจจุบันอยู่เสมอr+1*r

รุ่นก่อนหน้านี้เพิ่งผ่านการเปลี่ยนแปลงและการตรวจสอบr r[d]ด้วยสมาชิกอาเรย์ที่มีความยืดหยุ่นฉันจำเป็นต้องจัดเก็บตัวบ่งชี้ระดับสุดท้ายบางอย่างเพราะa[]ไม่ใช่ตัวชี้มันเป็นอาร์เรย์จริงโดยไม่ต้องอ้อม แต่สำหรับintptr_t *aสมาชิกฉันไม่สามารถทำได้nullptrสำหรับระดับลีฟเพราะฉันต้องการให้เป็นค่า

การย้อนกลับระดับปัจจุบันก่อนหรือหลังการแวะผ่านต้นไม้ไม่ควรสำคัญ ฉันไม่ได้พยายามที่จะทำมันในช่วง

ฉันไม่แน่ใจว่าstd::reverseคุ้มกับจำนวนไบต์เทียบกับลูปแบบแมนนวลโดยเฉพาะถ้าฉันสามารถโทรหาพอยน์เตอร์R()แต่ละตัวได้เพียงครั้งเดียวภายในลูปนั้น แต่ถ้าเท่านั้นd!=0

Mathematica ขนาด 7 ไบต์

Reverse

ฟังก์ชัน ให้รายการที่ซ้อนกันเป็นอาร์กิวเมนต์แรกและรายการระดับ / มิติตาม 1 เพื่อย้อนกลับเป็นอาร์กิวเมนต์ที่สอง ลองออนไลน์!

^{ในที่สุดความท้าทายอีกประการหนึ่งที่ Mathematica มีอยู่ในตัว!}