Find Beautiful Indices in the Given Array I

This approach is a straightforward, brute-force solution. It first identifies all occurrences of the substrings a and b within the main string s and stores their starting indices in two separate lists. Afterwards, it employs a pair of nested loops to compare every index from the first list against every index from the second. If any pair of indices (i, j) satisfies the condition |i - j| <= k, the index i is marked as beautiful and added to the result.

• Create two lists, indicesA and indicesB, to store the starting indices of all occurrences of strings a and b in s.
• Populate indicesA by iterating through s and checking for a at each position.
• Populate indicesB similarly by checking for b.
• Initialize an empty list result to store the beautiful indices.
• Iterate through each index i in indicesA with an outer loop.
• Inside, use a nested loop to iterate through each index j in indicesB.
• If Math.abs(i - j) <= k, it means i is a beautiful index. Add i to result and break the inner loop to proceed to the next i.
• Return the result list.

The implementation involves two main steps. First, we scan the string s twice to find all starting positions for a and b. A simple way to do this is by iterating from 0 to s.length() - pattern.length() and using s.startsWith(pattern, i). The found indices are stored in indicesA and indicesB.

Second, we iterate through each index i in indicesA. For each i, we iterate through all indices j in indicesB. We calculate the absolute difference |i - j| and check if it's less than or equal to k. If the condition holds, we add i to our result list and use break to stop searching for other j's for the current i, as one is sufficient.

import java.util.ArrayList;
import java.util.List;

class Solution {
    public List<Integer> beautifulIndices(String s, String a, String b, int k) {
        int n = s.length();
        int lenA = a.length();
        int lenB = b.length();

        List<Integer> indicesA = new ArrayList<>();
        for (int i = 0; i <= n - lenA; i++) {
            if (s.startsWith(a, i)) {
                indicesA.add(i);
            }
        }

        List<Integer> indicesB = new ArrayList<>();
        for (int i = 0; i <= n - lenB; i++) {
            if (s.startsWith(b, i)) {
                indicesB.add(i);
            }
        }

        List<Integer> result = new ArrayList<>();
        if (indicesA.isEmpty() || indicesB.isEmpty()) {
            return result;
        }

        for (int i : indicesA) {
            for (int j : indicesB) {
                if (Math.abs(i - j) <= k) {
                    result.add(i);
                    break; // Found a valid j, move to the next i
                }
            }
        }
        return result;
    }
}