c# - स्थिति के आधार पर स्ट्रिंग के हिस्से को कैसे बदलें?




string replace (10)

मेरे पास यह स्ट्रिंग है: ABCDEFGHIJ

मुझे स्ट्रिंग ZX साथ स्थिति 4 से स्थिति 5 में प्रतिस्थापित करने की आवश्यकता है

यह इस तरह दिखेगा: ABCZXFGHIJ

लेकिन string.replace("DE","ZX") साथ उपयोग नहीं करना है - मुझे स्थिति के साथ उपयोग करने की आवश्यकता है

मैं यह कैसे कर सकता हूं?


ReplaceAt (int सूचकांक, int लंबाई, स्ट्रिंग प्रतिस्थापित)

यहां एक एक्सटेंशन विधि है जो स्ट्रिंगबिल्डर या सबस्ट्रिंग का उपयोग नहीं करती है। यह विधि प्रतिस्थापन स्ट्रिंग को स्रोत स्ट्रिंग की लंबाई से आगे बढ़ाने की अनुमति भी देती है।

//// str - the source string
//// index- the start location to replace at (0-based)
//// length - the number of characters to be removed before inserting
//// replace - the string that is replacing characters
public static string ReplaceAt(this string str, int index, int length, string replace)
{
    return str.Remove(index, Math.Min(length, str.Length - index))
            .Insert(index, replace);
}

इस फ़ंक्शन का उपयोग करते समय, यदि आप संपूर्ण प्रतिस्थापन स्ट्रिंग को जितना संभव हो सके उतने वर्णों को प्रतिस्थापित करना चाहते हैं, तो प्रतिस्थापन स्ट्रिंग की लंबाई तक लंबाई निर्धारित करें:

"0123456789".ReplaceAt(7, 5, "Hello") = "0123456Hello"

अन्यथा, आप हटाए गए वर्णों की मात्रा निर्दिष्ट कर सकते हैं:

"0123456789".ReplaceAt(2, 2, "Hello") = "01Hello456789"

यदि आप लंबाई 0 निर्दिष्ट करते हैं, तो यह फ़ंक्शन सम्मिलित फ़ंक्शन की तरह कार्य करता है:

"0123456789".ReplaceAt(4, 0, "Hello") = "0123Hello456789"

मुझे लगता है कि यह अधिक कुशल है क्योंकि स्ट्रिंगबिल्डर वर्ग को प्रारंभ नहीं किया जाना चाहिए और चूंकि यह अधिक बुनियादी परिचालनों का उपयोग करता है। अगर मैं गलत हूं कृपया मुझे सही। :)


अन्य लोगों की तरह उल्लेख किया गया है कि Substring() फ़ंक्शन एक कारण के लिए है:

static void Main(string[] args)
{
    string input = "ABCDEFGHIJ";

    string output = input.Overwrite(3, "ZX"); // 4th position has index 3
    // ABCZXFGHIJ
}

public static string Overwrite(this string text, int position, string new_text)
{
    return text.Substring(0, position) + new_text + text.Substring(position + new_text.Length);
}

इसके अलावा मैंने स्ट्रिंगबिल्डर समाधान के खिलाफ यह समय लगाया और 9 00 बनाम बनाम 875 मिल गया। तो यह थोड़ा धीमा है।


आप इसे कुछ लिंक करने का प्रयास कर सकते हैं:

string str = "ABCDEFGHIJ";
str = str.Substring(0, 2) + "ZX" + str.Substring(5);

इस पोस्ट की मदद से, मैं अतिरिक्त लंबाई जांच के साथ निम्नलिखित फ़ंक्शन बना देता हूं

public string ReplaceStringByIndex(string original, string replaceWith, int replaceIndex)
{
    if (original.Length >= (replaceIndex + replaceWith.Length))
    {
        StringBuilder rev = new StringBuilder(original);
        rev.Remove(replaceIndex, replaceWith.Length);
        rev.Insert(replaceIndex, replaceWith);
        return rev.ToString();
    }
    else
    {
        throw new Exception("Wrong lengths for the operation");
    }
}

एक स्ट्रिंग में श्रेणियों को जोड़ने और हटाने का सबसे आसान तरीका स्ट्रिंगबिल्डर का उपयोग करना है।

