मैं एक स्ट्रिंग में एक चार की घटनाओं की संख्या कैसे गिनूं?

Question

मेरे पास तार है

a.b.c.d

मैं 'की घटनाओं को गिनना चाहता हूं।' मुहावरेदार तरीके से, अधिमानतः एक-लाइनर।

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

Comments

घर का पाठ? क्योंकि अन्यथा मुझे लूप से बचने की आवश्यकता नहीं दिखती है।

— फीलो

एक मुहावरेदार एक-लाइनर की तलाश में एक लूप के विपरीत नहीं।

— बार्ट

इस तरह की समस्या के लिए लूप्स बनाए गए थे, लूप को एक आम यूटिलिटी क्लास में लिखें, फिर अपने ताज़ा किए गए एक लाइनर को कॉल करें।

— चे जावरा

तार के समान प्रश्न: stackoverflow.com/questions/767759/…

— koppor

बस इंगित करने के लिए - मैं वन-लाइनर्स खोजने की सराहना करता हूं, यह मजेदार है और (एक सच्चे लाभ के रूप में) अक्सर याद रखना आसान होता है, लेकिन मैं यह बताना चाहूंगा कि एक अलग विधि और एक लूप हर तरह से बेहतर है - अस्थिरता और यहां तक ​​कि प्रदर्शन। नीचे दिए गए "सुरुचिपूर्ण" समाधानों में से अधिकांश बहुत अच्छा प्रदर्शन नहीं कर रहे हैं क्योंकि उनमें सुधार तार / कॉपी मेमोरी शामिल है, जबकि एक लूप जो सिर्फ स्ट्रिंग और गिनती की गई घटनाओं को स्कैन करता है, तेज और सरल होगा। ऐसा नहीं है कि प्रदर्शन आम तौर पर एक कारक होना चाहिए, लेकिन एक लूप पर एक-लाइन को न देखें और मान लें कि यह बेहतर प्रदर्शन करेगा।

— बिल के

Answer 1

इसके लिए मेरा 'मुहावरेदार वन-लाइनर' है:

int count = StringUtils.countMatches("a.b.c.d", ".");

जब यह पहले से ही कॉमन्स लैंग में है तो इसे खुद क्यों लिखें ?

इसके लिए स्प्रिंग फ्रेमवर्क का आईलाइनर है:

int occurance = StringUtils.countOccurrencesOf("a.b.c.d", ".");

Comments

अमरूद समतुल्य: int count = CharMatcher.is('.').countIn("a.b.c.d");... जैसा कि डुप्लिकेट द्वारा डुप्लिकेट प्रश्न में उत्तर दिया गया है।

— जॉनिक

हालांकि, मैं इसे कम नहीं करूंगा, यह (ए) 3 पार्टी के काम की आवश्यकता है और (बी) महंगा है।

— जावदबा २३'१४

यह केवल स्प्रिंग फ्रेम वर्क के साथ काम करना है।

— इसुरु मदुसनका

अगर किसी को इसकी आवश्यकता है: grepcode.com/file/repo1.maven.org/maven2/commons-lang/…

— cV2

क्या महंगा है, हर कंपनी में जिस पर मैंने काम किया है, बहुत खराब-लिखित और खराब-रखरखाव वाली "* यूटिल्स" कक्षाएं लगा रही है। आपकी नौकरी का हिस्सा यह जानना है कि Apache Commons में क्या उपलब्ध है।

— अबूनासर

Answer 2

इस बारे में कैसा है। यह नीचे दिए गए regexp का उपयोग नहीं करता है इसलिए अन्य समाधानों की तुलना में तेज होना चाहिए और लूप का उपयोग नहीं करेगा।

int count = line.length() - line.replace(".", "").length();

Comments

सबसे आसान तरीका। चतुर एक। और यह एंड्रॉइड पर काम करता है, जहां कोई

— स्ट्रिंग स्ट्रिंग

यह सबसे अच्छा जवाब है। इसका सबसे अच्छा कारण यह है कि आपको किसी अन्य पुस्तकालय को आयात करने की आवश्यकता नहीं है।

— एलेक्स स्पेंसर

बहुत ही व्यावहारिक लेकिन बदसूरत नरक के रूप में। मैं इसकी अनुशंसा नहीं करता क्योंकि यह भ्रामक कोड की ओर जाता है।

— डैनियल सैन

