आप एक स्ट्रिंग के भीतर एक स्ट्रिंग (वास्तव में एक चर) की घटनाओं को कैसे गिनेंगे?


864

मैं कुछ कर रहा हूं जहां मुझे एहसास हुआ कि मैं गिनना चाहता था कि मैं कितने /स्ट्रिंग में मिल सकता हूं, और फिर इसने मुझे मारा, कि इसे करने के कई तरीके थे, लेकिन क्या सबसे अच्छा (या सबसे आसान) तय नहीं कर सकता था ।

फिलहाल मैं कुछ इस तरह से जा रहा हूं:

string source = "/once/upon/a/time/";
int count = source.Length - source.Replace("/", "").Length;

लेकिन मुझे यह बिल्कुल पसंद नहीं है, कोई भी लेने वाला?

मैं वास्तव में इसके RegExलिए खुदाई नहीं करना चाहता , क्या मैं?

मुझे पता है कि मेरी स्ट्रिंग मेरे द्वारा खोजे जा रहे शब्द की है, इसलिए आप मान सकते हैं कि ...

बेशक तार के लिए जहां लंबाई> 1 ,

string haystack = "/once/upon/a/time";
string needle = "/";
int needleCount = ( haystack.Length - haystack.Replace(needle,"").Length ) / needle.Length;

34
+1: मुझे कहना होगा कि इसकी गणना करने का एक बहुत अलग तरीका है। मैं बेंच मार्क टेस्ट के परिणामों पर आश्चर्यचकित हूं :)
नवीन

4
यह इतना अलग नहीं है ... यह एसक्यूएल में इस कार्यक्षमता को लागू करने का विशिष्ट तरीका है LEN(ColumnToCheck) - LEN(REPLACE(ColumnToCheck,"N","")):।
शेरिदान

6
तथ्य की बात के रूप में आपको "/".Length
Gerard

3
क्या मैं पूछ सकता हूं, आपकी आवश्यकताओं का क्या कहना है कि गिनती "//" के भीतर "/////" की संख्या के लिए होनी चाहिए? 2 या 4?
लेस

1
रेगेक्स का उपयोग करना संभवतः इसके बारे में जाने का सबसे अच्छा तरीका है
एडम हिगिंस

जवाबों:


1009

यदि आप .NET 3.5 का उपयोग कर रहे हैं, तो आप LINQ के साथ वन-लाइनर में ऐसा कर सकते हैं:

int count = source.Count(f => f == '/');

यदि आप LINQ का उपयोग नहीं करना चाहते हैं, तो आप इसके साथ कर सकते हैं:

int count = source.Split('/').Length - 1;

आपको यह जानकर आश्चर्य हो सकता है कि आपकी मूल तकनीक इन दोनों की तुलना में लगभग 30% तेज लगती है! मैंने अभी "/ एक बार / पर / एक / समय /" के साथ एक त्वरित बेंचमार्क किया है और परिणाम निम्नानुसार हैं:

आपका मूल = 12s
source.Count = 19s
source.Split = 17s
foreach ( bobwienholt के उत्तर से ) = 10s

(समय 50,000,000 पुनरावृत्तियों के लिए हैं, इसलिए आप वास्तविक दुनिया में बहुत अंतर नोटिस नहीं कर सकते हैं।)


6
हाँ, VS स्ट्रिंग क्लास पर LINQ एक्सटेंशन मेथड्स को छुपाता है। मुझे लगता है कि उन्होंने सोचा कि देवता उन सभी विस्तार विधियों को स्ट्रिंग कक्षा पर नहीं दिखाना चाहेंगे। शायद एक बुद्धिमान निर्णय।
यहूदा गैब्रियल हिमंगो

11
यह संभव है कि यह व्यवहार इसलिए है क्योंकि VS2010 में स्वचालित रूप से System.Linq शामिल है नई कक्षा की फाइलें, VS2008 शायद नहीं। नामस्थान को काम करने के लिए अंतर्मुखी होने की आवश्यकता है।
अंकुरण

30
ध्यान दें कि काउंट और स्प्लिट सॉल्यूशन केवल तब काम करेंगे जब आप वर्णों की गिनती कर रहे हों। वे तार के साथ काम नहीं करेंगे, जैसे ओपी का समाधान करता है।
पीटर लिलवॉल्ड

5
f == '\' एक तार में चार के बारे में है, एक तार में तार नहीं है
थॉमस वेलर

9
यह एक अलग प्रश्न के उत्तर की तरह लगता है: "आप स्ट्रिंग के भीतर एक वर्ण की घटनाओं को कैसे गिनेंगे?"
बेन आरोनसन

181
string source = "/once/upon/a/time/";
int count = 0;
foreach (char c in source) 
  if (c == '/') count++;

source.Replace()खुद से तेज होना है।


18
आप फ़ॉरच के बजाय एक के लिए स्विच करके मामूली सुधार कर सकते हैं, लेकिन केवल एक छोटा सा, थोड़ा सा।
मार्क

17
नहीं। प्रश्न स्ट्रिंग की घटना को गिनने के लिए कहता है, चरित्र को नहीं।
युकीसकुर

3
यह एक स्ट्रिंग में वर्णों की गिनती कर रहा है। शीर्षक एक स्ट्रिंग में स्ट्रिंग की गिनती के बारे में है
थॉमस वेलर

2
@ मर्क ने इसे लूप के साथ परीक्षण किया और यह वास्तव में फोरच का उपयोग करने की तुलना में धीमा था। सीमा-जाँच के कारण हो सकता है? (5 सैन्य पुनरावृत्तियों पर समय 1.65 सेकंड बनाम 2.05 था।)
मापने

4
जबकि सवाल एक स्ट्रिंग के भीतर एक स्ट्रिंग के लिए पूछ रहा है, उदाहरण के लिए ओपी पोस्ट की गई समस्या वास्तव में सिर्फ एक चरित्र है, जिस स्थिति में मैं इस जवाब को अभी भी एक वैध समाधान कहूंगा, क्योंकि यह एक बेहतर तरीका दिखाता है (स्ट्रिंग खोज के बजाय चार खोज) हाथ में समस्या का समाधान करने के लिए।
चाड

