একটি স্ট্রিংয়ে অক্ষরের সমস্ত উপস্থিতির সূচি

Question

নিম্নলিখিত কোডটি 2 মুদ্রণ করবে

String word = "bannanas";
String guess = "n";
int index;
System.out.println( 
    index = word.indexOf(guess)
);

"বনান্নস" স্ট্রিংয়ে "এন" ("অনুমান") এর সমস্ত সূচকগুলি কীভাবে পাবেন তা আমি জানতে চাই

প্রত্যাশিত ফলাফলটি হবে: [2,3,5]

Answer 1

এই ছাড়া পজিশনের তালিকা প্রিন্ট করা উচিত -1শেষ যে পিটার Lawrey এর সমাধান করেছেন ছিল।

int index = word.indexOf(guess);
while (index >= 0) {
    System.out.println(index);
    index = word.indexOf(guess, index + 1);
}

এটি forলুপ হিসাবেও করা যেতে পারে :

for (int index = word.indexOf(guess);
     index >= 0;
     index = word.indexOf(guess, index + 1))
{
    System.out.println(index);
}

[দ্রষ্টব্য: যদি guessকোনও একক চরিত্রের চেয়ে বেশি দীর্ঘ হতে পারে তবে guessস্ট্রিং বিশ্লেষণ wordকরে উপরের লুপগুলির চেয়ে দ্রুত লুপ করা সম্ভব । এই ধরণের পদ্ধতির জন্য মাপদণ্ড হল বায়ার-মুর অ্যালগরিদম । যাইহোক, এই ধরনের পদ্ধতির ব্যবহারের পক্ষে শর্তগুলি উপস্থিত হবে বলে মনে হয় না]]

Answer 2

নিম্নলিখিতটি চেষ্টা করুন (যা এখন -1 প্রিন্ট হয় না!)

int index = word.indexOf(guess);
while(index >= 0) {
   System.out.println(index);
   index = word.indexOf(guess, index+1);
}

Comments

আপনি সর্বদা শেষে -1 মুদ্রণ করেন

— লুকাস্তেমো

@ পিটার আপনার উত্তর দেওয়ার জন্য আপনাকে অনেক ধন্যবাদ, এটি ঠিক বলে মনে হচ্ছে তবে জাভা নিয়ে এটি আসলে আমার প্রথম দিন তাই চূড়ান্ত ফলাফলের ফলে আমি কিছুটা বিভ্রান্ত হয়ে পড়েছি, এই বলে মনে হচ্ছে -1 শেষের দিকে আমি ডন করব না ' বেশ বুঝতে পারছিনা কেন! ধন্যবাদ !!

— ট্রুফা

@ ট্রুফা: এটি সর্বদা শেষে -১ প্রিন্ট করে কারণ indexOfচরিত্রটি পাওয়া না গেলে -1 ফেরত দেয়।

— কলিনড

@ ট্রাফা - যে কারণে এটি প্রিন্ট -1করে তা হ'ল doলুপটি শরীরটি কার্যকর করে এবং তারপরে এটি আবিষ্কার করে যে index == -1এটি সমাপ্ত হয় while।

— টেড হপ

@ যে অংশটি আমি পেয়েছি, তা আমি বুঝতে পারি না যা ঘটতে হবে তার জন্য ফাংশনটির সাথে কী ঘটবে, এটি চরিত্রটির উপস্থিতি সন্ধান করার শব্দের মাধ্যমে "লুপ" করে এবং ততক্ষণ এটি আর সঠিক খুঁজে পাবে না ? এবং এটির এই শেষ সূচকটি পাওয়া যায় না (-1) এটি কি ঘটছে? (আমি জানি না যে এটি

— ঠিকমতো

Answer 3

String string = "bannanas";
ArrayList<Integer> list = new ArrayList<Integer>();
char character = 'n';
for(int i = 0; i < string.length(); i++){
    if(string.charAt(i) == character){
       list.add(i);
    }
}

ফলাফলটি এইভাবে ব্যবহৃত হবে:

    for(Integer i : list){
        System.out.println(i);
    }

বা অ্যারে হিসাবে:

list.toArray();

Answer 4

জাভা 9 এর সাহায্যে, কেউ iterate(int seed, IntPredicate hasNext,IntUnaryOperator next)নিম্নলিখিত হিসাবে ব্যবহার করতে পারেন : -

List<Integer> indexes = IntStream
          .iterate(word.indexOf(c), index -> index >= 0, index -> word.indexOf(c, index + 1))
          .boxed()
          .collect(Collectors.toList());
System.out.printlnt(indexes);

Answer 5

এটি নিয়মিত এক্সপ্রেশন ব্যবহার করে জাভা 9 এর সাথে একটি কার্যকরী উপায়ে করা যেতে পারে:

Pattern.compile(Pattern.quote(guess)) // sanitize input and create pattern
            .matcher(word) // create matcher
            .results()     // get the MatchResults, Java 9 method
            .map(MatchResult::start) // get the first index
            .collect(Collectors.toList()) // collect found indices into a list
    );

