একটি তালিকা বাছাই করুন


20

নেস্টেড তালিকার "বাছাই" প্রক্রিয়াটি বিবেচনা করুন। বাছাই নিম্নলিখিত হিসাবে সংজ্ঞায়িত করা হয়:

  • যদি আর্গুমেন্টের তালিকা থাকে তবে তালিকা থেকে এলোমেলোভাবে (অভিন্নভাবে) একটি উপাদান নিয়ে যান এবং সেগুলি থেকে বেছে নিন।
  • যুক্তি যদি কোনও তালিকা না হয় তবে কেবল এটি ফিরিয়ে দিন।

পাইথনে উদাহরণ প্রয়োগ:

import random
def pick(obj):
    if isinstance(obj, list):
        return pick(random.choice(obj))
    else:
        return obj

সরলতার জন্য, আমরা ধরে নিই যে নেস্টেড তালিকাগুলিতে কেবল পূর্ণসংখ্যা বা আরও নেস্টেড তালিকা থাকে।

যে কোনও তালিকা দেওয়া থাকলে, এটি সমতল সংস্করণ তৈরি করা সম্ভব যা পৃথক পৃথক pick, অর্থাৎ এটি থেকে বাছাই করা একই সম্ভাবনা সহ একই ফলাফল দেয়।

উদাহরণস্বরূপ, তালিকাটি "পিক-ফ্ল্যাটটিং"

[1, 2, [3, 4, 5]]

তালিকা উত্পাদন করে

[1, 1, 1, 2, 2, 2, 3, 4, 5]

। কেবল চাটুকারিতা অবৈধ হওয়ার কারণ হ'ল সাব-তালিকার উপাদানগুলির নির্বাচনের সম্ভাবনা কম থাকে, উদাহরণস্বরূপ তালিকায় [1, [2, 3]]1 টিতে 2/4 = 1/2 সম্ভাবনা রয়েছে এবং 3 এবং 4 উভয়েরই 1/4 রয়েছে সুযোগ প্রতিটি।

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

চ্যালেঞ্জ

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

এটি , সুতরাং সংক্ষিপ্ততম বৈধ উত্তর (বাইটগুলিতে পরিমাপ করা) জয়ী।

বিশেষ উল্লেখ

  • ইনপুট [2, 3, 4], [2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4]এবং [2, [3, 3], [[4]]]সমতুল্য (অর্থাত তাদের সমমানের ফলাফল দেওয়া উচিত)।
  • আউটপুট [2, 2, 2, 2, 3, 3, 3, 3]এবং [2, 3]সমতুল্য (যেমন উভয়ই আউটপুট হতে পারে)।
  • আপনি অন্তর্ভুক্ত করতে পারেন যে অন্তর্ভুক্তিকালীন 1-100 পরিসরের সংখ্যাগুলি তালিকাতে উপস্থিত থাকবে।
  • আপনি ধরে নিতে পারেন শীর্ষ স্তরের ইনপুটটি একটি তালিকা হবে, অর্থাত 2কোনও বৈধ ইনপুট নয়।
  • আপনি উদাহরণস্বরূপ, নেস্টেড তালিকার কোনো যুক্তিসংগত উপস্থাপনা ব্যবহার করতে পারেন:
    [1, [2, 3]], 1 {2 3}, "[ 1 [ 2 3 ] ]", ইত্যাদি
  • তালিকার পরিবর্তে, আপনি একটি মাল্টিসেট বা ম্যাপিং আউটপুট করতে পারেন, বা যেহেতু কেবলমাত্র 1-100 পরিসরের সংখ্যাগুলি অনুমোদিত, তাই পরিমাণের প্রতিনিধিত্ব করে পূর্ণসংখ্যার দৈর্ঘ্য -100 তালিকা।

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

নোট করুন যে তালিকাবদ্ধ আউটপুটগুলি কেবল একটি বৈধ সম্ভাবনা; কোন বৈধ ইনপুট বা আউটপুট গঠন করে তার জন্য নির্দিষ্টকরণগুলি দেখুন।

format:
input -> output
[3]                          -> [3]
[1, [1, 1]]                  -> [1]
[1, [2, 3]]                  -> [1, 1, 2, 3]
[2, 3, [4, [5, 5, 6], 6, 7]] -> [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7]
[[1, 1, 2], [2, 3, 3]]       -> [1, 2, 3]
[[1, 1, 2], [2, 3, 3, 3]]    -> [1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3]

দৈর্ঘ্য এনকোডিং বিকল্প এবং সীমানা পরিসীমা দেওয়া, আমরা বিকল্পভাবে প্রতিটি পূর্ণসংখ্যার উপস্থিতি চিত্রিত 100 উপাদান একটি তালিকা আউটপুট করতে পারি? (যা দেওয়া উদাহরণের জন্য অনেক শূন্য সাথে ভালো ফলাফল হবে)
ঊরীয়েল

@ উরিল শিওর; আমি এটি উচ্চারণ করব।
52-

উত্তর:


8