136
int count = new Regex(Regex.Escape(needle)).Matches(haystack).Count;

8
+1 - कुछ मामलों में आप जोड़ना चाह सकते हैं RegexOptions.IgnoreCase
ट्रूविल

3
यह अविश्वसनीय रूप से कम नहीं है?
थॉमस अयूब

4
रेगेक्स ओवरहेड आदर्श नहीं है, प्लस "मैं वास्तव में इस के लिए RegEx खुदाई नहीं करना चाहता, क्या मैं?"
चाड

Regex.Escape(...)ऐसा नहीं चाह सकते हैंnew System.Text.RegularExpressions.Regex(needle).Matches(haystack).Count;
बार्लोप

2
मैं इस एक के साथ चला गया क्योंकि यह केवल पात्रों को नहीं, बल्कि तारों को खोज सकता है।
जेम्स

86

यदि आप संपूर्ण तारों की खोज करने में सक्षम होना चाहते हैं, और न केवल वर्ण:

src.Select((c, i) => src.Substring(i))
    .Count(sub => sub.StartsWith(target))

"स्ट्रिंग में प्रत्येक वर्ण के लिए, एक स्ट्रिंग के रूप में उस चरित्र से शुरू होने वाले बाकी स्ट्रिंग को पढ़ें। इसे गिनें यदि यह लक्ष्य स्ट्रिंग से शुरू होता है।"


1
निश्चित नहीं है कि मैं दिए गए विवरण की तुलना में इसे कैसे स्पष्ट तरीके से समझा सकता हूं। भ्रामक क्या है?
m

58
सुपर धीमी! इसे html के एक पृष्ठ पर आज़माया गया और इस पृष्ठ पर अन्य विधियों के रूप में लगभग 2 मिनट का समय लगा जिसमें 2 सेकंड लगे। उत्तर सही था; यह प्रयोग करने योग्य होने के लिए बहुत धीमा था।
जॉनब

2
सहमत, बहुत धीमा। मैं linq- शैली के समाधान का एक बड़ा प्रशंसक हूं, लेकिन यह सिर्फ व्यवहार्य नहीं है।
Sprague

5
ध्यान दें कि इसका कारण इतना धीमा है कि यह n स्ट्रिंग्स बनाता है, इस प्रकार लगभग n ^ 2/2 बाइट्स आवंटित करता है।
पीटर क्रैबट्री

6
OutOfMemoryException मेरे 210000 वर्ण तार के लिए डाली गई है।
एंडर

66

मैंने कुछ शोध किए हैं और पाया है कि ज्यादातर मामलों में रिचर्ड वॉटसन का समाधान सबसे तेज़ है। यह पोस्ट में हर समाधान के परिणामों के साथ तालिका है (उन उपयोग रेगेक्स को छोड़कर क्योंकि यह "परीक्षण {परीक्षण" जैसे स्ट्रिंग को पार्स करते समय अपवादों को फेंकता है)

    Name      | Short/char |  Long/char | Short/short| Long/short |  Long/long |
    Inspite   |         134|        1853|          95|        1146|         671|
    LukeH_1   |         346|        4490|         N/A|         N/A|         N/A|
    LukeH_2   |         152|        1569|         197|        2425|        2171|
Bobwienholt   |         230|        3269|         N/A|         N/A|         N/A|
Richard Watson|          33|         298|         146|         737|         543|
StefanosKargas|         N/A|         N/A|         681|       11884|       12486|

आप देख सकते हैं कि शॉर्ट स्ट्रिंग (10-50 अक्षरों) में शॉर्ट सब्सट्रिंग्स (1-5 वर्ण) की घटनाओं की संख्या ज्ञात करने के मामले में मूल एल्गोरिथ्म को प्राथमिकता दी जाती है।

इसके अलावा, मल्टीचैकर प्रतिस्थापन के लिए आपको निम्नलिखित कोड ( रिचर्ड वॉटसन के समाधान के आधार पर ) का उपयोग करना चाहिए

int count = 0, n = 0;

if(substring != "")
{
    while ((n = source.IndexOf(substring, n, StringComparison.InvariantCulture)) != -1)
    {
        n += substring.Length;
        ++count;
    }
}

मैं अपना खुद का 'निम्न स्तर' समाधान जोड़ने के बारे में था (सब्सट्रेट बनाए बिना, प्रतिस्थापित / विभाजन, या किसी भी रेगेक्स / लाइनक का उपयोग करके), लेकिन आपका संभवतः मेरा (और कम से कम छोटा) से भी बेहतर है। धन्यवाद!
डान डब्ल्यू

Regex समाधान के लिए, एक में जोड़नेRegex.Escape(needle)
थाइमिन

2
बस दूसरों के लिए इंगित करने के लिए, यदि खाली है, तो खोज मूल्य की जांच की जानी चाहिए, अन्यथा आप एक अनंत लूप में पहुंच जाएंगे।
WhoIsRich

2
हो सकता है कि यह सिर्फ मुझे है, लेकिन के लिए source="aaa" substring="aa"मैं इस, परिवर्तन वापस पाने के लिए 2, "ठीक" नहीं 1. करने के लिए की उम्मीद n += substring.Lengthकरने के लिएn++
ytoledano

आप overlappedइस तरह से अपने मामले को पूरा करने के लिए झंडा जोड़ सकते हैं :overlapped=True;.... if(overlapped) {++n;} else {n += substring.Length;}
tsionyx

54

LINQ सभी संग्रहों पर काम करता है, और चूंकि तार सिर्फ पात्रों का एक संग्रह है, इस बारे में कैसे अच्छा है एक-लाइनर:

var count = source.Count(c => c == '/');

सुनिश्चित करें कि आपके पास using System.Linq;आपकी कोड फ़ाइल के शीर्ष पर है, जैसा .Countकि उस नाम स्थान से विस्तार विधि है।


5
क्या यह वास्तव में वहाँ var का उपयोग करने लायक है क्या कोई मौका है कि गिनती एक ऐसी चीज के साथ बदल दी जाएगी जो एक इंट वापस नहीं करती है?
वॉट्सएप