CharSequenceএক্সটেনশন পদ্ধতিটি ব্যবহার করে এই যুক্তিকে নতুন একটি নতুন পদ্ধতি হিসাবে যুক্ত করার জন্য কোটলিন সমাধানটি এখানে রয়েছে :

 // Extension method
fun CharSequence.indicesOf(input: String): List<Int> =
    Regex(Pattern.quote(input)) // build regex
        .findAll(this)          // get the matches
        .map { it.range.first } // get the index
        .toCollection(mutableListOf()) // collect the result as list

// call the methods as
"Banana".indicesOf("a") // [1, 3, 5]

Answer 6

int index = -1;
while((index = text.indexOf("on", index + 1)) >= 0) {
   LOG.d("index=" + index);
}

Answer 7

String word = "bannanas";

String guess = "n";

String temp = word;

while(temp.indexOf(guess) != -1) {
     int index = temp.indexOf(guess);
     System.out.println(index);
     temp = temp.substring(index + 1);
}

Comments

সাধারণ ধারণাটি সঠিক, তবে word.substring(word)সংকলন করবে না। : পি

— পিটার লরে

এখনও একটি সমস্যা রয়েছে: এটি অবিচ্ছিন্নভাবে 2 টি প্রিন্ট করে

— POSIX_ME_HARDER

হ্যাঁ, এখানে আমি পোস্ট করা সমস্ত কিছু জাভ্যাক করা দরকার।

— asgs

Answer 8

    String input = "GATATATGCG";
    String substring = "G";
    String temp = input;
    String indexOF ="";
    int tempIntex=1;

    while(temp.indexOf(substring) != -1)
    {
        int index = temp.indexOf(substring);
        indexOF +=(index+tempIntex)+" ";
        tempIntex+=(index+1);
        temp = temp.substring(index + 1);
    }
    Log.e("indexOf ","" + indexOF);

Answer 9

এছাড়াও, আপনি যদি একটি স্ট্রিংয়ের একটি স্ট্রিংয়ের সমস্ত সূচি খুঁজে পেতে চান।

int index = word.indexOf(guess);
while (index >= 0) {
    System.out.println(index);
    index = word.indexOf(guess, index + guess.length());
}

Comments

এটি আকর্ষণীয় যে এটি "সমস্ত ঘটনা" এর অর্থ একটি অস্পষ্টতা উত্থাপন করে। যদি guess ছিল "aba"এবং wordছিল "ababa", এটি guessএকবার বা দু'বার মধ্যে ঘটে কিনা তা পরিষ্কার নয় word। (আমি বোঝাতে চাইছি, এটি পরিষ্কার যে একজন guessদুটি স্বতন্ত্র অবস্থান থেকে শুরু করতে পারেন , তবে যে ঘটনাগুলি ওভারল্যাপ হয়েছে সেগুলি উভয়ই গণনা করা উচিত কিনা তা পরিষ্কার নয়)) এই উত্তরটি এই ধারণাটি গ্রহণ করে যে ওভারল্যাপিংয়ের ঘটনাগুলি পৃথক হিসাবে গণনা করা হয় না। অবশ্যই, যেহেতু ওপি-র শব্দটি দৃ strongly়ভাবে নির্দেশ দেয় যে guessসর্বদা দৈর্ঘ্য 1 থাকবে, তাই অস্পষ্টতা তৈরি হয় না।

— টেড হপ

Answer 10

