从字符串中找出 substring 具有最大长度且字符不应重复

Question

I want to find the the substring from String s = "CHARACTERSTIC". Requirement is that substring should not contain repeated characters as well as substring should have maximum length. How to achive this in core java? Please help me as i am quite novice to java.

Answer 1

Hope this helps :)

   import java.util.HashSet;
   import java.util.Scanner;
   import java.util.Set;

   public class MyLongestSubstr {

   static Set<String> SubStringList = new HashSet<String>();
   static int Size = 0;

    public static  Set<String> getLongestSubstr(String input){
    SubStringList.clear();
    Size = 0;
    boolean[] flag = new boolean[256];
    int j = 0;
    char[] inputCharArr = input.toCharArray();
    for (int i = 0; i < inputCharArr.length; i++) {
        char c = inputCharArr[i];
        if (flag[c]) {
            extractSubString(inputCharArr,j,i);
            for (int k = j; k < i; k++) {
                if (inputCharArr[k] == c) {
                    j = k + 1;
                    break;
                }
                flag[inputCharArr[k]] = false;
            }  
        } else {
            flag[c] = true;
        }
    }
    extractSubString(inputCharArr,j,inputCharArr.length);
    return SubStringList;
}

private static String extractSubString(char[] inputArr, int start, int end){

    StringBuilder sb = new StringBuilder();
    for(int i=start;i<end;i++){
        sb.append(inputArr[i]);
    }
    String subStr = sb.toString();
    if(subStr.length() > Size){
        Size = subStr.length();
        SubStringList.clear();
        SubStringList.add(subStr);
    } else if(subStr.length() == Size){
        SubStringList.add(subStr);
    }

    return sb.toString();
}

public static void main(String a[]){
    Scanner sc = new Scanner(System.in);
    String str = sc.next();
    System.out.println(getLongestSubstr(str));

}
}  

This solution prints out such possible sub-strings with maximum length and no repeating characters.

Answer 2

Try this :-

/**
 * Method to get List of all possible non-repetitive String from input String
 */
public ArrayList<String> getUniqueSubstring(String input) {
    ArrayList<String> matchingString = new ArrayList<String>();
    for (int i = 0; i < input.length(); i++) {
        String s = String.valueOf(input.charAt(i));
        for (int j = i + 1; j < input.length(); j++)
            if (!s.contains(String.valueOf(input.charAt(j))))
                s += String.valueOf(input.charAt(j));
            else
                break;
        matchingString.add(s);
        if (s.length() == input.length())
            break;
    }

    return matchingString;
}

/**
 * Method to get longest String out of List
 */


public String getLongestString(List<String> list) {
      int maxLength = 0;
      String longestString = null;
      for (String s : list) {
          if (s.length() > maxLength) {
              maxLength = s.length();
              longestString = s;
          }
      }
      return longestString;
  }

/**
 * Main method to test & print the longest string
 */
public static void main(String[] args) {
    StringPattern s = new StringPattern();
    System.out.println(s.getLongestString(s.getUniqueSubstring("CHARACTERSTIC")));
}

Output :- ACTERS

PS:- Please try to create logic on your own & ask for help here if you are stuck somewhere, not for ready baked code. If you are novice start your leaning from Oracle Docs here Hope this helps.

Answer 3

You would want to append each character from your original String to another String or StringBuilder until you're appending a character that is already in your new String . Once you've reached either the end of your original String or come to a duplicate character, check if the new String is the longest and keep it if it is.

Sample:

public static void main(String[] args) throws Exception {
    String s = "CHARACTERSTIC";
    StringBuilder sb = new StringBuilder();

    String maxString = "";
    int maxStringLength = 0;
    int index = 0;
    while (index < s.length()) {
        String c = String.valueOf(s.charAt(index));
        if (sb.indexOf(c) == -1) {
            sb.append(c);
            index++; // Go to the next character
        } 

        // Check if we're at the end of the string of if the next character is duplicate
        if (index == s.length() || sb.indexOf(String.valueOf(s.charAt(index))) > -1) {
            System.out.println("Possible substring: " + sb);

            // Have to check the last substring
            if (sb.length() > maxStringLength) {
                maxString = sb.toString();
                maxStringLength = maxString.length();
                sb.setLength(0);
            }
        }
    }

    System.out.println("Max String: " + maxString);
    System.out.println("Max Length: " + maxStringLength);
}

Results:

Possible substring: CHAR
Possible substring: ACTERS
Possible substring: TIC
Max String: ACTERS
Max Length: 6

Answer 4

This has a fix for @Shar1er80 code for a String like "abcan" where max string might be "bcan":

public String getMaxSubstring(String s) {
    StringBuilder currentString = new StringBuilder();
    String maxString = "";
    int index = 0;
    while(index < s.length()) {
            if(currentString.indexOf(String.valueOf(s.toCharArray()[index])) == -1) {
                currentString.append(s.toCharArray()[index]);

            }else {
                // this will take care of already skipped substrings
                String ns = currentString.substring(currentString.indexOf(String.valueOf(s.toCharArray()[index]))+1) + String.valueOf(s.toCharArray()[index]);
                currentString = new StringBuilder(ns);
                currentString.setLength(ns.length());
            }               
            if(currentString.length() > maxString.length()) {
                maxString = currentString.toString();
            }               
            index++;
    }        
    return maxString;
}

Answer 5

private static void highestSubString(String str) {
    String longestSubString =null;
    int longestSubStringLength =0;
    Map<Character,Integer> characterSet = new HashMap<>();
    char[] arr = str.toCharArray();
    for (int i =0;i<arr.length;i++){

        char ch = arr[i];
        if(!characterSet.containsKey(ch)){
            characterSet.put(ch,i);

        }else {

            characterSet.clear();
        }

        if(characterSet.size() > longestSubStringLength){
            longestSubStringLength = characterSet.size();
            longestSubString = characterSet.keySet().toString();
        }

    }
    System.out.println(longestSubStringLength);
    System.out.println(longestSubString);
}