69
@Whatsit: आप अपने बाएं हाथ से 'var' टाइप कर सकते हैं जबकि 'int' के लिए दोनों हाथों की आवश्यकता होती है;)
Sean Bright

7
intसभी पत्र घर की चाबियों में रहते हैं, जबकि varनहीं। उह .. रुको, मैं ड्वोरक का उपयोग कर रहा हूँ
माइकल ब्यून

2
@BDotA सुनिश्चित करें कि आपके पास 'System.Linq का उपयोग कर रहे हैं?' आपकी फ़ाइल के शीर्ष पर। इसके अलावा, intellisense छिप सकता है। क्योंकि यह एक तार है। फिर भी, यह संकलन और बस ठीक चलेगा।
जुदा गेब्रियल हिमंगो

3
@ जुदागैरेलहिमंगो मैं तर्क देता हूं कि विशेष रूप से चर का उपयोग तब किया जाना चाहिए जब चर प्रकार स्पष्ट हो (और संक्षिप्तता और स्थिरता के लिए)
EriF89

50
string source = "/once/upon/a/time/";
int count = 0;
int n = 0;

while ((n = source.IndexOf('/', n)) != -1)
{
   n++;
   count++;
}

मेरे कंप्यूटर पर यह 50 मिलियन पुनरावृत्तियों के लिए प्रत्येक-वर्ण समाधान की तुलना में लगभग 2 सेकंड तेज है।

2013 संशोधन:

स्ट्रिंग को चार में बदलें [और उसके माध्यम से पुनरावृति करें। 50 मीटर पुनरावृत्तियों के लिए कुल समय में एक और दूसरा या दो बंद करता है!

char[] testchars = source.ToCharArray();
foreach (char c in testchars)
{
     if (c == '/')
         count++;
}

यह अभी भी तेज है:

char[] testchars = source.ToCharArray();
int length = testchars.Length;
for (int n = 0; n < length; n++)
{
    if (testchars[n] == '/')
        count++;
}

अच्छे माप के लिए, सरणी के अंत से 0 तक चलना सबसे तेज़ प्रतीत होता है, लगभग 5%।

int length = testchars.Length;
for (int n = length-1; n >= 0; n--)
{
    if (testchars[n] == '/')
        count++;
}

मैं सोच रहा था कि ऐसा क्यों हो सकता है और चारों ओर गोग्लिंग था (मुझे उल्टा पुनरावृत्ति होने के बारे में कुछ याद है), और इस एसओ सवाल पर आया था जो पहले से ही स्ट्रिंग [] तकनीक का उपयोग करता है। मुझे लगता है कि इस संदर्भ में उलटफेर की चाल नई है।

C # में स्ट्रिंग में अलग-अलग पात्रों के माध्यम से पुनरावृति करने का सबसे तेज़ तरीका क्या है?


1
आप डाल सकते हैं source.IndexOf('/', n + 1)और खो सकते हैं और n++जबकि के कोष्ठक :) इसके अलावा, string word = "/"चरित्र के बजाय एक चर डाल सकते हैं ।
neeKo

1
हे निको, नए उत्तरों की जांच करो। हालांकि, चर-लंबाई को प्रतिस्थापित करना कठिन हो सकता है।
रिचर्ड वॉटसन

मैंने उपशीर्षक के माध्यम से कदम बढ़ाकर कुछ इसी तरह का उपयोग किया; जब तक मुझे एहसास हुआ कि indexOf में एक startIndex है। मुझे पहला समाधान सबसे अधिक पसंद है क्योंकि यह गति और स्मृति पदचिह्न के बीच एक अच्छा संतुलन है।
समीर बंजानोविक

1
मैंने कहीं पढ़ा है कि यह तेजी से पीछे की ओर
चलना है

1
@ शितपु युत। यदि आप अंतर्निहित कोड को देखते हैं, तो यह एक देशी कॉल है। public char [] toCharArray () {... System.arraycopy (मान, 0, परिणाम, 0, value.length); ...}
रिचर्ड वॉटसन

46

ये दोनों केवल एकल-वर्ण खोज शब्दों के लिए काम करते हैं ...

countOccurences("the", "the answer is the answer");

int countOccurences(string needle, string haystack)
{
    return (haystack.Length - haystack.Replace(needle,"").Length) / needle.Length;
}

अब सुइयों के लिए बेहतर हो सकता है ...

लेकिन एक और अधिक सुंदर तरीका होना चाहिए। :)


बहु-चरित्र प्रतिस्थापन के लिए खाते में। इसके बिना, "द" इन द "द टेस्टिंग
इज

बेंचमार्किंग और स्ट्रिंग के साथ इसकी तुलना की गई। नमूना-तरीका - लगभग 1.5 गुना तेजी से काम करता है। कुडोस।
एलेक्स

20

संपादित करें:

source.Split('/').Length-1

2
मैं यह करता हूं। और source.Split(new[]{"//"}, StringSplitOptions.None).Count - 1बहु-चरित्र विभाजकों के लिए।
bzlm

4
यह ढेर पर कम से कम n स्ट्रिंग आवंटन प्रदर्शन करेगा, प्लस (संभवतः) कुछ सरणी फिर से आकार - और यह सब सिर्फ गिनती प्राप्त करने के लिए? बेहद अक्षम, अच्छी तरह से पैमाने पर नहीं है और किसी भी महत्वपूर्ण कोड में कभी भी इस्तेमाल नहीं किया जाना चाहिए।
ज़ार शारदान

17

C # में, एक अच्छा स्ट्रिंग सबस्ट्रिंग काउंटर यह अप्रत्याशित रूप से मुश्किल साथी है:

public static int CCount(String haystack, String needle)
{
    return haystack.Split(new[] { needle }, StringSplitOptions.None).Length - 1;
}

1
अच्छा समाधान - और स्ट्रिंग के लिए भी काम करना (न सिर्फ चार)!
चरीफ

धन्यवाद, जब भाषा की अदला-बदली की जा रही है, तो कुछ हद तक स्ट्रिंग हैंडलिंग की कुछ सूक्ष्मताओं को भूल जाना बहुत आसान है - जैसे हम में से अधिकांश को इन दिनों है!
डेव