अग्ली कोड को अपने स्वयं के "स्ट्रिंगरिल्स" वर्ग में एक विधि बनाकर कम से कम किया जा सकता है। तब बदसूरत कोड बिल्कुल एक जगह पर है, और हर जगह अच्छी तरह से पढ़ा जा सकता है।

— रॉन

लूप विधि इससे बहुत तेज है। खासकर जब एक स्ट्रिंग के बजाय एक चार्ट को गिनना चाहते हैं (क्योंकि कोई स्ट्रिंग नहीं है। स्ट्रिंग (चार, चार) विधि)। 15 कैरेक्टर स्ट्रिंग पर, मुझे 6049 एनएस बनाम 26,739 एनएस (100runs से अधिक औसत) का अंतर मिलता है। कच्चे नंबरों में बहुत अंतर होता है, लेकिन पर्किटेज वार ... यह और बढ़ाता है। स्मृति आवंटन से बचें - एक लूप का उपयोग करें!

— बेन

Answer 3

अन्य उत्तर को संक्षेप में बताएं और एक लाइनर का उपयोग करके इसे करने के सभी तरीके जानते हैं:

   String testString = "a.b.c.d";

1) अपाचे कॉमन्स का उपयोग करना

int apache = StringUtils.countMatches(testString, ".");
System.out.println("apache = " + apache);

2) स्प्रिंग फ्रेमवर्क का उपयोग करना

int spring = org.springframework.util.StringUtils.countOccurrencesOf(testString, ".");
System.out.println("spring = " + spring);

3) प्रतिस्थापित का उपयोग करना

int replace = testString.length() - testString.replace(".", "").length();
System.out.println("replace = " + replace);

4) प्रतिस्थापन का उपयोग करना (केस 1)

int replaceAll = testString.replaceAll("[^.]", "").length();
System.out.println("replaceAll = " + replaceAll);

5) प्रतिस्थापन का उपयोग करना (केस 2)

int replaceAllCase2 = testString.length() - testString.replaceAll("\\.", "").length();
System.out.println("replaceAll (second case) = " + replaceAllCase2);

6) विभाजन का उपयोग करना

int split = testString.split("\\.",-1).length-1;
System.out.println("split = " + split);

7) Java8 (केस 1) का उपयोग करना

long java8 = testString.chars().filter(ch -> ch =='.').count();
System.out.println("java8 = " + java8);

8) Java8 (केस 2 ) का उपयोग करना , केस 1 की तुलना में यूनिकोड के लिए बेहतर हो सकता है

long java8Case2 = testString.codePoints().filter(ch -> ch =='.').count();
System.out.println("java8 (second case) = " + java8Case2);

9) StringTokenizer का उपयोग करना

int stringTokenizer = new StringTokenizer(" " +testString + " ", ".").countTokens()-1;
System.out.println("stringTokenizer = " + stringTokenizer);

टिप्पणी से : StringTokenizer के लिए केयरफुल रहें, abcd के लिए यह काम करेगा लेकिन a ... bc ... d या ... abcd या के लिए .... b ...... c ..... d ... या आदि यह काम नहीं करेगा। बस इसके लिए गिनती होगी। पात्रों के बीच सिर्फ एक बार

अधिक जानकारी github में

परफॉमेंस टेस्ट ( JMH , मोड = एवरटाइम का उपयोग करके , 0.010फिर बेहतर स्कोर 0.351):

Benchmark              Mode  Cnt  Score    Error  Units
1. countMatches        avgt    5  0.010 ±  0.001  us/op
2. countOccurrencesOf  avgt    5  0.010 ±  0.001  us/op
3. stringTokenizer     avgt    5  0.028 ±  0.002  us/op
4. java8_1             avgt    5  0.077 ±  0.005  us/op
5. java8_2             avgt    5  0.078 ±  0.003  us/op
6. split               avgt    5  0.137 ±  0.009  us/op
7. replaceAll_2        avgt    5  0.302 ±  0.047  us/op
8. replace             avgt    5  0.303 ±  0.034  us/op
9. replaceAll_1        avgt    5  0.351 ±  0.045  us/op

Comments

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

— मार्टन बोडेवेस

केस 2, एक यूआरएफ -16 कोड इकाई से अधिक की आवश्यकता वाले कोडपाइंट के लिए सामान्यीकृत:"1🚲2🚲3 has 2".codePoints().filter((c) -> c == "🚲".codePointAt(0)).count()

