"সমানভাবে" আইটেম বিতরণ করতে অ্যালগরিদম

Question

আমি তালিকা থেকে মানগুলি বিতরণ করার জন্য একটি অ্যালগরিদম সন্ধান করছি যাতে ফলস্বরূপ তালিকাটি যথাসম্ভব "সুষম" বা "সমানভাবে বিতরণ" হিসাবে হয় (উক্তিগুলিতে কারণ আমি নিশ্চিত নই যে এগুলি বর্ণনা করার সর্বোত্তম উপায় ... পরে আমি ফলাফলগুলি অন্যের চেয়ে ভাল হয় কিনা তা পরিমাপের একটি উপায় সরবরাহ করব)।

সুতরাং, তালিকার জন্য:

[1, 1, 2, 2, 3, 3]

মানগুলি পুনরায় বিতরণের পরে সেরা ফলাফলগুলির মধ্যে একটি:

[1, 2, 3, 1, 2, 3]

এটির মতো আরও ভাল ফলাফল হতে পারে এবং মানগুলির কম ইউনিফর্ম সেট সহ এটি আরও জটিল হয়ে ওঠে।

ফলাফলগুলি যদি অন্যের চেয়ে ভাল হয় তবে এটি কীভাবে পরিমাপ করা যায়:

1. প্রতিটি আইটেম এবং পরের আইটেমের মধ্যে একই মান সহ দূরত্বগুলি গণনা করুন।

2. দূরত্বের সেই সেটটির জন্য স্ট্যান্ডার্ড বিচ্যুতি গণনা করুন। নিম্ন বিচ্ছুরণের অর্থ একটি ভাল ফলাফল।

পর্যবেক্ষণ:

• যখন একটি দূরত্ব গণনা করা হয় এবং একই মান সহ কোনও আইটেম না পেয়ে তালিকার শেষের দিকে পৌঁছে যায়, আমরা তালিকার শুরুতে ফিরে যাই। সুতরাং, বেশিরভাগ ক্ষেত্রে, একই আইটেমটি পাওয়া যাবে এবং সেই আইটেমটির দূরত্ব হবে তালিকার দৈর্ঘ্য। এর অর্থ হল তালিকাটি চক্রযুক্ত ;
• একটি সাধারণ তালিকায় quant 50 আইটেম রয়েছে quant 15 বিভিন্ন মান সহ বিভিন্ন পরিমাণে।

তাই:

• ফলাফলের জন্য [1, 2, 3, 1, 2, 3], দূরত্বগুলি [3, 3, 3, 3, 3, 3]হ'ল এবং মানক বিচ্যুতি হ'ল 0;
• ফলাফলের জন্য [1, 1, 2, 2, 3, 3], দূরত্বগুলি [1, 5, 1, 5, 1, 5]হ'ল এবং মানক বিচ্যুতি হ'ল 2;
• যা প্রথম ফলাফলকে দ্বিতীয়টির চেয়ে ভাল করে তোলে (নিম্ন বিচ্যুতি আরও ভাল)।

এই সংজ্ঞাগুলি দেওয়া, আমি কোন অ্যালগরিদম বা কৌশলগুলি অনুসন্ধান করতে হবে তার একটি সন্ধান জিজ্ঞাসা করি।

Comments

দেখে মনে হচ্ছে আপনি পার্টিশনের সমস্যার (কমপ্লেক্সটি অপ্টিমাইজেশনের রূপটি) কমপক্ষে আনুমানিকভাবে সমাধান করতে চান ly সম্ভবত এটির জন্য অনেক অ্যালগরিদম রয়েছে!

— রাফেল

এটি পুনরায় পড়া, কেন সমস্ত মানগুলির উপস্থিতি গণনা এবং তারপরে চক্রাকারে মানগুলি সর্বদা সর্বোত্তম সমাধান দেয় না?

— রাফেল

Answer 1

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

যদি আপনি 30,20,10 অনুপাতের (যেমন, এ এর ​​30 ইউনিট, বি এর 20 ইউনিট এবং সি এর 10 ইউনিট) তরল A, B এবং C মিশ্রিত করতে চান তবে আপনি যদি সমস্ত সংযোজন করেন তবে আপনি স্তরের সাথে শেষ করেন এ, তারপরে সমস্ত বি এবং তারপরে সমস্ত সি আপনি ছোট ইউনিটগুলিকে মেশানো ভাল। উদাহরণস্বরূপ, ক্রমানুসারে [A, B, A, C, B, A] একক-ইউনিট সংযোজন করুন। এটি পুরোপুরি স্তরবদ্ধতা প্রতিরোধ করবে।

আমি যেভাবে এটি দেখতে পেয়েছি তা হল এটি অগ্রাধিকারের সারি ব্যবহার করে এক ধরণের মার্জ হিসাবে বিবেচনা করা। আমি সংযোজনগুলি বর্ণনা করার জন্য যদি কোনও কাঠামো তৈরি করি:

MergeItem
    Item, Count, Frequency, Priority

ফ্রিকোয়েন্সিটি "প্রতিটি এন-তে একটি" হিসাবে প্রকাশিত হয়। সুতরাং এ, যা ছয়টির মধ্যে তিনবার যুক্ত হয়, তার ফ্রিকোয়েন্সি 2 (6/3) থাকে।

