বাসা ছেড়ে চলেছে

Question

বাম-থেকে-ডান পড়ার সময় ইনপুট তালিকার মূল ক্রমের মানগুলির সাথে, প্রতিটি নেস্টিং স্তরের পূর্ণসংখ্যাসূচক তালিকাগুলির তালিকা আউটপুট করুন, প্রতিটি নেস্টিং স্তরের পূর্ণসংখ্যাসূচক তালিকার একটি তালিকা আউটপুট করুন। যদি ইনপুট তালিকার মধ্যে দুটি বা ততোধিক তালিকাগুলি একই নেস্টিং স্তরে থাকে তবে সেগুলি আউটপুটে একটি একক তালিকায় একত্রিত করা উচিত। আউটপুটটিতে কোনও খালি তালিকা থাকা উচিত নয় - নেস্টিং স্তরগুলি যাতে কেবল তালিকা থাকে সম্পূর্ণভাবে এড়িয়ে যেতে হবে।

আপনি ধরে নিতে পারেন যে পূর্ণসংখ্যাগুলি সমস্ত (সমেত) ব্যাপ্তিতে থাকে [-100, 100]। তালিকার জন্য কোনও সর্বোচ্চ দৈর্ঘ্য বা নীড়ের গভীরতা নেই। ইনপুটটিতে কোনও খালি তালিকা থাকবে না - প্রতিটি নেস্টিং স্তরে কমপক্ষে একটি পূর্ণসংখ্যা বা তালিকা থাকবে।

ইনপুট এবং আউটপুট অবশ্যই আপনার ভাষার নেটিভ তালিকা / অ্যারে / গণনাযোগ্য / পুনরাবৃত্ত / ইত্যাদি হতে হবে। ফর্ম্যাট, বা কোনও যুক্তিসঙ্গত, দ্ব্যর্থহীন বিন্যাসে যদি আপনার ভাষার কোনও সিকোয়েন্স টাইপের অভাব থাকে।

উদাহরণ

[1, 2, [3, [4, 5], 6, [7, [8], 9]]] => [[1, 2], [3, 6], [4, 5, 7, 9], [8]]

[3, 1, [12, [14, [18], 2], 1], [[4]], 5] => [[3, 1, 5], [12, 1], [14, 2, 4], [18]]

[2, 1, [[5]], 6] => [[2, 1, 6], [5]]

[[54, [43, 76, [[[-19]]]], 20], 12] => [[12], [54, 20], [43, 76], [-19]]

[[[50]], [[50]]] => [[50, 50]]

Answer 1

পাইথ, 17

 us-GeaYsI#GQ)S#Y

নেতৃস্থানীয় স্থান গুরুত্বপূর্ণ। এটি sফাংশনে মানগুলি অবিচ্ছিন্ন কিনা সেই তালিকাটি ফিল্টার করে , তারপরে তালিকা থেকে এই মানগুলি সরিয়ে এবং এক স্তরের সমতল করবে। মানগুলি Yএতেও সঞ্চিত থাকে এবং যখন আমরা মুদ্রণ করি আমরা তালিকাটির খালি মানটি সত্য বলে ফিল্টার করে খালি মানগুলি সরিয়ে ফেলি।

পরীক্ষা স্যুট

বিকল্পভাবে, একটি সন্দেহজনক আউটপুট ফর্ম্যাট সহ 15 বাইট উত্তর:

 us-GpWJsI#GJQ)

পরীক্ষা স্যুট

সম্প্রসারণ:

 us-GeaYsI#GQ)S#Y     ##   Q = eval(input)
 u          Q)        ##   reduce to fixed point, starting with G = Q
        sI#G          ##   get the values that are not lists from G
                      ##   this works because s<int> = <int> but s<list> = flatter list
      aY              ##   append the list of these values to Y
     e                ##   flatten the list
   -G                 ##   remove the values in the list from G
              S#Y     ##   remove empty lists from Y

Answer 2

গণিত, 56 54 52 বাইট

_{-২ বাইট আলেফালফার কারণে ।}

_{ক্যাটস আরফ্লফির কারণে -২ বাইট ।}