— टॉम ब्लोडेट

Answer 4

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

हर तरह से एक अलग विधि में लूप encapsulate, जैसे

public static int countOccurrences(String haystack, char needle)
{
    int count = 0;
    for (int i=0; i < haystack.length(); i++)
    {
        if (haystack.charAt(i) == needle)
        {
             count++;
        }
    }
    return count;
}

फिर आपको अपने मुख्य कोड में लूप की आवश्यकता नहीं है - लेकिन लूप को कहीं न कहीं होना चाहिए।

Comments

(int i = 0, l = haystack.length (); i <l; i ++) आपके ढेर के समान हो

— क्रिस

(मुझे यह भी निश्चित नहीं है कि टिप्पणी का "स्टैक" कहां से आता है। ऐसा नहीं है कि यह उत्तर मेरे पुनरावर्ती है, जो वास्तव में स्टैक के लिए बुरा है।)

— जॉन स्कीट

इतना ही नहीं, लेकिन यह संभवतः एक विरोधी अनुकूलन है जो जीट क्या करता है पर एक नज़र डाले बिना। यदि आप उदाहरण के लिए पाश के लिए एक सरणी पर ऊपर किया है तो आप चीजों को बदतर बना सकते हैं।

— शुग्गीकोउक

@ सुलु: एक तुच्छ JIT अनुकूलन के सामने क्रिस की चिंता बेबुनियाद है । क्या कोई कारण है कि टिप्पणी ने आपका ध्यान फिलहाल तीन साल बाद खींचा है? बस दिलचस्पी है।

— जॉन स्कीट

शायद @sulai सिर्फ इस सवाल पर आई थी जैसा कि मैंने किया था (जबकि सोच रहा था कि जावा में इसके लिए एक अंतर्निहित विधि है) और तारीखों पर ध्यान नहीं दिया था। हालाँकि, मैं उत्सुक हूं length()कि लूप के बाहर कॉल को स्थानांतरित करने से प्रदर्शन कितना खराब हो सकता है , जैसा कि @ShuggyCoUk द्वारा कुछ टिप्पणियों को बताया गया है।

— JKillian

Answer 5

मुझे माल्डेन के समान एक विचार था, लेकिन इसके विपरीत ...

String s = "a.b.c.d";
int charCount = s.replaceAll("[^.]", "").length();
println(charCount);

Comments

सही बात। रिप्लेसमेंट ("।") किसी भी वर्ण को प्रतिस्थापित करेगा, केवल डॉट नहीं। रिप्लेसमेंट ("\\")) ने काम किया होगा। आपका समाधान अधिक सीधा है।

— VonC

jjnguy ने वास्तव में मेरे "abcd" .split ("\\")) को देखते हुए एक प्रतिस्थापन ("[^।]") का सुझाव दिया था। लंबाई -1 समाधान। लेकिन 5 बार हिट होने के बाद, मैंने अपना उत्तर (और उसकी टिप्पणी) हटा दिया।

— VonC

(Oblig।) "... अब आपके पास दो समस्याएं हैं" वैसे भी, मैं वहाँ में क्रियान्वित छोरों के दसियों हैं कि यकीन था replaceAll()और length()। ठीक है, अगर यह दिखाई नहीं देता है, तो यह मौजूद नहीं है; ओ)

— पिस्कोर ने

मुझे नहीं लगता कि regex का उपयोग करना और गिनती के लिए एक नया स्ट्रिंग बनाना एक अच्छा विचार है। मैं बस एक स्थिर विधि बनाऊंगा जो संख्या की गणना करने के लिए स्ट्रिंग के प्रत्येक वर्ण को लूप करेगी।

— मिंगफई

@mingfai: वास्तव में, लेकिन मूल प्रश्न वन-लाइनर बनाने के बारे में है, और यहां तक ​​कि, लूप के बिना (आप एक पंक्ति में एक लूप कर सकते हैं, लेकिन यह बदसूरत होगा!)। प्रश्न पर सवाल करें, जवाब नहीं ... :-)

— फीलो

Answer 6

String s = "a.b.c.d";
int charCount = s.length() - s.replaceAll("\\.", "").length();

रिप्लेसमेंट ("") सभी वर्णों को बदल देगा।

