ऑब्जेक्ट्स की सूची ऑर्डर करने के लिए एल्गोरिदम

Question

कहें कि आपके पास ऑब्जेक्ट्स की एक सूची है। जब वह काम कर रहा है तो उपयोगकर्ता ज्यादातर ऑब्जेक्ट्स का उपयोग करता है। आप ऑब्जेक्ट्स की सूची कैसे ऑर्डर कर सकते हैं, ताकि सूची ऑर्डर के अनुकूल हो, उपयोगकर्ता अधिकतर उपयोग करते हैं? इसके लिए आप किस एल्गोरिदम का उपयोग कर सकते हैं?

संपादित करें: कई उत्तरों ने ऑब्जेक्ट का उपयोग करने की संख्या की गणना करने का सुझाव दिया है। यह काम नहीं करता है, क्योंकि सभी वस्तुओं को एक ही राशि का उपयोग किया जाता है, केवल अलग-अलग ऑर्डर में।

Answer 1

जब उपयोगकर्ता किसी ऑब्जेक्ट तक पहुंचता है तो डेटाटाइम की एक सूची जोड़ें। प्रत्येक बार जब कोई उपयोगकर्ता किसी ऑब्जेक्ट का उपयोग करता है, तो डेटाटाइम जोड़ें।

अब अपनी सूची में डेटाटाइम प्रविष्टियों की संख्या की गणना करें जो डब्ल्यू (अब - एक्स दिन) हैं और इसके अनुसार क्रमबद्ध करें। आप उन डेटाटाइम को हटा सकते हैं जो> (अब - x दिन) हैं।

यह संभव है कि उपयोगकर्ता एक महीने में विभिन्न वस्तुओं का उपयोग करता है, यह उन परिवर्तनों को प्रतिबिंबित करेगा।

Answer 2

अपनी ऑब्जेक्ट के अंदर, इस्तेमाल किया गया काउंटर रखें। जब भी वस्तु का उपयोग किया जाता है, तो इस गिनती को बढ़ाएं। , ++ यह हर बार वस्तु का इस्तेमाल किया और सॉर्ट सूची है कि क्षेत्र से

objects.OrderByDescending(o => o.UsedCount); 

Answer 3

आप अपने वस्तु वर्ग के लिए एक NUMBER_OF_VIEWS क्षेत्र जोड़ सकते हैं: तो फिर तुम बस ऐसा कर सकते हैं। और आपको सभी ऑब्जेक्ट्स पर number_of_views बनाना चाहिए, लेकिन 0.

Answer 4

मैं प्रत्येक ऑब्जेक्ट के लिए इसके उपयोग की निगरानी करने के लिए काउंटर का भी उपयोग करता हूं, लेकिन पूरी सूची को पुन: व्यवस्थित करने के बजाय प्रत्येक उपयोग के बाद, मैं सिर्फ "स्थानीय रूप से" सूची को क्रमबद्ध करने की अनुशंसा करता हूं। एक बबल प्रकार की तरह, मैं केवल उस वस्तु की तुलना करूंगा जिसका काउंटर ऊपरी वस्तु के साथ बढ़ गया था, और यदि आवश्यक हो तो उन्हें स्वैप करें। यदि स्वैप किया गया है, तो मैं ऑब्जेक्ट और इसकी नई ऊपरी वस्तु की तुलना करता हूं और इसी तरह।

हालांकि, अगर यह सही तरीके से कार्यान्वित किया गया है, तो यह पिछली विधियों से बहुत अलग नहीं है।

Answer 5

अपने प्रयोक्ता वर्ग तो ऐसा दिखाई देता है:

class User 
{ 
    Collection<Algo> algosUsed = new List<Algo>();  //Won't compile, used for explanation 
    ... 
} 

और अपने एल्गो वर्ग तो दिखाई देता है:

class Algo 
{ 
    int usedCount; 
... 
} 

आप User वस्तु को Algo वस्तु के विशिष्ट उदाहरण बाध्य करने के लिए सक्षम होना चाहिए जो रिकॉर्डिंग के लिए अनुमति देता है कि कितनी बार इसका उपयोग किया जाता है। सबसे बुनियादी स्तर पर आप जानकारी को फ़ाइल या स्ट्रीम में क्रमबद्ध करेंगे। सबसे अधिक संभावना है कि आप डेटाबेस का उपयोग क्या किया जा रहा है इसका ट्रैक रखने के लिए चाहते हैं। फिर जब आप अपने User आकर्षित करने तथा sort समारोह आह्वान आप Algo

Answer 6

संपादित की usedCount परम द्वारा User की algos परम आदेश: जोड़ा गया एक आदेश preferrence !!! कोड

मुझे आखिरी प्रयुक्त विधि पसंद नहीं है क्योंकि कैरा ने कहा क्योंकि यह कई तरह के बदलावों को भ्रमित करता है जो भ्रमित है।

count_accessed फ़ील्ड बहुत बेहतर है, हालांकि मुझे लगता है कि इसे
पर ले जाना चाहिए, उपयोगकर्ता ने पिछले XX मिनट/घंटे/दिनों में इस आइटम को कितनी बार एक्सेस किया था आदि ...

कि के लिए सबसे अच्छा आंकड़ा संरचना निश्चित रूप से

