मेरे पास एक विधि है जिसमें दो तार मिलते हैं। इन तारों में एक ही समय में संख्या, ASCII वर्ण या दोनों हो सकते हैं।

एल्गोरिथ्म इस तरह काम करता है:

  1. दोनों तारों को चार टुकड़े ए और बी में विभाजित करें।
  2. तत्व <उप> i और B <उप> i को एक सूत्र में जोड़ने की कोशिश करें
  3. तत्वों की तुलना करें ए <उप> मैं तत्व के साथ बी <उप> मैं , पूर्णांक के मामले में प्रत्यक्ष तुलना का उपयोग करते हैं, वर्णों के मामले में, क्रमिक स्ट्रिंग तुलना का उपयोग करते हैं।
  4. परिणाम के आधार पर काम करें

अब, मैं सोच रहा हूँ: क्या मुझे वास्तव में तत्वों को पार्स करने की आवश्यकता है? मैं साधारणतया प्रत्येक तत्व की तुलना एक तारकीय तुलना में कर सकता था और उसे एक ही परिणाम मिलेगा, है ना? प्रदर्शन के निहितार्थ यहाँ क्या हैं? क्या पार्सिंग और सामान्य तुलना क्रमिक स्ट्रिंग की तुलना में तेज है? क्या यह धीमा है?

क्या मेरी धारणा (पार्सिंग और तुलना के बजाय क्रमिक स्ट्रिंग की तुलना का उपयोग करना) सही है?

यहाँ प्रश्न में विधि है:

internal static int CompareComponentString(this string componentString, string other)
{
    bool componentEmpty = string.IsNullOrWhiteSpace(componentString);
    bool otherEmtpy = string.IsNullOrWhiteSpace(other);

    if (componentEmpty && otherEmtpy)
    {
        return 0;
    }

    if (componentEmpty)
    {
        return -1;
    }

    if (otherEmtpy)
    {
        return 1;
    }

    string[] componentParts = componentString.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
    string[] otherParts = other.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);

    for (int i = 0; i < Math.Min(componentParts.Length, otherParts.Length); i++)
    {
        string componentChar = componentParts[i];
        string otherChar = otherParts[i];
        int componentNumVal, otherNumVal;
        bool componentIsNum = int.TryParse(componentChar, out componentNumVal);
        bool otherIsNum = int.TryParse(otherChar, out otherNumVal);

        if (componentIsNum && otherIsNum)
        {
            if (componentNumVal.CompareTo(otherNumVal) == 0)
            {
                continue;
            }

            return componentNumVal.CompareTo(otherNumVal);
        }
        else
        {
            if (componentIsNum)
            {
                return -1;
            }

            if (otherIsNum)
            {
                return 1;
            }

            int comp = string.Compare(componentChar, otherChar, StringComparison.OrdinalIgnoreCase);

            if (comp != 0)
            {
                return comp;
            }
        }
    }

    return componentParts.Length.CompareTo(otherParts.Length);
}

यह ऐसे तार हैं जिनका उपयोग किया जा सकता है। मैं केवल के बाद भाग को जोड़ सकता हूं, ऋण चिह्न का उपयोग किया जाता है।

  • 1.0.0 अल्फा
  • 1.0.0 - alpha.1
  • 1.0.0 - alpha.beta
  • 1.0.0 - beta.2
1
Ruhrpottpatriot 28 नवम्बर 2015, 22:49

1 उत्तर

एससीआई स्ट्रिंग्स के लिए .net तुलना तर्क -

  private unsafe static int CompareOrdinalIgnoreCaseHelper(String strA, String strB)
    {
        Contract.Requires(strA != null);
        Contract.Requires(strB != null);
        Contract.EndContractBlock();
        int length = Math.Min(strA.Length, strB.Length);

        fixed (char* ap = &strA.m_firstChar) fixed (char* bp = &strB.m_firstChar)
        {
            char* a = ap;
            char* b = bp;

            while (length != 0) 
            {
                int charA = *a;
                int charB = *b;

                Contract.Assert((charA | charB) <= 0x7F, "strings have to be ASCII");

                // uppercase both chars - notice that we need just one compare per char
                if ((uint)(charA - 'a') <= (uint)('z' - 'a')) charA -= 0x20;
                if ((uint)(charB - 'a') <= (uint)('z' - 'a')) charB -= 0x20;

                //Return the (case-insensitive) difference between them.
                if (charA != charB)
                    return charA - charB;

                // Next char
                a++; b++;
                length--;
            }

            return strA.Length - strB.Length;
        }
    }

यह कहते हुए कि, जब तक आपके पास एक सख्त प्रदर्शन बाधा नहीं है, मैं कहूंगा कि यदि आपको पहले से लागू और परीक्षण किए गए फ़ंक्शन से एक ही परिणाम मिलता है, तो इसका पुन: उपयोग करने के लिए बेहतर है और पहिया को सुदृढ़ करने के लिए नहीं। यह कार्यान्वयन, इकाई परीक्षण, डिबगिंग और बग फिक्सिंग समय में इतना समय बचाता है। और सॉफ्टवेयर को सरल रखने में मदद करता है।

0
Kapoor 28 नवम्बर 2015, 21:30