এবং প্রাথমিকভাবে রয়েছে এমন একটি গাদা শুরু করুন:

(A, 3, 2, 2)
(B, 2, 3, 3)
(C, 1, 6, 6)

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

(B, 2, 3, 0)
(A, 2, 2, 4)
(C, 1, 6, 6)

এরপরে, খকে বিটিকে অপসারণ করুন, আউটপুট এবং আপডেট করুন, তারপরে আবার গাদাতে যুক্ত করুন:

(A, 2, 2, 4)
(C, 1, 6, 6)
(B, 1, 3, 6)

যদি আমি সেই ফ্যাশনটিতে চালিয়ে যাই তবে আমি পছন্দসই মিশ্রণটি পাই। সমান অগ্রাধিকারের আইটেমগুলি যখন গাদা হয়ে inোকানো হয় তখন এটি সর্বাধিক ফ্রিকোয়েন্সি মান সহ (যেমন সর্বনিম্ন ঘন ঘন) প্রথমে আদেশ করা হয় তা নিশ্চিত করতে আমি একটি কাস্টম তুলক ব্যবহার করি use

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

মন্তব্যের পরে আপডেট করুন

আমি মনে করি আমার সমস্যাটি ওপি-র সমস্যার সাথে সমান এবং তাই আমার সমাধান সম্ভাব্য উপকারী। ওপির প্রশ্নের শর্তে আমার উত্তর আরও প্রকাশ না করার জন্য আমি ক্ষমাপ্রার্থী।

প্রথম আপত্তিটি, যে আমার সমাধানটি 0, 1, এবং 2 এর পরিবর্তে এ, বি এবং সি ব্যবহার করছে, সহজেই প্রতিকার করা যেতে পারে। এটি কেবল নামকরণের বিষয়। আমি "দু'এক" এর চেয়ে "দু'এ" এর কথা চিন্তা করা এবং বলতে আরও সহজ এবং কম বিভ্রান্তি পেয়েছি। তবে এই আলোচনার উদ্দেশ্যগুলির জন্য আমি ওপি'র নামকরণ ব্যবহার করতে নীচে আমার আউটপুটগুলি সংশোধন করেছি।

অবশ্যই আমার সমস্যা দূরত্বের ধারণা নিয়ে কাজ করে। আপনি যদি "জিনিসগুলি সমানভাবে ছড়িয়ে দিতে চান" তবে দূরত্ব বোঝানো হয়। তবে, আবারও আমার সমস্যাটি ওপি-র সমস্যার সাথে কীভাবে মিল রয়েছে তা পর্যাপ্তরূপে না দেখানোর ক্ষেত্রে এটি ব্যর্থ হয়েছিল।

ওপি সরবরাহ করে দুটি উদাহরণ দিয়ে আমি কয়েকটি পরীক্ষা চালিয়েছি। এটাই:

[1,1,2,2,3,3]  // which I converted to [0,0,1,1,2,2]
[0,0,0,0,1,1,1,2,2,3]

আমার নামকরণগুলিতে সেগুলি যথাক্রমে [2,2,2] এবং [4,3,2,1] হিসাবে প্রকাশিত হয় এটি, সর্বশেষ উদাহরণে, "প্রকারের 4 টি আইটেম, 1 ধরণের 3 আইটেম, 2 ধরণের আইটেম এবং 3 ধরণের 1 আইটেম" is

আমি আমার পরীক্ষার প্রোগ্রামটি চালিয়েছি (সাথে সাথে নীচে বর্ণিত), এবং আমার ফলাফল পোস্ট করেছি। ওপি থেকে অনুপস্থিত ইনপুট, আমি বলতে পারব না যে আমার ফলাফলগুলি এর চেয়ে খারাপ, তার চেয়ে খারাপ বা তার চেয়ে ভাল কিনা। বা অন্য কারও ফলাফলের সাথে আমি আমার ফলাফলগুলি তুলনা করতে পারি না কারণ অন্য কেউ কোনও পোস্ট করেনি।

তবুও আমি বলতে পারি যে তরল মিশ্রিত করার সময় অ্যালগোরিদম আমার স্তরবদ্ধতা দূরীকরণের সমস্যার একটি ভাল সমাধান সরবরাহ করে । এবং দেখে মনে হচ্ছে এটি অপের সমস্যার কোনও যুক্তিসঙ্গত সমাধান সরবরাহ করে।

নীচে দেখানো ফলাফলের জন্য, আমি আমার ব্লগ এন্ট্রিতে বিশদ অ্যালগরিদমটি ব্যবহার করেছি, এতে প্রাথমিক অগ্রাধিকার সেট করা হয়েছে Frequency/2এবং আরও ঘন ঘন আইটেমটির পক্ষে apাল তুলক সংশোধন করা হয়েছে। পরিবর্তিত কোডগুলি এখানে দেখানো হয়েছে, পরিবর্তিত লাইনের সাথে মন্তব্য করা হয়েছে।

private class HeapItem : IComparable<HeapItem>
{
    public int ItemIndex { get; private set; }
    public int Count { get; set; }
    public double Frequency { get; private set; }
    public double Priority { get; set; }

    public HeapItem(int itemIndex, int count, int totalItems)
    {
        ItemIndex = itemIndex;
        Count = count;
        Frequency = (double)totalItems / Count;
        // ** Modified the initial priority setting.
        Priority = Frequency/2;
    }