फील्हो का समाधान रिप्लेसमेंट ("[^।]", "") का उपयोग करता है, जिसे बचने की आवश्यकता नहीं है, क्योंकि []] चरित्र 'डॉट' का प्रतिनिधित्व करता है, न कि 'किसी भी वर्ण' का।

Comments

मैं यह पसंद है। वहाँ अभी भी एक लूप है, ज़ाहिर है, जैसा कि वहाँ होना है।

— अर्चेतपाल पॉल

एनबी है कि आप इस संख्या को विभाजित करने की आवश्यकता है अगर आप लंबाई> 1

— rogerdpack

Answer 7

मेरा 'मुहावरेदार वन-लाइनर' समाधान:

int count = "a.b.c.d".length() - "a.b.c.d".replace(".", "").length();

पता नहीं क्यों StringUtils का उपयोग करने वाला एक समाधान स्वीकार किया जाता है।

Comments

इस पद के समान एक पुराना समाधान है।

— JCalcines

क्योंकि यह समाधान वास्तव में अक्षम है

— एन्द्रेस

यह सिर्फ एक गिनती पैदा करने के लिए एक अतिरिक्त स्ट्रिंग बनाता है। पता नहीं क्यों StringUtils पर कोई भी इसे पसंद करेगा अगर StringUtils एक विकल्प है। यदि यह एक विकल्प नहीं है, तो उन्हें एक उपयोगिता वर्ग में लूप के लिए एक सरल बनाना चाहिए।

— क्रश करें

Answer 8

String s = "a.b.c.d";
long result = s.chars().filter(ch -> ch == '.').count();

Comments

एक देशी समाधान के लिए वोट +।

— स्केज

Answer 9

एक छोटा उदाहरण है

String text = "a.b.c.d";
int count = text.split("\\.",-1).length-1;

Comments

ऐसा लगता है कि यह बहुत बड़ा ओवरहेड है, चेतावनी दी जाती है कि यह बहुत सारे छोटे तार पैदा कर सकता है। आम तौर पर यह ज्यादा मायने नहीं रखता है लेकिन देखभाल के साथ उपयोग करें।

— मार्टन Bodewes 16

Answer 10

यहाँ एक लूप के बिना समाधान है:

public static int countOccurrences(String haystack, char needle, int i){
    return ((i=haystack.indexOf(needle, i)) == -1)?0:1+countOccurrences(haystack, needle, i+1);}


System.out.println("num of dots is "+countOccurrences("a.b.c.d",'.',0));

ठीक है, एक लूप है, लेकिन यह अदृश्य है :-)

- योनातन

Comments

जब तक आपका तार इतना लंबा न हो जाए कि आपको आउटऑफमेरीऑरर मिल जाए।

— स्पेंसर कोरमोस

समस्या होमवर्क होने के लिए पर्याप्त रूप से वंचित लगती है, और यदि हां, तो यह पुनरावृत्ति संभवतः वह उत्तर है जिसे आपको खोजने के लिए कहा जा रहा है।

— एरिकासन

यह indexOf का उपयोग करता है, जो लूप करेगा ... लेकिन एक अच्छा विचार है। एक मिनट में सही मायने में "बस पुनरावर्ती" समाधान पोस्टिंग ...

— जॉन स्कीट

यदि यह अधिक घटनाएँ है कि आपके उपलब्ध स्टैक स्लॉट, आपके पास एक स्टैक ओवरफ़्लो अपवाद होगा?)

— लुका सी।

Answer 11

मुझे इस उद्देश्य के लिए एक नया स्ट्रिंग आवंटित करने का विचार पसंद नहीं है। और जैसा कि स्ट्रिंग में पहले से ही एक चार सरणी है, जहां यह मूल्य रखता है, String.charAt () व्यावहारिक रूप से मुफ़्त है।

for(int i=0;i<s.length();num+=(s.charAt(i++)==delim?1:0))

केवल J2SE के साथ 1 पंक्ति या उससे कम में संग्रह की आवश्यकता वाले अतिरिक्त आवंटन के बिना, चाल करता है।

Comments

इस एक के लिए कुछ प्यार देना क्योंकि यह एक ही है जो स्ट्रिंग पर एक एकल पास कर रहा है। मुझे प्रदर्शन की परवाह है।

— जवदाबा

