एक स्ट्रिंग में चरित्र की सभी घटनाओं के सूचकांक

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

निम्नलिखित का प्रयास करें (जो अंत में प्रिंट नहीं करता है!)

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

Comments

आप हमेशा अंत में -1 प्रिंट करते हैं

— लुकास्टिमो

@Peter जवाब देने के लिए बहुत-बहुत धन्यवाद, यह सही प्रतीत होता है, लेकिन यह वास्तव में जावा के साथ मेरा पहला दिन है इसलिए मैं अंतिम परिणाम से थोड़ा भ्रमित हूं, यह आउटपुट -1 के अंत में मुझे एक डॉन लगता है ' टी काफी समझ क्यों! धन्यवाद!!

— तृफा

@ तृप्ता: यह हमेशा अंत में -1 प्रिंट करता है क्योंकि indexOfरिटर्न -1 तब मिलता है जब चरित्र नहीं मिलता है।

— कॉलिनड

@ ट्राफा - इसका कारण यह -1है कि अंत में प्रिंट doकरता है कि लूप शरीर को निष्पादित करता है और फिरindex == -1 समाप्ति में पता चलता है while।

— टेड हॉप

@ColinD वह हिस्सा जो मुझे मिलता है, जो मुझे समझ नहीं आता है वह यह है कि ऐसा होने के लिए फ़ंक्शन के साथ क्या होता है, यह "लूप्स" शब्द के माध्यम से होता है जो चरित्र की घटना की तलाश में है और जब तक यह है कि यह और अधिक सही नहीं मिल सकता है ? और इस के अंतिम सूचकांक को नहीं मिला है (-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

Java9 के साथ, एक 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

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

Answer 6

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

हे भगवान, मैं यहाँ पोस्ट मैं सब कुछ javac करने की जरूरत है।

— asgs

Answer 7

यह नियमित अभिव्यक्ति का उपयोग करके जावा 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 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दो अलग-अलग पदों पर शुरू कर सकता है , लेकिन घटनाओं के ओवरलैप होने के बाद यह स्पष्ट नहीं है कि उन्हें दोनों को गिना जाना चाहिए।) यह जवाब इस बात को ध्यान में रखता है कि ओवरलैपिंग की घटनाओं को अलग-अलग नहीं गिना जाता है। बेशक, क्योंकि ओपी का शब्दांकन दृढ़ता से बताता है कि 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

इसमें पैरामीटर को iterating myStringऔर shifting द्वारा किया जा सकता है :fromIndexindexOf()

  int currentIndex = 0;

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

    System.out.println(currentIndex);

    currentIndex++;
  }

Comments

क्या आपने भी इस कोड को चलाने का प्रयास किया था? यह प्रत्येक स्थिति (0, 1, 2, ...) को अंतिम स्थिति के सूचकांक तक प्रिंट करेगा mySubstring, चाहे वह mySubstringप्रत्येक स्थिति पर पाया जा सके। ओपी क्या नहीं चाहता था ..

— टेड हॉप

Answer 14

इसे इस्तेमाल करे

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

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

Comments

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

— पांच

हालांकि यह कोड प्रश्न का उत्तर दे सकता है, लेकिन समस्या को हल करने के तरीके के बारे में अतिरिक्त संदर्भ प्रदान करता है और यह समस्या को हल करता है ताकि उत्तर के दीर्घकालिक मूल्य में सुधार हो सके।

— निक 3500

इस सवाल का जवाब नहीं है। प्रश्न को सभी सूचकांकों की एक सूची की आवश्यकता होती है

— sheu