1
-1 क्योंकि: क्या आप गणना () और गणना या लंबाई के बीच अंतर जानते हैं? अगर कोई गिनती या लंबाई के बजाय काउंट () का उपयोग कर रहा है तो मैं ट्रिगर हो जाता हूं। गणना () IEnumerator बनाता है, फिर IEnumerable की सभी घटनाओं के माध्यम से जाता है जबकि गणना या लंबाई पहले से ही उस वस्तु के गुण हैं जो सभी तत्वों पर पुनरावृति करने की आवश्यकता के बिना पहले से ही इच्छित गिनती को पकड़ते हैं।
एरोसॉन

अच्छी जगह है, और यह अजीब है कि मेरी लाइब्रेरी में, जहां से मैंने फ़ंक्शन लिया, मैं "लंबाई" का उपयोग कर रहा हूं। संपादित!
डेव

15
Regex.Matches(input,  Regex.Escape("stringToMatch")).Count

1
यह सही नहीं है, यदि इनपुट में रेग्ज रेक्सक्स स्पेशल चार्ज़ यानी | वहाँ एक Regex.Escape (इनपुट) होने की आवश्यकता है
Esben स्कोव पेडर्सन

1
वास्तव में stringToMatchभागने की जरूरत है, नहीं input
थियोडोर ज़ूलियास

आप सही हैं। ठीक कर दिया।
cederlof

13
private int CountWords(string text, string word) {
    int count = (text.Length - text.Replace(word, "").Length) / word.Length;
    return count;
}

क्योंकि मूल समाधान, चेरों के लिए सबसे तेज़ था, मुझे लगता है कि यह तार के लिए भी होगा। इसलिए यहां मेरा योगदान है।

संदर्भ के लिए: मैं एक लॉग फ़ाइल में 'विफल' और 'सफल' जैसे शब्दों की तलाश कर रहा था।

जीआर, बेन


2
बस "शब्द" चर (शून्य त्रुटि से विभाजन) के लिए एक खाली स्ट्रिंग पास न करें।
एंड्रयू जेन्स

12
string s = "65 fght 6565 4665 hjk";
int count = 0;
foreach (Match m in Regex.Matches(s, "65"))
  count++;

20
या Regex.Matches (s, "65")। गिनती ^ _ ^
मेटा

हर तार के लिए काम करता है। "Abc ++ def ++ xyz" में "++" खोजने का प्रयास करें
marsh-wiggle

7

स्ट्रिंग विस्तार विधि का उपयोग करने के लिए तैयार किसी के लिए,

यहां मैं वह उपयोग कर रहा हूं जो पोस्ट किए गए उत्तरों में से सर्वश्रेष्ठ पर आधारित था:

public static class StringExtension
{    
    /// <summary> Returns the number of occurences of a string within a string, optional comparison allows case and culture control. </summary>
    public static int Occurrences(this System.String input, string value, StringComparison stringComparisonType = StringComparison.Ordinal)
    {
        if (String.IsNullOrEmpty(value)) return 0;

        int count    = 0;
        int position = 0;

        while ((position = input.IndexOf(value, position, stringComparisonType)) != -1)
        {
            position += value.Length;
            count    += 1;
        }

        return count;
    }

    /// <summary> Returns the number of occurences of a single character within a string. </summary>
    public static int Occurrences(this System.String input, char value)
    {
        int count = 0;
        foreach (char c in input) if (c == value) count += 1;
        return count;
    }
}

दूसरी विधि उफान पर नहीं जाएगी यदि स्ट्रिंग पास हो गई है या शून्य है? विशुद्ध रूप से एक शैली की दृष्टि से, आप इनपुट को सिस्टम के रूप में क्या परिभाषित कर रहे हैं?
नोडॉइड

7
public static int GetNumSubstringOccurrences(string text, string search)
{
    int num = 0;
    int pos = 0;

    if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(search))
    {
        while ((pos = text.IndexOf(search, pos)) > -1)
        {
            num ++;
            pos += search.Length;
        }
    }
    return num;
}

5

मुझे लगता है कि ऐसा करने का सबसे आसान तरीका रेगुलर एक्सप्रेशंस का उपयोग करना है। इस तरह आप myVar.Split ('x') का उपयोग कर सकते हैं, लेकिन एक से अधिक वर्ण सेटिंग में समान स्प्लिट काउंट प्राप्त कर सकते हैं।

string myVar = "do this to count the number of words in my wording so that I can word it up!";
int count = Regex.Split(myVar, "word").Length;

3
string search = "/string";
var occurrences = (regex.Match(search, @"\/")).Count;

यह हर बार इस कार्यक्रम की गणना करेगा कि प्रोग्राम "/ s" बिल्कुल (केस संवेदी) है और इसके होने की संख्या को "आवृत्तियों" में संग्रहीत किया जाएगा।


3

मुझे लगा कि हमारे पास कुछ प्रकार की उप स्ट्रिंग गिनती की कमी थी, जैसे कि असुरक्षित बाइट-बाइट तुलना। मैंने मूल पोस्टर की विधि और मेरे विचार के किसी भी तरीके को एक साथ रखा।

ये मेरे द्वारा बनाए गए स्ट्रिंग एक्सटेंशन हैं।

namespace Example
{
    using System;
    using System.Text;

    public static class StringExtensions
    {
        public static int CountSubstr(this string str, string substr)
        {
            return (str.Length - str.Replace(substr, "").Length) / substr.Length;
        }

        public static int CountSubstr(this string str, char substr)
        {
            return (str.Length - str.Replace(substr.ToString(), "").Length);
        }

        public static int CountSubstr2(this string str, string substr)
        {
            int substrlen = substr.Length;
            int lastIndex = str.IndexOf(substr, 0, StringComparison.Ordinal);
            int count = 0;
            while (lastIndex != -1)
            {
                ++count;
                lastIndex = str.IndexOf(substr, lastIndex + substrlen, StringComparison.Ordinal);
            }

            return count;
        }

