सी # में अगले उपलब्ध अनूठा नाम जनरेट कर रहा है

Question

आप अपने ऐप्लिकेशन में एक नामकरण प्रणाली जहां एप्लिकेशन 100 कार्यों का कहना होता है जो नई वस्तुओं बनाता है, जैसे के लिए गए थे, तो:

Blur 
Sharpen 
Contrast 
Darken 
Matte 
... 

और हर बार जब आप एक का उपयोग करें इनमें से, एक नया संपादन एक अद्वितीय संपादन योग्य नाम के साथ बनाया गया है, जैसे Blur01, Blur02, Blur03, Sharpen01, Matte01, आदि। आप अगले उपलब्ध अद्वितीय नाम कैसे उत्पन्न करेंगे, ताकि यह ओ (1) ऑपरेशन या निरंतर समय के निकट हो । ध्यान रखें कि उपयोगकर्ता RemoveFaceDetails आदि जैसे कस्टम नामों में भी नाम बदल सकता है,

अक्षरों, संख्याओं, अंडरस्कोर इत्यादि का उपयोग करके वर्णों की संख्या को प्रतिबंधित करने जैसी कुछ बाधाओं को स्वीकार करना स्वीकार्य है।

संपादित करें: आप "अंतराल को भरने" के बिना भी समाधान का सुझाव दे सकते हैं जो पहले से ही उपयोग किए बिना, लेकिन हटाए गए नामों का उपयोग किए बिना, कस्टम के अलावा।

Answer 1

मैं एक्शन क्लास में एक स्थिर पूर्णांक बनाउंगा जो वर्ग के प्रत्येक नए उदाहरण के हिस्से के रूप में वृद्धि और असाइन किया जाता है।

class Blur 
{ 
    private static int count = 0; 

    private string _name; 
    public string Name 
    { 
     get { return _name; } 
     set { _name = value; } 
    } 

    public Blur() 
    { 
     _name = "Blur" + count++.ToString(); 
    } 
} 

के बाद से गिनती स्थिर है, हर बार जब आप एक नया वर्ग बनाने के लिए, यह वृद्धि और डिफ़ॉल्ट नाम से जोड़ दिए जाएंगे: उदाहरण के लिए। ओ (1) समय।

संपादित

आप छेद में भरने के लिए जब आप हटाना की जरूरत है, मैं निम्नलिखित सुझाव है। यह स्वचालित रूप से जब आइटम का नाम बदला जाता है संख्या कतार होगा, लेकिन यह अधिक महंगा समग्र होगा:

class Blur 
    { 
     private static int count = 0; 
     private static Queue<int> deletions = new Queue<int>(); 

     private string _name; 
     public string Name 
     { 
      get { return _name; } 
      set 
      { 
       _name = value; 
       Delete(); 
      } 
     } 

     private int assigned; 

     public Blur() 
     { 
      if (deletions.Count > 0) 
      { 
       assigned = deletions.Dequeue(); 
      } 
      else 
      { 
       assigned = count++; 
      } 
      _name = "Blur" + assigned.ToString(); 
     } 

     public void Delete() 
     { 
      if (assigned >= 0) 
      { 
       deletions.Enqueue(assigned); 
       assigned = -1; 
      } 
     } 
    } 

इसके अलावा, जब आप किसी ऑब्जेक्ट हटाने के लिए, आप() वस्तु पर .Delete कॉल करने के लिए की आवश्यकता होगी।

CounterClass शब्दकोश संस्करण

class CounterClass 
{ 
    private int count; 
    private Queue<int> deletions; 

    public CounterClass() 
    { 
     count = 0; 
     deletions = new Queue<int>(); 
    } 

    public string GetNumber() 
    { 
     if (deletions.Count > 0) 
     { 
      return deletions.Dequeue().ToString(); 
     } 
     return count++.ToString(); 
    } 

    public void Delete(int num) 
    { 
     deletions.Enqueue(num); 
    } 
} 