আমি এই পদ্ধতিটি না আসা পর্যন্ত আমারও সমস্যা ছিল।

public static int[] indexesOf(String s, String flag) {
    int flagLen = flag.length();
    String current = s;
    int[] res = new int[s.length()];
    int count = 0;
    int base = 0;
    while(current.contains(flag)) {
        int index = current.indexOf(flag);
        res[count] = index + base;
        base += index + flagLen;
        current = current.substring(current.indexOf(flag) + flagLen, current.length());
        ++ count;
    }
    return Arrays.copyOf(res, count);
}

এই পদ্ধতিটি স্ট্রিংয়ের যে কোনও দৈর্ঘ্যের যে কোনও পতাকার সূচকের সন্ধান করতে ব্যবহৃত হতে পারে, উদাহরণস্বরূপ:

public class Main {

    public static void main(String[] args) {
        int[] indexes = indexesOf("Hello, yellow jello", "ll");

        // Prints [2, 9, 16]
        System.out.println(Arrays.toString(indexes));
    }

    public static int[] indexesOf(String s, String flag) {
        int flagLen = flag.length();
        String current = s;
        int[] res = new int[s.length()];
        int count = 0;
        int base = 0;
        while(current.contains(flag)) {
            int index = current.indexOf(flag);
            res[count] = index + base;
            base += index + flagLen;
            current = current.substring(current.indexOf(flag) + flagLen, current.length());
            ++ count;
        }
        return Arrays.copyOf(res, count);
    }
}

Answer 11

বিভক্ত স্ট্রিংয়ের জন্য একটি বর্গ নিয়ে এসেছি। একটি সংক্ষিপ্ত পরীক্ষা শেষে দেওয়া হয়।

SplitStringUtils.smartSplitToShorterStrings(String str, int maxLen, int maxParts) শব্দগুলি না ভেঙে ফাঁক দিয়ে বিভক্ত হবে, যদি সম্ভব হয় এবং যদি না হয় তবে ম্যাক্সলেন অনুসারে সূচি দ্বারা বিভক্ত হবে।

এটি কীভাবে বিভক্ত হয় তা নিয়ন্ত্রণের জন্য সরবরাহ করা অন্যান্য পদ্ধতি: bruteSplitLimit(String str, int maxLen, int maxParts), spaceSplit(String str, int maxLen, int maxParts)।

public class SplitStringUtils {

  public static String[] smartSplitToShorterStrings(String str, int maxLen, int maxParts) {
    if (str.length() <= maxLen) {
      return new String[] {str};
    }
    if (str.length() > maxLen*maxParts) {
      return bruteSplitLimit(str, maxLen, maxParts);
    }

    String[] res = spaceSplit(str, maxLen, maxParts);
    if (res != null) {
      return res;
    }

    return bruteSplitLimit(str, maxLen, maxParts);
  }

  public static String[] bruteSplitLimit(String str, int maxLen, int maxParts) {
    String[] bruteArr = bruteSplit(str, maxLen);
    String[] ret = Arrays.stream(bruteArr)
          .limit(maxParts)
          .collect(Collectors.toList())
          .toArray(new String[maxParts]);
    return ret;
  }

  public static String[] bruteSplit(String name, int maxLen) {
    List<String> res = new ArrayList<>();
    int start =0;
    int end = maxLen;
    while (end <= name.length()) {
      String substr = name.substring(start, end);
      res.add(substr);
      start = end;
      end +=maxLen;
    }
    String substr = name.substring(start, name.length());
    res.add(substr);
    return res.toArray(new String[res.size()]);
  }

  public static String[] spaceSplit(String str, int maxLen, int maxParts) {
    List<Integer> spaceIndexes = findSplitPoints(str, ' ');
    List<Integer> goodSplitIndexes = new ArrayList<>();
    int goodIndex = -1; 
    int curPartMax = maxLen;
    for (int i=0; i< spaceIndexes.size(); i++) {
      int idx = spaceIndexes.get(i);
      if (idx < curPartMax) {
        goodIndex = idx;
      } else {
        goodSplitIndexes.add(goodIndex+1);
        curPartMax = goodIndex+1+maxLen;
      }
    }
    if (goodSplitIndexes.get(goodSplitIndexes.size()-1) != str.length()) {
      goodSplitIndexes.add(str.length());
    }
    if (goodSplitIndexes.size()<=maxParts) {
      List<String> res = new ArrayList<>();
      int start = 0;
      for (int i=0; i<goodSplitIndexes.size(); i++) {
        int end = goodSplitIndexes.get(i);
        if (end-start > maxLen) {
          return null;
        }
        res.add(str.substring(start, end));
        start = end;
      }
      return res.toArray(new String[res.size()]);
    }
    return null;
  }


