তালিকাগুলির একটি তালিকাকে দুঃখ-তালিকায় পার্স করুন


12

এই চ্যালেঞ্জের মধ্যে আপনাকে অবশ্যই তালিকার একটি তালিকা একটি সরল তালিকা বিন্যাসে পার্স করতে হবে।

এই চ্যালেঞ্জটি আমার স্যাডফ্লাক পার্সারের উপর ভিত্তি করে। আমার স্যাডফ্ল্যাক পার্সারে, প্রোগ্রামটি আরও দ্রুত চালিত করার জন্য এটি তালিকার শুরুতে () গুলি যোগ করে সমস্ত () সরিয়ে ফেলা হয়েছে।

একটি দু: খ-তালিকায় পার্স করার জন্য আপনাকে এটি করতে হবে (অজগর বাস্তবায়ন জিনিস, একটি টিপলস টুপল ব্যবহার করে):

def sadlistfunc(list):
    new-sadlist = [0]
    for i in list:
        if i == ():
            new-sadlist[0]+=1
        else:
            new-sadlist.append(sadlistfunc(i))

এটি একটি পুনরাবৃত্তি ফাংশন। তালিকার জন্য, তালিকা ইনপুট থেকে () সংখ্যা দিয়ে শুরু করে একটি নতুন তালিকা শুরু করুন, তারপরে এই তালিকার বাকিগুলি তালিকার ইনপুট থেকে ক্রম অনুসারে প্রতিটি তালিকার দুঃখ-তালিকার সংস্করণ। তালিকাটি ফিরিয়ে দিন।

ইনপুট:

আপনি কয়েকটি আলাদা ফর্ম্যাটে ইনপুট নিতে পারেন:

  • আপনি এটি একটি তালিকা হিসাবে নিতে পারেন
  • আপনি এটি একটি tuple হিসাবে নিতে পারেন
  • আপনি এটি একটি স্ট্রিং হিসাবে নিতে পারেন

যদি আপনি এটি একটি স্ট্রিং হিসাবে গ্রহণ করেন তবে আপনার ব্রেনের কিছু সেট ব্যবহার করা উচিত, যেমন মস্তিষ্ক-ফ্ল্যাঙ্কে প্রদর্শিত হবে। আপনি 1 এবং 2 অক্ষর ব্যবহার করতে পারেন

ঠিক যুক্তিযুক্ত

ইনপুট সর্বদা একটি তালিকার অভ্যন্তরে থাকবে তবে আপনার প্রোগ্রামটি ইনপুটটির বাইরে একটি অন্তর্নিহিত তালিকা স্তর ধরে নিতে পারে, যেমন () () () () (() () ()), বা এটি নাও বেছে নিতে পারে। উদাহরণগুলি সুস্পষ্ট বাইরের তালিকার সাথে থাকবে

আউটপুট:

তালিকা বা টিপল বা স্ট্রিং বা যা কিছু হতে পারে। আপনি মেটা sensকমত্য হিসাবে যুক্তিসঙ্গত আউটপুট ফর্ম্যাটটি ব্যবহার করতে পারেন।

উদাহরণ:

(()()()) = [3]
(((()))) = [0,[0,[1]]]
((())()(())) = [1, [1], [1]]
() = invalid input, if the outside bracket is explicit.
((((())())())(())()) = [1, [1, [1, [1]]], [1]]

নোট করুন যে ইনপুট কঠোর নয়। এই ইনপুটগুলি হতে পারে:

[[],[],[]]
[[[[]]]]
[[[]],[],[[]]]
[]
[[[[[]],[]],[]],[[]],[]]

বা অন্য কিছু যুক্তিসঙ্গত বিন্যাস

ব্যাখ্যা পরীক্ষার কেস:

(()()((())())())

এটি "দুঃখিত" করতে, প্রথমে আমরা () এর সংখ্যা গণনা করি

 ()()        ()
(    ((())())  )

