বহুমাত্রিক বিপরীত


23

অ-নেতিবাচক পূর্ণসংখ্যার একটি এন-ডাইমেনশনাল অরথোগোনাল (অ-র‌্যাগড) অ্যারে দেওয়া হয়েছে এবং কোন দিকটি বিপরীত হবে, অ্যারেটি ফিরিয়ে দেবে তবে সেই মাত্রাগুলিগুলির সাথে বিপরীত হবে an ইঙ্গিতটি দৈর্ঘ্য N এর বুলিয়ান তালিকা বা 0 বা 1 থেকে সূচিত প্রথম এন মাত্রার একটি উপসেটের তালিকা হিসাবে দেওয়া যেতে পারে।

দয়া করে আপনার ইনপুট ফর্ম্যাটগুলি বর্ণনা করুন। কোড ব্যাখ্যা অনেক প্রশংসা করা হয়।

পদচারণা উদাহরণ

আমাদের 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]]]]


আমার কাছে মনে হয় বেশিরভাগ স্ট্যাটিক্যালি টাইপ করা ভাষাগুলির মধ্যে সবচেয়ে শক্ত অংশটি জড়িত প্রকারের স্বাক্ষরগুলিকে গল্ফ করে দেবে।
0urous

@ Οurous এই ভাষাগুলি কীভাবে সাধারণভাবে স্বেচ্ছাসেবী অ্যারে ডেটা ব্যবহার করে?
অ্যাডাম

1
আমি দেখতে পাচ্ছি "সাধারণ" ব্যবহারের জন্য এখানে তিনটি মামলা রয়েছে: কেবল অ্যারের এক স্তর সম্পর্কে উদ্বেগজনক (উদাঃ reverseস্বেচ্ছাসেবী অ্যারেগুলিতে কাজ করে তবে কেবল প্রথম স্তর সম্পর্কে যত্নশীল), জেনেরিক্স বা পুনরাবৃত্ত শ্রেণি (টাইপ / অবজেক্ট ক্লাস ক্রিয়াকলাপের উপর নির্ভর করে) বা ওওপি, তবে অনুরূপ ব্যবহারের ক্ষেত্রে)। পরের দুটি সাধারণত আরও বেশি ভার্বোজ হয়।
3urous

আমরা ম্যাট্রিক্সকে পয়েন্টারগুলিতে পয়েন্টারগুলির অ্যারে হিসাবে (সি বা asm তে) সংরক্ষণ করতে পারি, যেখানে যথাযথ বহু-মাত্রিক অ্যারের পরিবর্তে সমস্ত কিছু স্মৃতিতে সামঞ্জস্যপূর্ণ? আমি খুব নিশ্চিত যে সমস্ত সাধারণ উচ্চ স্তরের / গতিশীল টাইপযুক্ত ভাষা তালিকাগুলির নির্বিচারে বাসা বাঁধার সাথে ইতিমধ্যে জিনিসগুলি তালিকাগুলির তালিকা হিসাবে গণ্য করা হচ্ছে, ম্যাট্রিক্স নয়, তাই আমি এটি ধরে নিচ্ছি ঠিক আছে ume
পিটার কর্ডস

@ পিটারকর্ডস অবশ্যই, এগিয়ে যান
Adám

উত্তর:


8

এপিএল (ডায়ালগ) , 20 9 বাইট

⊃{⌽[⍺]⍵}/

এটি অনলাইন চেষ্টা করুন!

কিভাবে?

/ - হ্রাস - ইনপুট (অ্যারে) এ ডান দিকের উপাদানটি নিন এবং বাম যুক্তি হিসাবে পরবর্তী বাম উপাদান সহ ফাংশনটি প্রয়োগ করুন

{⌽[⍺]⍵}- left argument( ) মাত্রায় বিপরীত

- বদ্ধ অ্যারে সমতল করুন


8

এপিএল (ডায়ালগ ইউনিকোড) , 9 বাইট

