Solution 1_ Java Program to Count and Map Character Reversals in a String- Interview Question Asked in TCS, Wipro, Deloitte, Tech-Mahindra

### Brief Explanation of the Java Code

The provided Java program analyzes a given string to count the occurrences of each character when comparing it with the reversed sequence of the string. The result is stored in a `HashMap` that maps each character to its calculated count.

#### Step-by-Step Breakdown of the Code:

1. **Initialization**:

- The input string `str` is initialized with the value `"deepakkumar"`.

- A `StringBuilder sb` is created to build intermediate results while checking character occurrences.

- The string `str` is converted to a character array `ch` using `toCharArray()`, which allows the program to process each character individually.

- A `HashMap map` is created to store each character and its calculated count.

2. **Main Loop to Process Characters**:

- The outer `for` loop iterates over each character in the character array `ch` using index `j`.

- **Nested Loop for Reverse Comparison**:

- For each character `ch[j]` in the original string, the inner `for` loop compares it with each character in the reversed sequence of the array `ch` using index `k`.

- `ch[ch.length - k - 1]` is used to access the characters from the end of the array to the beginning.

- **Checking for Matching Characters**:

- If the character `ch[j]` matches a character in the reversed sequence (`ch[ch.length - k - 1]`), it is appended to the `StringBuilder sb`.

3. **Storing Results in the HashMap**:

- After processing each character with the inner loop:

- If the `StringBuilder sb` is not empty (`sb.length() > 0`), it means that matches were found. The character `ch[j]` is added to the `HashMap map` with the length of the `StringBuilder` as its value (`sb.length()`), representing the count of matches.

- If no matches are found (`sb.length() == 0`), the character `ch[j]` is added to the `HashMap map` with a value of `1`.

- The `StringBuilder sb` is then reset (`sb.setLength(0)`) for the next character's processing.

4. **Final Output**:

- The `HashMap map` is printed, which contains each character from the string `str` and its corresponding count based on the matches found with the reversed sequence.

### Example Execution:

For the input string `"deepakkumar"`, the program processes the characters and compares each with the reversed sequence.

- **Processing 'd'**:

- No characters match in the reversed sequence → `d` is added to the map with value `1`.

- **Processing 'e'**:

- Matches found for 'e' when compared with the reversed sequence (matches 'r') → `e` is added with the appropriate count.

- **Continue processing** for each character similarly.

### Example Output:

Given the input `"deepakkumar"`, the output might look something like:

### Key Points:

- The program effectively maps each character to a count based on the number of times it matches when compared with the reversed sequence of the string.

- The use of a `HashMap` allows for easy storage and retrieval of character counts.

- This approach highlights the ability to analyze strings in terms of both forward and backward sequences, providing insights into character distribution and occurrence patterns.