    public int CompareTo(HeapItem other)
    {
        if (other == null) return 1;
        var rslt = Priority.CompareTo(other.Priority);
        if (rslt == 0)
        {
            // ** Modified to favor the more frequent item.
            rslt = Frequency.CompareTo(other.Frequency);
        }
        return rslt;
    }
}

ওপির প্রথম উদাহরণ দিয়ে আমার পরীক্ষা প্রোগ্রাম চালানো, আমি পেয়েছি:

Counts: 2,2,2
Sequence: 1,0,2,1,0,2
Distances for item type 0: 3,3
Stddev = 0
Distances for item type 1: 3,3
Stddev = 0
Distances for item type 2: 3,3
Stddev = 0

সুতরাং আমার অ্যালগরিদম সমস্ত সংখ্যা সমান হওয়ার তুচ্ছ সমস্যার জন্য কাজ করে।

ওপি পোস্ট করা দ্বিতীয় সমস্যাটির জন্য, আমি পেয়েছি:

Counts: 4,3,2,1
Sequence: 0,1,2,0,1,3,0,2,1,0
Distances for item type 0: 3,3,3,1
Stddev = 0.866025403784439
Distances for item type 1: 3,4,3
Stddev = 0.471404520791032
Distances for item type 2: 5,5
Stddev = 0
Distances for item type 3: 10
Stddev = 0
Standard dev: 0.866025403784439,0.471404520791032,0,0

আমি এটির উন্নতি করার কোনও সুস্পষ্ট উপায় দেখতে পাচ্ছি না। এটি আইটেম 0 [2,3,2,3] বা 2 এবং 3 এর অন্য কোনও ব্যবস্থার জন্য দূরত্ব তৈরি করতে পুনরায় ব্যবস্থা করা যেতে পারে তবে এটি আইটেম 1 এবং / অথবা 2 এর বিচ্যুতির পরিবর্তন ঘটবে আমি সত্যিই জানি না "সর্বোত্তম" এই পরিস্থিতিতে আছে। আরও ঘন ঘন বা কম ঘন ঘন আইটেমগুলিতে আরও বড় বিচ্যুতি থাকা কি ভাল?

ওপি থেকে অন্যান্য সমস্যার অভাবের কারণে আমি তার বিবরণগুলি নিজের কয়েকটি তৈরি করতে ব্যবহার করেছি। তিনি তার পোস্টে বলেছেন:

একটি সাধারণ তালিকায় quant 50 আইটেম রয়েছে quant 15 বিভিন্ন মান সহ বিভিন্ন পরিমাণে।

সুতরাং আমার দুটি পরীক্ষা ছিল:

[8,7,6,5,5,4,3,3,2,2,2,1,1,1,1]  // 51 items, 15 types
[12,6,5,4,4,3,3,3,2,2,2,1,1]     // 48 items, 13 types

এবং আমার ফলাফল:

Counts: 8,7,6,5,5,4,3,3,2,2,2,1,1,1,1
Sequence: 0,1,2,3,4,5,7,6,0,1,2,8,9,10,4,3,0,1,5,2,0,1,3,4,6,7,14,11,13,12,0,2,5,1,0,3,4,2,8,10,9,1,0,7,6,5,3,4,2,1,0
Distances for item type 0: 8,8,4,10,4,8,8,1
Stddev = 2.82566363886433
Distances for item type 1: 8,8,4,12,8,8,3
Stddev = 2.76272565797339
Distances for item type 2: 8,9,12,6,11,5
Stddev = 2.5
Distances for item type 3: 12,7,13,11,8
Stddev = 2.31516738055804
Distances for item type 4: 10,9,13,11,8
Stddev = 1.72046505340853
Distances for item type 5: 13,14,13,11
Stddev = 1.08972473588517
Distances for item type 6: 17,20,14
Stddev = 2.44948974278318
Distances for item type 7: 19,18,14
Stddev = 2.16024689946929
Distances for item type 8: 27,24
Stddev = 1.5
Distances for item type 9: 28,23
Stddev = 2.5
Distances for item type 10: 26,25
Stddev = 0.5
Distances for item type 11: 51
Stddev = 0
Distances for item type 12: 51
Stddev = 0
Distances for item type 13: 51
Stddev = 0
Distances for item type 14: 51
Stddev = 0

এবং দ্বিতীয় উদাহরণের জন্য:

Counts: 12,6,5,4,4,3,3,3,2,2,2,1,1
Sequence: 0,1,2,0,3,4,7,5,6,0,1,8,9,10,0,2,0,3,4,1,0,2,6,7,5,12,11,0,1,0,3,4,2,0,1,10,8,9,0,7,5,6,0,
4,3,2,1,0
Distances for item type 0: 3,6,5,2,4,7,2,4,5,4,5,1
Stddev = 1.68325082306035
Distances for item type 1: 9,9,9,6,12,3
Stddev = 2.82842712474619
Distances for item type 2: 13,6,11,13,5
Stddev = 3.44093010681705
Distances for item type 3: 13,13,14,8
Stddev = 2.34520787991171
Distances for item type 4: 13,13,12,10
Stddev = 1.22474487139159
Distances for item type 5: 17,16,15
Stddev = 0.816496580927726
Distances for item type 6: 14,19,15
Stddev = 2.16024689946929
Distances for item type 7: 17,16,15
Stddev = 0.816496580927726
Distances for item type 8: 25,23
Stddev = 1
Distances for item type 9: 25,23
Stddev = 1
Distances for item type 10: 22,26
Stddev = 2
Distances for item type 11: 48
Stddev = 0
Distances for item type 12: 48
Stddev = 0

