আমি একটি স্ট্রিংয়ে চরের সংঘটনগুলির সংখ্যাটি কীভাবে গণনা করব?

Question

আমার স্ট্রিং আছে

a.b.c.d

আমি 'এর ঘটনাগুলি গণনা করতে চাই।' একটি অহঙ্কারী উপায়ে, একটি ওয়ানলাইনার সাধারণত।

(পূর্বে আমি এই বাধাটি "লুপ ছাড়াই" হিসাবে প্রকাশ করেছি, যদি আপনি ভাবছেন যে লুপটি ব্যবহার না করে কেন সবাই উত্তর দেওয়ার চেষ্টা করছে)।

Comments

বাড়ির কাজ? কারণ অন্যথায় আমি লুপটি এড়ানোর প্রয়োজনীয়তাটি দেখছি না।

— ফিলিহো

কোনও আইডোমেটিক ওয়ান-লাইনার সন্ধানের মতো কোনও লুপকে বিরক্ত করবেন না।

— বার্ট

লুপগুলি এ জাতীয় সমস্যার জন্য তৈরি করা হয়েছিল, একটি সাধারণ ইউটিলিটি ক্লাসে লুপটি লিখুন এবং আপনার তাজা মিন্টেড একটি লাইনারে কল করুন।

— চে জাভারা

স্ট্রিং জন্য অনুরূপ প্রশ্ন: stackoverflow.com/questions/767759/...

— koppor

কেবল উল্লেখ করার জন্য - আমি ওয়ান-লাইনারগুলি খুঁজে পাওয়ার জন্য প্রশংসা করি, এটি মজাদার এবং (সত্যিকারের সুবিধা হিসাবে) প্রায়শই সহজেই মনে রাখা সহজ তবে আমি উল্লেখ করতে চাই যে একটি পৃথক পদ্ধতি এবং লুপ প্রায় প্রতিটি উপায়েই আরও ভাল better - পাঠযোগ্যতা এবং এমনকি কর্মক্ষমতা। নীচের বেশিরভাগ "এলিগ্যান্ট" সমাধানগুলি খুব ভাল সম্পাদন করতে যাচ্ছে না কারণ তারা স্ট্রিংগুলি সংশোধন / মেমরি অনুলিপি করার সাথে জড়িত রয়েছে, তবে একটি লুপ যা কেবল স্ট্রিংটিকে স্ক্যান করেছে এবং গণনা করা ঘটনাগুলি দ্রুত এবং সহজ হবে। পারফরম্যান্স সাধারণত ফ্যাক্টর হওয়া উচিত নয়, তবে লুপের ওপরে এক-লাইনের দিকে তাকান না এবং ধরে নিন যে এটি আরও ভাল সম্পাদন করবে।

— বিল কে

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");... যেমন একটি সদৃশ প্রশ্নের ডগবনে উত্তর ।

— জোনিক

যদিও আমি এটিকে হ্রাস করব না, এটি (ক) তৃতীয় পক্ষের লিবসের প্রয়োজন এবং (খ) ব্যয়বহুল।

— জাভাদবা

এটি কেবল বসন্ত ফ্রেমের কাজের সাথে আমদানি করতে হবে।

— ইসুরু মাদুসঙ্কা

কারও যদি এটির প্রয়োজন হয়: grepcode.com/file/repo1.maven.org/maven2/commons-lang/…

— cV2

যা ব্যয়বহুল হয়েছে, প্রতিটি সংস্থায় আমি যে কাজ করেছি, সেখানে প্রচুর খারাপ-লিখিত এবং দুর্বল রক্ষণাবেক্ষণ করা "* ইউটিস" ক্লাস রয়েছে। আপনার কাজের একটি অংশ হ'ল অ্যাপাচি কমন্সে কী উপলব্ধ।

— আবু নাসার

Answer 2

এই সম্পর্কে কিভাবে। এটি নীচে রিজেক্সপ ব্যবহার করে না তাই অন্যান্য সমাধানগুলির চেয়ে দ্রুত হওয়া উচিত এবং লুপ ব্যবহার করবে না।

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

Comments

সহজ রাস্তা. চালাক এক। এবং এটি অ্যান্ড্রয়েডে কাজ করে, যেখানে স্ট্রিং ইউটিলস শ্রেণি নেই