        public static int CountSubstr2(this string str, char substr)
        {
            int lastIndex = str.IndexOf(substr, 0);
            int count = 0;
            while (lastIndex != -1)
            {
                ++count;
                lastIndex = str.IndexOf(substr, lastIndex + 1);
            }

            return count;
        }

        public static int CountChar(this string str, char substr)
        {
            int length = str.Length;
            int count = 0;
            for (int i = 0; i < length; ++i)
                if (str[i] == substr)
                    ++count;

            return count;
        }

        public static int CountChar2(this string str, char substr)
        {
            int count = 0;
            foreach (var c in str)
                if (c == substr)
                    ++count;

            return count;
        }

        public static unsafe int CountChar3(this string str, char substr)
        {
            int length = str.Length;
            int count = 0;
            fixed (char* chars = str)
            {
                for (int i = 0; i < length; ++i)
                    if (*(chars + i) == substr)
                        ++count;
            }

            return count;
        }

        public static unsafe int CountChar4(this string str, char substr)
        {
            int length = str.Length;
            int count = 0;
            fixed (char* chars = str)
            {
                for (int i = length - 1; i >= 0; --i)
                    if (*(chars + i) == substr)
                        ++count;
            }

            return count;
        }

        public static unsafe int CountSubstr3(this string str, string substr)
        {
            int length = str.Length;
            int substrlen = substr.Length;
            int count = 0;
            fixed (char* strc = str)
            {
                fixed (char* substrc = substr)
                {
                    int n = 0;

                    for (int i = 0; i < length; ++i)
                    {
                        if (*(strc + i) == *(substrc + n))
                        {
                            ++n;
                            if (n == substrlen)
                            {
                                ++count;
                                n = 0;
                            }
                        }
                        else
                            n = 0;
                    }
                }
            }

            return count;
        }

        public static int CountSubstr3(this string str, char substr)
        {
            return CountSubstr3(str, substr.ToString());
        }

        public static unsafe int CountSubstr4(this string str, string substr)
        {
            int length = str.Length;
            int substrLastIndex = substr.Length - 1;
            int count = 0;
            fixed (char* strc = str)
            {
                fixed (char* substrc = substr)
                {
                    int n = substrLastIndex;

                    for (int i = length - 1; i >= 0; --i)
                    {
                        if (*(strc + i) == *(substrc + n))
                        {
                            if (--n == -1)
                            {
                                ++count;
                                n = substrLastIndex;
                            }
                        }
                        else
                            n = substrLastIndex;
                    }
                }
            }

            return count;
        }

        public static int CountSubstr4(this string str, char substr)
        {
            return CountSubstr4(str, substr.ToString());
        }
    }
}

परीक्षण कोड द्वारा पीछा किया ...