var theString = "ABCDEFGHIJ";
var aStringBuilder = new StringBuilder(theString);
aStringBuilder.Remove(3, 2);
aStringBuilder.Insert(3, "ZX");
theString = aStringBuilder.ToString();

एक विकल्प String.Substring का उपयोग String.Substring , लेकिन मुझे लगता है कि String.Substring कोड अधिक पठनीय हो जाता है।


बाएं हिस्से को काटने के लिए String.Substring() ( here विवरण String.Substring() उपयोग करें, फिर अपना प्रतिस्थापन, फिर दायां हिस्सा। इंडेक्स के साथ खेलो जब तक आप इसे सही न हो :)

कुछ इस तरह:

string replacement=original.Substring(0,start)+
    rep+original.Substring(start+rep.Length);

मैं निम्नलिखित आवश्यकताओं के साथ एक समाधान की तलाश में था:

  1. केवल एक एकल, एक-पंक्ति अभिव्यक्ति का उपयोग करें
  2. केवल सिस्टम बिल्टिन विधियों का उपयोग करें (कोई कस्टम कार्यान्वित उपयोगिता नहीं)

समाधान 1

जो समाधान सबसे अच्छा है वह यह है:

// replace `oldString[i]` with `c`
string newString = new StringBuilder(oldString).Replace(oldString[i], c, i, 1).ToString();

यह StringBuilder.Replace(oldChar, newChar, position, count) का उपयोग करता है। जगह StringBuilder.Replace(oldChar, newChar, position, count)

समाधान 2

दूसरा समाधान जो मेरी आवश्यकताओं को पूरा करता है, Substring को Substring साथ उपयोग करना है:

string newString = oldStr.Substring(0, i) + c + oldString.Substring(i+1, oldString.Length);

यह भी ठीक है। मुझे लगता है कि यह पहले एक प्रदर्शन के रूप में कुशल नहीं है (अनावश्यक स्ट्रिंग concatenation के कारण)। लेकिन समयपूर्व अनुकूलन सभी बुराई की जड़ है

तो वह सबसे चुनें जिसे आप सबसे ज्यादा पसंद करते हैं :)


String.substr() का उपयोग करना बेहतर है।

इस कदर:

ReplString = GivenStr.substr(0, PostostarRelStr)
           + GivenStr(PostostarRelStr, ReplString.lenght());

s.Remove(3, 2).Insert(3, "ZX");

-> स्ट्रिंग में यूनिकोड चार जैसे इमोजिस होते हैं तो यह काम नहीं करता है।

इस विषय के साथ, मैं निक मिलर के एल्गोरिदम को बनाए रखने की स्थिति द्वारा प्रतिस्थापित करने के लिए स्ट्रिंगइन्फो क्लास का विस्तार करता हूं:

public static class StringInfoUtils
{
    public static string ReplaceByPosition(this string str, string replaceBy, int offset, int count)
    {
        return new StringInfo(str).ReplaceByPosition(replaceBy, offset, count).String;
    }

    public static StringInfo ReplaceByPosition(this StringInfo str, string replaceBy, int offset, int count)
    {
        return str.RemoveByTextElements(offset, count).InsertByTextElements(offset, replaceBy);
    }

    public static StringInfo RemoveByTextElements(this StringInfo str, int offset, int count)
    {
        return new StringInfo(string.Concat(
            str.SubstringByTextElements(0, offset),
            offset + count < str.LengthInTextElements
                ? str.SubstringByTextElements(offset + count, str.LengthInTextElements - count - offset)
                : ""
            ));
    }
    public static StringInfo InsertByTextElements(this StringInfo str, int offset, string insertStr)
    {
        if (string.IsNullOrEmpty(str?.String))
            return new StringInfo(insertStr);
        return new StringInfo(string.Concat(
            str.SubstringByTextElements(0, offset),
            insertStr,
            str.LengthInTextElements - offset > 0 ? str.SubstringByTextElements(offset, str.LengthInTextElements - offset) : ""
        ));
    }
}

string s = "ABCDEFGH";
s= s.Remove(3, 2).Insert(3, "ZX");




replace