3. তারপরে আমরা এগুলি সরিয়ে ফেলব এবং শুরুতে একটি 3 যুক্ত করব

(3,((())()))

এই তালিকায় একটি তালিকা আছে। আমরা এই দুঃখ

((())())

কতগুলো ()?

     ()
((())  )

1. আমরা সরাতে শুরু করি এবং 1 টি যুক্ত করি

(1,(()))

এটিতে এটির একটি তালিকা রয়েছে

(())

গণনা

 ()
(  )

মুছে ফেলুন এবং গণনা যোগ করুন

(1)

তারপরে আমরা এটিকে আবার তার তালিকায় রাখি

(1,(1))

তারপরে আমরা এটিকে আবার তার তালিকায় রাখি

(3,(1,(1)))

সম্পন্ন

এটি , তাই খাটো আরও ভাল


নোট করুন যে আসল সাদামাটা-ফ্ল্যাঙ্ক পার্সারে, () এর সংখ্যাটি হ'ল তালিকার দ্বিতীয় আইটেম, এবং প্রথম আইটেমটি কমান্ডের সূচী
ধ্বংসাত্মক লেবু

গুড ওল জাভাস্ক্রিপ্ট for... in, আপনি কেন এটি কখনও ব্যবহার করবেন না তা আমাকে স্মরণ করিয়ে দেওয়ার জন্য: ফিডল
স্টিফেন

আমি অনুমান ((((())())())(())()) = [1, [1, [1, [1]], [1]]করা উচিত ((((())())())(())()) = [1, [1, [1, [1]]], [1]]
রেঞ্জো

উত্তর:


4

পাইথ , 13 বাইট

L+]/bYyM-b]Yy

টেস্ট স্যুট

কিভাবে এটা কাজ করে

L+]/bYyM-b]Yy
L               define a function y with argument b:
   /bY              list 1: count how many [] can be found in b
  ]                         wrap into singleton
        -b]Y        list 2: filter out [] from b
      yM                    apply y (this function) to each
 +                  concatenate the two lists above
            y   apply y to the input

আপনি প্রথমে অপসারণ করতে পারেন ]
এরিক আউটগলফার


2

বাইটস এবং অক্ষর সমতুল্য নয়। ইউটিএফ -8 ব্যবহার করে, এটি কেবল 21 টি অক্ষর থাকা সত্ত্বেও 33 বাইট গ্রহণ করতে পারে ।
সামাদি

1
@ সামাদি ব্র্যাচল্যাগ নিজস্ব কোড পৃষ্ঠা ব্যবহার করে , যা এই মেটা উত্তর অনুসারে অনুমোদিত ।
ফাঁস নুন

আহ আমি দেখি. আমি কিছুটা বিভ্রান্ত হয়ে পড়েছিলাম । স্পষ্ট করার জন্য ধন্যবাদ!
সামাদি

@ সামাদি কোন সমস্যা নেই, এই প্রশ্নটি সর্বদা জিজ্ঞাসা করা হয়।
ফাঁস নুন

2

গণিত, 42 বাইট

