একটি স্ট্রিংয়ে অক্ষরের নবম উপস্থিতিটি কীভাবে সন্ধান করবেন?

Question 1

এখানে পোস্ট করা একটি প্রশ্নের অনুরূপ , আমি জাভাতে একটি সমাধান খুঁজছি।

অর্থাত্, একটি স্ট্রিং থেকে একটি অক্ষর / স্ট্রিংয়ের নবম উপস্থিতির সূচকটি কীভাবে সন্ধান করবেন?

উদাহরণ: " / ফোল্ডার 1 / ফোল্ডার 2 / ফোল্ডার 3 / "। এই ক্ষেত্রে, যদি আমি স্ল্যাশ (/) এর তৃতীয় ঘটনাটি জিজ্ঞাসা করি তবে এটি ফোল্ডার 3 এর আগে উপস্থিত হবে এবং আমি এই সূচক অবস্থানটি প্রত্যাশা করব। আমার আসল উদ্দেশ্যটি কোনও চরিত্রের নবম উপস্থিতি থেকে একে বাদ দেওয়া।

জাভা এপিআই তে কি কোনও সুবিধাজনক / প্রস্তুত ব্যবহারের পদ্ধতি উপলব্ধ বা এটি সমাধান করার জন্য আমাদের নিজেরাই একটি ছোট যুক্তি লিখতে হবে?

এছাড়াও,

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

Question 2

যদি আপনার প্রকল্পটি ইতিমধ্যে অ্যাপাচি কমন্সের উপর নির্ভর করে আপনি ব্যবহার করতে পারেন StringUtils.ordinalIndexOf, অন্যথায়, এখানে একটি বাস্তবায়ন রয়েছে:

public static int ordinalIndexOf(String str, String substr, int n) {
    int pos = str.indexOf(substr);
    while (--n > 0 && pos != -1)
        pos = str.indexOf(substr, pos + 1);
    return pos;
}

এই পোস্টটি এখানে একটি নিবন্ধ হিসাবে আবার লেখা হয়েছে ।

Question 3

আমি বিশ্বাস করি যে স্ট্রিংয়ের নবম উপস্থিতি সন্ধানের সবচেয়ে সহজ সমাধান হ'ল অ্যাপাচি কমন্স থেকে স্ট্রিংইটিলস.অর্ডিনাল ইন্ডেক্সঅফ () ব্যবহার করা ।

উদাহরণ:

StringUtils.ordinalIndexOf("aabaabaa", "b", 2)  == 5

Question 4

দুটি সহজ বিকল্প ঘটে:

charAt()বারবার ব্যবহার করুন
indexOf()বারবার ব্যবহার করুন

উদাহরণ স্বরূপ:

public static int nthIndexOf(String text, char needle, int n)
{
    for (int i = 0; i < text.length(); i++)
    {
        if (text.charAt(i) == needle)
        {
            n--;
            if (n == 0)
            {
                return i;
            }
        }
    }
    return -1;
}

এটি indexOfবারবার ব্যবহারের পাশাপাশি পারফরম্যান্স নাও করতে পারে তবে এটি সঠিকভাবে পাওয়া সহজ।

Question 5

আপনি এরকম কিছু চেষ্টা করতে পারেন:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
      System.out.println(from3rd("/folder1/folder2/folder3/"));
    }

    private static Pattern p = Pattern.compile("(/[^/]*){2}/([^/]*)");

    public static String from3rd(String in) {
        Matcher m = p.matcher(in);

        if (m.matches())
            return m.group(2);
        else
            return null;
    }
}

দ্রষ্টব্য যে আমি রেজেক্সে কিছু অনুমান করেছি:

ইনপুট পাথ পরম (যেমন "/" দিয়ে শুরু হয়);
ফলস্বরূপ আপনার তৃতীয় "/" দরকার নেই।

একটি মন্তব্যে অনুরোধ করা হিসাবে, আমি রেজেক্স ব্যাখ্যা করার চেষ্টা করব: (/[^/]*){2}/([^/]*)

নিয়মিত প্রকাশের ভিজ্যুয়ালাইজেশন

/[^/]*একটি /অনুসরণ করে [^/]*(কোনও অক্ষর যে একটি নয় /),
(/[^/]*)একটি একক সত্তা মধ্যে পূর্বের অভিব্যক্তি গ্রুপ। এটি হ'ল 1এক্সপ্রেশন-এর গ্রুপ
(/[^/]*){2}এর অর্থ গ্রুপটি অবশ্যই প্রায় {2}বার মিলবে ,
[^/]*আবার এমন কোনও সংখ্যক অক্ষর যা একটি নয় /,
([^/]*)একটি একক সত্তা মধ্যে previos এক্সপ্রেশন গ্রুপ। এটি হল 2অভিব্যক্তির এনডি গ্রুপ।