आप प्रत्येक स्ट्रिंग के लिए काउंटरों को देखने के लिए एक शब्दकोश बना सकते हैं। बस सुनिश्चित करें कि आप इंडेक्स को पार्स करते हैं और कॉल करते हैं। जब भी आप किसी नाम का नाम बदलते हैं या हटाते हैं तो हटाएं।

Answer 2

आप इसे O(m) जहां m, n पर निर्भर नहीं सूची में आइटम्स की संख्या नाम के मौजूदा उदाहरणों (और की संख्या है में आसानी से कर सकते हैं।

1. प्रश्न में स्ट्रिंग S को फिर से देखें । यदि S सूची में नहीं है, बस हो गया।
2. S मौजूद है, इसलिए S+"01" का निर्माण और उस के लिए जाँच करें। incrementing (जैसे अगले S+"02" कोशिश जब तक यह मौजूद नहीं है।

जारी रखें

यह आपको अद्वितीय नाम देता है लेकिन वे अभी भी "सुंदर" और मानव-पठनीय हैं।

जब तक आप बड़ी संख्या में डुप्लीकेट की अपेक्षा नहीं करते हैं, यह "निकट-स्थिर" समय होना चाहिए क्योंकि m इतना छोटा होगा।

चेतावनी: क्या होगा यदि स्ट्रिंग स्वाभाविक रूप से उदा साथ समाप्त होता है "01"? आपके मामले में यह असंभव लगता है तो शायद आपको परवाह नहीं है। यदि आप परवाह करते हैं, तो अधिक प्रत्यय जोड़ने पर विचार करें, उदा। "_01" बस "01" के बजाय "उन्हें अलग करना आसान है।

Answer 3

यदि आप ओ (1) समय चाहते हैं तो बस ट्रैक करें कि आपके प्रत्येक के कितने उदाहरण हैं। जब आप ऑब्जेक्ट बनाते हैं, उस ऑब्जेक्ट के मान को बढ़ाते हैं और नाम में परिणाम का उपयोग करते हैं, तो सभी संभावित ऑब्जेक्ट्स के साथ हैशटेबल रखें।

Answer 4

आप निश्चित रूप से उपयोगकर्ता इंटरफ़ेस में GUID का खुलासा नहीं करना चाहते हैं।

क्या आप "ब्लर04" जैसे प्रारंभिक नाम का प्रस्ताव दे रहे हैं, उपयोगकर्ता को इसका नाम बदलने दें, और उसके बाद उपयोगकर्ता का कस्टम नाम विवादित होने पर त्रुटि संदेश उठा रहा है? या चुपचाप इसे "CustomName01" या फिर जो भी नाम दे रहा है?

आप ओ (1) समय में डुप्लिकेट की जांच के लिए एक शब्दकोश का उपयोग कर सकते हैं। आप कक्षा में प्रत्येक प्रभाव प्रकार के लिए काउंटर बढ़ाना कर सकते हैं जो आपके नए प्रभाव उदाहरण बनाता है। केविन की तरह उल्लेख किया गया है, यदि प्रभाव हटा दिए जाने पर आपको संख्या में अंतर को भरना पड़ता है तो यह अधिक जटिल हो जाता है।

Answer 5

मैं माइकल ए जैक्सन के Two Rules of Program Optimization का उल्लेख:

1. ऐसा मत करो।
2. केवल विशेषज्ञों के लिए: अभी तक ऐसा न करें।

सरल, maintainable कोड दूर रफ्तार समस्या आप आपको लगता है कि हो सकता है बाद के लिए अनुकूलन से ज्यादा महत्वपूर्ण है।

मैं सरल शुरू करूंगा: उम्मीदवार का नाम बनाएं (उदा। "Sharpen01"), फिर मौजूदा फ़िल्टर के माध्यम से लूप करें यह देखने के लिए कि क्या यह नाम मौजूद है या नहीं। यदि ऐसा होता है, तो वृद्धि करें और पुनः प्रयास करें। यह ओ (एन) है, लेकिन जब तक आपको हजारों फ़िल्टर नहीं मिलते हैं, तो यह काफी अच्छा होगा।

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

ओ (एन) पर्याप्त होगा। आपको ओ (1) की आवश्यकता नहीं है। उपयोगकर्ता कोई अंतर होने के लिए पर्याप्त समय "तेज" पर क्लिक नहीं करेगा।

Answer 6

आप कुछ इस तरह कर सकता है: के रूप में string myNextName = GetNextName("Blur");

private Dictionary<string, int> instanceCounts = new Dictionary<string, int>(); 

    private string GetNextName(string baseName) 
    { 
     int count = 1; 

     if (instanceCounts.TryGetValue(baseName, out count)) 
     { 
      // the thing already exists, so add one to it 
      count++; 
     } 

     // update the dictionary with the new value 
     instanceCounts[baseName] = count; 

     // format the number as desired 
     return baseName + count.ToString("00"); 
    } 

फिर आप बस इसे आधार नाम आप चाहते थे के साथ GetNextName (...) को फोन करके प्रयोग करेंगे, इस तरह इस का उपयोग करना, आपको शब्दकोश को प्री-इनिट नहीं करना पड़ेगा। यह भर जाएगा क्योंकि आपने विभिन्न मूल शब्दों का उपयोग किया था। इसके अलावा, यह ओ (1) है।

Answer 7

मैं एक स्ट्रिंग कुंजी और एक पूर्णांक मान के साथ एक शब्दकोश बनाउंगा, जो किसी दिए गए क्रिया के लिए उपयोग करने के लिए अगली संख्या संग्रहीत करेगा। यह अभ्यास में लगभग ओ (1) होगा।

private IDictionary<String, Int32> NextFreeActionNumbers = null;  

private void InitializeNextFreeActionNumbers() 
{ 
    this.NextFreeActionNumbers = new Dictionary<String, Int32>(); 

    this.NextFreeActionNumbers.Add("Blur", 1); 
    this.NextFreeActionNumbers.Add("Sharpen", 1); 
    this.NextFreeActionNumbers.Add("Contrast", 1); 
    // ... and so on ... 
} 

private String GetNextActionName(String action) 
{ 
    Int32 number = this.NextFreeActionNumbers[action]; 

    this.NextFreeActionNumbers[action] = number + 1; 

    return String.Format("{0} {1}", action, number); 
} 

और आपको उपयोगकर्ता संपादित मूल्यों के साथ टकराव के खिलाफ जांच करनी होगी। फिर एक शब्दकोश एक स्मार्ट पसंद हो सकता है। उसके आसपास कोई रास्ता नहीं है। आप अपने नामों को किस तरह से उत्पन्न करते हैं, उपयोगकर्ता हमेशा आपके द्वारा उत्पन्न किए गए किसी भी मौजूदा नाम को तब तक बदल सकता है जब तक आप पीढ़ी स्कीमा में सभी मौजूदा नाम शामिल नहीं करते। (या उपयोगकर्ता नामित नामों में एक विशेष चरित्र की अनुमति नहीं है, लेकिन यह अच्छा नहीं होगा।)

छेद का पुन: उपयोग करने की टिप्पणियों के कारण मैं इसे यहां भी जोड़ना चाहता हूं। पुनर्मूल्यांकन या हटाना उत्पन्न छेद का पुन: उपयोग न करें। यह उपयोगकर्ता को भ्रमित करेगा क्योंकि हटाए गए या संशोधित नाम अचानक गायब हो जाएंगे।

Answer 8

मैं समस्या को सरल बनाने के तरीकों की तलाश करता हूं।

क्या कोई बाधाएं लागू की जा सकती हैं? उदाहरण के तौर पर, क्या यह पर्याप्त होगा यदि प्रत्येक उपयोगकर्ता के पास केवल एक (सक्रिय) प्रकार की कार्रवाई हो सकती है? फिर, उपयोगकर्ता के नाम (या आईडी) का उपयोग करके कार्यों को अलग किया जा सकता है।

• धुंधला (बेन एफ)
• धुंधला (एड्रियन एच)
• फोकस (बेन एफ)

शायद यह इस मामले में एक विकल्प नहीं है, लेकिन शायद कुछ और ही संभव होगा । प्रस्तावित समाधानों में जटिलता से बचने के लिए मैं बहुत अधिक समय तक जाऊंगा!