— জোসে_জিডি

এটি সেরা উত্তর। এটি সর্বোত্তম হওয়ার কারণ হ'ল আপনাকে অন্য লাইব্রেরি আমদানি করতে হবে না।

— অ্যালেক্স স্পেন্সার

খুব ব্যবহারিক কিন্তু জাহান্নাম হিসাবে কুরুচিপূর্ণ। আমি এটির প্রস্তাব দিচ্ছি না কারণ এটি বিভ্রান্তিকর কোডের দিকে নিয়ে যায়।

— ড্যানিয়েল সান

কুরুচিপূর্ণ কোডটিকে আপনার নিজস্ব "স্ট্রিং ইউটিলস" শ্রেণিতে একটি পদ্ধতি তৈরি করে ছোট করা যেতে পারে। তারপরে কুৎসিত কোডটি হুবহু এক জায়গায় রয়েছে এবং অন্য যে কোনও জায়গায় সুন্দরভাবে পাঠযোগ্য।

— রনআর

লুপ পদ্ধতিটি এর চেয়ে অনেক দ্রুত। বিশেষত যখন স্ট্রিংয়ের পরিবর্তে একটি চর গণনা করতে চান (যেহেতু স্ট্রিং.রেপ্লেস (চর, চর) কোনও পদ্ধতি নেই)। 15 টি চরিত্রের স্ট্রিং-এ, আমি 6049 এনএস বনাম 26,739 এনএস (100 টিরও বেশি গড়) এর একটি পার্থক্য পেয়েছি। কাঁচা সংখ্যা বিশাল পার্থক্য, কিন্তু অনুধাবন বুদ্ধিমান ... এটি যোগ করে। মেমরি বরাদ্দ এড়ানো - একটি লুপ ব্যবহার করুন!

— বেন

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) জাভা 8 ব্যবহার করে (কেস 1)

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

8) জাভা 8 (কেস 2) ব্যবহার করা, ইউনিকোডের ক্ষেত্রে কেস 1 এর চেয়ে ভাল

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

9) স্ট্রিংটোকেনাইজার ব্যবহার করে

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

মন্তব্য থেকে : স্ট্রিংটোকেনাইজারের জন্য সাবধান থাকুন, এবিসিডির জন্য এটি কাজ করবে তবে একটি ... বিসি ... ডি বা ... অ্যাবিসিডি বা একটি .... খ ...... সি ..... ডি ... বা ইত্যাদি কাজ করে না। এটি কেবল গণনা করা হবে। অক্ষরের মাঝে একবার

গিথুবে আরও তথ্য

পারফোমেন্স পরীক্ষা ( জেএমএইচ , মোড = অ্যাভারেজটাইম ব্যবহার করে , 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.leth (); i <l; i ++) আপনার স্ট্যাকের সাথে সদয় হন

— ক্রিস

(আমি এমনকি নিশ্চিত যাতে মন্তব্যটি এর "স্ট্যাকের" বিট থেকে আসে মতো নয়। এই উত্তর আমার রিকার্সিভ এক, যা প্রকৃতপক্ষে স্ট্যাকে কদর্য হয়।)

— জন স্কিট

শুধু তা-ই নয় তবে জিট কী করে তা একবার না দেখে সম্ভবত এটি একটি বিরোধী অপ্টিমাইজেশন। উদাহরণস্বরূপ আপনি লুপের জন্য একটি অ্যারেতে যদি উপরে কাজ করেন তবে আপনি জিনিসগুলি আরও খারাপ করতে পারেন।

— ShuggyCoUk

@ সুলাই: তুচ্ছ জেআইটি অপ্টিমাইজেশনের মুখে আইএমও ক্রিসের উদ্বেগ ভিত্তিহীন । এমন কি কোনও কারণ আছে যে মন্তব্যটি এই মুহূর্তে আপনার দৃষ্টি আকর্ষণ করেছিল, তিন বছর পরে? শুধু আগ্রহ।

— জন স্কিটি

