23

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

এই উদাহরণটি উদাহরণ হিসাবে নেওয়া যাক:

((5, 2), 2, 7, (2, 1, (3, 4)), 9)

এই তালিকার প্রতিটি উপাদানটির একটি "অগ্রাধিকার" রয়েছে। একটি উপাদান একটি সংখ্যা বা সাবলিস্ট হিসাবে গণনা করা হয়। প্রথমে একই উপাদানটিতে প্রতিটি উপাদানটির অগ্রাধিকার পান। যদি কোনও উপাদান কেবল একটি সংখ্যা হয় তবে এর অগ্রাধিকারটি সংখ্যার মতোই। যদি কোনও উপাদান একটি সাবলিস্ট হয় তবে এর অগ্রাধিকার হ'ল এটিতে সমস্ত সংখ্যার যোগফল , কোনও উপ-উপ-তালিকা সহ নয়।

সুতরাং, গভীরতা 1 এর সমস্ত উপাদানগুলির অগ্রাধিকারগুলি হ'ল :

 (  7 )  2  7  (    3       )  9
((5, 2), 2, 7, (2, 1, (3, 4)), 9)

প্রতিটি উপাদানকে অগ্রাধিকার অনুসারে বাছাই করুন। যদি কোনও টাই থাকে তবে আপনাকে অবশ্যই মূল তালিকার মতো একই ক্রমটি রাখতে হবে।

 2  (     3      )  (  7 )  7  9
(2, (2, 1, (3, 4)), (5, 2), 7, 9)

প্রতিটি সাবলিস্টের জন্য পুনরাবৃত্তি করুন। সুতরাং এই সাবলিস্টে

(2, 1, (3, 4))

আমাদের অগ্রাধিকারগুলি দেখতে দেখতে:

 2  1  (  7  )
(2, 1, (3, 4))

সাজানো তাই দেখে মনে হচ্ছে:

(1, 2, (3, 4))

(3, 4)ইতিমধ্যে বাছাই করা হয়েছে, তাই আমরা সম্পন্ন করেছি। পুনরাবৃত্তি করুন (5, 2)যার ফলাফল (2, 5)এবং আমরা সম্পন্ন করেছি! আমাদের চূড়ান্ত তালিকাটি হ'ল:

(2, (1, 2, (3, 4)), (2, 5), 7, 9)

নিয়মাবলী:

অত্যন্ত সন্দেহজনক, তবে কেবল গণিতের কাছে যদি এর জন্য কিছু থাকে তবে কোনও নেস্টেড তালিকা বাছাইয়ের বিল্টিনগুলি অনুমোদিত নয়। নিয়মিত বাছাই ফাংশন হয় মঞ্জুরিপ্রাপ্ত।
আই / ও যে কোনও যুক্তিসঙ্গত বিন্যাসে থাকতে পারে।
প্রতিটি সাবলিস্টে কমপক্ষে একটি নম্বর বা তালিকা থাকবে। এছাড়াও, সাবলিস্টগুলি কয়েক স্তরের গভীরভাবে নেস্ট করা যেতে পারে। উদাহরণস্বরূপ, যেহেতু এটা একমাত্র sublists আছে, 0 একটি অগ্রাধিকার হয়েছে। (1, 2, (((3))))(((3)))
অবৈধ তালিকাগুলি (তুলনাহীন বন্ধনী, অ-সংখ্যা, ভুল বন্ধনী প্রকারের, নেতিবাচক সংখ্যা ইত্যাদি) এর ফলে অপরিবর্তিত আচরণ হয়।

পরীক্ষা I / O:

(1, 2, 3) ---> (1, 2, 3)

(1, 2, 6, 3, 9, 8) ---> (1, 2, 3, 6, 8, 9)

(4, 3, (2), (1)) ---> ((1), (2), 3, 4)

(4, 3, (2), ((1))) ---> (((1)), (2), 3, 4)

(5, (1, 2, (9, 8))) ---> ((1, 2, (8, 9)), 5)

(3, (1, 2), (2, 1)) ---> (3, (1, 2), (1, 2))

(3, (1, 2, (99)), (2, 1, (34))) ---> (3, (1, 2, (99)), (1, 2, (34)))