Comments

@ ডিডাব্লু দয়া করে আমার আপডেট দেখুন। আমি বিশ্বাস করি যে আমি কীভাবে আমার সমস্যাটি ওপি-র সমস্যার সাথে সমান এবং আমার অ্যালগোরিদম কীভাবে ওপি-র সমস্যার সমাধান দেয় show

— জিম মিসেল 27'15

ভাল জিনিস! চমৎকার আপডেটের জন্য ধন্যবাদ। সম্মত।

— DW

বেশ আকর্ষণীয়, যেমনটি আমি আগে বলেছি। ধারণার সরলতা আবেদনময়ী। এগুলি সমস্ত মনোযোগ সহকারে পড়ার সময় আমার ছিল না। আপনার সমাধানটি কি মূল প্রশ্নটির চক্রবৃত্তিকে বিবেচনা করে? এটির জন্য এটির সাথে মানিয়ে নেওয়ার কোনও উপায় থাকতে পারে তবে আমি পুরোপুরি নিশ্চিত নই he তবে এটি খারাপ।

— বাবু

@ বাবু: আমার দূরত্বের গণনাগুলি প্রায় গুটিয়ে যায়, আপনি যেমন ফলাফল দেখতে পাচ্ছেন, তবে অ্যালগরিদম নিজেই ওপি'র সমস্যার চক্রবৃত্তীয় প্রকৃতির জন্য কোনও নির্দিষ্ট ভাতা দেয় না। অথবা আমি কোনও উপায়ই দেখতে পাচ্ছি না যা করতে আমি অ্যালগরিদমকে মানিয়ে নিতে পারি। বা, এই বিষয়টির জন্য, চক্রাকার প্রকৃতি কীভাবে বিবেচনায় নেওয়া ফলাফলের উন্নতি করবে। যদিও এটি সমস্ত বিষয়কে দ্বিগুণ করার বিষয়ে বিবেচনা করা আকর্ষণীয় (অর্থাত্ [৩,২,১]] [4,৪,২]] এ পরিণত হয়েছে, যা কার্যকরভাবে একই জিনিস হবে। আমার সন্দেহ হ'ল অ্যালগরিদম অভিন্ন ফলাফল আনতে পারে।

— জিম মিসেল

Answer 2

এটি "দুর্গন্ধযুক্ত" এটি এনপি-হার্ড হতে পারে। সুতরাং, আপনার যখন এনপি-হার্ড সমস্যা রয়েছে তখন আপনি কী করবেন? এটিতে একটি হিউরিস্টিক নিক্ষেপ করুন, বা একটি আনুমানিক অ্যালগরিদম, বা একটি স্যাট সমাধানকারী ব্যবহার করুন।

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

$t$$\le t$$\le t^2$$x_{i,j}$$x_{i,j}$$i$$j$$\le t^2$

তবে আমি আপনাকে সিমুলেটেড অ্যানিলিং দিয়ে শুরু করার পরামর্শ দেব। এটিই আমি প্রথম চেষ্টা করব, কারণ আমি মনে করি এটি কেবল কার্যকর হতে পারে।

Comments

আপনার পরামর্শগুলি কি এই ধরণের সময়সূচী সমস্যাগুলি সমাধান করার মানক উপায়। আমি অনুমান করি যে এর জন্য কয়েকটি বাণিজ্যিক সফ্টওয়্যার রয়েছে। তারা কীভাবে এটি পরিচালনা করবে?

— বাবু

@ বাবু, দুর্দান্ত প্রশ্ন - আমার কোনও ধারণা নেই!

— DW

আমি আমার অ্যালগরিদমের বিশদটি আরও বিকাশ করেছি, তবে আমি সন্দেহ করি যে বিদ্যমান অ্যাপ্লিকেশনগুলি এটি ব্যবহার করবে। প্রকৃতপক্ষে, আমি এমনকি আশ্চর্যও করি যে নির্ধারিত অ্যাপ্লিকেশনগুলি এই ধরণের কোনও সমস্যা নিয়ে কাজ করে। আমি এসই.সফটওয়্যারিক্সে তথ্য চাইছি, আমি এখানে যেমন মন্তব্য করেছি, তা ছাড়া আমি এখানে কীভাবে প্রশ্ন জিজ্ঞাসা করব তা আমি দেখতে পাচ্ছি না।

— বাবু

সর্বোত্তম সমাধান দ্বারা NP-কঠিন হতে পারে। তবে একটি যথেষ্ট কার্যক্ষম সমাধান হ'ল ও (এন লগ কে), যেখানে এন হল আইটেমগুলির মোট সংখ্যা এবং কে আইটেমের ধরণের সংখ্যা। আমার উত্তর, এবং আমার লিঙ্কযুক্ত ব্লগ পোস্ট দেখুন।

— জিম মিশেল

Answer 3

একটি হিউরিস্টিক অ্যালগরিদমের স্কেচ