ওল্ফ্রাম ভাষা (গণিত) , 41 20 বাইট by

Flatten@*Tuples//@#&

এটি অনলাইন চেষ্টা করুন! অনেক সতর্কতা উপেক্ষা করুন, এটি সব শেষে কাজ করে।

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

গভীরতা 2 একটি তালিকার জন্য যেমন {{1,2},{3},{4,5,6}}, Tuplesতালিকা উত্পন্ন করবে {{1,3,4},{1,3,5},{1,3,6},{2,3,4},{2,3,5},{2,3,6}}সব উপায় থেকে একটি উপাদান বাছাই সংশ্লিষ্ট {1,2} এবং থেকে একটি উপাদান বাছাই {3} এবং থেকে একটি উপাদান বাছাই {4,5,6}

আমরা যদি Flattenএই, তারপর আমরা সঠিক ফ্রিকোয়েন্সি সঙ্গে সব উপাদান, কারণ থেকে একটি উপাদান অবচয় পেতে এক এর {1,2}, {3}বা {4,5,6}তাদের সব থেকে একটি উপাদান অবচয়, তারপর কোনটি রাখা চয়নের দেওয়ার সমতুল্য।

আমরা ইনপুটটির //@সমস্ত স্তরে এটি প্রয়োগ করতে ব্যবহার করি । প্রক্রিয়াতে, ম্যাথামেটিকার অনেক অভিযোগ, কারণ এটি পরমাণুগুলিকে যেমন 17রূপান্তরিত করে Tuples[17], যা আসলে কোনও জিনিস হওয়ার কথা নয়। তবে এগুলি পরে সঠিক ফলাফলটিকে সহজতর করে ( 1 টি দৈর্ঘ্যের তালিকার হিসাবে Tuplesবিবেচনা করতে পেরে খুশি Tuples[17], যদিও এর চেয়ে অন্য মাথা থাকে List), তাই অভিযোগটি অপ্রাসঙ্গিক।



4

জেলি , 9 8 বাইট

߀Œp$¬¡F

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

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

߀Œp$¬¡F  Main link. Argument: x (array or positive integer)

     ¬    Compute elementwise logical NOT of x: a non-empty array for a non-empty array, 0 for a positive integer.
      ¡   Apply the link to the left once if ¬ returned a non-empty
          array, zero timed if it returned 0.
    $     Monadic chain:
߀            Map the main link over x.
  Œp          Take the Cartesian product.
       F  Flatten the result.


1

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

def f(l,p=0):m=reduce(int.__mul__,[i*0<[]or len(i)for i in l]);return p*(p==l)or f(sum([(([i],i)[i*0>0]*m)[:m]for i in l],[]),l)

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

আমার জেলি উত্তর পোর্ট।

-12 জনাথন ফ্রেচকে ধন্যবাদ ।


আমার মনে হয় type(i)==intহতে পারে i*0<[]
জোনাথন ফ্রেচ

@ জোনাথনফ্রেচ শিওর, 0<[]... এবং type(i)==listহতে পারে i*0>0;)
এরিক দি আউটগল্ফার

1

সি (জিসিসি) , 234 223 বাইট

h[9][101];o[101];n[9];l;L;e;main(x){for(;(x=scanf("%d",&e))>=0;x?++h[l][e],++n[l]:(e=getchar())-'['?e-']'?0:--l:++l>L&&++L);for(e=1,l=L+1;l--;){for(x=101;--x;o[x]+=e*h[l][x]);e*=n[l];}while(o[x]--?printf("%d ",x):++x<101);}

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

ব্যাখ্যা:

h[9][101];  // <- number occurences per nesting level
o[101];     // <- number occurences in "flattened" array
n[9];       // <- number of entries per nesting level
l;          // <- current nesting level
L;          // <- max nesting level
e;          // <- multi-purpose temporary
main(x){    // x: multi-purpose temporary
    for(;
            // while not EOF try reading number
            (x=scanf("%d",&e))>=0;

            // number was read?
            x

                // then increment occurence and # entries in level
                ?++h[l][e],++n[l]

                // else read any character ... if not [
                :(e=getchar())-'['

                    // if not ]
                    ?e-']'

                        // do nothing
                        ?0

                        // else decrement nesting level
                        :--l

                    // else increment nesting level and adjust max level
                    :++l>L&&++L);

    // init factor in e to 1, iterate over nesting level from innermost
    for(e=1,l=L+1;l--;){

        // iterate over all numbers
        for(x=101;
                --x;

                // add factor times occurence on current level to output
                o[x]+=e*h[l][x]);

        // multiply factor by number of entries on current level
        e*=n[l];
    }

    // iterate over all numbers and output count times
    while(o[x]--?printf("%d ",x):++x<101);
}



0

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

f=A=>(_=(a,m)=>[].concat(...a.map(m)),n=1,A=A.map(a=>a.map?f(a):[a]),_(A,a=>n*=a.length),_(A,a=>_(a.map(x=>Array(n/a.length).fill(x)))))

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