সম্ভবত @ সুলাই কেবল যেমনটি করেছিলেন ঠিক তেমন প্রশ্নটি জুড়ে এসেছিল (ভেবে ভেবেছিলেন যে জাভা এর জন্য অন্তর্নির্মিত পদ্ধতি আছে কিনা) এবং তারিখগুলি লক্ষ্য করে না। যাইহোক, আমি আগ্রহী যে কীভাবে length()লুপের বাইরে কলটি সরিয়ে নেওয়া পারফরম্যান্সকে আরও খারাপ করতে পারে , যেমনটি @ শুগিকুক কিছু মন্তব্য করেছেন।

— জেকিলিয়ান

Answer 5

ম্লাদেনের মতো আমার ধারণা ছিল, তবে বিপরীত ...

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

Comments

সঠিক। রিপ্লেসএল ("।") কেবল বিন্দু নয়, কোনও অক্ষর প্রতিস্থাপন করবে। রিপ্লেসএল ("\\।") কাজ করবে। আপনার সমাধানটি আরও সোজা।

— ভোনসি

আমার "abcd" .স্প্লিট ("\\।")। দৈর্ঘ্য -1 সমাধান দেখে প্রথমে jjnguy প্রথমে একটি প্রতিস্থাপনের পরামর্শ দিয়েছিল ("[^।]")) তবে 5 বার আঘাত করার পরে, আমি আমার উত্তর (এবং তার মন্তব্য) মুছলাম।

— ভোনসি

(oblig।) "... এখন আপনি দুটি সমস্যা আছে" যাই হোক, আমি সেখানে নির্বাহ লুপ দশ আছে বাজি ধরে বলতে পারি চাই replaceAll()এবং length()। ঠিক আছে, যদি এটি দৃশ্যমান না হয় তবে এর অস্তিত্ব নেই; ও)

— পিসকভোর

আমি মনে করি না রেজেক্স ব্যবহার করা এবং গণনার জন্য একটি নতুন স্ট্রিং তৈরি করা ভাল ধারণা। আমি কেবল একটি স্থিতিশীল পদ্ধতি তৈরি করব যা সংখ্যাটি গণনা করার জন্য স্ট্রিংয়ের প্রতিটি অক্ষরকে লুপ করে।

— মিংফাই

@ এমফিং: আসলে, তবে মূল প্রশ্নটি একটি লাইন ছাড়াই এবং এমনকি লুপ ছাড়াই (আপনি এক লাইনে লুপ করতে পারেন, তবে এটি কুৎসিত হবে!)। প্রশ্নটি করুন, উত্তর নয় ... :-)

— ফিলিহো

Answer 6

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

রিপ্লেসএল ("।") সমস্ত অক্ষর প্রতিস্থাপন করবে।

পিলহোর সমাধানটিতে রিপ্লেসএল ("[^।]", "") ব্যবহার করা হয়েছে, যেটিকে পালানোর দরকার নেই, যেহেতু [।] 'কোনও অক্ষর' নয়, 'ডট' চরিত্রটিকে উপস্থাপন করে।

Comments

আমার এটা ভাল লেগেছে. এখনও সেখানে একটি লুপ আছে অবশ্যই আছে there

— আরকিটিপাল পল

আপনি যে দৈর্ঘ্যের সাবস্ট্রিংগুলি> 1

— রজারডপ্যাক

Answer 7

আমার 'আইডোমেটিক ওয়ান-লাইনার' সমাধান:

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

স্ট্রিংগিলগুলি ব্যবহার করে এমন কোনও সমাধান কেন গৃহীত হয়েছে তা সম্পর্কে কোনও ধারণা নেই।

Comments

এই পোস্টে এটির মতো একটি পুরানো সমাধান রয়েছে।

— জ্যাককালিনস

কারণ এই সমাধানটি সত্যই অদক্ষ

— অ্যান্ড্রেস

এটি কেবল একটি কাউন্ট তৈরি করতে অতিরিক্ত স্ট্রিং তৈরি করে। স্ট্রিং ইউটিলেস বিকল্প হিসাবে যদি কেউ স্ট্রিংগটিলগুলির চেয়ে কেন এটিকে পছন্দ করে সে সম্পর্কে ধারণা নেই। যদি এটি কোনও বিকল্প না হয় তবে তাদের কেবল একটি ইউটিলিটি শ্রেণিতে লুপের জন্য একটি সহজ তৈরি করা উচিত।

— পিষ্ট করুন

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