আমার এই সমস্যার কোনও সঠিক সমাধান নেই। তবে রাফেলের মন্তব্য যেহেতু এটিকে পার্টিশনের সমস্যার মতো মনে হচ্ছে, যার জন্য হিউরিস্টিক অ্যালগরিদমগুলি বিকাশিত হয়েছে, তাই আমি একটি হিউরিস্টিক পদ্ধতির চেষ্টা করব। এটি কেবল একটি হিউরিস্টিক অ্যালগরিদমের স্কেচ।

$v$$n$$[1..n]$$i$$n_i$

$n$$vn$$vn/n$$v$

আমাদের উদ্দেশ্য হ'ল দূরত্বের স্ট্যান্ডার্ড বিচ্যুতি হ্রাস করা, যা দূরত্বের বিচ্যুতির স্কোয়ারের যোগফলকে কমিয়ে আনা, অর্থাৎ মধ্যে পার্থক্যের পরিমাণ of$v$

$i$$n/n_i$$n\mod n_i$$n/n_i$

এটি আমাদের অ্যালগরিদমকে গাইড করবে।

$n$

$i$$|n/n_i -v|$

এটি প্রথমে খুব কম সংখ্যক ঘটনার সাথে একটি মান হতে পারে। আমি মনে করি এটি আসলে কোনও পার্থক্য করে না, যেহেতু স্লট দখল করে তৈরি করা সীমাবদ্ধতাগুলি ভাল মানের (?) সংখ্যার তুলনায় হয়।

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

বাকী স্লটগুলিতে একটি মান উপস্থিতির স্থাননির্ধারণ একটি গতিশীল প্রোগ্রামিং অ্যালগরিদম দিয়ে করা যেতে পারে, যাতে দুটি পজিশনের মধ্যে একই সংখ্যার মান স্থাপনকারী গণনাগুলিকে মার্জ করা যায়, কেবলমাত্র স্ট্যান্ডার্ড বিচ্যুতির ক্ষেত্রে ন্যূনতম অবদান রয়েছে এমনগুলি রেখে ( তাদের বিচ্যুতির স্কোয়ারের যোগফলের জন্য সর্বনিম্ন মান)।

$v$

$j$$|n/n_j -v|$

তারপরে আপনি বাকী স্লটে সিঙ্গলটন মান রেখেছেন।

আমি বিশ্বাস করি এটি সাধারণত যুক্তিসঙ্গত সমাধান দিতে পারে, তবে এটি কীভাবে প্রমাণ করতে হবে বা অনুকূল সমাধানের সাথে ফাঁকটি অনুমান করা যায় তা সম্পর্কে এখনও আমার কোনও ধারণা নেই।

Comments

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

— মোড়গুলি

$v$$n/v$$V$

আপনার অর্থ কি, 10 টি মান [0, 0, 0, 0, 1, 1, 1, 2, 2, 3]এবং v সহ একটি তালিকার জন্য 4আমরা প্রথম মানগুলি 1( 10/3 = 3.33, v এর নিকটতম), তারপরে 2( 10/2 = 5, পরবর্তী নিকটতম), তারপর 0( 10/4 = 2.5) রাখব ? অথবা: আপনি "মান ভি থেকে দূরত্বের হ্রাস হওয়া গড় বিচ্যুতি" এর উদাহরণ দিতে পারেন?

— মোড়গুলি

না, আমি ঠিক এর বিপরীতে করি। আপনার উদাহরণটি বিবেচনা করে, অবস্থান নির্ধারণের ক্রমটি প্রথমে O কারণ যেহেতু তার গড় দূরত্ব ২,৫ সবচেয়ে বেশি বিচ্যুত হয় ভি = ৪ থেকে, তারপরে ২, তারপরে ১, এবং সিঙ্গেলটন ৩ - - - কি ইউপু পরামর্শ দিচ্ছেন যে আরও কিছু পরিষ্কার করে আমার আবার লিখতে হবে? এই কৌশলটির জন্য আমার ব্যাখ্যার অংশ?

— বাবু

না ঠিক আছে. আমি এই ধারণাটি বরাবর কিছু চেষ্টা করব এবং ফিরে রিপোর্ট করব।

— মোড়গুলি

Answer 4

দেখে মনে হচ্ছে আমি পার্টিতে খুব দেরি করেছি, তবে কেউ যদি আবার এ নিয়ে যায় তবে পোস্টিং। আমার সমাধান @ বাবুর প্লাসের মতো। আজকের আগে, আমার এম্বেড করা সিস্টেমে একটি শিডিয়ুলিং সমস্যা ছিল যা আমাকে এই থ্রেডে নিয়ে গেছে। আমার সি-তে আমার সমস্যার সাথে সম্পর্কিত একটি বাস্তবায়ন রয়েছে, তবে আমি বুঝতে পেরেছিলাম যে আমি পাইথনে আরও জেনেরিক সমাধান এখানে পোস্ট করেছি (সি সংস্করণটি জটিল যে আমি নিজেকে একটি ছোট, স্থির আকারের স্ট্যাকের মধ্যে সীমাবদ্ধ রেখেছি এবং কোনও স্মৃতি নেই) বরাদ্দ, সুতরাং আমি পুরো অ্যালগরিদমকে জায়গায় রাখি। নীচে ব্যবহৃত অ্যান্টি-এলিয়জিং কৌশলটি এমন কিছু যা আপনি 2 বিট রঙের স্ক্রিনে একটি লাইন আঁকার জন্য ব্যবহার করতে পারেন। নির্দিষ্ট সমাধানের চেয়ে জিম মিশেল ব্যবহার করা ইনপুটগুলির জন্য স্ট্যান্ডার্ড বিচ্যুতির যোগটি ব্যবহার করে যখন পরিমাপ করা হয় তখন এখানে অ্যালগোরিদম একটি কম স্কোর অর্জন করে (যেমন, আরও ভাল)।

