সি # বাছাই করুন এবং অর্ডারবিয়ের তুলনা করুন

Question

আমি বাছাই বা অর্ডারবাই ব্যবহার করে একটি তালিকা বাছাই করতে পারি। কোনটি দ্রুত? দুজনেই কি একই অ্যালগরিদমে কাজ করছেন?

List<Person> persons = new List<Person>();
persons.Add(new Person("P005", "Janson"));
persons.Add(new Person("P002", "Aravind"));
persons.Add(new Person("P007", "Kazhal"));

1।

persons.Sort((p1,p2)=>string.Compare(p1.Name,p2.Name,true));

2।

var query = persons.OrderBy(n => n.Name, new NameComparer());

class NameComparer : IComparer<string>
{
    public int Compare(string x,string y)
    {
      return  string.Compare(x, y, true);
    }
}

Comments

আমি বিশ্বাস করতে পারি না যে উত্তরের উত্তরগুলির মধ্যে এর কোনওটিই উল্লেখ করা হয়নি, তবে সবচেয়ে বড় পার্থক্যটি হ'ল: অর্ডারবাই অ্যারে বা তালিকার একটি সাজানো অনুলিপি তৈরি করে, যখন সাজান এটির জায়গায় এটি সাজান orts

— PRMan

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

— একলাব্য

@ পিআরমন নোপ, অর্ডারবাই একটি অলস গণনার সৃষ্টি করে। আপনি যদি ফিরিয়ে দেওয়া গণনার জন্য টোলিস্টের মতো কোনও কল করেন তবেই আপনি একটি সাজানো অনুলিপি পান।

— স্টুয়ার্ট