আপনি কেবল দ্বিতীয় গ্রুপের সাথে মেলে এমন স্ট্রিংগুলি পেতে পারেন: return m.group(2);

চিত্র সৌজন্যে ডেবাগেক্স

Question 6

আইওবের উত্তরে আমি কয়েকটি পরিবর্তন করেছি এবং একটি নবম লাস্ট ইনডেক্স অফ সংস্করণ পেয়েছি এবং কিছু এনপিই সমস্যা সমাধান করেছি। নীচে কোড দেখুন:

public int nthLastIndexOf(String str, char c, int n) {
        if (str == null || n < 1)
            return -1;
        int pos = str.length();
        while (n-- > 0 && pos != -1)
            pos = str.lastIndexOf(c, pos - 1);
        return pos;
}

Question 7

 ([.^/]*/){2}[^/]*(/)

/ দু'বারের পরে যেকোনো কিছু মিলবে, তারপরে আবার। তৃতীয়টি হ'ল আপনি যা চান তা

ম্যাচার রাষ্ট্র যেখানে গত / বলতে ব্যবহার করা যেতে পারে

Question 8

public static int nth(String source, String pattern, int n) {

   int i = 0, pos = 0, tpos = 0;

   while (i < n) {

      pos = source.indexOf(pattern);
      if (pos > -1) {
         source = source.substring(pos+1);
         tpos += pos+1;
         i++;
      } else {
         return -1;
      }
   }

   return tpos - 1;
}

Question 9

আজকাল সেখানে অ্যাপাচি কমন্স ল্যাংয়ের স্ট্রিং ইউটিলসের সমর্থন রয়েছে ,

এটি আদিম:

int org.apache.commons.lang.StringUtils.ordinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal)

আপনার সমস্যার জন্য আপনি নিম্নলিখিত কোড করতে পারেন: StringUtils.ordinalIndexOf(uri, "/", 3)

আপনি লাস্ট অর্ডিনাল ইন্ডেক্সফ পদ্ধতিতে একটি স্ট্রিংয়ে কোনও অক্ষরের সর্বশেষ নবম উপস্থিতি খুঁজে পেতে পারেন ।

Question 10

আপনি স্ট্রিং.স্প্লিট (..) পদ্ধতিতেও এটি অর্জন করতে পারেন।

String str = "";
String[] tokens = str.split("/")
return tokens[nthIndex] == null

Question 11

অন্য পদ্ধতি:

public static void main(String[] args) {
    String str = "/folder1/folder2/folder3/"; 
    int index = nthOccurrence(str, '/', 3);
    System.out.println(index);
}

public static int nthOccurrence(String s, char c, int occurrence) {
    return nthOccurrence(s, 0, c, 0, occurrence);
}

public static int nthOccurrence(String s, int from, char c, int curr, int expected) {
    final int index = s.indexOf(c, from);
    if(index == -1) return -1;
    return (curr + 1 == expected) ? index : 
        nthOccurrence(s, index + 1, c, curr + 1, expected);
}

Question 12

এই উত্তরটি @aioobe এর উত্তরে উন্নতি করেছে। এই উত্তরে দুটি বাগ স্থির করা হয়েছিল।
1. এন = 0 এর ফিরে আসা উচিত -1।
2. নবম ঘটনাটি -1 ফিরে এসেছে, তবে এটি এন -1 তম ঘটনাগুলিতে কাজ করেছে।

এটা চেষ্টা কর !

    public int nthOccurrence(String str, char c, int n) {
    if(n <= 0){
        return -1;
    }
    int pos = str.indexOf(c, 0);
    while (n-- > 1 && pos != -1)
        pos = str.indexOf(c, pos+1);
    return pos;
}

Question 13

public class Sam_Stringnth {

    public static void main(String[] args) {
        String str="abcabcabc";
        int n = nthsearch(str, 'c', 3);
        if(n<=0)
            System.out.println("Character not found");
        else
            System.out.println("Position is:"+n);
    }
    public static int nthsearch(String str, char ch, int n){
        int pos=0;
        if(n!=0){
            for(int i=1; i<=n;i++){
                pos = str.indexOf(ch, pos)+1;
            }
            return pos;
        }
        else{
            return 0;
        }
    }
}

Question 14

আমার সমাধান:

/**
 * Like String.indexOf, but find the n:th occurance of c
 * @param s string to search
 * @param c character to search for
 * @param n n:th character to seach for, starting with 1
 * @return the position (0-based) of the found char, or -1 if failed
 */

public static int nthIndexOf(String s, char c, int n) {
    int i = -1;
    while (n-- > 0) {
        i = s.indexOf(c, i + 1);
        if (i == -1)
            break;
    }
    return i;
}