def generate(item_counts):
'''item_counts is a list of counts of "types" of items. E.g., [3, 1, 0, 2] represents
   a list containing [1, 1, 1, 2, 4, 4] (3 types of items/distinct values). Generate
   a new list with evenly spaced values.'''
# Sort number of occurrences by decreasing value.
item_counts.sort(reverse=True)
# Count the total elements in the final list.
unplaced = sum(item_counts)
# Create the final list.
placements = [None] * unplaced

# For each type of item, place it into the list item_count times.
for item_type, item_count in enumerate(item_counts):
    # The number of times the item has already been placed
    instance = 0
    # Evenly divide the item amongst the remaining unused spaces, starting with
    # the first unused space encountered.
    # blank_count is the number of unused spaces seen so far and is reset for each
    # item type.
    blank_count = -1
    for position in range(len(placements)):
        if placements[position] is None:
            blank_count += 1
            # Use an anti-aliasing technique to prevent bunching of values.
            if blank_count * item_count // unplaced == instance:
                placements[position] = item_type
                instance += 1
    # Update the count of number of unplaced items.
    unplaced -= item_count

return placements

জন্য ফলাফল

Input counts: 8,7,6,5,5,4,3,3,2,2,2,1,1,1,1
Sum of stddev: 16.8 (vs. 22.3 via Jim Mischel)

Input of counts: 12,6,5,4,4,3,3,3,2,2,2,1,1
Sum of stddev: 18.0 (vs. 19.3 via Jim Mischel)