@ স্টিওয়ার্ট, আপনি অ্যারে.কপি বা সংগ্রহের বিষয়ে বিবেচনা করবেন না System টেমিলেটে [[] বাফার ইন সিস্টেম.কোয়ার / সিস্টেম / লিনক / এনিউমারেবল সিগুলিকে অনুলিপি হিসাবে বিবেচনা করুন? এবং আপনি যদি IENumerable এ টোললিস্ট কল করেন তবে মুহুর্তে একবারে 3 টি কপি মেমরিতে থাকতে পারে। এটি খুব বড় অ্যারেগুলির জন্য একটি সমস্যা, যা আমার বক্তব্যের অংশ ছিল। এছাড়াও, যদি আপনার একই ধরণের একাধিকবার প্রয়োজন হয়, তবে স্থায়ীত্বের কারণে বার বার তালিকায় বাছাই করার চেয়ে একবার স্থানে বাছাই করা অনেক বেশি দক্ষ।

— PRMan

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

— স্টুয়ার্ট

Answer 1

কেন এটি পরিমাপ করবেন না:

class Program
{
    class NameComparer : IComparer<string>
    {
        public int Compare(string x, string y)
        {
            return string.Compare(x, y, true);
        }
    }

    class Person
    {
        public Person(string id, string name)
        {
            Id = id;
            Name = name;
        }
        public string Id { get; set; }
        public string Name { get; set; }
    }

    static void Main()
    {
        List<Person> persons = new List<Person>();
        persons.Add(new Person("P005", "Janson"));
        persons.Add(new Person("P002", "Aravind"));
        persons.Add(new Person("P007", "Kazhal"));

        Sort(persons);
        OrderBy(persons);

        const int COUNT = 1000000;
        Stopwatch watch = Stopwatch.StartNew();
        for (int i = 0; i < COUNT; i++)
        {
            Sort(persons);
        }
        watch.Stop();
        Console.WriteLine("Sort: {0}ms", watch.ElapsedMilliseconds);

        watch = Stopwatch.StartNew();
        for (int i = 0; i < COUNT; i++)
        {
            OrderBy(persons);
        }
        watch.Stop();
        Console.WriteLine("OrderBy: {0}ms", watch.ElapsedMilliseconds);
    }

    static void Sort(List<Person> list)
    {
        list.Sort((p1, p2) => string.Compare(p1.Name, p2.Name, true));
    }

    static void OrderBy(List<Person> list)
    {
        var result = list.OrderBy(n => n.Name, new NameComparer()).ToArray();
    }
}

আমার কম্পিউটারে যখন রিলিজ মোডে সংকলিত হয় তখন এই প্রোগ্রামটি মুদ্রণ করে:

Sort: 1162ms
OrderBy: 1269ms

---

হালনাগাদ:

@ স্টেফান দ্বারা প্রস্তাবিত হিসাবে একটি বড় তালিকা কয়েকবার বাছাইয়ের ফলাফল:

List<Person> persons = new List<Person>();
for (int i = 0; i < 100000; i++)
{
    persons.Add(new Person("P" + i.ToString(), "Janson" + i.ToString()));
}

Sort(persons);
OrderBy(persons);

const int COUNT = 30;
Stopwatch watch = Stopwatch.StartNew();
for (int i = 0; i < COUNT; i++)
{
    Sort(persons);
}
watch.Stop();
Console.WriteLine("Sort: {0}ms", watch.ElapsedMilliseconds);

watch = Stopwatch.StartNew();
for (int i = 0; i < COUNT; i++)
{
    OrderBy(persons);
}
watch.Stop();
Console.WriteLine("OrderBy: {0}ms", watch.ElapsedMilliseconds);

ছাপে:

Sort: 8965ms
OrderBy: 8460ms

এই দৃশ্যে দেখে মনে হচ্ছে অর্ডারবাই আরও ভাল পারফর্ম করে।

---

UPDATE2:

এবং এলোমেলো নাম ব্যবহার:

List<Person> persons = new List<Person>();
for (int i = 0; i < 100000; i++)
{
    persons.Add(new Person("P" + i.ToString(), RandomString(5, true)));
}

কোথায়:

private static Random randomSeed = new Random();
public static string RandomString(int size, bool lowerCase)
{
    var sb = new StringBuilder(size);
    int start = (lowerCase) ? 97 : 65;
    for (int i = 0; i < size; i++)
    {
        sb.Append((char)(26 * randomSeed.NextDouble() + start));
    }
    return sb.ToString();
}

উৎপাদনের:

Sort: 8968ms
OrderBy: 8728ms

তবুও অর্ডারবি দ্রুততর

Comments

আমি মনে করি, এটি একটি খুব ছোট তালিকা (3 টি আইটেম) 1000000 বার বাছাই করা বা খুব বড় একটি তালিকা (1000000 আইটেম) কয়েকবার সাজানোর চেয়ে অনেক আলাদা। উভয়ই খুব প্রাসঙ্গিক। অনুশীলনে, মাঝারি আকারের তালিকা (মাঝারিটি কী? ... আসুন এখনকার জন্য 1000 আইটেম বলি) সবচেয়ে আকর্ষণীয়। আইএমএইচও, 3 টি আইটেমের সাথে তালিকাগুলি বাছাই করা খুব অর্থবহ নয়।

— স্টিফান স্টেইনেগার

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

— এরিক লিপার্ট 16

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

— ফগ

LINQইন-প্লেস List<T>.Sortবাস্তবায়নের তুলনায় অতিরিক্ত মেমরি ব্যয় করতে হবে এই বিষয়টি বিবেচনা করে এই ফলাফলগুলি বেশ অবাক করে চলেছে IM তারা আরও নতুন। নেট সংস্করণে এটিকে উন্নতি করেছে কিনা তা সম্পর্কে আমি নিশ্চিত নই, তবে আমার মেশিনে (i7 তৃতীয় জেন 64৪-বিট। নেট ) Sort.৪ রিলিজ) OrderByসমস্ত ক্ষেত্রে ছাপিয়ে গেছে । তদ্ব্যতীত, OrderedEnumerable<T>উত্স কোডটি দেখে মনে হয় এটি শেষ পর্যন্ত কুইকোর্টকে কল করার আগে সূচকগুলির অ্যারেটি সাজানোর জন্য তিনটি অতিরিক্ত অ্যারে তৈরি করে (প্রথমে একটি Buffer<T>, তারপরে অনুমিত কীগুলির একটি অ্যারে, পরে সূচকের একটি অ্যারে) তৈরি করে।

— গ্রো