⊃{⊖[⍺]⍵}⌿

এটি অনলাইন চেষ্টা করুন!

দেখে মনে হচ্ছে উরিল প্রথমে প্রায় অভিন্ন কিছুতে সম্পাদিত হয়েছিল তবে আমি এটি স্বাধীনভাবে বিকাশ করেছি। আমি ভেবেছিলাম এই ইনপুট ফর্ম্যাটটি অবৈধ।


8

জাভাস্ক্রিপ্ট (নোড.জেএস) , 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

শুধু ব্যবহার rinplace এর r||-1 কাজ বলে মনে হয়
শেগি

চান f=([r,...b])=>a=>1/r?a.sort(_=>r).map(f(b)):aকাজ করে? আমার ফোনে তাই সঠিকভাবে পরীক্ষা করতে পারবেন না।
শেগি

@ শেগি নিস! আমি এটি বরং অস্বাভাবিক প্রক্রিয়াকরণ প্রবাহ পছন্দ করি।
আর্নল্ড


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.

1
এটা কি সাংঘাতিক. খুব সুন্দর!
অ্যাডম

5

আর , 80 78 77 বাইট

[উল্লিখিত সিকোয়েন্সগুলির একটি তালিকা তৈরি করে আর এর এক্সট্রাক্টরে কল তৈরি করুন where এগুলিতে আসলে শূন্য থাকে, যা নিঃশব্দে উপেক্ষা করা হয়। 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))

এটি অনলাইন চেষ্টা করুন!

@ জায়েসি কে সম্মানজনক উল্লেখ, যিনি একটি ভিন্নতা নিয়ে এসেছিলেন যা একই দৈর্ঘ্যে একই ফলাফল পায়:

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

এটি অনলাইন চেষ্টা করুন!


1
78 বাইট খুব সুন্দর উত্তর!
জিউসেপে

1
খুব গভীর উত্তর। এটি পুরোপুরি বুঝতে আমার কিছুটা সময় লেগেছে। আমি এটি ব্যবহার না করেই এর অনুলিপি করার চেষ্টা করেছি do.call- এটি এখন 83 বাইটে দীর্ঘ, এটি এখনও রেফারেন্সের জন্য মন্তব্য হিসাবে এখানে পোস্ট করছে: টিআইও
জাইসি

আসলে, @ জাসি, আপনার দুর্দান্ত উত্তরটি 78 বাইটে
জে.ডো

5

হাস্কেল, 120 119 বাইট

ফাংশন এফ এন-ডাইমেনশনাল তালিকা এবং ইনপুট হিসাবে বুলের একটি তালিকা নেয়

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)

1
আপনার চারপাশে প্রথম বন্ধনী প্রয়োজন নেই F r
janrjan জোহানসেন

1
পরীক্ষার কেস এবং ওজে-র 1-বাইট গল্ফের সাথে টিআইও লিঙ্ক
খুলনায়সথ না'বাড়িয়া

4

05 এ বি 1 , 23 11 10 বাইট

'€s×'R«J.V

এটি অনলাইনে চেষ্টা করুন।

-12 বাইটস @ মিঃ এক্সএক্সকোডারকে ধন্যবাদ ।

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

1
ভাল উত্তর, কিন্তু ... আহ ... এই 11 বাইটার কাজ করবে?
মিঃ এক্সকোডার 15

@ মিঃ এক্সকোডার ধন্যবাদ! এটা সত্যিই অনেক সহজ। এবং প্রিপেন্ডিং এবং তারপরে বিপরীত পরিবর্তে প্রতিটি যুক্ত করে আরও 1 টি বাইট গল্ফ করতে সক্ষম হয়েছি।
কেভিন ক্রুইজসেন

@ মিঃ এক্সকোডার বিটিডব্লিউ, ওয়াপ ব্যবহার না করে এন পরিমাণে 'x*বারবার পুনরাবৃত্তি করার জন্য কেন কাজ হয় তবে তা কার্যকর হয় না ? .. সম্পাদনা: কেবলমাত্র উত্তরাধিকার সূত্রে ..xs'€*
কেভিন ক্রুইজসেন