(7, 2, (1, (9, 12)), (4, 3, 2, (1, 2))) ---> ((1, (9, 12)), 2, 7, (2, 3, (1, 2), 4))

বাইট জিতে সংক্ষিপ্ত উত্তর।

code-golf array-manipulation sorting

— ডিজেএমসিএমহেম
সূত্র

আমরা কি সংখ্যাটি পূর্ণসংখ্যা বলে ধরে নিতে পারি?

— isaacg

হ্যাঁ, আপনি পারেন

— ডিজেএমসিএমহেম

5

জেলি, 13 বাইট

fFSµ€Ụịß€µ¹<?

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

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

fFSµ€Ụịß€µ¹<?  Main link. Input: A (list)

   µ€          Apply the chain to the left to each item B in A.
 F             Flatten B.
f              Filter; intersect B with flattened B, yielding a list.
               This returns the numbers in B if B is a list, [B] if B is a number.
  S            Compute the sum of the resulting list.
     Ụ         Sort the indices of A according to the computed sums.
       ß€      Recursively apply the main link to each B in A.
      ị        Retrieve the items of the list (right) at those indices (left).
         µ     Convert the preceding chain into a single link.
            ?  If:
           <     A compared with itself is truthy:
                   Execute the link to the left.
          ¹      Else, apply the identity function to A.

তুলনা করা হচ্ছে ( <) নিজেই সঙ্গে একটি সংখ্যা উৎপাদ 0 (falsy), কিন্তু নিজেই সঙ্গে একটি খালি তালিকা তুলনা একটি তালিকা উৎপাদ 0 'গুলি (truthy), তাই <তালিকা থেকে নম্বর পার্থক্য ব্যবহার করা যাবে।

— ডেনিস
সূত্র

0 টি মিথ্যা, তবে 0 এর একটি বাক্স সত্য, তবে একটি ফাঁকা বাক্স মিথ্যা। পাইথন কীভাবে কাজ করে তা আকর্ষণীয়। : পি

— বিড়াল

আমার কাছে 25 বাইট (ইউটিএফ -8 এ এনকোড থাকা অবস্থায়) দেখে মনে হচ্ছে।

— রোটসর

@ রটারস যে সঠিক সম্পর্কে শোনাচ্ছে। তবে, জেলি কাস্টম কোড পৃষ্ঠা ব্যবহার করে যা 256 টি অক্ষরকে একক বাইট হিসাবে বোঝে এমন সমস্ত এনকোড করে।

— ডেনিস

17

পাইথন 2, 114 101 78 73 62 বাইট

k=lambda t:t*(t<[])or t.sort(key=k)or sum(z for z in t if[]>z)

আমি জানতাম তালিকার বাইরে ফিল্টার করার আরও ভাল উপায় ছিল।

স্থানটিতে অজগর তালিকার তালিকা (এবং এর উপলিস্ট) বাছাই করে।

https://eval.in/540457 ধন্যবাদ আমাকে ইনট-প্লেস সমাধানগুলি গ্রহণের জন্য জানার জন্য @ ট্যাক এবং আরও অনুকূলিতকরণের জন্য @ xnor + @feersum!

— Orez
সূত্র

1

আরো কিছু অপটিমাইজেশন: k=lambda t:t*(t<[])or sum(z for z in t if[t.sort(key=k)]>z)।

— xnor

@ এক্সনর আমি মনে করি যে সমাধানটি বেশ সঠিক নয়: eval.in/540447 । এই উদাহরণস্বরূপ, আমরা প্রথম সাবলিস্টে পুনরাবৃত্তি করি এবং zএটি থেকে প্রাথমিকটি ধরি , ৫. তারপরে শর্তসাপেক্ষে, আমরা তালিকাটি পুনরায় সাজিয়ে যাচ্ছি (!), সুতরাং যখন আমরা পরবর্তী জেডটি ধরব তখন এটি ALSO 5, 10 এর যোগফলের দিকে নিয়ে যায় আমরা তারপরে এই কীগুলির সাহায্যে বাইরের তালিকাটি বাছাই করে এবং [6, [1, 5]] পাই যা "যদি টাই থাকে তবে আপনাকে অবশ্যই মূল তালিকার মতো একই ক্রমটি রাখতে হবে। " মজার বিষয় হ'ল আমরা sortউভয় তালিকায় দু'বার কল করেছিলাম , সুতরাং এটি কেবল সমান কীগুলিতে ঘটে: সাবলিস্টটি যদি কম হত তবে তা আবার সাজানো হত।

