Initial commit - String problems

Author: apdesai16

.DS_Store

@@ -0,0 +1,30 @@
+import java.util.Arrays;
+
+// Sort both strings.
+// If the sorted strings are equal, the original strings are anagrams.
+
+public class AnagramChecker {
+
+    public static boolean areAnagrams(String str1, String str2) {
+        // Convert strings to char arrays and sort them
+        char[] charArray1 = str1.toCharArray();
+        char[] charArray2 = str2.toCharArray();
+
+        Arrays.sort(charArray1);
+        Arrays.sort(charArray2);
+
+        // Compare the sorted char arrays
+        return Arrays.equals(charArray1, charArray2);
+    }
+
+    public static void main(String[] args) {
+        String str1 = "listen";
+        String str2 = "silent";
+
+        // Check if the strings are anagrams
+        boolean result = areAnagrams(str1, str2);
+
+        // Print the result
+        System.out.println("Are '" + str1 + "' and '" + str2 + "' anagrams? " + result);
+    }
+}

STRING/AnagramChecker.java

@@ -0,0 +1,31 @@
+// The countOccurrences method takes a string (input) and a target character (targetChar) as parameters.
+// It initializes a counter (count) to zero.
+// It uses a loop to iterate through each character in the input string.
+// Inside the loop, it checks if the current character is equal to the target character, and if so, increments the counter.
+// The final count is returned.
+
+public class CharacterCount {
+
+    public static int countOccurrences(String input, char targetChar) {
+        int count = 0;
+
+        // Iterate through each character in the string
+        for (char currentChar : input.toCharArray()) {
+            // Check if the current character matches the target character
+            if (currentChar == targetChar) {
+                count++;
+            }
+        }
+
+        return count;
+    }
+
+    public static void main(String[] args) {
+        String inputString = "Hello, World!";
+        char targetCharacter = 'o';
+
+        // Count the occurrences of the target character and print the result
+        int occurrences = countOccurrences(inputString, targetCharacter);
+        System.out.println("Number of occurrences of '" + targetCharacter + "': " + occurrences);
+    }
+}

STRING/CharacterCount.java

@@ -0,0 +1,22 @@
+public class PalindromeChecker {
+
+    public static boolean isPalindrome(String input) {
+        // Remove non-alphanumeric characters and convert to lowercase
+        String cleanInput = input.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
+
+        // Compare the original and reversed strings
+        return cleanInput.equals(new StringBuilder(cleanInput).reverse().toString());
+    }
+
+    public static void main(String[] args) {
+        String palindromeString = "A man, a plan, a canal, Panama";
+        String nonPalindromeString = "Hello, World!";
+
+        // Check if the strings are palindromes and print the results
+        boolean result1 = isPalindrome(palindromeString);
+        boolean result2 = isPalindrome(nonPalindromeString);
+
+        System.out.println("'" + palindromeString + "' is a palindrome: " + result1);
+        System.out.println("'" + nonPalindromeString + "' is a palindrome: " + result2);
+    }
+}

STRING/PalindromeChecker.java

@@ -0,0 +1,38 @@
+public class RemoveCharacter {
+
+    // public static String removeSpecificCharacter(String input, char charToRemove) {
+    //     StringBuilder result = new StringBuilder();
+
+    //     for (char currentChar : input.toCharArray()) {
+    //         if (currentChar != charToRemove) {
+    //             result.append(currentChar);
+    //         }
+    //     }
+
+    //     return result.toString();
+    // }
+
+    public static String removeSpecificCharacter(String input, char charToRemove) {
+        // Use replace() to remove all occurrences of the specified character
+        String result = input.replace(String.valueOf(charToRemove), "");
+
+        return result;
+    }
+
+    public static String removeFirstOccurrence(String input, char charToRemove) {
+        // Use replaceFirst() to remove the first occurrence of the specified character
+        String result = input.replaceFirst(String.valueOf(charToRemove), "");
+
+        return result;
+    }
+
+    public static void main(String[] args) {
+        String originalString = "Hello, World!";
+        char charToRemove = 'o';
+
+        // Remove the specified character and print the result
+        String stringWithoutChar = removeSpecificCharacter(originalString, charToRemove);
+        System.out.println("Original: " + originalString);
+        System.out.println("String without '" + charToRemove + "': " + stringWithoutChar);
+    }
+}

STRING/RemoveCharacter.java

@@ -0,0 +1,34 @@
+public class ReverseString {
+
+    public static String reverseWithStringBuilder(String input) {
+        // Use StringBuilder to efficiently reverse the string
+        return new StringBuilder(input).reverse().toString();
+    }
+
+    public static String reverseWithLoop(String input) {
+        char[] characters = input.toCharArray();
+        int left = 0;
+        int right = characters.length - 1;
+
+        // Swap characters from both ends towards the center
+        while (left < right) {
+            char temp = characters[left];
+            characters[left] = characters[right];
+            characters[right] = temp;
+
+            left++;
+            right--;
+        }
+
+        return new String(characters);
+    }
+
+    public static void main(String[] args) {
+        String original = "Hello, World!";
+        
+        // Reverse the string using StringBuilder and print the result
+        String reversed = reverseWithStringBuilder(original);
+        System.out.println("Original: " + original);
+        System.out.println("Reversed: " + reversed);
+    }
+}

STRING/ReverseString.java

@@ -0,0 +1,43 @@
+// Explanation:
+
+// printPermutations Method:
+// This is the public method that initializes the recursive process.
+
+// printPermutationsHelper Method:
+// The recursive helper method generates permutations by swapping characters.
+// It prints the current permutation when the start index reaches the end of the string.
+
+// swap Method:
+// A helper method to swap characters in the array.
+
+
+public class StringPermutations {
+
+    public static void printPermutations(String str) {
+        printPermutationsHelper(str.toCharArray(), 0, str.length() - 1);
+    }
+
+    private static void printPermutationsHelper(char[] chars, int start, int end) {
+        if (start == end) {
+            System.out.println(new String(chars));
+        } else {
+            for (int i = start; i <= end; i++) {
+                swap(chars, start, i);
+                printPermutationsHelper(chars, start + 1, end);
+                swap(chars, start, i); // Backtrack to restore the original order
+            }
+        }
+    }
+
+    private static void swap(char[] chars, int i, int j) {
+        char temp = chars[i];
+        chars[i] = chars[j];
+        chars[j] = temp;
+    }
+
+    public static void main(String[] args) {
+        String input = "abc";
+        System.out.println("All Permutations of " + input + ":");
+        printPermutations(input);
+    }
+}

STRING/StringPermutations.java

@@ -0,0 +1,13 @@
+public class TotatCharacters {
+  public static void main(String[] args) {
+    String str = "Scaler by InterviewBit";
+    int count = 0;
+    System.out.println("Input String: " + str);
+    //Count total characters in the given string except space
+    for (int i = 0; i < str.length(); i++) {
+      if (str.charAt(i) != ' ') count++;
+    }
+    //Display total number of characters in the given string
+    System.out.println("The total number of characters in the given string: " + coun
+  }
+}