... এবং তারপরেও এই সমস্ত কিছুর পরেও ToArrayকল রয়েছে যা ফলাফলগুলি তৈরি করে। মেমোরি অপারেশন এবং অ্যারে ইনডেক্সিং অবিশ্বাস্যভাবে দ্রুত অপারেশন, তবে আমি এখনও এই ফলাফলগুলির পিছনে যুক্তি খুঁজে পাচ্ছি না।

— গ্রো

Answer 2

না, তারা একই অ্যালগরিদম নয়। প্রারম্ভিকদের জন্য, লিনিক্যু স্থিতিশীলOrderBy হিসাবে নথিভুক্ত করা হয়েছে (অর্থাত্ যদি দুটি আইটেম একই থাকে তবে সেগুলি তাদের মূল ক্রমে উপস্থিত হবে)।Name

আপনি ক্যোয়ারী বনাম এটি বার বার পুনরাবৃত্তি করবেন কিনা তার উপরও নির্ভর করে (লিনকু-টু-অবজেক্টস, আপনি যদি ফলাফলটি বাফার না করেন তবে প্রতি পুনরায় অর্ডার দেবেন foreach)।

জন্য OrderByক্যোয়ারী, আমিও ব্যবহার করতে প্রলুব্ধ করা হবে:

OrderBy(n => n.Name, StringComparer.{yourchoice}IgnoreCase);

( {yourchoice}এক CurrentCulture, Ordinalবা জন্য InvariantCulture)।

List<T>.Sort

এই পদ্ধতিতে অ্যারে.সোর্ট ব্যবহার করে, যা কুইকসোর্ট অ্যালগরিদম ব্যবহার করে। এই প্রয়োগটি একটি অস্থিতিশীল বাছাই করে; এটি হ'ল যদি দুটি উপাদান সমান হয় তবে তাদের ক্রমটি সংরক্ষণ করা যাবে না। বিপরীতে, একটি স্থিতিশীল বাছাই সমান যে উপাদানগুলির ক্রম সংরক্ষণ করে।

Enumerable.OrderBy

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

Comments

আপনি যদি Enumerable.OrderByঅভ্যন্তরীণ বাস্তবায়নের জন্য উন্মুক্ত ক্রস করতে এবং ডিল নিট করার জন্য। নেট প্রতিফলক বা আইএলএসপি ব্যবহার করেন তবে আপনি দেখতে পাচ্ছেন যে অর্ডারবাই বাছাই করা অ্যালগরিদমটি কুইকসোর্টের একটি রূপ যা স্থিতিশীল বাছাই করে। (দেখুন System.Linq.EnumerableSorter<TElement>।) সুতরাং, Array.Sortএবং Enumerable.OrderByউভয়ই O (N লগ এন) সম্পাদনের সময় আশা করতে পারে , যেখানে সংগ্রহের উপাদানগুলির সংখ্যা N।

— জন বেয়ার

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

— মুকুস

@ মুকুস কল্পনা করুন যে আপনি কোনও কোম্পানির ঠিকানা বই নাম অনুসারে বাছাই করেছেন (বা প্রকৃতপক্ষে জন্ম তারিখ অনুসারে) - অনুলিপিটি অনুলিপি হতে চলেছে। প্রশ্নটি শেষ পর্যন্ত: তাদের জন্য কী ঘটে? উপ-আদেশ সংজ্ঞায়িত করা হয়?

— মার্ক গ্র্যাভেল

Answer 3

দারিন দিমিত্রভের উত্তরটি দেখায় যে ইতিমধ্যে সাজানো ইনপুটটির মুখোমুখি হওয়ার OrderByচেয়ে কিছুটা দ্রুত List.Sort। আমি তার কোডটি পরিবর্তন করেছি যাতে এটি বারবার অরসোর্টড ডেটা বাছাই করে এবং OrderByবেশিরভাগ ক্ষেত্রে সামান্য ধীর হয়।

তদ্ব্যতীত, OrderByপরীক্ষাগুলি ToArrayলিনক এনুমিরেটরকে জোর করার জন্য ব্যবহার করে, তবে এটি স্পষ্টতই একটি প্রকার ( Person[]) দেয় যা ইনপুট ধরণের ( List<Person>) থেকে পৃথক । তাই আমি এর ToListপরিবর্তে ব্যবহার করে পরীক্ষাটি পুনরায় চালিয়েছি ToArrayএবং আরও বড় পার্থক্য পেয়েছি:

Sort: 25175ms
OrderBy: 30259ms
OrderByWithToList: 31458ms

কোড:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;

class Program
{
    class NameComparer : IComparer<string>
    {
        public int Compare(string x, string y)
        {
            return string.Compare(x, y, true);
        }
    }

    class Person
    {
        public Person(string id, string name)
        {
            Id = id;
            Name = name;
        }
        public string Id { get; set; }
        public string Name { get; set; }
        public override string ToString()
        {
            return Id + ": " + Name;
        }
    }

    private static Random randomSeed = new Random();
    public static string RandomString(int size, bool lowerCase)
    {
        var sb = new StringBuilder(size);
        int start = (lowerCase) ? 97 : 65;
        for (int i = 0; i < size; i++)
        {
            sb.Append((char)(26 * randomSeed.NextDouble() + start));
        }
        return sb.ToString();
    }

    private class PersonList : List<Person>
    {
        public PersonList(IEnumerable<Person> persons)
           : base(persons)
        {
        }

        public PersonList()
        {
        }

        public override string ToString()
        {
            var names = Math.Min(Count, 5);
            var builder = new StringBuilder();
            for (var i = 0; i < names; i++)
                builder.Append(this[i]).Append(", ");
            return builder.ToString();
        }
    }

    static void Main()
    {
        var persons = new PersonList();
        for (int i = 0; i < 100000; i++)
        {
            persons.Add(new Person("P" + i.ToString(), RandomString(5, true)));
        } 

        var unsortedPersons = new PersonList(persons);

        const int COUNT = 30;
        Stopwatch watch = new Stopwatch();
        for (int i = 0; i < COUNT; i++)
        {
            watch.Start();
            Sort(persons);
            watch.Stop();
            persons.Clear();
            persons.AddRange(unsortedPersons);
        }
        Console.WriteLine("Sort: {0}ms", watch.ElapsedMilliseconds);

        watch = new Stopwatch();
        for (int i = 0; i < COUNT; i++)
        {
            watch.Start();
            OrderBy(persons);
            watch.Stop();
            persons.Clear();
            persons.AddRange(unsortedPersons);
        }
        Console.WriteLine("OrderBy: {0}ms", watch.ElapsedMilliseconds);

        watch = new Stopwatch();
        for (int i = 0; i < COUNT; i++)
        {
            watch.Start();
            OrderByWithToList(persons);
            watch.Stop();
            persons.Clear();
            persons.AddRange(unsortedPersons);
        }
        Console.WriteLine("OrderByWithToList: {0}ms", watch.ElapsedMilliseconds);
    }

    static void Sort(List<Person> list)
    {
        list.Sort((p1, p2) => string.Compare(p1.Name, p2.Name, true));
    }

    static void OrderBy(List<Person> list)
    {
        var result = list.OrderBy(n => n.Name, new NameComparer()).ToArray();
    }

    static void OrderByWithToList(List<Person> list)
    {
        var result = list.OrderBy(n => n.Name, new NameComparer()).ToList();
    }
}

Comments

আমি এখন লিনকপ্যাড 5 (। নেট 5) এ পরীক্ষার কোডটি চালিত করি এবং OrderByWithToListএকই হিসাবে সময় নেয় OrderBy।

— dovid

Answer 4

আমার মনে হয় এটা মধ্যে অন্য পার্থক্য খেয়াল করা জরুরী Sortএবং OrderBy:

ধরুন এখানে একটি Person.CalculateSalary()পদ্ধতি রয়েছে , যা অনেক সময় নেয়; সম্ভবত একটি বৃহত তালিকা বাছাইয়ের ক্রিয়াকলাপের চেয়েও বেশি।

তুলনা করা

// Option 1
persons.Sort((p1, p2) => Compare(p1.CalculateSalary(), p2.CalculateSalary()));
// Option 2
var query = persons.OrderBy(p => p.CalculateSalary()); 

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

Comments

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

— ফুগ

Answer 5

সংক্ষেপে :

তালিকা / অ্যারে বাছাই করুন ():