@ মোরেস দ্বারা নির্দিষ্ট ফর্মের ইনপুটগুলি দেওয়া হলে, কেউ এই ফাংশন দ্বারা ও (এন) পদক্ষেপে এটি ব্যবহারযোগ্য একটি ফর্মে রূপান্তর করতে পারেন বিগ ওমেগা (এন * লগ (এন)) মেমরির বিটগুলি যেখানে n আইটেমের সংখ্যা ( 255 টি উপাদান সহ একটি তালিকায় আপনার পুনরাবৃত্তি গণনাগুলির সাথে সমান্তরাল অ্যারে রেখে 255 অতিরিক্ত বাইটের বেশি প্রয়োজন হবে না। পর্যায়ক্রমে, ও (1) অতিরিক্ত মেমরির সাহায্যে কেউ জায়গা জুড়ে এক ধরণের জুড়ি সম্পাদন করতে পারে।

দ্রষ্টব্য

import numpy
import collections

def evaluate(l):
    '''Given a distribution solution, print the sum of stddevs for each type in the solution.'''
    l2 = l * 2
    distances = [None] * len(l)
    distance_dict = collections.defaultdict(list)
    for i in range(len(l)):
        distances[i] = l2.index(l[i], i + 1) - i
        distance_dict[l[i]].append(l2.index(l[i], i + 1) - i)

    keys = list(distance_dict.keys())
    keys.sort()
    score = 0
    # Calculate standard deviations for individual types.
    for key in keys:
        sc = numpy.std(distance_dict[key])
        score += sc
    print('Stddev sum: ', score)

সম্পাদনা: আমি জানি এই সমাধানটি কাউন্টারেক্সেক্স দ্বারা সর্বোত্তম আউটপুট উত্পাদন করে না। একটি ইনপুট [6, 2, 1]উৎপন্ন [0, 1, 0, 0, 2, 0, 0, 1, 0]; একটি ভাল সমাধান হয় [0, 0, 1, 0, 2, 0, 0, 1, 0]।

Comments

আমি বিশ্বাস করি যে আমি কোড অ্যালগরিদমকে কোড মন্তব্যে এবং উপস্থার মধ্যে অ্যালগরিদমের ভিত্তিকে ব্যাখ্যা করেছি।

— লুঙ্গজ

আমি আপনার অ্যালগরিদমের পিছনে ধারণাগুলির একটি স্ব-সংযুক্ত বিবরণ এবং অ্যালগরিদমের জন্য সংক্ষিপ্ত সিউডোকোড দেখতে পছন্দ করতাম। বর্তমানে আমি প্রবর্তনীয় পাঠ্যে যা দেখছি তা হ'ল (১) আপনার পন্থা @ বাবুর মতো এবং (২) এটি একটি অ্যান্টি-এলিয়জিং কৌশল (কোনওভাবে) ব্যবহার করে। এছাড়াও, এখানে প্রত্যেকে পাইথন পড়ে না। যাইহোক, এটি একটি পুরানো উত্তর, তাই আপনি যদি এটির উন্নতি করতে চান না তবে আমি বুঝতে পেরেছি, তবে আমি কেবল এই সাইটের জন্য আমাদের প্রত্যাশাগুলি লক্ষ্য করছি - কেবল আপনার জন্য নয়, অন্যদের জন্য যারা এই পৃষ্ঠাটি জুড়ে চলতে পারে ভবিষ্যতের এবং উত্তর দিতে ঝুঁকতে।

— ডিডাব্লিউ

Answer 5

এই অ্যালগরিদম পূর্ণসংখ্যার অ্যারের সাথে কাজ করে, যেখানে প্রতিটি পূর্ণসংখ্যা একটি পৃথক বিভাগের প্রতিনিধিত্ব করে। এটি প্রতিটি বিভাগের জন্য পৃথক অ্যারে তৈরি করে। উদাহরণস্বরূপ, প্রারম্ভিক অ্যারেটি যদি [1, 1, 1, 2, 2, 3] হয় তবে এটি তিনটি অ্যারে তৈরি করবে, [3], [2, 2], [1, 1, 1]

সেখান থেকে এটি দুটি ছোট ছোট অ্যারেগুলিকে পুনরাবৃত্তভাবে একত্রিত করে (উদাহরণস্বরূপ, [3], এবং [২,২]) এবং ছোট অ্যারের উপাদানগুলির স্থান নির্ধারণ করে বেশিরভাগ সংখ্যার অনুপাতের ভিত্তিতে বৃহত্তর বনাম ছোট বিভাগগুলির সংঘটনগুলি। এই উদাহরণে, আমরা [2,3,2] এর সাথে বয়ে যাব। তারপরে এটি এই অ্যারেটিকে আরও ছোট অ্যারে হিসাবে ব্যবহার করবে যা পরের বৃহত অ্যারেতে একত্রিত হবে, যতক্ষণ না কেবলমাত্র একটি অ্যারে বাকি থাকে।

<?php
/**
 *This will separete the source array into separate arrays for each category
 */
function splitArrayByCategory($source) {

    //  index is the category, value is the tally
    $categoryCounts  = array_count_values($source);

    // Sort that list, keep index associations
    asort($categoryCounts);

    // build separate arrays for each category
    // index = order, smaller index = smaller category count
    // value = array of each category
    $separated = array();
    foreach ($categoryCounts as $category => $tally)
        $separated[] = array_fill(0, $tally, $category);

    return $separated;
}

/**
 * Will take the array of arrays generated by splitArrayByCategory, and merge
 * them together so categories are evenly distributed
 */
function mergeCategoryArrays($categoryArray) {

    // How many entries are there, for the smallest & second smallest categories
    $smallerCount = count($categoryArray[0]);
    $largerCount  = count($categoryArray[1]);

    // Used to determine how much space there should be between these two categories
    $space = $largerCount/$smallerCount;

    // Merge the array of the smallest category into the array of the second smallest
    foreach ($categoryArray[0] as $domIndex => $domain) {
        // Where should we splice the value into the second array?
        $location = floor($domIndex*$space+$domIndex+($space/2));
        // actually perform the splice
        array_splice($categoryArray[1], $location, 0, $domain);
    }

    // remove the smallest domain we just spliced into the second smallest
    unset($categoryArray[0]);

    // reset the indexes
    $categoryArray = array_values($categoryArray);

    // If we have more than one index left in the categoryArray (i.e. some things
    // still need to get merged), let's re-run this function,
    if (count($categoryArray)>1)
        $categoryArray = mergeCategoryArrays($categoryArray);

    return $categoryArray;
}

// The sample list we're working with.
// each integer represents a different category
$listSample = [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,6,6,7,7,7,7];

// Split the sample list into separate arrays for each category
$listSplitByCategory = splitArrayByCategory($listSample);

// If there are not at least two categories, what's the point?
if (count($listSplitByCategory) < 2) throw new Exception("You need at least two categories");

// perform the actual distribution of categories.
$listEvenlyDistributed = mergeCategoryArrays($listSplitByCategory)[0];

// Display the array before and after the categories are evenly distributed
for ($i=0; $i<count($listSample); $i++) {
    print $listSample[$i].",";
    print $listEvenlyDistributed[$i]."\n";
}

Comments

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

— ডিডাব্লু

কম্পিউটার বিজ্ঞানে স্বাগতম ! কেবলমাত্র আপনি সচেতন না হলে বা আপনি একটি মুহুর্তের জন্য ভুলে গিয়েছিলেন, একটি বিশেষ ভাষায় কোড পড়ার বিষয়টি আমাদের কাছে থাকা সবচেয়ে কঠিন কাজগুলির মধ্যে একটি, যদিও কোডটি নিজেই লিখেছিলেন। এই কারণেই আমরা এই সাইটে সত্যিকারের কোডটির খুব বেশি প্রশংসা করি না এর একটি অংশ, যদিও এটি শিথিলভাবে লিখিত সিউডোকোডের চেয়ে অনেক বেশি কাজের প্রতিনিধিত্ব করতে পারে। অবশ্যই, আমি সমস্ত বাস্তব কোডিং কোডকে প্রশংসা করি যা তাৎক্ষণিকভাবে চালানো বা পাকানো যায়।

— এপাস.জ্যাক

ব্যাখ্যা আছে। মন্তব্যযুক্ত প্রদর্শন কোডে; যা এপিএলের মতো কিছু প্রত্নতাত্ত্বিক বাক্য গঠনতে নয়, তবে সিউডো কোডের যথেষ্ট পরিমাণে সিনট্যাক্স বোঝা সহজ। আমার ব্যাখ্যা মনোস্পেস ফন্টে না থাকলে এটি কী সহায়তা করবে?

— vtim

হ্যাঁ। এটা সাহায্য করে। সবাই পিএইচপি পড়ে না, সম্ভবত সবাই মন্তব্য কি তা নির্ধারণ করতে পারে না (সম্ভবত এটি স্ট্রো ম্যান আর্গুমেন্ট) অথবা কোডের ব্লকটি পড়তে এবং এটি ব্যাখ্যা করতে চায় না, তবে ধারণাটি পড়ুন, যা আপনি শীর্ষে অন্তর্ভুক্ত করেছেন এবং এটা সব বলে। আমার কাছ থেকে +1 আপনার কোডটি পরিষ্কার এবং ভাল-ডকুমেন্টেড, তবে আমরা কেবল কোডিং সাইট নই, সুতরাং এখানে পাঠ্য বিবরণ গুরুত্বপূর্ণ। আপনার সম্পাদনার জন্য আপনাকে ধন্যবাদ।

— এভিল

Answer 6

এএনএসআই সি কোড

এই কোডটি এন ডাইমেনশনাল স্পেসে একটি সরল রেখা কল্পনা করে কাজ করে (যেখানে এন বিভাগগুলির সংখ্যা) যেখানে দিকনির্দেশক ভেক্টর (ভি 1, ভি 2, ..., ভিআই, ... ভিএন) সহ সংখ্যার যেখানে সংখ্যার সংখ্যা বিভাগে আইটেম i। উত্স থেকে শুরু করে লাইনটির পরবর্তী নিকটতম পয়েন্টটি সন্ধান করা। [0 0 0 0 0 1 1 1 2 2 2 3] উদাহরণ ব্যবহার করে এটি ফলাফল [0 1 2 0 3 1 0 2 0 1 2 0] করে। লুংজের উদাহরণ ব্যবহার করে [0 0 0 0 0 0 1 1 2] আমরা পেয়েছি [0 1 0 0 2 0 0 1 0], যা লুঙ্গজের ফলাফলের মতোই।

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

# নির্ধারণ করা MAXCATEGORIES 100

int main () i int i = 0; int j = 0; int catsize = 0; int ভেক্টর [MAXCATEGORIES]; ইন্ট পয়েন্ট [MAXCATEGORIES]; int বিভাগগুলি = 0; int টোটালাইটাম = 0; int best = 0; দীর্ঘ d2 = 0L; দীর্ঘ ভিপি = 0 এল; দীর্ঘ ভি 2 = 0 এল; দীর্ঘ ডেল্টা = 0 এল; দীর্ঘ বিটা = 0 এল;

printf("Enter the size of each category (enter 0 to finish):\r\n");
do
{
    catsize = 0;
    #ifdef _MSVC_LANG
            scanf_s("%d", &catsize);
    #else
            scanf("%d", &catsize)
    #endif
    if (catsize > 0)
    {
        vector[categories] = catsize;
        totalitems += catsize;
        categories++;
    }
} while (catsize > 0);

for (i = 0; i < categories; i++)
{
    v2 += vector[i] * vector[i];
    point[i] = 0;
}

for (i = 0; i < totalitems; i++)
{
    for (j = 0; j < categories; j++)
    {
        delta = (2 * point[j] + 1)*v2 - (2 * vp + vector[j])*vector[j];
        if (j == 0 || delta < beta)
        {
            best = j;
            beta = delta;
        }
    }
    point[best]++;
    vp += vector[best];
    printf("%c ", best + '0');  // Change '0' to 'A' if you like letters instead
}
return 0;

}

