1.
Longest Palindromic Substring
💡 Problem:
Given a string s, return the longest palindromic substring in s.
🔹 Example:
Input: s = "babad"
Output: "bab"
Explanation: "aba" is also a valid answer.
🔹 Constraints:
• 1 <= [Link] <= 1000
• s consists only of lowercase English letters.
package [Link];
public class LongestPalindromicSubstring {
public static void main(String[] args) {
String input = "babad";
[Link]("Longest Palindromic Substring: " +
findLongestPalindromeSubstring(input));
}
public static String findLongestPalindromeSubstring(String input) {
if ([Link]() > 1) {
int start = 0;
int end = 0;
for (int i = 0; i < [Link](); i++) {
int evenLengthPalindrome = findLengthOfPalindrome(input, i,
i);
int oddLengthPalindrome = findLengthOfPalindrome(input, i,
i + 1);
int length = [Link](evenLengthPalindrome,
oddLengthPalindrome);
if (length > end - start) {
start = i - (length - 1) / 2;
end = i + length / 2;
}
}
return [Link](start, end + 1);
} else {
return "Input String should contains minimum 2 characters";
}
}
public static int findLengthOfPalindrome(String input, int left, int right) {
while (left >= 0 && right < [Link]() && [Link](left) ==
[Link](right)) {
left--;
right++;
}
return right - left - 1;
}
===================================================================================
====
2. Decode String
💡 Problem:
Given an encoded string, return its decoded form.
The encoding rule is: k[encoded_string], where encoded_string inside the brackets
is repeated k times.
You may assume that the input string is always valid.
🔹 Example:
Input: s = "3[a]2[bc]"
Output: "aaabcbc"
🔹 Constraints:
• 1 <= [Link] <= 30
• s contains only digits, square brackets, and lowercase English letters.
package [Link];
import [Link];
public class StringDecode {
public static void main(String[] args) {
String input = "3[a2[c]]";
[Link](stringDecode(input));
}
public static String stringDecode(String input) {
Stack<Integer> numberStack = new Stack<>();
Stack<StringBuilder> stringStack = new Stack<>();
StringBuilder stringBuilder = new StringBuilder();
int num = 0;
for (char ch : [Link]()) {
if ([Link](ch)) {
num = num * 10 + (ch - '0');
} else if (ch == '[') {
[Link](num);
num = 0;
[Link](stringBuilder);
stringBuilder = new StringBuilder();
} else if (ch == ']') {
int k = [Link]();
StringBuilder temp = stringBuilder;
stringBuilder = [Link]();
while (k-- > 0) {
[Link](temp);
}
} else {
[Link](ch);
}
}
return [Link]();
}
}
===================================================================================
======
3. Group Anagrams
💡 Problem:
Given an array of strings strs, group anagrams together.
An anagram is a word or phrase formed by rearranging the letters of a different
word.
🔹 Example:
Input: strs = ["eat","tea","tan","ate","nat","bat"]
Output: [["bat"],["nat","tan"],["ate","eat","tea"]]
🔹 Constraints:
• 1 <= [Link] <= 10^4
• strs[i] consists of lowercase English letters.
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class GroupAnagrams {
public static void main(String[] args) {
String[] wordsArray = { "eat", "tea", "tan", "ate", "nat", "bat" };
[Link](groupAnagrams(wordsArray));
}
public static List<List<String>> groupAnagrams(String[] wordsArray){
Map<String, List<String>> anagramMap = new HashMap<>();
for(String word : wordsArray) {
char[] characters = [Link]();
[Link](characters);
String sortedWord = new String(characters );
[Link](sortedWord, new ArrayList<>());
[Link](sortedWord).add(word);
}
return new ArrayList<>([Link]());
}
===================================================================================
============
4. Minimum Window Substring
💡 Problem:
Given two strings s and t, return the minimum window substring of s that contains
all characters of t.
If there is no such substring, return "" (empty string).
🔹 Example:
Input: s = "ADOBECODEBANC", t = "ABC"
Output: "BANC"
🔹 Constraints:
• 1 <= [Link], [Link] <= 10^5
• s and t consist of uppercase and lowercase English letters.
package [Link];
import [Link];
import [Link];
public class MinWindowSubstring {
public static void main(String[] args) {
String s = "ADOBECODEBANC";
String t = "ABC";
[Link](minWindow(s, t));
}
public static String minWindow(String s, String t) {
if ([Link]() < [Link]())
return "";
Map<Character, Integer> tMap = new HashMap<>();
for (char c : [Link]()) {
[Link](c, [Link](c, 0) + 1);
}
int left = 0, right = 0, minLen = Integer.MAX_VALUE;
int start = 0;
int required = [Link]();
int formed = 0;
Map<Character, Integer> windowMap = new HashMap<>();
while (right < [Link]()) {
char c = [Link](right);
[Link](c, [Link](c, 0) + 1);
if ([Link](c) && [Link](c).intValue() ==
[Link](c).intValue()) {
formed++;
}
while (formed == required) {
if (right - left + 1 < minLen) {
minLen = right - left + 1;
start = left;
}
char leftChar = [Link](left);
[Link](leftChar, [Link](leftChar) - 1);
if ([Link](leftChar) && [Link](leftChar) <
[Link](leftChar)) {
formed--;
}
left++;
}
right++;
}
return minLen == Integer.MAX_VALUE ? "" : [Link](start, start +
minLen);
}
}
=========================================================
5. Zigzag Conversion
💡 Problem:
The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of
rows.
You need to return the converted string when read row-wise.
🔹 Example:
Input: s = "PAYPALISHIRING", numRows = 3
Output: "PAHNAPLSIIGYIR"
Explanation:
P A H N
A P L S I I G
Y I R
🔹 Constraints:
• 1 <= [Link] <= 1000
• 1 <= numRows <= 1000
package [Link];
public class ZigzagConversion {
public static void main(String[] args) {
String s = "PAYPALISHIRING";
int numRows = 3;
[Link](convert(s, numRows));
}
public static String convert(String s, int numRows) {
if (numRows == 1 || [Link]() <= numRows) {
return s;
}
StringBuilder[] rows = new StringBuilder[numRows];
for (int i = 0; i < numRows; i++) {
rows[i] = new StringBuilder();
}
int index = 0;
boolean down = true;
for (char c : [Link]()) {
rows[index].append(c);
if (index == 0) {
down = true;
} else if (index == numRows - 1) {
down = false;
}
index += down ? 1 : -1;
}
StringBuilder result = new StringBuilder();
for (StringBuilder row : rows) {
[Link](row);
}
return [Link]();
}
}