{#~Count~{0},##&@@#~DeleteCases~{0}}&//@#&

//@( MapAll) ব্যবহার করে সুস্পষ্ট পুনরাবৃত্তি এড়াতে যা গাছের প্রতিটি নোডের উপরে একটি ফাংশন ম্যাপ করে। এর অর্থ হ'ল ফাংশনগুলি পাতা থেকে উপরের দিকে চালিত হয়। তবে এটি প্রয়োগ করা হবে {}যা {0}প্রক্রিয়ায় রূপান্তরিত হয় । এজন্য আমরা এর {0}পরিবর্তে গণনা এবং অপসারণ করি {}



2

Clojure, 59 বাইট

(fn f[i](conj(map f(remove #{[]}i))(count(filter #{[]}i))))

কমনলিস্প উত্তর থেকে খুব আলাদা নয় । এটি countএবং removeমনে হচ্ছে কিছুটা সুন্দর কন্সট্রাক্ট গ্রহণ করুন, এখানে আমাকে সেট ব্যবহার করতে হয়েছিল।


2

আসলে , 12 বাইট

;[]@c@;░Q£Mo

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

সুস্পষ্ট বাহ্যিক ব্র্যাকারগুলির সাথে কমা-বিচ্ছিন্ন স্কয়ার-বন্ধনী তালিকা হিসাবে ইনপুট নেয়।

ব্যাখ্যা:

;[]@c@;░Q£Mo
;[]@c         count the number of empty lists
     @;░      filter out empty lists
        Q£Mo  recurse with filtered list and append result

2

পাইথন 2 , 69 46 45 বাইট

f=lambda l:[l.count([])]+map(f,filter(len,l))

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


আমি মনে করি আপনাকে f=আপনার বাইটোকন্টে যুক্ত করা দরকার , যেহেতু আপনি ফ ফাংশনটি ব্যবহার করছেন এবং অন্যথায় নামকরণ করা আপনার সমাধানটি ভেঙে দেবে
লিও

@ লিও আপনি ঠিক বলেছেন
ovs

1

জেলি , 10 বাইট

Tị߀;@ċ“”$

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

তালিকাগুলির তালিকাগুলির তালিকা হিসাবে ইনপুট নেয় ...

অবশ্যই এটি অন্যান্য উত্তরগুলি ব্যবহার করে আলগোরিদিম ব্যবহার করে। ;)


এটি 10 ​​বাইট নয়। এটি 10 ​​টি অক্ষর । বাইটের সংখ্যা আপনি কী এনকোডিং ব্যবহার করেন তার উপর নির্ভর করবে।
সামাদি

2
@ সামাদী নো, জেলির একটি উত্সর্গীকৃত অক্ষর সেট রয়েছে যা এটির ডিফল্ট এবং এটি প্রতিটি অক্ষরকে একটি বাইট হিসাবে উপস্থাপন করতে পারে। এখানে দেখুন ।
অ্যাডম

আমি দেখি. স্পষ্টতার জন্য ধন্যবাদ!
সামাদি

1

হাস্কেল , ১০২ বাইট

data L=I Int|T[L]deriving Show
(I n:r)#m=r#(n+m)
(x:r)#m=x:r#m
_#m=[I m]
f(T[])=I 1
f(T t)=T$map f t#0

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

যেহেতু হাস্কেল কঠোরভাবে টাইপ করা হয়েছে, সেখানে কোনও ইচ্ছামত নেস্টেড তালিকা নেই। প্রতিকার হিসাবে data L=I Int|T[L]deriving Showগাছের মতো নেস্টেড তালিকে ইন্ট বা খালি তালিকে পাতা হিসাবে ঘোষণা করে।

ইনপুট, দ্বিতীয় উদাহরণ বিন্যাসে মত হল একটি অতিরিক্ত কন্সট্রাকটর সঙ্গে Tপ্রতিটি খোলার বক্রবন্ধনী আগে: T[T[T[]],T[],T[T[]]]। একই ফলাফল আউটপুট জন্য যায়, প্রতিটি সংখ্যক একটি কনস্ট্রাক্টর দ্বারা পূর্বে I। ফাংশন দুঃখজনকf করে তোলে

পরীক্ষার ক্ষেত্রে আউটপুট:

T [I 3]
T [T [T [I 1],I 0],I 0]
T [T [I 1],T [I 1],I 1]
T [T [T [T [I 1],I 1],I 1],T [I 1],I 1]

1

জাভাস্ক্রিপ্ট (ES6), 77 বাইট

Golfed:

let m=a=>!a.length||a.map(m).reduce((b,c)=>(c.length?b.push(c):b[0]++,b),[0])

Ungolfed:

const traverse = arr => !arr.length || arr
    .map(traverse)
    .reduce(
        (accum, val) => (val.length ? accum.push(val) : accum[0]++, accum),
        [0]
    );

ডেমো

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