charAt16 बिट कोड के माध्यम से पुनरावृत्त वर्ण नहीं! एक charजावा में एक चरित्र नहीं है। तो यह उत्तर बताता है कि कोड के बिंदु के बराबर उच्च सरोगेट होने के साथ कोई यूनिकोड प्रतीक नहीं होना चाहिए delim। मुझे यकीन नहीं है कि यह डॉट के लिए सही है, लेकिन सामान्य तौर पर यह सही नहीं हो सकता है।

— बजे

Answer 12

ठीक है, योनातन के समाधान से प्रेरित, यहाँ एक जो पूरी तरह से पुनरावर्ती है - केवल पुस्तकालय के तरीकों का उपयोग किया जाता है length()और charAt(), जिनमें से कोई भी लूपिंग नहीं करता है:

public static int countOccurrences(String haystack, char needle)
{
    return countOccurrences(haystack, needle, 0);
}

private static int countOccurrences(String haystack, char needle, int index)
{
    if (index >= haystack.length())
    {
        return 0;
    }

    int contribution = haystack.charAt(index) == needle ? 1 : 0;
    return contribution + countOccurrences(haystack, needle, index+1);
}

क्या पुनरावृत्ति लूपिंग के रूप में मायने रखता है, इस पर निर्भर करता है कि आप किस सटीक परिभाषा का उपयोग करते हैं, लेकिन यह संभवतः उतना ही करीब है जितना आपको मिलेगा।

मुझे नहीं पता कि इन दिनों अधिकांश JVM टेल-रिकर्स करते हैं ... यदि नहीं, तो आप निश्चित रूप से लंबे समय के स्ट्रिंग्स के लिए एपॉइड स्टैक ओवरफ्लो प्राप्त करेंगे।

Comments

नहीं, पूंछ पुनरावृत्ति संभवतः जावा 7 में होगी, लेकिन यह अभी तक व्यापक नहीं है। यह सरल, प्रत्यक्ष पूंछ पुनरावृत्ति को संकलन समय पर एक लूप में अनुवाद किया जा सकता है, लेकिन जावा 7 सामान वास्तव में विभिन्न तरीकों के माध्यम से चेनिंग को संभालने के लिए जेवीएम में बनाया गया है।

— एरिक्सन

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

— स्टीफन डेने

Answer 13

जॉन स्कीट से प्रेरित होकर, एक गैर-लूप संस्करण जो आपके स्टैक को नहीं उड़ाएगा। इसके अलावा उपयोगी प्रारंभिक बिंदु यदि आप कांटा-जुड़ने की रूपरेखा का उपयोग करना चाहते हैं।

public static int countOccurrences(CharSequeunce haystack, char needle) {
    return countOccurrences(haystack, needle, 0, haystack.length);
}

// Alternatively String.substring/subsequence use to be relatively efficient
//   on most Java library implementations, but isn't any more [2013].
private static int countOccurrences(
    CharSequence haystack, char needle, int start, int end
) {
    if (start == end) {
        return 0;
    } else if (start+1 == end) {
        return haystack.charAt(start) == needle ? 1 : 0;
    } else {
        int mid = (end+start)>>>1; // Watch for integer overflow...
        return
            countOccurrences(haystack, needle, start, mid) +
            countOccurrences(haystack, needle, mid, end);
    }
}

(अस्वीकरण: परीक्षण नहीं, संकलित नहीं, समझदार नहीं।)

शायद सबसे अच्छा (एकल-पिरोया, कोई सरोगेट-जोड़ी समर्थन) इसे लिखने का तरीका:

public static int countOccurrences(String haystack, char needle) {
    int count = 0;
    for (char c : haystack.toCharArray()) {
        if (c == needle) {
           ++count;
        }
    }
    return count;
}

Answer 14

इस की दक्षता के बारे में निश्चित नहीं है, लेकिन यह सबसे छोटा कोड है जिसे मैं तीसरी पार्टी के काम में लाए बिना लिख ​​सकता हूं:

public static int numberOf(String target, String content)
{
    return (content.split(target).length - 1);
}

Comments

स्ट्रिंग के अंत में होने वाली घटनाओं को भी गिनने के लिए आपको इस तरह एक नकारात्मक सीमा तर्क के साथ विभाजन को कॉल करना होगा return (content.split(target, -1).length - 1);:। डिफ़ॉल्ट रूप से स्ट्रिंग के अंत में विभाजित () से उत्पन्न एरे में छोड़ा जाता है। Doku