এটির তুলনামূলকভাবে বড় ওভারহেড রয়েছে বলে মনে হচ্ছে, এটি অনেক ছোট স্ট্রিং তৈরি করতে পারে। সাধারণত এটি খুব বেশি গুরুত্বপূর্ণ না তবে যত্ন সহ ব্যবহার করুন।

— মার্টেন বোদেউয়েস

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

যদি আপনার স্ট্রিংটি এত দীর্ঘ না হয় আপনি একটি আউটঅফমিউরিওর পেতে পারেন।

— স্পেন্সার Kormos

হোমওয়ার্ক হিসাবে সমস্যাটি যথেষ্ট সংশ্লেষিত মনে হচ্ছে এবং যদি তাই হয় তবে এই পুনরাবৃত্তি সম্ভবত উত্তর যা আপনাকে সন্ধান করতে বলা হচ্ছে।

— এরিকসন

এটি ইনডেক্সফ ব্যবহার করে, যা লুপ করবে ... তবে একটি দুর্দান্ত ধারণা। এক মিনিটে সত্যই "কেবল পুনরাবৃত্ত" সমাধান পোস্ট করা হচ্ছে ...

— জন স্কিটি

যদি এটির আরও উপস্থিতিগুলি থাকে যে আপনার উপলব্ধ স্ট্যাক স্লট, আপনার কাছে একটি স্ট্যাক ওভারফ্লো ব্যতিক্রম থাকবে;)

— লুকা সি

Answer 11

এই উদ্দেশ্যে একটি নতুন স্ট্রিং বরাদ্দ করার ধারণাটি আমি পছন্দ করি না। এবং স্ট্রিংটির ইতিমধ্যে পিছনে একটি চর অ্যারে রয়েছে যেখানে এটি এর মান সঞ্চয় করে, স্ট্রিংকআরএট () কার্যত নিখরচায়।

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

কেবল জে 2 এসই দিয়ে 1 লাইন বা তারও কম সংকলন প্রয়োজন এমন অতিরিক্ত বরাদ্দ ছাড়াই কৌশলটি কাজ করে।

Comments

এটির জন্য কিছু ভালবাসা দেওয়া কারণ এটিই কেবল স্ট্রিংয়ের উপরে একক পাস করে। আমি পারফরম্যান্স সম্পর্কে যত্নশীল।

— জাভাদবা

charAtঅক্ষর নয় 16 বিট কোড পয়েন্ট মাধ্যমে পুনরাবৃত্তি! 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);
}

লুপিং হিসাবে পুনরাবৃত্তি গণনা করা হয় তা নির্ভর করে আপনি কোন সঠিক সংজ্ঞাটি ব্যবহার করেন তার উপর নির্ভর করে তবে এটি সম্ভবত আপনি যতটা কাছাকাছি পাবেন।

আমি জানি না যে বেশিরভাগ জেভিএমরা আজকাল পুচ্ছ-পুনরাবৃত্তি করে কিনা ... যদি না হয় তবে অবশ্যই উপযুক্ত দীর্ঘ স্ট্রিংয়ের জন্য আপনি উপাধি স্ট্যাকের ওভারফ্লো পাবেন।

Comments

না, লেজ পুনরাবৃত্তি সম্ভবত জাভা 7 এ হবে তবে এটি এখনও ব্যাপক নয়। এই সাধারণ, সরাসরি লেজ পুনরাবৃত্তিটি সংকলনের সময় একটি লুপে অনুবাদ করা যেতে পারে, তবে জাভা 7 স্টাফটি বিভিন্ন পদ্ধতির মাধ্যমে শৃঙ্খলা পরিচালনা করার জন্য জেভিএম-তে আসলে অন্তর্নির্মিত।

— এরিকসন

সংযোজন সম্পাদনের ফলাফলটি না ফেরানোর পরিবর্তে যদি আপনার পদ্ধতিটি নিজের কাছে কোনও কল ফিরে (চলমান মোট প্যারামিটার সহ) করে তবে আপনি লেজ পুনরাবৃত্তি হওয়ার সম্ভাবনা বেশি পাবেন।

— স্টিফেন ডেন

Answer 13

জোন স্কিট দ্বারা অনুপ্রাণিত, একটি নন-লুপ সংস্করণ যা আপনার স্ট্যাকটি ফুঁকবে না। এছাড়াও আপনি কাঁটাচামচ ফ্রেমওয়ার্ক ব্যবহার করতে চাইলে দরকারী সূচনা পয়েন্ট point

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