Cases[#,_?AtomQ,{i}]~Table~{i,Depth@#}/.{}->Nothing&

আসলে খালি স্তরগুলি মুছে দেয়।

Comments

Cases[#,_?AtomQ,{i}]~Table~{i,Depth@#}~DeleteCases~{}&

— আলেফালফ

Cases[#,_?AtomQ,{i}]~Table~{i,Depth@#}/.{}->Nothing&, 2 বাইট ছোট

— ক্যালকুলেটরফাইন

Answer 3

পাইথন 2, 78 বাইট

f=lambda l:l and zip(*[[x]for x in l if[]>x])+f(sum([x for x in l if[]<x],[]))

Answer 4

রেটিনা , 79

আমি জানি রেটিনা বিশেষজ্ঞরা আরও গল্ফ পাবেন তবে এখানে একটি শুরু:

{([^{}]+)}(,?)([^{}]*)
$3$2<$1>
)`[>}],?[<{]
,
(\d),+[<{]+
$1},{
<+
{
,*[>}]+
}

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

Answer 5

গণিত 55 55 62 বাইট

#~Select~AtomQ/.{}->Nothing&/@Table[Level[#,{k}],{k,Depth@#}]&

---

%&[{1, 2, {3, {4, 5}, 6, {7, {8}, 9}}}]

{{1, 2}, {3, 6}, {4, 5, 7, 9}, {8}

Answer 6

জাভাস্ক্রিপ্ট, 112 80 বাইট

F=(a,b=[],c=0)=>a.map(d=>d!==+d?F(d,b,c+1):b[c]=[...b[c]||[],d])&&b.filter(d=>d)

32 বাইট শেভ করতে সাহায্য করার জন্য নীলকে ধন্যবাদ জানাই।

Comments

এখানে গল্ফ করার জন্য প্রচুর সুযোগ। কিছু সহজ বেশী অপসারণ করতে চলেছেন !=nullযেমন nullfalsy যাহাই হউক না কেন হয়। b=এছাড়াও অপ্রয়োজনীয়। মুছে রয়ে আপনি তারপর স্থানান্তর করতে পারেন .filter(a=>x)থেকে &&bযা পরে যা আপনি করতে পারেন তারপর ইনলাইন ভেতরের ফাংশন একটি কলে বাইরের ফাংশন হ্রাস করা হয়। আমি এই সাথে বাম করছি: f=(a,b=[],c=0)=>a.map(d=>d[0]?f(d,b,c+1):b[c]=[...b[c]||[],d])&&b.filter(d=>d)।

— নিল

@ নীল এটির সমান , যা সীমার মধ্যে রয়েছে তা d[0]?মূল্যায়ন করবে । এবং তাই হবেfalse0[-100,100]d=>d

— প্যাট্রিক রবার্টস

@ নীল এইটাকে হুড়োহুড় করে ফেলেছে, তাই আমি জানতাম যে এটি সঙ্কুচিত করার আরও অনেক সুযোগ রয়েছে, তবে এটি তখনও আমি যেভাবে করতে পারতাম তার থেকে অনেক বেশি ভাল। ধন্যবাদ! ওহ, এবং সেই কারণেই প্যাট্রিক নাল চেকের জন্য প্রয়োজনীয়। আমি d===+dযদিও সাথে গিয়েছিলাম , যেহেতু এটি নাল চেকটিতে 2 বাইট সঞ্চয় করে।

— Mwr247

@ ডেনড্রোবিয়াম এটি শেষ কেস (বা কোনও মামলা [...,[[...]]]) সঠিকভাবে পরিচালনা করবে না

— এমড্রব্লু

@ পেট্রিকরোবার্টস d=>dঠিক আছে যেহেতু dসর্বদা সেই বিন্দুতে একটি অ্যারে বা নাল, তবে এটি সম্পর্কে একটি ন্যায্য বিষয় d[0]যদিও এটি সবসময় থাকে d.mapযা একটি অ্যারের পক্ষে সত্যবাদী তবে একটি সংখ্যার জন্য মিথ্যা।

— নিল

Answer 7

জেলি, 24 বাইট

fFW®;©ṛ¹ḟF;/µŒḊ’$¡W®Tị¤;

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

যদি নিউলাইন-বিচ্ছিন্ন তালিকাগুলির অনুমতি দেওয়া হয় তবে এটি 14 বাইটে গল্ফ করা যেতে পারে ।

fFṄ¹¹?ḟ@¹;/µ¹¿

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

Answer 8

পাইথন, 108 99 বাইট

এটি আমার কাছে কিছুটা দীর্ঘ মনে হচ্ছে, তবে আমি ওয়ান-লাইনারকে আরও ছোট করতে পারিনি, এবং আমি যদি এর orপরিবর্তে ব্যবহার করার চেষ্টা ifকরি তবে ফলাফলগুলিতে খালি তালিকা পাই।

def f(L):
    o=[];i=[];j=[]
    for x in L:[i,j][[]<x]+=[x]
    if i:o+=[i]
    if j:o+=f(sum(j,[]))
    return o

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

সম্পাদনা করুন: স্ট্যাক ওভারফ্লোতে 9 বাইট সংরক্ষণ করা হয়েছে

Comments

আপনার ইনডেন্টগুলি একক স্পেসে পরিবর্তন করা উচিত, তাই তারা কোড ব্লকে সঠিকভাবে রেন্ডার করে। আপনি filter(None,o)খালি তালিকাগুলি সরিয়ে ফেলতেও ব্যবহার করতে পারেন যা নীড়ের নীড়ের স্তরে রয়েছে o।

— মেগো

আমি আমার কোডটি ট্যাব সহ দেখতে পছন্দ করি। স্থানগুলি অশুভ are

— mbomb007

এসই মার্কডাউন ট্যাবগুলিকে 4 টি স্পেসে রূপান্তরিত করে, তাই সেগুলি যেভাবেই ছাড়বে না :) মার্কডাউনে একটি একক স্থান ব্যবহার করে কোড ব্লকের বাইট গণনাটি আসলে কোডের বাইট গণনাটির সাথে মেলে।

— মেগো

আপনি যদি এটি সম্পাদনা করতে চান তবে আমার কোডটিতে নিজেই ট্যাব রয়েছে। এটি গণনা করা হয় ভিতরে ভিতরে কি। ;)

— mbomb007

Answer 9

পাইথন 3, 109 বাইট

বরাবরের মতো, বোকামি পাইথন 2 এর বৈশিষ্ট্যগুলি ints এর সাথে তুলনা করার listঅর্থ পাইথন 3 পিছনে আসে। আচ্ছা ভালো...

def d(s):
 o=[]
 while s:
  l,*n=[],
  for i in s:
   try:n+=i
   except:l+=[i]
  if l:o+=[l]
  s=n
 return o

Answer 10

পার্ল, 63 বাইট

{$o[$x++]=[@t]if@t=grep{!ref}@i;(@i=map{@$_}grep{ref}@i)&&redo}

ইনপুট আশা করা হয় @i, আউটপুট উত্পাদিত হয় @o। (আমি এটি গ্রহণযোগ্য আশা করি)।

উদাহরণ:

@i=[[54, [43, 76, [[[-19]]]], 20], 12];                              # input

{$o[$x++]=[@t]if@t=grep{!ref}@i;(@i=map{@$_}grep{ref}@i)&&redo}      # the snippet

use Data::Dumper;                                                    # print output
$Data::Dumper::Indent=0;  # keep everything on one line
$Data::Dumper::Terse=1;   # don't print $VAR =
print Dumper(\@o);

আউটপুট:

[[12],[54,20],[43,76],[-19]]

Answer 11

Clojure, 119 বাইট

(১১6 সেক? এবং তালিকা হিসাবে ইনপুট, একটি তুচ্ছ পরিবর্তন)

(defn f([v](vals(apply merge-with concat(sorted-map)(flatten(f 0 v)))))([l v](map #(if(number? %){l[%]}(f(inc l)%))v)))

ভাল উদ্দেশ্যে:

(defn f([v]  (vals(apply merge-with concat(sorted-map)(flatten(f 0 v)))))
       ([l v](map #(if(number? %){l[%]}(f(inc l)%))v)))

যখন দুটি আর্গুমেন্ট (বর্তমান স্তর এবং একটি সংগ্রহ) দিয়ে ডাকা হয় এটি হয় একটি অ্যালিমেন্টের মতো আনর্ডারড -ম্যাপ তৈরি করে {level: value}বা fএকটি অ-সংখ্যা (সম্ভবত একটি সংগ্রহ) দেখা গেলে পুনরাবৃত্তভাবে কল করে ।

এই মিনি-মানচিত্রগুলি তখন একক sorted-mapএবং মূল সংঘর্ষগুলিতে মিশ্রিত হয় concatফাংশন দ্বারা পরিচালিত । valsপ্রথম স্তরের থেকে শেষ পর্যন্ত মানচিত্রের মানগুলি ফেরত দেয়।

যদি তার স্তরে কোনও সংখ্যা একমাত্র হয় তবে এটি একটি থেকে যায় vec, অন্যরা তালিকাগুলিতে রূপান্তরিত হয় concat।

(f [[54, [43, 76, [[[-19]]]], 20], 12])
([12] (54 20) (43 76) [-19])

যদি ইনপুট একটি ছিল listপরিবর্তে vecতারপর number?দ্বারা প্রতিস্থাপিত হতে পারে seq?, অদ্ভুত ভেক্টর নয় seq?কিন্তু এটা sequential?। তবে আমি সেই সংস্করণটি বাস্তবায়িত করতে খুব অলস, উদাহরণগুলি আবার করি etc.

Answer 12

র‌্যাকেট 259 বাইট

(let((ol'())(m 0))(let p((l l)(n 0))(cond[(empty? l)][(list?(car l))(set! m(+ 1 n))
(p(car l)(+ 1 n))(p(cdr l)n)][(set! ol(cons(list n(car l))ol))(p(cdr l)n )]))
(for/list((i(+ 1 m)))(flatten(map(λ(x)(cdr x))(filter(λ(x)(= i(list-ref x 0)))(reverse ol))))))

Ungolfed:

(define (f l)
  (define ol '())
  (define maxn 0)
  (let loop ((l l)              ; in this loop each item is added with its level
             (n 0))
    (cond
      [(empty? l)]
      [(list? (first l))
       (set! maxn (add1 n))
       (loop (first l) (add1 n))
       (loop (rest l) n)]
      [else
       (set! ol (cons (list n (first l)) ol))
       (loop (rest l) n )]))

  ; now ol is '((0 1) (0 2) (1 3) (2 4) (2 5) (1 6) (2 7) (3 8) (2 9)) 

  (for/list ((i (add1 maxn)))   ; here similar levels are combined
    (flatten
     (map (λ (x) (rest x))      ; level numbers are removed
          (filter (λ (x) (= i(list-ref x 0)))
                  (reverse ol))))))

পরীক্ষামূলক:

(f '[1 2 [3 [4 5] 6 [7 [8] 9]]])

আউটপুট:

'((1 2) (3 6) (4 5 7 9) (8))

Answer 13

এমএটিএল , 37 বাইট

j']['!=dYsXKu"GK@=)'[\[\],]'32YXUn?1M

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

সঙ্গে কাজ করে বর্তমান রিলিজ (13.0.0) ভাষা / কম্পাইলার করুন।

এটি আউটপুটকে স্থান-বিভাজিত মানগুলির রেখারূপে উত্পাদন করে, যেখানে প্রতিটি লাইন একই নীড়সংশ্লিষ্ট স্তরের সাথে সামঞ্জস্য করে, এবং বিভিন্ন নেস্টিং স্তরগুলি নিউলাইন দ্বারা পৃথক করা হয়।

j            % read input as string (row array of chars)
']['!        % 2x1 array containing ']'  and '['
=            % test for equality, all combinations
d            % row array obtained as first row minus second row
Ys           % cumulative sum. Each number is a nesting level
XK           % copy to clibdoard K
u            % unique values: all existing nesting levels
"            % for each nesting level
  G          %   push input
  K          %   push array that indicates nesting level of each input character
  @          %   push level corresponding to this iteration
  =          %   true for characters corresponding to that nesting level
  )          %   pick those characters
  '[\[\],]'  %   characters to be replaced
  32         %   space
  YX         %   regexp replacement
  U          %   only numbers and spaces remain: convert string to array of numbers
  n?         %   if non-empty
    1M       %     push that array of numbers again
             %   end if implicitly
             % end for each implicitly