লিগ্যাসির সংস্করণটি বেশ বগল, এটি এখনও অক্ষরে অক্ষরে থাকা সত্ত্বেও অপারেটর হিসাবে বিভক্ত হওয়ার কারণে হতে পারে ? সৎ হতে নিশ্চিত না। নতুন সংস্করণে, *তবে একইভাবে আচরণ করবেন না।
মিঃ এক্সকোডার

3

জাভাস্ক্রিপ্ট (নোড.জেএস) , 60 বাইট

একটি ভিন্ন (পুনরাবৃত্ত) পদ্ধতির আরনাউল্ডের উত্তরটি মারেনি ... তবুও ...

হিসাবে ইনপুট নেয় 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]))


3

পাইথ , 15 বাইট

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

এখানে চেষ্টা করুন!

বিরক্তিকরভাবে, খালি মাত্রা তালিকার কেসটি পরিচালনা করতে 2 বাইটের চেয়ে কম লাগবে না ... আমি বরং এটির ssজায়গায় ব্যবহার করব jk.n: | ধরে নেওয়া যায় যে রূপান্তরিত হতে হবে তালিকাটি একটি স্ট্রিং হিসাবে দেশীয় পাইথ সিনট্যাক্সে দেওয়া যেতে পারে। পরীক্ষাকে আরও সহজ করার জন্য আমি পাইথ সিনট্যাক্সে একটি রূপান্তরকারী লিখেছি । দুর্ভাগ্যজনক ক্ষেত্রে যে ওপি এটির অনুমতি দেয় না, 17-বাইটার এটি "ঠিক" করে দেবে:

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

3

জাপট , 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

3

পরিষ্কার , 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


1

(অনির্ধারিত তবে আমি সঠিক মনে করি comp

জিএনইউ সি ++ (পোর্টেবল) 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));}};

জিএনইউ সি ++ (ইনট = পয়েন্টার এবং একটি অ-শূন্য ফাংশন ইউবি থেকে পড়ে) 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));}};

এটি গভীরতার কাউন্টার, দৈর্ঘ্য, {পূর্ণসংখ্যা বা পয়েন্টার of এর অ্যারে একটি কাঠামো} এই নন-বাইনারি গাছের নীচের স্তরে ( depth==0) এর intptr_tঅ্যারে হল পূর্ণসংখ্যার অ্যারে। উচ্চ স্তরে, এটি একটি struct m*সঞ্চিত intptr_t। ট্র্যাভারসাল একটি কাস্ট নেয়।

দ্য R()বিপরীত ফাংশন সদস্য ফাংশন যা কারণ একটি ARG প্রকাশক সংরক্ষণ, এবং অনেকটা সংরক্ষণ p->বনাম অন্তর্নিহিত struct হয় সদস্যদের রেফারেন্স সিনট্যাক্স thisপয়েন্টার।

একমাত্র GNU এক্সটেনশান হ'ল C99 নমনীয় অ্যারে সদস্য একটি পরিবর্তনশীল-আকারের স্ট্রাক্ট তৈরির , যা GNU এক্সটেনশন হিসাবে সি ++ তে সমর্থিত। আমি কোনও *aসদস্যকে আলাদাভাবে বরাদ্দ করা অ্যারেগুলিকে নির্দেশ করে ব্যবহার করতে পারতাম এবং এটি সরল আইএসও সি ++ থাকতে পারি। (এবং এটি অন্য কোনও পরিবর্তনের প্রয়োজন ছাড়াই আসলে একটি বাইট সংরক্ষণ করবে)। আমি এটি asm সংস্করণের জন্য মকআপ / রেফারেন্স বাস্তবায়ন হিসাবে লিখেছি wrote


