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 <= s.length <= 1000
• s consists only of lowercase English letters.

package com.htc.leetcodesolutions.main;

public class LongestPalindromicSubstring {

public static void main(String[] args) {

String input = "babad";

System.out.println("Longest Palindromic Substring: " +
findLongestPalindromeSubstring(input));
}

public static String findLongestPalindromeSubstring(String input) {

if (input.length() > 1) {

int start = 0;
int end = 0;

for (int i = 0; i < input.length(); i++) {

int evenLengthPalindrome = findLengthOfPalindrome(input, i,

i);
int oddLengthPalindrome = findLengthOfPalindrome(input, i,
i + 1);
int length = Math.max(evenLengthPalindrome,
oddLengthPalindrome);

if (length > end - start) {

start = i - (length - 1) / 2;
end = i + length / 2;
}
}
return input.substring(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 < input.length() && input.charAt(left) ==

input.charAt(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 <= s.length <= 30
• s contains only digits, square brackets, and lowercase English letters.

package com.htc.leetcodesolutions.main;

import java.util.Stack;

public class StringDecode {

public static void main(String[] args) {

String input = "3[a2[c]]";
System.out.println(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 : input.toCharArray()) {

if (Character.isDigit(ch)) {
num = num * 10 + (ch - '0');
} else if (ch == '[') {
numberStack.push(num);
num = 0;
stringStack.push(stringBuilder);
stringBuilder = new StringBuilder();
} else if (ch == ']') {
int k = numberStack.pop();
StringBuilder temp = stringBuilder;
stringBuilder = stringStack.pop();

while (k-- > 0) {

stringBuilder.append(temp);
}
} else {
stringBuilder.append(ch);
 }
}

return stringBuilder.toString();
}
}
===================================================================================
======

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 <= strs.length <= 10^4
• strs[i] consists of lowercase English letters.

package com.htc.leetcodesolutions.main;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class GroupAnagrams {

public static void main(String[] args) {

String[] wordsArray = { "eat", "tea", "tan", "ate", "nat", "bat" };

System.out.println(groupAnagrams(wordsArray));
}

public static List<List<String>> groupAnagrams(String[] wordsArray){

Map<String, List<String>> anagramMap = new HashMap<>();

for(String word : wordsArray) {

char[] characters = word.toCharArray();
Arrays.sort(characters);
String sortedWord = new String(characters );

anagramMap.putIfAbsent(sortedWord, new ArrayList<>());

anagramMap.get(sortedWord).add(word);

}
return new ArrayList<>(anagramMap.values());
}

===================================================================================
============
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 <= s.length, t.length <= 10^5
• s and t consist of uppercase and lowercase English letters.

package com.htc.leetcodesolutions.main;

import java.util.HashMap;
import java.util.Map;

public class MinWindowSubstring {

public static void main(String[] args) {
String s = "ADOBECODEBANC";
String t = "ABC";

System.out.println(minWindow(s, t));
}

public static String minWindow(String s, String t) {

if (s.length() < t.length())
return "";

Map<Character, Integer> tMap = new HashMap<>();

for (char c : t.toCharArray()) {
tMap.put(c, tMap.getOrDefault(c, 0) + 1);
}

int left = 0, right = 0, minLen = Integer.MAX_VALUE;

int start = 0;
int required = tMap.size();
int formed = 0;
Map<Character, Integer> windowMap = new HashMap<>();

while (right < s.length()) {

char c = s.charAt(right);
windowMap.put(c, windowMap.getOrDefault(c, 0) + 1);

if (tMap.containsKey(c) && windowMap.get(c).intValue() ==

tMap.get(c).intValue()) {
formed++;
}

while (formed == required) {

if (right - left + 1 < minLen) {
minLen = right - left + 1;
start = left;
}

char leftChar = s.charAt(left);

windowMap.put(leftChar, windowMap.get(leftChar) - 1);
 if (tMap.containsKey(leftChar) && windowMap.get(leftChar) <
tMap.get(leftChar)) {
formed--;
}

left++;
}

right++;
}

return minLen == Integer.MAX_VALUE ? "" : s.substring(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 <= s.length <= 1000
• 1 <= numRows <= 1000

package com.htc.leetcodesolutions.main;

public class ZigzagConversion {

public static void main(String[] args) {
String s = "PAYPALISHIRING";
int numRows = 3;
System.out.println(convert(s, numRows));
}

public static String convert(String s, int numRows) {

if (numRows == 1 || s.length() <= 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 : s.toCharArray()) {
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) {
result.append(row);
}

return result.toString();
}
}