— ওরেজ

ভালো বল ধরা. এটি মজার যে পুনরায় সাজানো তালিকার সাথে পুনরাবৃত্তিটি অব্যাহত রয়েছে। আমার মনে হচ্ছে এর Noneআউটপুট আটকে রাখার জন্য আরও একটি ছোট উপায় থাকা উচিত t.sort(key=k), তবে আমি এটি দেখছি না।

— xnor

False+এক্সটেনশন দ্বারা এবং এর দ্বারা 0 হয় sum। যদিও এটি কীভাবে বাইট সংরক্ষণ করে তা ভাবতে পারি না।

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

@ ক্যাটস আরেফ্লুফি list.sortফিরে আসে None, না False।

— ডেনিস

4

লুয়া, 172 বাইট

function p(a)if type(a)~="table"then return a end s(a)local t=0 for i,v in next,a do t=t+p(v)end return t end
function s(t)table.sort(t,function(a,b)return p(a)<p(b)end)end

ফাংশনটি sলুয়া টেবিলটি সাজায় (একটি ডেটা স্ট্রাকচার যা লুয়ার অন্যান্য জিনিসের মধ্যে একটি তালিকা হিসাবে কাজ করে) যথাযথভাবে নিয়ম অনুসারে।

— Trebuchette
সূত্র

আমি পছন্দ করি কীভাবে type(a)একটি স্ট্রিং ফিরিয়ে দেয়

— বিড়াল

লুয়া ব্যবহার করে অবশেষে একটি উত্তর।

— ফাঁস নুন

3

গণিত, 50 বাইট

#0/@SortBy[#,Tr@Cases[#,_Integer,{0,1}]&]~Check~#&

সাধারণ পুনরাবৃত্তির পদ্ধতি যা ব্যবহার করে SortBy। বার্তা উপেক্ষা করুন।

— LegionMammal978
সূত্র

3

হাস্কেল, ~~160~~ ~~151~~ 135 বাইট

import Data.List
data T=N Int|T[T]deriving Show
p(N x)=x
p(T t)=sum$[x|N x<-t]
f(N x)=N x
f(T t)=T$sortBy((.p).compare.p)$map f$t

প্রথম সমস্যা নেস্টেড তালিকা। হাস্কেলের প্রয়োজন যে তালিকার সমস্ত উপাদান একই রকম থাকে; বিশেষত, একটি পূর্ণসংখ্যা এবং পূর্ণসংখ্যার তালিকা একই ধরণের নয়। অন্য কথায়, একটি পরিবর্তনশীল-নেস্টেড তালিকা কোনও তালিকা নয়, এটি গোলাপ গাছ!

সুতরাং প্রথমে, আমাদের গোলাপ গাছগুলির জন্য একটি ডেটা ধরণের সংজ্ঞা দিতে হবে:

data T = N Int | T [T]

(স্ট্রিক্টলি, deriving Showশুধুমাত্র প্রয়োজনীয় যদি আপনি করতে চান দেখুন জায়গায় এই সংজ্ঞা সঙ্গে, আমরা যেমন একটি তালিকা লিখতে পারেন ফলাফল নেই। কিন্তু যে একটি পরিভাষা হচ্ছে।) (1, 2, (3, 4))যেমন

T [N 1, N 2, T [N 3, N 4]]

যা যথেষ্ট কম পাঠযোগ্য। কিন্তু যাই হোক না কেন; এটি একটি তুচ্ছ, যান্ত্রিক অনুবাদ। প্রতিটি সংখ্যা সহ Nএবং প্রতিটি সাবট্রির সাথে উপসর্গ করুন T।

এখন আমাদের অগ্রাধিকারগুলি গণনা করা দরকার। সাবট্রির অগ্রাধিকারটি এতে থাকা সমস্ত উপাদানের যোগফল যদি সহজ হয় তবে এটি সহজ হবে। এটি একটি তুচ্ছ পুনরাবৃত্তি লুপ হবে। তবে যেহেতু এটি নয়, আমাদের দুটি ফাংশন সংজ্ঞায়িত করতে হবে: একটি যা পুনরাবৃত্তি করে, এবং একটি যা না হয়।