Comments

সাইটে স্বাগতম! ফর্ম্যাটিং-ভিত্তিক, আপনার কোডের প্রতিটি লাইন চারটি স্পেস সহ ইনডেন্ট করা দরকার যাতে সিস্টেমটি মার্ক-আপটি ডান পায়। সাধারণভাবে, আমরা প্রশ্নের উত্তর হিসাবে কোডের বড় ব্লকগুলি খুঁজছি না এবং বিশেষত, আপনার ডেটা এন্ট্রি রুটিনগুলি এখানে কিছু যুক্ত করছে না। আপনার পোস্টের শীর্ষে আপনার কিছু ব্যাখ্যা রয়েছে, তবে এটির উপর প্রসারিত এবং কোডটি কেটে ফেলা ভাল।

— ডেভিড রিচার্বি

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

— ডিডাব্লু

Answer 7

আমার সমাধান:

    vc = train['classes'].value_counts()
    vc = dict(sorted(vc.items()))
    df = pd.DataFrame()
    train['col_for_sort'] = 0.0

    i=1
    for k,v in vc.items():
        step = train.shape[0]/v
        indent = train.shape[0]/(v+1)
        df2 = train[train['classes'] == k].reset_index(drop=True)
        for j in range(0, v):
        df2.at[j, 'col_for_sort'] = indent + j*step + 0.0001*i   
    df= pd.concat([df2,df])
    i+=1

    train = df.sort_values('col_for_sort', ascending=False).reset_index(drop=True)
    del train['col_for_sort']

Comments

আপনার অ্যালগরিদম বর্ণনা করতে দয়া করে সিউডোকোড (কিছু প্রয়োজনীয় মন্তব্য সহ) ব্যবহার করুন।

— xskxzr

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

— ডিডাব্লু