— vlz

Answer 15

साथ में जावा-8आप इसे प्राप्त करने के लिए धाराओं का उपयोग भी कर सकते हैं। जाहिर है कि पर्दे के पीछे एक पुनरावृति है, लेकिन आपको इसे स्पष्ट रूप से लिखना नहीं है!

public static long countOccurences(String s, char c){
    return s.chars().filter(ch -> ch == c).count();
}

countOccurences("a.b.c.d", '.'); //3
countOccurences("hello world", 'l'); //3

Comments

के .codePoints()बजाय का उपयोग .chars()करना तो किसी भी यूनिकोड मूल्य (सरोगेट जोड़े की आवश्यकता सहित) का समर्थन करेंगे

— ल्यूक उशेरवुड

Answer 16

इस समस्या को हल करने के लिए जावा 8 में कमी का उपयोग करना भी संभव है:

int res = "abdsd3$asda$asasdd$sadas".chars().reduce(0, (a, c) -> a + (c == '$' ? 1 : 0));
System.out.println(res);

आउटपुट:

3

Answer 17

पूरा नमूना:

public class CharacterCounter
{

  public static int countOccurrences(String find, String string)
  {
    int count = 0;
    int indexOf = 0;

    while (indexOf > -1)
    {
      indexOf = string.indexOf(find, indexOf + 1);
      if (indexOf > -1)
        count++;
    }

    return count;
  }
}

कॉल करें:

int occurrences = CharacterCounter.countOccurrences("l", "Hello World.");
System.out.println(occurrences); // 3

Comments

गलत कोड इसका काम नहीं कर रहा है जब मैं int घटनाओं की कोशिश करता हूं = CharacterCounter.countOccurrences ("1", "101"); Println (घटनाओं); // 1

— ज्येष्ठ

मैं उसी तर्क के साथ काम करने वाले कोड के लिए एक फिक्स करता

— हूं

Answer 18

उत्तर पाने का सबसे सरल तरीका इस प्रकार है:

public static void main(String[] args) {
    String string = "a.b.c.d";
    String []splitArray = string.split("\\.",-1);
    System.out.println("No of . chars is : " + (splitArray.length-1));
}

Comments

यह स्निपेट किसी दिए गए इनपुट "एबीसी" के लिए डॉट्स की सही मात्रा नहीं लौटाता है

— dekaru

@ डेरेकु आप टिप्पणी में अपना स्टिंग पेस्ट कर सकते हैं ताकि हम देख सकें।

— अमर

Answer 19

यदि आप स्प्रिंग फ्रेमवर्क का उपयोग कर रहे हैं, तो आप "स्ट्रिंगरिल्स" क्लास का भी उपयोग कर सकते हैं। विधि "countOccurrencesOf" होगी।

Answer 20

आप split()फ़ंक्शन को केवल एक लाइन कोड में उपयोग कर सकते हैं

int noOccurence=string.split("#",-1).length-1;

Comments

स्प्लिट वास्तव में स्ट्रिंग्स की सरणी बनाता है, जिसमें बहुत समय लगता है।

— पालेक

आप सही हैं, यह एक सच्ची चिंता है। दूसरे तरीके से यह आपके प्रोजेक्ट में (यदि अभी तक नहीं किया गया है) तीसरे पक्ष के लिबास को लाने से बचा जाता है। यह निर्भर करता है कि आप क्या करना चाहते हैं और प्रदर्शन अपेक्षा क्या है।

— बेंज

इस समाधान में अनुगामी खाली हिट शामिल नहीं होंगे, क्योंकि तर्क limitइस अतिभारित विभाजन विधि कॉल में शून्य पर सेट है। एक उदाहरण: "1##2#3#####".split("#")केवल आकार 4 ( [0:"1";1:""; 2:"2"; 3:"3"]) के बजाय आकार 9 ( [0:"1"; 1:""; 2:"2"; 3:"3"; 4:""; 5:""; 6:""; 7:""; 8:""]) की एक सरणी देगा ।

— कलार

Answer 21

public static int countOccurrences(String container, String content){
    int lastIndex, currIndex = 0, occurrences = 0;
    while(true) {
        lastIndex = container.indexOf(content, currIndex);
        if(lastIndex == -1) {
            break;
        }
        currIndex = lastIndex + content.length();
        occurrences++;
    }
    return occurrences;
}