p (N x) = x
p (T t) = sum $ map q t

q (N x) = x
q _     = 0

আমরা যদি সমস্ত সাফল্যের যোগফল যোগাড় করি তবে qবিপুল সংখ্যক অক্ষর সংরক্ষণ করে অস্তিত্বের প্রয়োজন হবে না। আচ্ছা ভালো!

সম্পাদনা: আসলে, বিভিন্ন commentors বাতলান আপনি এড়াতে পারেন qএকটি তালিকা ধী ব্যবহার করছে: [ x | N x <- t]। শুভ ডাক, বলছি!

(আসলে, pঅন্যথায় থাকার দরকার নেই; আমরা Ordমুষ্টিমেয় অক্ষরে আমাদের জন্য একটি সংকলক স্বয়ংক্রিয়ভাবে তৈরি করতে পারি এবং এই ডিফল্ট বাস্তবায়নটি সেই বৈশিষ্টটির সাথে মেলে))

শেষ অবধি, আমাদের সমস্ত উপ-গাছের উপরে পুনরাবৃত্তি করতে হবে এবং সেগুলি বাছাই করতে হবে:

f (N x) = N x
f (T t) = T $ sortBy (\ x y -> compare (p x) (p y)) $ map f $ t

অর্থাত্, fসমস্ত উপাদানগুলিতে ( map f) পুনরাবৃত্তভাবে নিজেকে প্রয়োগ করে এবং পরে sortByফাংশনটিকে শীর্ষ স্তরের বাছাই করে একটি গাছ সাজান। প্রথম লাইনটি বলে যে একটি সংখ্যা বাছাই করা কিছুই করে না এবং পুনরাবৃত্তিটি সমাপ্ত করার জন্য প্রয়োজনীয়।

— MathematicalOrchid
সূত্র

2

sortBy (\ x y -> compare (p x) (p y))ঠিক হয় sortOn p। মানচিত্রের এর পোতা সংস্করণ ব্যবহার করুন p: sum$q<$>t।

— নিমি

@নিমি কোথায় sortOnসংজ্ঞায়িত হয়েছে? আমি সর্বদা জানতে চেয়েছিলাম ...

— ম্যাথমেটিক্যালআরচিড

4.8.0.0 থেকে ডেটা.লিস্ট ।

— নিমিম

2

আপনি এখনও তালিকার বোঝাপড়া কৌশল সহ 16 টি বাইট মুণ্ডন করতে পারেন p(T t)=sum[x|N x<-t]এবং data T=N Int|T[T]deriving Show। :)

— নেস

1

আপনি কি আপনার গণনায় প্রতিটি নিউলাইনের জন্য 2 বাইট অন্তর্ভুক্ত করেছেন? আমি মনে করি আমাদের তাদের একক হিসাবে গণনা করার অনুমতি দেওয়া হয়েছে । এছাড়াও, কোন প্রয়োজন $মধ্যে sum$[x|N x<-t]। সুতরাং, 135-5-1 = 129। :)

— নেস

2

CLISP, 380 বাইট