Question 15

/* program to find nth occurence of a character */

import java.util.Scanner;

public class CharOccur1
{

    public static void main(String arg[])
    {
        Scanner scr=new Scanner(System.in);
        int position=-1,count=0;
        System.out.println("enter the string");
        String str=scr.nextLine();
        System.out.println("enter the nth occurence of the character");
        int n=Integer.parseInt(scr.next());
        int leng=str.length();
        char c[]=new char[leng];
        System.out.println("Enter the character to find");
        char key=scr.next().charAt(0);
        c=str.toCharArray();
        for(int i=0;i<c.length;i++)
        {
            if(c[i]==key)
            {
                count++;
                position=i;
                if(count==n)
                {
                    System.out.println("Character found");
                    System.out.println("the position at which the " + count + " ocurrence occurs is " + position);
                    return;
                }
            }
        }
        if(n>count)
        { 
            System.out.println("Character occurs  "+ count + " times");
            return;
        }
    }
}

Question 16

কোডটি অরফ ফিল্ডের প্রস্থকে স্ট্রিং করে নবম সংঘটন অবস্থানগুলি প্রদান করে। উদাহরণ। যদি "লো মেলোয় স্ট্যাক ওভারফ্লো" স্ট্রিংটি টোকেন "লো" এর দ্বিতীয় ঘটনা অনুসন্ধান করার স্ট্রিং হয় , আপনি আমার সাথে সম্মত হবেন যে এটি দ্বিতীয় ঘটনাটি "18 এবং 21" বিয়োগে রয়েছে । ইনডেক্স অফস্যাকিউরেন্স ("লো মেলোয় স্ট্যাক ওভারফ্লো", কম, 2) 18 এবং 21 টি স্ট্রিংয়ে ফিরে আসে।

class Example{
    public Example(){
    }
            public String indexOfOccurance(String string, String token, int nthOccurance) {
                    int lengthOfToken = token.length();
                    int nthCount = 0;
                    for (int shift = 0,count = 0; count < string.length() - token.length() + 2; count++, shift++, lengthOfToken++)
                        if (string.substring(shift, lengthOfToken).equalsIgnoreCase(token)) { 
                    // keeps count of nthOccurance
                            nthCount++; 
                        if (nthCount == nthOccurance){
                    //checks if nthCount  == nthOccurance. If true, then breaks 
                             return String.valueOf(shift)+ " " +String.valueOf(lengthOfToken);   
                        }  
                    }
                    return "-1";
                }
    public static void main(String args[]){
    Example example = new Example();
    String string = "the man, the woman and the child";
    int nthPositionOfThe = 3;
   System.out.println("3rd Occurance of the is at " + example.indexOfOccurance(string, "the", nthPositionOfThe));
    }
    }

Question 17

public static int findNthOccurrence(String phrase, String str, int n)
{
    int val = 0, loc = -1;
    for(int i = 0; i <= phrase.length()-str.length() && val < n; i++)
    {
        if(str.equals(phrase.substring(i,i+str.length())))
        {
            val++;
            loc = i;
        }
    }

    if(val == n)
        return loc;
    else
        return -1;
}

Question 18

// স্কেলা

// থ্রোক্স -1 মানটি নবম সময়ের জন্য উপস্থিত না থাকলেও এটি এন -1 ম সময় পর্যন্ত উপস্থিত থাকলেও। // থ্রোকের সূচক যদি মান নবম সময়ের জন্য উপস্থিত থাকে

def indexOfWithNumber(tempString:String,valueString:String,numberOfOccurance:Int):Int={
var stabilizeIndex=0 
var tempSubString=tempString 
var tempIndex=tempString.indexOf(valueString) 
breakable
{
for ( i <- 1 to numberOfOccurance)
if ((tempSubString.indexOf(valueString) != -1) && (tempIndex != -1))
{
tempIndex=tempSubString.indexOf(valueString)
tempSubString=tempSubString.substring(tempIndex+1,tempSubString.size) // ADJUSTING FOR 0
stabilizeIndex=stabilizeIndex+tempIndex+1 // ADJUSTING FOR 0
}
else
{ 
stabilizeIndex= -1
tempIndex= 0
break
}
}
stabilizeIndex match { case value if value <= -1 => -1 case _ => stabilizeIndex-1 } // reverting for adjusting 0 previously
}


indexOfWithNumber("bbcfgtbgft","b",3) // 6
indexOfWithNumber("bbcfgtbgft","b",2) //1
indexOfWithNumber("bbcfgtbgft","b",4) //-1

indexOfWithNumber("bbcfgtbcgft","bc",1)  //1
indexOfWithNumber("bbcfgtbcgft","bc",4) //-1
indexOfWithNumber("bbcfgtbcgft","bc",2) //6