  private static List<Integer> findSplitPoints(String str, char c) {
    List<Integer> list = new ArrayList<Integer>();
    for (int i = 0; i < str.length(); i++) {
      if (str.charAt(i) == c) {
        list.add(i);
      }
    }
    list.add(str.length());
    return list;
  }
}

সাধারণ পরীক্ষার কোড:

  public static void main(String[] args) {
    String [] testStrings = {
        "123",
        "123 123 123 1123 123 123 123 123 123 123",
        "123 54123 5123 513 54w567 3567 e56 73w45 63 567356 735687 4678 4678 u4678 u4678 56rt64w5 6546345",
        "1345678934576235784620957029356723578946",
        "12764444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444",
        "3463356 35673567567 3567 35 3567 35 675 653 673567 777777777777777777777777777777777777777777777777777777777777777777"
    };

    int max = 35;
    int maxparts = 2;


    for (String str : testStrings) {
      System.out.println("TEST\n    |"+str+"|");
      printSplitDetails(max, maxparts);
      String[] res = smartSplitToShorterStrings(str, max, maxparts);
      for (int i=0; i< res.length;i++) {
        System.out.println("  "+i+": "+res[i]);
      }
      System.out.println("===========================================================================================================================================================");
    }

  }

  static void printSplitDetails(int max, int maxparts) {
    System.out.print("  X: ");
    for (int i=0; i<max*maxparts; i++) {
      if (i%max == 0) {
        System.out.print("|");
      } else {
        System.out.print("-");
      }
    }
    System.out.println();
  }

Answer 12

এটি একটি জাভা 8 সমাধান।

public int[] solution (String s, String subString){
        int initialIndex = s.indexOf(subString);
        List<Integer> indexList = new ArrayList<>();
        while (initialIndex >=0){
            indexList.add(initialIndex);
            initialIndex = s.indexOf(subString, initialIndex+1);
        }
        int [] intA = indexList.stream().mapToInt(i->i).toArray();
        return intA;
    }

Answer 13

এটি পরামিতি পুনরাবৃত্তি myStringএবং স্থানান্তরিত দ্বারা করা যেতে পারে :fromIndexindexOf()

  int currentIndex = 0;

  while (
    myString.indexOf(
      mySubstring,
      currentIndex) >= 0) {

    System.out.println(currentIndex);

    currentIndex++;
  }

Comments

আপনি কি এই কোডটি চালানোর চেষ্টা করেছেন? এটি প্রতিটি অবস্থানের সন্ধান করা যায় mySubstringকিনা তা বিবেচনা না করে প্রতিটি অবস্থানের (0, 1, 2, ...) মুদ্রণ করবে occ mySubstringওপি যা চেয়েছিল তা মোটেও নয় ..

— টেড হপ

Answer 14

এটা চেষ্টা কর

String str = "helloslkhellodjladfjhello";
String findStr = "hello";

System.out.println(StringUtils.countMatches(str, findStr));

Comments

বৃহত্তর স্ট্রিংয়ের ক্ষেত্রে একটি স্ট্রিংয়ের উদাহরণ গণনা করার জন্য এটি ভাল তবে মিলগুলির সূচকগুলি ফেরত দেয় না।

— ফাইভ ক্লাবগুলি

যদিও এই কোডটি প্রশ্নের উত্তর দিতে পারে, কীভাবে এবং / বা কেন এটি সমস্যার সমাধান করে তা সম্পর্কিত অতিরিক্ত প্রসঙ্গ সরবরাহ করলে উত্তরের দীর্ঘমেয়াদী মান উন্নত হবে।

— নিক 3500

এটি প্রশ্নের উত্তর দেয় না। প্রশ্নটির জন্য সমস্ত সূচকের একটি তালিকা প্রয়োজন

— শেও