Answer 22

import java.util.Scanner;

class apples {

    public static void main(String args[]) {    
        Scanner bucky = new Scanner(System.in);
        String hello = bucky.nextLine();
        int charCount = hello.length() - hello.replaceAll("e", "").length();
        System.out.println(charCount);
    }
}//      COUNTS NUMBER OF "e" CHAR´s within any string input

Answer 23

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

public static int count( final String s, final char c ) {
  final char[] chars = s.toCharArray();
  int count = 0;
  for(int i=0; i<chars.length; i++) {
    if (chars[i] == c) {
      count++;
    }
  }
  return count;
}

ReplaceAll का उपयोग करना (जो कि RE है) जाने के लिए सबसे अच्छा तरीका नहीं है।

Comments

मुझे लगता है कि यह सबसे सुंदर समाधान है। आपनेCharArray का उपयोग क्यों किया और सीधे चार्ज नहीं किया?

— पनयोटिस

कम से कम चारपाई के साथ ढलान कम धीमी गति से हुआ करता था। मंच पर भी निर्भर हो सकता है। वास्तव में पता लगाने का एकमात्र तरीका अंतर को मापना होगा।

— tcurdt

Answer 24

ठीक है, एक बहुत ही समान कार्य के साथ मैं इस थ्रेड पर ठोकर खाई। मैंने कोई प्रोग्रामिंग लैंग्वेज प्रतिबंध नहीं देखा और चूँकि एक जावा vm पर ग्रूवी चलता है: यहाँ मैं ग्रूवी का उपयोग करके अपनी समस्या को हल करने में सक्षम था।

"a.b.c.".count(".")

किया हुआ।

Answer 25

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

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

int getOccurences(String characters, String string) { String[] words = string.split(characters); return words.length - 1; }

यह 4 के मामले में वापस आ जाएगा: getOccurences("o", "something about a quick brown fox");

Comments

यहां समस्या यह है कि एक सरणी आवंटित की जानी है, जो बहुत धीमी है।

— पलक

Answer 26

कहीं कोड में, कुछ को लूप करना है। इसके चारों ओर एकमात्र तरीका लूप का पूर्ण रूप से घूमना है:

int numDots = 0;
if (s.charAt(0) == '.') {
    numDots++;
}

if (s.charAt(1) == '.') {
    numDots++;
}


if (s.charAt(2) == '.') {
    numDots++;
}

... आदि, लेकिन फिर आप स्रोत संपादक में लूप, मैन्युअल रूप से कर रहे हैं - कंप्यूटर के बजाय जो इसे चलाएगा। स्यूडोकोड देखें:

create a project
position = 0
while (not end of string) {
    write check for character at position "position" (see above)
}
write code to output variable "numDots"
compile program
hand in homework
do not think of the loop that your "if"s may have been optimized and compiled to

Answer 27

यहाँ एक अलग शैली पुनरावृत्ति समाधान है:

public static int countOccurrences(String haystack, char needle)
{
    return countOccurrences(haystack, needle, 0);
}

private static int countOccurrences(String haystack, char needle, int accumulator)
{
    if (haystack.length() == 0) return accumulator;
    return countOccurrences(haystack.substring(1), needle, haystack.charAt(0) == needle ? accumulator + 1 : accumulator);
}

Answer 28

क्यों न केवल चरित्र पर विभाजित किया जाए और फिर परिणामी सरणी की लंबाई प्राप्त करें। सरणी की लंबाई हमेशा उदाहरणों की संख्या होगी।

Answer 29

निम्नलिखित स्रोत कोड आपको उपयोगकर्ता द्वारा दर्ज किए गए शब्द में दिए गए स्ट्रिंग की संख्याएँ देता है: -

import java.util.Scanner;

public class CountingOccurences {

    public static void main(String[] args) {

        Scanner inp= new Scanner(System.in);
        String str;
        char ch;
        int count=0;

        System.out.println("Enter the string:");
        str=inp.nextLine();

        while(str.length()>0)
        {
            ch=str.charAt(0);
            int i=0;

            while(str.charAt(i)==ch)
            {
                count =count+i;
                i++;
            }

            str.substring(count);
            System.out.println(ch);
            System.out.println(count);
        }

    }
}

Answer 30

int count = (line.length() - line.replace("str", "").length())/"str".length();