সংক্ষিপ্ত সংস্করণ সবেমাত্র intঘোষণা করেR()int পরিবর্তে ফিরে হিসাবেvoid । হ্যাকারি এই দুটি বিট অপ্রাসঙ্গিক; এটি কেবলমাত্র "কমপক্ষে একটি বাস্তবায়নে কাজ করে" সংস্করণ।

এটি 32-বিট লক্ষ্যগুলিতে (যেখানে intপয়েন্টার ধরে রাখতে পারে) কাজ করতে হবে, যতক্ষণ আপনি gcc7 বা তার চেয়ে বেশি পুরানো দিয়ে সংকলন করেন বা অপ্টিমাইজেশান অক্ষম করেন। ( gcc8 -O3ধরে নেওয়া হয় যে কার্যকরকরণ কোনও অ- voidকার্যের নীচে পৌঁছতে পারে না কারণ এটি ইউবি হবে)) x86gcc -m32 -O3 জিসিসি 7 দিয়ে কাজ করা উচিত, গডবোল্টের মতো যেখানে আমি উভয় সংস্করণ (বিভিন্ন নামের জায়গাগুলিতে ) এবং একটি সদস্যবিহীন -ফাংশন সংস্করণ অন্তর্ভুক্ত করেছি ।

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

যখন আমরা পুনরাবৃত্তি করি, আমরা পাস করি r+1, সুতরাং বর্তমান গভীরতা চেক করা সর্বদা*r

পূর্ববর্তী সংস্করণটি সবেমাত্র rঅপরিবর্তিত হয়ে গেছে এবং এটি পরীক্ষা করা হয়েছে r[d]। নমনীয় অ্যারে সদস্যের সাথে, আমাকে এক ধরণের শেষ স্তরের সূচক সঞ্চয় করতে হবে কারণ a[]এটি কোনও পয়েন্টার নয়, এটি সত্যিকারের অ্যারে নেই যার কোনও নির্দেশনা নেই। তবে একজন intptr_t *aসদস্যের সাথে আমি কেবল nullptrপাতাগুলির জন্য থাকতে পারি না, কারণ আমি এটির মান হতে চাই।

গাছের ট্র্যাভারসালের আগে বা পরে বর্তমান স্তরের বিপরীত হওয়া কোনও বিষয় নয়। আমি এর সময় করার চেষ্টা করিনি ।

আমি নিশ্চিত নই যে std::reverseবাইট গণনা বনাম একটি ম্যানুয়াল লুপের মূল্যবান, বিশেষত যদি আমি R()প্রতিটি পয়েন্টারে কল করার কাজটি ঠিক সেই কোথাও কোথাও কোথাও করতে পারি। তবে কেবল যদিd!=0


ওহ, চিত্তাকর্ষক।
Adám

@ অ্যাডাম: ধন্যবাদ, আমি এটি লেখার পরে আশ্চর্যজনকভাবে প্রাকৃতিকভাবে এবং ভালভাবে নেমে গেছে। আমি x86 মেশিন কোডে কী করতে পারি তা জানতে আগ্রহী: পি
পিটার কর্ডেস

1

গণিত, 7 বাইট

Reverse

ফাংশন। এটি প্রথম আর্গুমেন্ট হিসাবে নেস্টেড তালিকা এবং দ্বিতীয় আর্গুমেন্ট হিসাবে বিপরীতে স্তর / মাত্রার 1-ভিত্তিক তালিকা দিন। এটি অনলাইন চেষ্টা করুন!

অবশেষে, আরেকটি চ্যালেঞ্জ যেখানে ম্যাথামেটিকার একটি বিল্টিন রয়েছে!


বিপরীতে স্তরগুলি ? টিআইওর লিঙ্কটি হয়ত?
অ্যাডম

@ অ্যাডম এটি, বিপরীত মাত্রাগুলির তালিকা , সাধারণত গণিতের স্তর হিসাবে উল্লেখ করা হয় levels
LegionMammal978
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.