static TimeSpan TIME_TO_LIVE; 
    static int userOrderFactor = 0; 

    LinkedList<KeyValuePair<DateTime, int>> myAccessList = new  LinkedList<KeyValuePair<DateTime, int>>(); 

    private void Access_Detected() 
    { 
     userOrderFactor++; 
     myAccessList.AddLast(new KeyValuePair<DateTime, int>(DateTime.Now, userOrderFactor)); 
     myPriority += userOrderFactor; // take total count differential, so we dont waste time summing the list 
    } 



    private int myPriority = 0; 
    public int MyPriority 
    { 
     get 
     { 
      DateTime expiry = DateTime.Now.Subtract(TIME_TO_LIVE); 
      while (myAccessList.First.Value.Key < expiry) 
      { 
       myPriority += myAccessList.First.Value.Value; // take care of the Total Count 
       myAccessList.RemoveFirst(); 
      } 
      return myPriority; 
     } 
    } 

आशा इस मदद करता है ... है यह लगभग हमेशा हे (1) BTW ...
मुझे कुछ हद तक याद दिलाता है आपरेटिंग सिस्टम

की नींद तंत्र की है

Answer 7

लगता है जैसे आप एक कैश चाहते हैं। मैं सोचता हूं कि आप कैश का उपयोग करने वाले एल्गोरिदम देख सकते हैं और फिर संपूर्ण स्विच को संदर्भ स्विचिंग के बारे में देख सकते हैं ... "घड़ी स्वीप" नामक एक एल्गोरिदम है ... लेकिन मेह जो कि आप जो खोज रहे हैं उसके लिए बहुत जटिल हो सकता है । आलसी तरीके से जाने के लिए मैं कहूंगा कि "इस्तेमाल की गई चीज़" का हैश बनाएं: num_of_uses या, अपनी कक्षा में, ऑब्जेक्ट का उपयोग होने पर हर बार + var होता है।

प्रत्येक बार और थोड़ी देर में हैश को num_of_uses या ऑब्जेक्ट्स द्वारा उनके ++ 'डी चर के मूल्य से क्रमबद्ध करें।

Answer 8

https://stackoverflow.com/a/2619065/1429439 से

:

शायद कुंजी के रूप में usedCount और मूल्य के रूप में वस्तु के साथ OrderedMultiDictionary का उपयोग करें।

Answer 9

मैं एक चलती गिनती रखूंगा कि वस्तु का कितनी बार उपयोग किया गया था, और किस क्रम में इसका उपयोग किया गया था।

तो यदि ऑब्जेक्ट एक्स का उपयोग तीसरा किया गया था, तो इसे चलने वाली गिनती के साथ औसत करें और परिणाम का उपयोग सूची में स्थिति के रूप में करें।

उदाहरण के लिए:

 
Item  Uses  Order of Use 
--------------------------------------- 
Object X 10  1,2,3,1,2,1,3,1,2,2 (18) 
Object Y 10  3,1,2,3,3,3,1,3,3,1 (23) 
Object Z 10  2,3,1,2,1,2,2,2,2,3 (20) 

उपयोग किया जाएगा कि कितनी बार उपयोगकर्ता वस्तु, उपयोग के आदेश, जहां मद क्रम में प्रयोग किया जाता है की एक सूची (या योग) होगा इस्तेमाल किया।

व्यक्तिगत रूप से प्रत्येक आदेश की एक सूची का उपयोग करके कुछ प्रदर्शन समस्याएं हो सकती हैं, इसलिए आप केवल पदों को जोड़ना चाहते हैं। यदि आप योग रखते हैं, तो ऑब्जेक्ट का उपयोग होने पर हर बार उस योग को ऑर्डर जोड़ें।

स्थिति की गणना करने के लिए, आप केवल उपयोग की संख्या से विभाजित स्थितियों के योग का उपयोग करेंगे और आपके औसत होंगे। आपको उस बिंदु पर करना होगा औसत की सूची ऑर्डर करें।

 
Object X 1.8 
Object Z 2.0 
Object Y 2.3 

Answer 10

एक उपयोगकर्ता एक वस्तु के साथ सूचना का आदान प्रदान करते हैं तो पिछले वस्तु की आईडी को बचाने कि दूसरी वस्तु पर पर काम किया तो:

उदाहरण में ऊपर, तो आपको निम्न औसत (और व्यवस्था) प्राप्त होता है कि आपके पास हमेशा किसी दिए गए ऑब्जेक्ट से पहले ऑब्जेक्ट के लिए पॉइंटर होता है।

इसके अतिरिक्त, सबसे पहले उपयोग की जाने वाली वस्तु की आईडी स्टोर करें ताकि आपको पता चले कि कहां से शुरू करना है।

जब आप प्रदर्शित करने के लिए ऑब्जेक्ट्स की अपनी सूची बना रहे हैं, तो आप सबसे पहले इस्तेमाल होने वाली ऑब्जेक्ट के रूप में संग्रहीत किए गए एक से शुरू करते हैं, फिर उस ऑब्जेक्ट की खोज करें जिसमें प्रदर्शित करने के लिए पहले उपयोग की गई ऑब्जेक्ट आईडी है आगामी।