এছাড়াও পংক্তির শেষে occurences গণনা আপনি এটির মতো একটি নেতিবাচক সীমা আর্গুমেন্ট সহ বিভক্ত ডাকতে হবে: 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

ভুল সংস্থাগুলি কাজ করছে না যখন আমি অন্তর্গত ঘটনাগুলি চেষ্টা করি = ক্যারেক্টার কাউন্টার.কাউন্টঅ্যাকসিয়েন্সস ("1", "101"); System.out.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

এই স্নিপেট কোনও প্রদত্ত ইনপুট "এবিসি" এর জন্য বিন্দুর সঠিক পরিমাণ ফেরত দেয় না

— দেকারু

@ দেকারু আপনি কি দয়া করে মন্তব্যে আপনার স্টিং পেস্ট করতে পারেন যাতে আমরা একবার খেয়াল করতে পারি?

— আমার মাগার

Answer 19

আপনি যদি বসন্তের কাঠামো ব্যবহার করেন তবে আপনি "স্ট্রিং ইউটিলস" বর্গও ব্যবহার করতে পারেন। পদ্ধতিটি হবে "কাউন্টোসিভারেন্সঅফ"।

Answer 20

আপনি split()কেবলমাত্র একটি লাইন কোডে ফাংশনটি ব্যবহার করতে পারেন

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

Comments

স্প্লিট সত্যিই স্ট্রিংগুলির অ্যারে তৈরি করে, যা অনেক বেশি সময় ব্যয় করে।

— প্যালেক

আপনি সত্য , এটি একটি সত্য উদ্বেগ। অন্য উপায়ে এটি আপনার প্রকল্পে তৃতীয় পক্ষের lib আনতে এড়ানো (যদি এখনও না করা হয়)। এটি নির্ভর করে আপনি কী করতে চান এবং পারফরম্যান্সের প্রত্যাশা কী।

— বেঞ্জ

এই সমাধানটিতে খালি হিটগুলি অনুসরণ করা হবে না কারণ যুক্তিটি limitএই ওভারলোডেড স্প্লিট পদ্ধতি কলটিতে শূন্যতে সেট করা আছে। একটি উদাহরণ: "1##2#3#####".split("#")কেবলমাত্র [0:"1";1:""; 2:"2"; 3:"3"]9 ( [0:"1"; 1:""; 2:"2"; 3:"3"; 4:""; 5:""; 6:""; 7:""; 8:""]) এর পরিবর্তে আকার 4 ( ) আকারের একটি অ্যারে দেবে ।

— ক্লার

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;
}

রিপ্লেসমএল (এটি আরইউ) ব্যবহার করা সবচেয়ে ভাল যাওয়ার মতো শোনায় না।

Comments

আমি মনে করি এটি সবচেয়ে মার্জিত সমাধান। আপনি কেন চ্যারিআরয়ে ব্যবহার করলেন এবং সরাসরি চ্যাটআউট করলেন না?

— পানায়োটিস

CharAt দিয়ে লুপিং কমপক্ষে ধীরে ধীরে ব্যবহৃত হত। প্ল্যাটফর্মের উপরও নির্ভর করতে পারে। সত্যিই খুঁজে বের করার একমাত্র উপায় হ'ল পার্থক্যটি পরিমাপ করা।

— tcurdt

Answer 24

ঠিক আছে, বেশ একটি অনুরূপ কাজ দিয়ে আমি এই থ্রেডটিতে হোঁচট খেয়েছি। আমি কোনও প্রোগ্রামিং ভাষার সীমাবদ্ধতা দেখতে পাইনি এবং যেহেতু গ্রোভি জাভা ভিএম-তে চালায়: আমি গ্রোভি ব্যবহার করে কীভাবে আমার সমস্যা সমাধান করতে সক্ষম হয়েছিল তা এখানে।

"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

কেন কেবল চরিত্রটিতে বিভক্ত হন না এবং তারপরে ফলাফলের অ্যারের দৈর্ঘ্য পান। অ্যারের দৈর্ঘ্য সর্বদা উদাহরণগুলির সংখ্যা হবে? 1। ঠিক?

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();