static void Main()
{
    const char matchA = '_';
    const string matchB = "and";
    const string matchC = "muchlongerword";
    const string testStrA = "_and_d_e_banna_i_o___pfasd__and_d_e_banna_i_o___pfasd_";
    const string testStrB = "and sdf and ans andeians andano ip and and sdf and ans andeians andano ip and";
    const string testStrC =
        "muchlongerword amuchlongerworsdfmuchlongerwordsdf jmuchlongerworijv muchlongerword sdmuchlongerword dsmuchlongerword";
    const int testSize = 1000000;
    Console.WriteLine(testStrA.CountSubstr('_'));
    Console.WriteLine(testStrA.CountSubstr2('_'));
    Console.WriteLine(testStrA.CountSubstr3('_'));
    Console.WriteLine(testStrA.CountSubstr4('_'));
    Console.WriteLine(testStrA.CountChar('_'));
    Console.WriteLine(testStrA.CountChar2('_'));
    Console.WriteLine(testStrA.CountChar3('_'));
    Console.WriteLine(testStrA.CountChar4('_'));
    Console.WriteLine(testStrB.CountSubstr("and"));
    Console.WriteLine(testStrB.CountSubstr2("and"));
    Console.WriteLine(testStrB.CountSubstr3("and"));
    Console.WriteLine(testStrB.CountSubstr4("and"));
    Console.WriteLine(testStrC.CountSubstr("muchlongerword"));
    Console.WriteLine(testStrC.CountSubstr2("muchlongerword"));
    Console.WriteLine(testStrC.CountSubstr3("muchlongerword"));
    Console.WriteLine(testStrC.CountSubstr4("muchlongerword"));
    var timer = new Stopwatch();
    timer.Start();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountSubstr(matchA);
    timer.Stop();
    Console.WriteLine("CS1 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrB.CountSubstr(matchB);
    timer.Stop();
    Console.WriteLine("CS1 and: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrC.CountSubstr(matchC);
    timer.Stop();
    Console.WriteLine("CS1 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountSubstr2(matchA);
    timer.Stop();
    Console.WriteLine("CS2 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrB.CountSubstr2(matchB);
    timer.Stop();
    Console.WriteLine("CS2 and: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrC.CountSubstr2(matchC);
    timer.Stop();
    Console.WriteLine("CS2 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountSubstr3(matchA);
    timer.Stop();
    Console.WriteLine("CS3 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrB.CountSubstr3(matchB);
    timer.Stop();
    Console.WriteLine("CS3 and: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrC.CountSubstr3(matchC);
    timer.Stop();
    Console.WriteLine("CS3 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountSubstr4(matchA);
    timer.Stop();
    Console.WriteLine("CS4 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrB.CountSubstr4(matchB);
    timer.Stop();
    Console.WriteLine("CS4 and: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrC.CountSubstr4(matchC);
    timer.Stop();
    Console.WriteLine("CS4 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountChar(matchA);
    timer.Stop();
    Console.WriteLine("CC1 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountChar2(matchA);
    timer.Stop();
    Console.WriteLine("CC2 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountChar3(matchA);
    timer.Stop();
    Console.WriteLine("CC3 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountChar4(matchA);
    timer.Stop();
    Console.WriteLine("CC4 chr: " + timer.Elapsed.TotalMilliseconds + "ms");
}

परिणाम: CSX काउंटसर्स्ट्रक्स के साथ मेल खाता है और CCX काउंटचार्क्स के साथ मेल खाता है। "chr" '_' के लिए एक स्ट्रिंग खोजता है, "और" के लिए एक स्ट्रिंग खोजता है "और", और "mlw" "muchlongerword" के लिए एक स्ट्रिंग खोजता है

CS1 chr: 824.123ms
CS1 and: 586.1893ms
CS1 mlw: 486.5414ms
CS2 chr: 127.8941ms
CS2 and: 806.3918ms
CS2 mlw: 497.318ms
CS3 chr: 201.8896ms
CS3 and: 124.0675ms
CS3 mlw: 212.8341ms
CS4 chr: 81.5183ms
CS4 and: 92.0615ms
CS4 mlw: 116.2197ms
CC1 chr: 66.4078ms
CC2 chr: 64.0161ms
CC3 chr: 65.9013ms
CC4 chr: 65.8206ms

और अंत में, मेरे पास 3.6 मिलियन पात्रों वाली एक फ़ाइल थी। यह "derp adfderdserp dfaerpderp deasderp" 100,000 बार दोहराया गया था। मैंने फ़ाइल के अंदर "derp" के लिए उपरोक्त विधियों के साथ 100 बार इन परिणामों की खोज की।

CS1Derp: 1501.3444ms
CS2Derp: 1585.797ms
CS3Derp: 376.0937ms
CS4Derp: 271.1663ms

तो मेरी 4 वीं विधि निश्चित रूप से विजेता है, लेकिन, वास्तविक रूप से, यदि 3.6 मिलियन चरित्र वाली फ़ाइल को केवल 10086 में सबसे खराब स्थिति के रूप में लिया गया है, तो यह सब काफी नगण्य है।

वैसे, मैंने 3.6 मिलियन कैरेक्टर फाइल में 'd' चार स्कैन काउंटसब्रस्ट और काउंटचार् तरीके के साथ स्कैन किया। परिणाम ...

CS1  d : 2606.9513ms
CS2  d : 339.7942ms
CS3  d : 960.281ms
CS4  d : 233.3442ms
CC1  d : 302.4122ms
CC2  d : 280.7719ms
CC3  d : 299.1125ms
CC4  d : 292.9365ms

मूल पोस्टर विधि इस के अनुसार एक बड़े हिस्टैक में एकल चरित्र सुइयों के लिए बहुत खराब है।

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


प्रदर्शन के परिणामों के लिए धन्यवाद। 10 की गति में एक कारक अंतर एक linq या अन्य बड़े करीने से लिखे गए समाधान पर विचार नहीं करने का एक कारण हो सकता है लेकिन एक विस्तार विधि के साथ जाना।
एंड्रियास रीफ

2

तार की घटनाओं के लिए एक सामान्य कार्य:

public int getNumberOfOccurencies(String inputString, String checkString)
{
    if (checkString.Length > inputString.Length || checkString.Equals("")) { return 0; }
    int lengthDifference = inputString.Length - checkString.Length;
    int occurencies = 0;
    for (int i = 0; i < lengthDifference; i++) {
        if (inputString.Substring(i, checkString.Length).Equals(checkString)) { occurencies++; i += checkString.Length - 1; } }
    return occurencies;
}

2
यह अस्थायी तार की एक बड़ी संख्या बनाता है और कचरा संग्रहकर्ता को बहुत कठिन काम करता है।
एरिकला

2
string source = "/once/upon/a/time/";
int count = 0, n = 0;
while ((n = source.IndexOf('/', n) + 1) != 0) count++;

रिचर्ड वॉटसन के जवाब पर एक भिन्नता, दक्षता में सुधार के साथ थोड़ा तेज है कि स्ट्रिंग में अधिक बार चार बार होता है, और कम कोड!

हालांकि मुझे कहना होगा कि हर परिदृश्य का व्यापक परीक्षण किए बिना, मैंने उपयोग करके बहुत महत्वपूर्ण गति सुधार देखा:

int count = 0;
for (int n = 0; n < source.Length; n++) if (source[n] == '/') count++;

2
            var conditionalStatement = conditionSetting.Value;

            //order of replace matters, remove == before =, incase of ===
            conditionalStatement = conditionalStatement.Replace("==", "~").Replace("!=", "~").Replace('=', '~').Replace('!', '~').Replace('>', '~').Replace('<', '~').Replace(">=", "~").Replace("<=", "~");

            var listOfValidConditions = new List<string>() { "!=", "==", ">", "<", ">=", "<=" };

            if (conditionalStatement.Count(x => x == '~') != 1)
            {
                result.InvalidFieldList.Add(new KeyFieldData(batch.DECurrentField, "The IsDoubleKeyCondition does not contain a supported conditional statement. Contact System Administrator."));
                result.Status = ValidatorStatus.Fail;
                return result;
            }

एक तार से सशर्त बयानों का परीक्षण करने के लिए कुछ समान करने की आवश्यकता है।

एक चरित्र के साथ मैं जो देख रहा था उसे बदला और एकल चरित्र के उदाहरणों को गिना।

स्पष्ट रूप से आपके द्वारा उपयोग किए जा रहे एकल वर्ण को गलत गणना से बचने के लिए स्ट्रिंग में मौजूद नहीं होने के लिए जाँचने की आवश्यकता होगी।


2

स्ट्रिंग में स्ट्रिंग:

"Etc" को ".. JD JD JD JD इत्यादि" और "JDJDJDJDJDJDJDJDJD" और "

var strOrigin = " .. JD JD JD JD etc. and etc. JDJDJDJDJDJDJDJD and etc.";
var searchStr = "etc";
int count = (strOrigin.Length - strOrigin.Replace(searchStr, "").Length)/searchStr.Length.

इस एक को निराधार / अनाड़ी के रूप में त्यागने से पहले प्रदर्शन की जाँच करें ...


2

मेरे शुरुआती ने मुझे कुछ इस तरह दिया:

public static int CountOccurrences(string original, string substring)
{
    if (string.IsNullOrEmpty(substring))
        return 0;
    if (substring.Length == 1)
        return CountOccurrences(original, substring[0]);
    if (string.IsNullOrEmpty(original) ||
        substring.Length > original.Length)
        return 0;
    int substringCount = 0;
    for (int charIndex = 0; charIndex < original.Length; charIndex++)
    {
        for (int subCharIndex = 0, secondaryCharIndex = charIndex; subCharIndex < substring.Length && secondaryCharIndex < original.Length; subCharIndex++, secondaryCharIndex++)
        {
            if (substring[subCharIndex] != original[secondaryCharIndex])
                goto continueOuter;
        }
        if (charIndex + substring.Length > original.Length)
            break;
        charIndex += substring.Length - 1;
        substringCount++;
    continueOuter:
        ;
    }
    return substringCount;
}

public static int CountOccurrences(string original, char @char)
{
    if (string.IsNullOrEmpty(original))
        return 0;
    int substringCount = 0;
    for (int charIndex = 0; charIndex < original.Length; charIndex++)
        if (@char == original[charIndex])
            substringCount++;
    return substringCount;
}

प्रतिस्थापित और विभाजन का उपयोग करते हुए एक हाईस्टैक दृष्टिकोण में सुई 21+ सेकंड की उपज देती है जबकि इसमें लगभग 15.2 लगते हैं।

थोड़ा जोड़ने के बाद संपादित करें जो जोड़ देगा substring.Length - 1 charIndex में देगा (जैसे इसे चाहिए), यह 11.6 सेकंड पर है।

संपादित करें 2: मैंने एक स्ट्रिंग का उपयोग किया था जिसमें 26 दो-वर्ण स्ट्रिंग्स थे, यहां एक ही नमूना ग्रंथों को अपडेट किया गया है:

सुई एक घास का मैदान (ओपी संस्करण) में: 7.8 सेकंड

सुझाया गया तंत्र: 4.6 सेकंड।

संपादन 3: एकल वर्ण कोने-केस को जोड़कर, यह 1.2 सेकंड तक चला गया।

संपादन 4: संदर्भ के लिए: 50 मिलियन पुनरावृत्तियों का उपयोग किया गया था।


2

सोचा कि मैं अपनी विस्तार विधि को रिंग में फेंक दूंगा (अधिक जानकारी के लिए टिप्पणियां देखें)। मैंने कोई औपचारिक बेंच मार्किंग नहीं की है, लेकिन मुझे लगता है कि ज्यादातर परिदृश्यों के लिए यह बहुत तेज होना चाहिए।

संपादित करें: ठीक है - तो यह एसओ प्रश्न मुझे यह सोचने के लिए मिला कि हमारे वर्तमान कार्यान्वयन का प्रदर्शन यहां प्रस्तुत कुछ समाधानों के खिलाफ कैसे ढेर होगा। मैंने थोड़ी सी बेंच मार्किंग करने का फैसला किया और पाया कि हमारा समाधान रिचर्ड वाटसन द्वारा प्रदान किए गए समाधान के प्रदर्शन के अनुरूप था। जब तक कि आप बड़े स्ट्रिंग्स (100 Kb +), बड़े सबस्ट्रिंग (32 Kb +) के साथ आक्रामक खोज नहीं कर रहे हैं ) और कई एम्बेडेड दोहराव (10K +)। उस समय हमारा समाधान 2X से 4X धीमा था। इस और इस तथ्य को देखते हुए कि हम वास्तव में रिचर्ड वॉटसन द्वारा प्रस्तुत समाधान को पसंद करते हैं, हमने अपने समाधान को उसी के अनुसार फिर से बनाया है। मैं बस इसे किसी के लिए भी उपलब्ध कराना चाहता था जो इससे लाभान्वित हो सके।

हमारा मूल समाधान:

    /// <summary>
    /// Counts the number of occurrences of the specified substring within
    /// the current string.
    /// </summary>
    /// <param name="s">The current string.</param>
    /// <param name="substring">The substring we are searching for.</param>
    /// <param name="aggressiveSearch">Indicates whether or not the algorithm 
    /// should be aggressive in its search behavior (see Remarks). Default 
    /// behavior is non-aggressive.</param>
    /// <remarks>This algorithm has two search modes - aggressive and 
    /// non-aggressive. When in aggressive search mode (aggressiveSearch = 
    /// true), the algorithm will try to match at every possible starting 
    /// character index within the string. When false, all subsequent 
    /// character indexes within a substring match will not be evaluated. 
    /// For example, if the string was 'abbbc' and we were searching for 
    /// the substring 'bb', then aggressive search would find 2 matches 
    /// with starting indexes of 1 and 2. Non aggressive search would find 
    /// just 1 match with starting index at 1. After the match was made, 
    /// the non aggressive search would attempt to make it's next match 
    /// starting at index 3 instead of 2.</remarks>
    /// <returns>The count of occurrences of the substring within the string.</returns>
    public static int CountOccurrences(this string s, string substring, 
        bool aggressiveSearch = false)
    {
        // if s or substring is null or empty, substring cannot be found in s
        if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(substring))
            return 0;

        // if the length of substring is greater than the length of s,
        // substring cannot be found in s
        if (substring.Length > s.Length)
            return 0;

        var sChars = s.ToCharArray();
        var substringChars = substring.ToCharArray();
        var count = 0;
        var sCharsIndex = 0;

        // substring cannot start in s beyond following index
        var lastStartIndex = sChars.Length - substringChars.Length;

        while (sCharsIndex <= lastStartIndex)
        {
            if (sChars[sCharsIndex] == substringChars[0])
            {
                // potential match checking
                var match = true;
                var offset = 1;
                while (offset < substringChars.Length)
                {
                    if (sChars[sCharsIndex + offset] != substringChars[offset])
                    {
                        match = false;
                        break;
                    }
                    offset++;
                }
                if (match)
                {
                    count++;
                    // if aggressive, just advance to next char in s, otherwise, 
                    // skip past the match just found in s
                    sCharsIndex += aggressiveSearch ? 1 : substringChars.Length;
                }
                else
                {
                    // no match found, just move to next char in s
                    sCharsIndex++;
                }
            }
            else
            {
                // no match at current index, move along
                sCharsIndex++;
            }
        }

        return count;
    }

और यहाँ हमारे संशोधित समाधान है:

    /// <summary>
    /// Counts the number of occurrences of the specified substring within
    /// the current string.
    /// </summary>
    /// <param name="s">The current string.</param>
    /// <param name="substring">The substring we are searching for.</param>
    /// <param name="aggressiveSearch">Indicates whether or not the algorithm 
    /// should be aggressive in its search behavior (see Remarks). Default 
    /// behavior is non-aggressive.</param>
    /// <remarks>This algorithm has two search modes - aggressive and 
    /// non-aggressive. When in aggressive search mode (aggressiveSearch = 
    /// true), the algorithm will try to match at every possible starting 
    /// character index within the string. When false, all subsequent 
    /// character indexes within a substring match will not be evaluated. 
    /// For example, if the string was 'abbbc' and we were searching for 
    /// the substring 'bb', then aggressive search would find 2 matches 
    /// with starting indexes of 1 and 2. Non aggressive search would find 
    /// just 1 match with starting index at 1. After the match was made, 
    /// the non aggressive search would attempt to make it's next match 
    /// starting at index 3 instead of 2.</remarks>
    /// <returns>The count of occurrences of the substring within the string.</returns>
    public static int CountOccurrences(this string s, string substring, 
        bool aggressiveSearch = false)
    {
        // if s or substring is null or empty, substring cannot be found in s
        if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(substring))
            return 0;

        // if the length of substring is greater than the length of s,
        // substring cannot be found in s
        if (substring.Length > s.Length)
            return 0;

        int count = 0, n = 0;
        while ((n = s.IndexOf(substring, n, StringComparison.InvariantCulture)) != -1)
        {
            if (aggressiveSearch)
                n++;
            else
                n += substring.Length;
            count++;
        }

        return count;
    }

1
string Name = "Very good nice one is very good but is very good nice one this is called the term";
bool valid=true;
int count = 0;
int k=0;
int m = 0;
while (valid)
{
    k = Name.Substring(m,Name.Length-m).IndexOf("good");
    if (k != -1)
    {
        count++;
        m = m + k + 4;
    }
    else
        valid = false;
}
Console.WriteLine(count + " Times accures");

1
string s = "HOWLYH THIS ACTUALLY WORKSH WOWH";
int count = 0;
for (int i = 0; i < s.Length; i++)
   if (s[i] == 'H') count++;

यह सिर्फ स्ट्रिंग में प्रत्येक चरित्र की जांच करता है, यदि चरित्र वह चरित्र है जिसे आप खोज रहे हैं, गिनती में जोड़ें।


1

यदि आप इस वेबपेज को देखते हैं , तो इसे करने के 15 अलग-अलग तरीकों को बेंचमार्क किया जाता है, जिसमें समानांतर छोरों का उपयोग करना भी शामिल है।

सबसे तेज़ तरीका या तो सिंगल थ्रेडेड-लूप (यदि आपके पास। नेट वर्जन <4.0) का उपयोग कर रहा है या एक समानांतर.फ्लो लूप (यदि .Net> 4.0 चेक के हजारों के साथ) का उपयोग कर रहा है।

मान लें कि "ss" आपकी खोज स्ट्रिंग है, "ch" आपका चरित्र सरणी है (यदि आपके पास एक से अधिक चार वर्ण हैं जिनकी आप तलाश कर रहे हैं), तो यहां कोड का मूल सार है जो सबसे तेज चलने वाला एकल सिंगल थ्रेडेड है:

for (int x = 0; x < ss.Length; x++)
{
    for (int y = 0; y < ch.Length; y++)
    {
        for (int a = 0; a < ss[x].Length; a++ )
        {
        if (ss[x][a] == ch[y])
            //it's found. DO what you need to here.
        }
    }
}

बेंचमार्क स्रोत कोड भी प्रदान किया गया है ताकि आप अपने स्वयं के परीक्षण चला सकें।


1
str="aaabbbbjjja";
int count = 0;
int size = str.Length;

string[] strarray = new string[size];
for (int i = 0; i < str.Length; i++)
{
    strarray[i] = str.Substring(i, 1);
}
Array.Sort(strarray);
str = "";
for (int i = 0; i < strarray.Length - 1; i++)
{

    if (strarray[i] == strarray[i + 1])
    {

        count++;
    }
    else
    {
        count++;
        str = str + strarray[i] + count;
        count = 0;
    }

}
count++;
str = str + strarray[strarray.Length - 1] + count;

यह चरित्र की गिनती को गिनने के लिए है। इस उदाहरण के लिए आउटपुट "a4b4j3" होगा


2
अधिक 'नॉट ए स्ट्रिंग ऑफ काउंटिंग' अधिक गिनती वाले पात्र हैं - यह निर्दिष्ट करने के तरीके के बारे में कि स्ट्रिंग से मिलान करने का तरीका क्या था?
पॉल सुलिवन

1
int count = 0; string str = "हमारे पास फू और फू है कृपया इस में फू को गिनें"; स्ट्रिंग स्ट्रोक = "फू"; string [] strarray = str.Split (''); Array.Sort (strarray); str = ""; for (int i = 0; मैं <strarray.Length - 1; i ++) {if (strarray [i] == strccurance) {गिनती ++; }} str = "" स्ट्रोकहेयर + "के लिए होने वाली संख्या" + गणना है; इसके माध्यम से आप इस उदाहरण में किसी भी प्रकार के तनाव की गणना कर सकते हैं, मैं "फू" के प्रदूषण की गणना कर रहा हूं और यह मुझे आउटपुट देगा 3.
नरेंद्र कुमार

1

एक स्ट्रिंग सीमांकक के मामले के लिए (चार के मामले के लिए नहीं, जैसा कि विषय कहता है):
स्ट्रिंग स्रोत = "@@@ एक बार @@@ @@@ @@@@@@ @@@ @@;
int count = source.Split (new [] {"@@@"}, StringSplitOptions.RemoveEmptyEntries) .Length - 1;

पोस्टर के मूल स्रोत का मूल्य ("/ एक बार / पर / एक / समय /") प्राकृतिक सीमांकक एक चार '/' है और प्रतिक्रियाएं बताती हैं source.Split (char []) विकल्प हालांकि ...


हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.