Categories: Data Structure

Problems based on Strings

In the previous post, we got an introduction to Strings and their methods. Let us now take a look at a few problems related to it.

Given a string s, return the longest palindromic substring in s.

Example:

Input: s = "babad"
Output: "bab"
Explanation: "aba" is also a valid answer.

Solution:

class Solution {
    public String longestPalindrome(String s) {
        char[] charArray = s.toCharArray();
        int start = 0;
        int maxLen = 0;
        for (int i = 0; i < charArray.length; i++) {
            for (int len = 0; i + len < charArray.length; len++) {
                if (isPalindrome(charArray, i, len) && len + 1 > maxLen) {
                    maxLen = len + 1;
                    start = i;
                }
            }
        }

        return s.substring(start, start + maxLen);
    }

    public boolean isPalindrome(char[] charArray, int start, int len) {
        while (len > 0) {
            if (charArray[start] != charArray[start + len]) {
                return false;
            }

            start++;
            len -= 2;
        }

        return true;
    }
}

Time complexity: O(n^3), where n is the length of the input string

Space complexity: O(1)

  • The given code contains two methods, one for finding the longest palindrome substring in a given string, and the other method isPalindrome() checks if a given substring is a palindrome or not.
  • The approach of the longestPalindrome() method is to loop through all the possible substrings of the given string and check if each substring is a palindrome or not using the isPalindrome() method.
  • If a palindrome substring is found whose length is greater than the previously found palindrome substring, then its length and starting index are updated.

Given a string s, find the length of the longest substring without repeating characters.

Example:

Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.

Solution:

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length();
        int left = 0, right = 0;
        int maxLength = 0;
        HashSet<Character> set = new HashSet<>();

        while (right < n) {
            if (!set.contains(s.charAt(right))) {
                set.add(s.charAt(right));
                right++;
                maxLength = Math.max(maxLength, right - left);
            } else {
                set.remove(s.charAt(left));
                left++;
            }
        }

        return maxLength;
    
    }
}

Time complexity: O(n), where n is the length of the input string

Space complexity: O(min(n, m)), where n is the length of the input string

  • Here we used a sliding window approach with two pointers, left and right.
  • We also use a HashSet to keep track of the characters in the current substring. Then start with left = 0 and right = 0.
  • We then move the right pointer to the right until we encounter a character that is already in the HashSet. Now record the length of the current substring and shift the left pointer to the right until the duplicate character is removed from the HashSet.

Write a function to find the longest common prefix string amongst an array of strings. If there is no common prefix, return an empty string "".

Example:

Input: strs = ["flower","flow","flight"]
Output: "fl"

Solution:

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs.length == 0) {
            return "";
        }

        String prefix = strs[0];

        for (int i = 1; i < strs.length; i++) {
            while (strs[i].indexOf(prefix) != 0) {
                prefix = prefix.substring(0, prefix.length() - 1);
                if (prefix.isEmpty()) {
                    return "";
                }
            }
        }

        return prefix; 
    }
}

Time complexity: O(S), where S is the total number of characters in all strings combined

Space complexity: O(1)

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

Symbol       Value
I                       1
V                      5
X                      10
L                       50
C                      100
D                      500
M                     1000

Given a roman numeral, convert it to an integer.

Example:

Input: s = "III"
Output: 3
Explanation: III = 3.

Solution:

class Solution {
    public int romanToInt(String s) {
         Map<Character, Integer> symbolToValue = new HashMap<>();
        symbolToValue.put('I', 1);
        symbolToValue.put('V', 5);
        symbolToValue.put('X', 10);
        symbolToValue.put('L', 50);
        symbolToValue.put('C', 100);
        symbolToValue.put('D', 500);
        symbolToValue.put('M', 1000);

        int total = 0;
        int prevValue = 0;

        for (int i = 0; i < s.length(); i++) {
            int curValue = symbolToValue.get(s.charAt(i));
            total += curValue;
            if (curValue > prevValue) {
                total -= 2 * prevValue;
            }
            prevValue = curValue;
        }

        return total;
    }
}

Time complexity: O(N), where N is the length of the input string

Space complexity: O(1)

we started by creating a HashMap to map each symbol to its corresponding value and iterated over the input string and add the value of each symbol to the total, subtracting the value of the previous symbol if it is less than the current symbol.

Given an integer, convert it to a Roman numeral.(Above question part -II)

Solution:

class Solution {
    public String intToRoman(int num) {
         int[] values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        String[] symbols = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < values.length; i++) {
            while (num >= values[i]) {
                num -= values[i];
                sb.append(symbols[i]);
            }
        }

        return sb.toString();
    }
}

Time complexity: O(1)

Space complexity: O(1)

Again, we created a mapping from the integer values to their corresponding Roman numeral symbols. We then iterate over the mapping in descending order, subtracting the value of each symbol from the input integer until the input integer becomes 0.

Note: also read about DSA: Strings Concept

Follow Me

If you like my post please follow me to read my latest post on programming and technology.

https://www.instagram.com/coderz.py/

https://www.facebook.com/coderz.py

Recent Posts

Find Intersection of Two Singly Linked Lists

You are given two singly linked lists that intersect at some node. Your task is…

3 months ago

Minimum Cost to Paint Houses with K Colors

A builder plans to construct N houses in a row, where each house can be…

3 months ago

Longest Absolute Path in File System Representation

Find the length of the longest absolute path to a file within the abstracted file…

3 months ago

Efficient Order Log Storage

You manage an e-commerce website and need to keep track of the last N order…

4 months ago

Select a Random Element from a Stream

You are given a stream of elements that is too large to fit into memory.…

4 months ago

Estimate π Using Monte Carlo Method

The formula for the area of a circle is given by πr². Use the Monte…

4 months ago