• অস্থির সাজান।
• জায়গায় জায়গায় সম্পন্ন।
• ইন্ট্রোসোর্ট / কুইকসোর্ট ব্যবহার করুন।
• একটি তুলনামূলক সরবরাহ করে কাস্টম তুলনা করা হয়। যদি তুলনা ব্যয়বহুল হয় তবে এটি অর্ডারবাইয়ের চেয়ে ধীর হতে পারে () কীগুলি ব্যবহারের অনুমতি দেয়, নীচে দেখুন)।

অর্ডারবাই / থাউনবি ():

• স্থিতিশীল বাছাই।
• জায়গায় নেই।
• কুইকসোর্ট ব্যবহার করুন। কুইকসোর্ট স্থিতিশীল বাছাই নয়। কৌশলটি এখানে: বাছাই করার সময়, যদি দুটি উপাদানের সমান কী থাকে তবে এটি তাদের প্রাথমিক ক্রমের সাথে তুলনা করে (যা সাজানোর আগে সংরক্ষণ করা হয়েছিল)।
• কীগুলি (ল্যাম্বডাস ব্যবহার করে) তাদের মানগুলিতে উপাদানগুলি সাজানোর জন্য (যেমন:) ব্যবহারের অনুমতি দেয় x => x.Id। বাছাইয়ের আগে সমস্ত কীগুলি প্রথমে বের করা হয়। এর ফলে বাছাই () এবং একটি কাস্টম তুলনামূলক ব্যবহারের চেয়ে আরও ভাল পারফরম্যান্স হতে পারে।

উত্স: এমডিএসএন , রেফারেন্স উত্স এবং ডটনেট / কোরসিএলআর সংগ্রহস্থল (গিটহাব)।

উপরের তালিকাভুক্ত কিছু বিবৃতি বর্তমান .NET ফ্রেমওয়ার্ক বাস্তবায়নের উপর ভিত্তি করে (4.7.2)। ভবিষ্যতে এটি পরিবর্তন হতে পারে।

Answer 6

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

আমি অর্ডারবাইয়ের সন্ধানও করেছি, তবে এমএসডিএন লাইব্রেরিতেও আমি কোনও তথ্য পাইনি। যদি আপনার কেবলমাত্র একটি সম্পত্তির সাথে সম্পর্কিত কোনও মান এবং বাছাই না থাকে তবে আমি বাছাই করুন () পদ্ধতিটি ব্যবহার করতে পছন্দ করি; যদি অর্ডারবাই ব্যবহার না করে থাকে।

Comments

বর্তমান এমএসডিএন ডকুমেন্টেশন অনুসারে বাছাই ইনপুট উপর ভিত্তি করে 3 বিভিন্ন বাছাই অ্যালগোরিদম ব্যবহার করে। যার মধ্যে কুইকসোর্ট রয়েছে। OrderBy প্রশ্ন () অ্যালগরিদম এখানে (Quicksort): stackoverflow.com/questions/2792074/...

— থর

Answer 7

আমি কেবল যে অর্ডারবাই যুক্ত করতে চাই এটি আরও কার্যকর।

কেন? কারণ আমি এটি করতে পারি:

Dim thisAccountBalances = account.DictOfBalances.Values.ToList
thisAccountBalances.ForEach(Sub(x) x.computeBalanceOtherFactors())
thisAccountBalances=thisAccountBalances.OrderBy(Function(x) x.TotalBalance).tolist
listOfBalances.AddRange(thisAccountBalances)

জটিল তুলক কেন? কেবল ক্ষেত্রের উপর ভিত্তি করে সাজান। এখানে আমি টোটাল ব্যালেন্সের ভিত্তিতে বাছাই করছি।

খুব সহজ.

আমি বাছাই করে এটি করতে পারি না। আমি ভাবছি কেন. অর্ডার দিয়ে জরিমানা করুন।

গতির ক্ষেত্রে এটি সর্বদা ও (এন) থাকে।

Comments

প্রশ্ন: আপনার উত্তরে ও (এন) সময় (আমি ধরে নিই) অর্ডারবাই বা তুলনাকারীকে বোঝায়? আমি মনে করি না দ্রুত সাজানোর ফলে ও (এন) সময় অর্জন সম্ভব।

— কেভম্যান