(defun q(L)(if(null L)L(append(append(q(car(s(cdr L)(car L))))(list(car L)))(q(cadr(s(cdr L)(car L))))))))(defun s(L E)(if(not(atom(car L)))(setq L(cons(q(car L))(cdr L))))(cond((null L)'(nil nil))((<(v(car L))E)(list(cons(car L)(car(s(cdr L)E)))(cadr(s(cdr L)E))))(T(list(car(s(cdr L)E))(cons(car L)(cadr(s(cdr L)E)))))))(defun v(L)(if(atom L)L(apply'+(remove-if-not #'atom L))))

একটি তালিকা সহ ফাংশন q কল করুন।

আমি একটি লিস্প নুব, দয়া করে আমাকে হত্যা করবেন না ^^

— জবা
সূত্র

হাহাহা, আমি আশা করছিলাম কেউ লিস্পে এটি করবে!

— ডিজেএমসিএমহেম

1

পাইথ, 15 বাইট

L?sIbbossI#NyMb

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

একটি পুনরাবৃত্ত ফাংশন, যা নিম্নলিখিত হিসাবে কাজ করে:

L?sIbbossI#NyMb
L                  define y(b):
 ?sIb              If b is an integer:          (invariant under the s function)
     b             Return it.
            yMb    Else, apply y recursively to all of the elements of b,
      o            Then sort b by
        sI#N       For each element, the elements of that list that are integers.
                   This is luckily a nop on integers.
       s           Summed.

— isaacg
সূত্র

1

জাভা, 219 বাইট

import java.util.*;List f(List l){l.sort(Comparator.comparing(o->{if(o instanceof Integer)return(Integer)o;f((List)o);return((List) o).stream().filter(i->i instanceof Integer).mapToInt(i->(Integer)i).sum();}));return l;}

লাইন বিরতি সহ:

import java.util.*;
List f(List l){
    l.sort(Comparator.comparing(o -> {
        if (o instanceof Integer)
            return (Integer) o;
        f((List) o);
        return ((List) o).stream().filter(i -> i instanceof Integer).mapToInt(i -> (Integer) i).sum();
    }));
    return l;
}

এখানে প্রচুর ingালাই চলছে যা সত্যই বাইট গণনাটি রেকর্ড করে। : P: P

পূর্ণসংখ্যার মানগুলি একটি তুলনাকারীতে খাওয়ানো হয় এবং তুলনামূলককে কেবল পূর্ণসংখ্যা মানের যোগফল দেওয়ার আগে নেস্টেড তালিকাগুলি প্রথমে সাজানো হয়। এই মানগুলি হল যখন তুলনামূলকটি বাছাই করা হয় যখন তালিকার মধ্যে তাদের অবস্থান নির্ধারণ করে।

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

— টিঅ্যান্ডটি
সূত্র

1

এখানে একই কৌশলটি 154 বাইটে রয়েছে

int f(List l){l.sort(Comparator.comparing(o->o instanceof Integer?(int)o:f((List)o)));return l.stream().mapToInt(o->o instanceof Integer?(int)o:0).sum();}

— আন্দ্রেয়াস

আমি মনে করি খুব বেশি কিছু নিবারণ আছে।

— আন্দ্রেয়াস

কিন্তু একটি দম্পতি বিষয় আছে: আপনি স্পষ্টভাবে রূপান্তর করতে পারবেন না Objectকরার intমত, এবং চ্যালেঞ্জ প্রয়োজন যে একটি তালিকা আউটপুট বলে মনে হয়।

— টিএনটি

আপনি পূর্ণসংখ্যার পরিবর্তে তালিকার জন্য চেক করতে উদাহরণস্বরূপ পরিবর্তন করে 1 বাইট সংরক্ষণ করেন। পূর্ণসংখ্যাটি 7 বাইট ডাব্লু / ও কোঁকড়া ধনুর্বন্ধনী, তবে তালিকাটি এর সাথে 6 বাইট।

— নীল

@ টিএনটি আপনি জাভা ১.7 বা তারও বেশি উচ্চমানের কোনও বস্তুকে নিক্ষেপ করতে পারেন। অবশ্যই যদি অবজেক্টটি নাল হয় তবে আপনি একটি এনপাই পাবেন। আমি তালিকাটি স্থানে বাছাই করতে কোনও সমস্যা দেখছি না, চ্যালেঞ্জটি সরাসরি ইস্যুতে কথা বলে মনে হচ্ছে না।

— আন্দ্রেয়াস

0

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

f=a=>a.map?a.map(f).sort((a,b)=>p(a)-p(b),p=a=>a.map?a.map(a=>t+=a.map?0:a,t=0)|t:a):a

সমস্ত অ্যারে চেকিং :-(

— নিল
সূত্র

1

map.map.map.map.map.map.map.map.map

— বিড়াল

নেস্টেড তালিকা বাছাই করুন

নিয়মাবলী:

পরীক্ষা I / O:

জেলি, 13 বাইট

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

পাইথন 2, 114 101 78 73 62 বাইট

লুয়া, 172 বাইট

গণিত, 50 বাইট

CLISP, 380 বাইট

পাইথ, 15 বাইট

জাভা, 219 বাইট

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