Scribd
Upload
75 views7 pages

Top50 Java String Array Problems

The document contains a collection of 40 Java coding problems focused on string and array manipulation, utilizing Java Collections and Streams. Each problem includes a method implementation that addresses a specific task, such as counting character frequency, checking for anagrams, and finding duplicates in arrays. The solutions demonstrate various programming techniques and best practices in Java.

Uploaded by

akash
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
75 views7 pages

Top50 Java String Array Problems

The document contains a collection of 40 Java coding problems focused on string and array manipulation, utilizing Java Collections and Streams. Each problem includes a method implementation that addresses a specific task, such as counting character frequency, checking for anagrams, and finding duplicates in arrays. The solutions demonstrate various programming techniques and best practices in Java.

Uploaded by

akash
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

// Top 50 String and Array Manipulation Problems Using Java Collections and Streams

import [Link].*;
import [Link];
import [Link].*;

public class JavaCodingProblems {

// 1. Count frequency of characters in a string


public static Map<Character, Long> charFrequency(String str) {
return [Link]()
.mapToObj(c -> (char) c)
.collect([Link](c -> c, [Link]()));
}

// 2. First non-repeating character


public static Character firstNonRepeatingChar(String str) {
return [Link]()
.mapToObj(c -> (char) c)
.collect([Link](c -> c, LinkedHashMap::new,
[Link]()))
.entrySet().stream()
.filter(e -> [Link]() == 1)
.map([Link]::getKey)
.findFirst().orElse(null);
}

// 3. Check if two strings are anagrams


public static boolean areAnagrams(String str1, String str2) {
return [Link]().sorted().boxed().collect([Link]())
.equals([Link]().sorted().boxed().collect([Link]()));
}

// 4. Reverse each word in a string


public static String reverseWords(String str) {
return [Link]([Link](" "))
.map(w -> new StringBuilder(w).reverse().toString())
.collect([Link](" "));
}

// 5. Remove duplicate characters


public static String removeDuplicateChars(String str) {
return [Link]()
.mapToObj(c -> (char) c)
.distinct()
.map(String::valueOf)
.collect([Link]());
}

// 6. Find duplicate characters


public static Set<Character> duplicateChars(String str) {
return [Link]()
.mapToObj(c -> (char) c)
.collect([Link](c -> c, [Link]()))
.entrySet().stream()
.filter(e -> [Link]() > 1)
.map([Link]::getKey)
.collect([Link]());
}

// 7. Check if string is a palindrome


public static boolean isPalindrome(String str) {
return [Link](0, [Link]() / 2)
.allMatch(i -> [Link](i) == [Link]([Link]() - 1 - i));
}

// 8. Longest word in sentence


public static String longestWord(String sentence) {
return [Link]([Link](" "))
.max([Link](String::length)).orElse("");
}

// 9. Most frequent character


public static Character mostFrequentChar(String str) {
return [Link]()
.mapToObj(c -> (char) c)
.collect([Link]([Link](), [Link]()))
.entrySet().stream()
.max([Link]())
.get().getKey();
}

// 10. Check string rotation


public static boolean isRotation(String str1, String str2) {
return [Link]() == [Link]() && (str1 + str1).contains(str2);
}

// 11. Remove duplicates from array


public static Integer[] removeDuplicates(Integer[] arr) {
return [Link](arr).distinct().toArray(Integer[]::new);
}

// 12. Max and min in array


public static int[] maxMin(int[] arr) {
return new int[] { [Link](arr).min().orElseThrow(),
[Link](arr).max().orElseThrow() };
}

// 13. Sort array descending


public static int[] sortDescending(int[] arr) {
return
[Link](arr).boxed().sorted([Link]()).mapToInt(Integer::intValue)
.toArray();
}

// 14. Find duplicates in array


public static Set<Integer> findDuplicates(int[] arr) {
return [Link](arr).boxed()
.collect([Link]([Link](), [Link]()))
.entrySet().stream()
.filter(e -> [Link]() > 1)
.map([Link]::getKey)
.collect([Link]());
}

// 15. Find common elements


public static List<Integer> commonElements(int[] arr1, int[] arr2) {
Set<Integer> set1 = [Link](arr1).boxed().collect([Link]());
return
[Link](arr2).filter(set1::contains).boxed().collect([Link]());
}

// 16. Find missing number 1 to N


public static int findMissing(int[] arr, int n) {
int total = [Link](1, n).sum();
int sum = [Link](arr).sum();
return total - sum;
}

// 17. Second highest number


public static int secondHighest(int[] arr) {
return [Link](arr).boxed().distinct()
.sorted([Link]()).skip(1).findFirst().orElseThrow();
}

// 18. Group even and odd


public static Map<Boolean, List<Integer>> groupEvenOdd(int[] arr) {
return [Link](arr).boxed().collect([Link](n -> n % 2
== 0));
}

// 19. Count frequencies


public static Map<Integer, Long> countFrequencies(int[] arr) {
return [Link](arr).boxed()
.collect([Link]([Link](), [Link]()));
}

// 20. Find majority element


public static Optional<Integer> majorityElement(int[] arr) {
int n = [Link];
return [Link](arr).boxed()
.collect([Link]([Link](), [Link]()))
.entrySet().stream()
.filter(e -> [Link]() > n / 2)
.map([Link]::getKey).findFirst();
}

// 21. Find all pairs with a given sum


public static List<List<Integer>> findPairsWithSum(int[] arr, int target) {
Set<Integer> seen = new HashSet<>();
List<List<Integer>> result = new ArrayList<>();
for (int num : arr) {
int complement = target - num;
if ([Link](complement)) {
[Link]([Link](complement, num));
}
[Link](num);
}
return result;
}

// 22. Rotate array to the right by k steps


public static int[] rotateRight(int[] arr, int k) {
int n = [Link];
return [Link](0, n)
.map(i -> arr[(n - k + i) % n])
.toArray();
}

// 23. Check if array contains a number


public static boolean contains(int[] arr, int key) {
return [Link](arr).anyMatch(x -> x == key);
}

// 24. Merge two arrays and remove duplicates


public static int[] mergeUnique(int[] arr1, int[] arr2) {
return [Link]([Link](arr1).boxed(), [Link](arr2).boxed())
.distinct().mapToInt(i -> i).toArray();
}

// 25. Intersect two arrays


public static int[] intersectArrays(int[] arr1, int[] arr2) {
Map<Integer, Long> map = [Link](arr1).boxed()
.collect([Link]([Link](), [Link]()));
return [Link](arr2).filter(n -> [Link](n, 0L) > 0 && [Link](n,
[Link](n) - 1) >= 1)
.toArray();
}

// 26. Find kth smallest element


public static int kthSmallest(int[] arr, int k) {
return [Link](arr).sorted().skip(k - 1).findFirst().orElseThrow();
}

// 27. Find all palindromic substrings


public static List<String> palindromicSubstrings(String str) {
Set<String> result = new HashSet<>();
for (int i = 0; i < [Link](); i++) {
for (int j = i + 1; j <= [Link](); j++) {
String sub = [Link](i, j);
if (isPalindrome(sub)) [Link](sub);
}
}
return new ArrayList<>(result);
}

// 28. Find longest palindromic substring


public static String longestPalindrome(String str) {
String res = "";
for (int i = 0; i < [Link](); i++) {
for (int j = i + 1; j <= [Link](); j++) {
String sub = [Link](i, j);
if (isPalindrome(sub) && [Link]() > [Link]()) res = sub;
}
}
return res;
}

// 29. Convert string to title case


public static String toTitleCase(String str) {
return [Link]([Link](" "))
.map(s -> [Link](0, 1).toUpperCase() + [Link](1).toLowerCase())
.collect([Link](" "));
}

// 30. Replace all spaces with underscore


public static String replaceSpaces(String str) {
return [Link](" ", "_");
}

// 31. Find all permutations of a string (recursive approach)


public static Set<String> permutations(String str) {
if ([Link]() == 0) return [Link]("");
Set<String> result = new HashSet<>();
char ch = [Link](0);
for (String perm : permutations([Link](1))) {
for (int i = 0; i <= [Link](); i++) {
[Link]([Link](0, i) + ch + [Link](i));
}
}
return result;
}

// 32. Group words by anagram


public static Collection<List<String>> groupAnagrams(List<String> words) {
return [Link]().collect([Link](
w -> [Link]().sorted().collect(StringBuilder::new,
StringBuilder::appendCodePoint, StringBuilder::append).toString()
)).values();
}

// 33. Remove all vowels from string


public static String removeVowels(String str) {
return [Link]("[aeiouAEIOU]", "");
}

// 34. Convert string to camel case


public static String toCamelCase(String str) {
String[] parts = [Link](" ");
StringBuilder sb = new StringBuilder(parts[0].toLowerCase());
for (int i = 1; i < [Link]; i++) {
[Link](parts[i].substring(0,
1).toUpperCase()).append(parts[i].substring(1).toLowerCase());
}
return [Link]();
}

// 35. Find max occurring word in a sentence


public static String maxOccurringWord(String str) {
return [Link]([Link](" "))
.collect([Link]([Link](), [Link]()))
.entrySet().stream().max([Link]())
.map([Link]::getKey).orElse("");
}

// 36. Capitalize alternate characters


public static String capitalizeAlternate(String str) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < [Link](); i++) {
[Link](i % 2 == 0 ? [Link]([Link](i)) :
[Link](i));
}
return [Link]();
}

// 37. Count digits, letters and special characters


public static Map<String, Long> countTypes(String str) {
return [Link]().mapToObj(c -> (char) c).collect([Link](c -> {
if ([Link](c)) return "Digits";
else if ([Link](c)) return "Letters";
else return "Specials";
}, [Link]()));
}

// 38. Reverse string without affecting special characters


public static String reversePreserveSpecial(String str) {
char[] chars = [Link]();
int i = 0, j = [Link] - 1;
while (i < j) {
if (![Link](chars[i])) i++;
else if (![Link](chars[j])) j--;
else {
char temp = chars[i];
chars[i] = chars[j];
chars[j] = temp;
i++;
j--;
}
}
return new String(chars);
}
// 39. Encode string with run-length encoding
public static String runLengthEncode(String str) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < [Link](); i++) {
int count = 1;
while (i + 1 < [Link]() && [Link](i) == [Link](i + 1)) {
count++;
i++;
}
[Link]([Link](i)).append(count);
}
return [Link]();
}

// 40. Decode run-length encoded string


public static String runLengthDecode(String str) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < [Link](); i += 2) {
char ch = [Link](i);
int count = [Link](i + 1) - '0';
[Link]([Link](ch).repeat(count));
}
return [Link]();
}

}
}

You might also like