Permutation of a string so that the patterns match

Question

The question is to count how many permutations of a string B have an equivalent pattern into a bigger string A. For example, if A="aabbccd" and B="xx", then it should print 3, since "aa", "bb", "cc" are all substrings of A which share the same pattern as B.

I have tried to pass the substrings as numbers, such as xx becomes "11" and do the same for string A, but I still can't get it to work. Any ideas? Length can be up to 10^7.

Here's the code for changing pattern:

void transform(int* dest, char* original, int len) {
    int j=1;
    Al[original[0]-'a']=j;
    dest[0]=j;
    j++;
    for (int i=1;i<len;i++) {
        if (Al[original[i]-'a']==0) 
            Al[original[i]-'a']=j++;
        dest[i]=Al[original[i]-'a'];
    }
}

Answer 1

Concept: Use Regular Expressions

You would need the following regular expression (\\w)\\1{(REPETITIONS-1)}
I don't know about C but Java provides a library to compile RegEx patterns. Here's a class that implements just what you want:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringPatternPermutation {
    public static void main(String[] args) {
        int REPETITIONS = 3;
        String REGEX = "(\\w)\\1{" + (REPETITIONS-1) + "}";
        String INPUT = "abbbbbbccddeffff";

        Pattern p = Pattern.compile(REGEX);
        Matcher m = p.matcher(INPUT); 

        int count = 0;
        while(m.find()){
            String match = m.group();
            System.out.println(match);
            count++;
        }

        System.out.println(count);
    }
}

Here's a test of the code above: https://ideone.com/5nztaa
Here's a useful website to test any RegEx: https://regexr.com/

Answer 2

Without Regular Expressions

public class StringPatternPermutation {

    public static void main(String[] args) {
        String a = "abjjjiixsssppw";
        String b = "qwwwee";

        String patternA = detectPattern(a);
        String patternB = detectPattern(b);

        System.out.println("-String A: " + a);
        System.out.println("-Pattern A: " + patternA);
        System.out.println("-String B: " + b);
        System.out.println("-Pattern B: " + patternB);
        System.out.println("-A contains B? " + patternA.contains(patternB));

        int count = 0;
        int index = 0;      
        while((index = patternA.indexOf(patternB)) != -1){
            count++;
            patternA = patternA.substring(index+1, patternA.length());
        }

        System.out.println("-Number of occurances: " + count);
    }

    private static String detectPattern(String a){
        StringBuilder sb = new StringBuilder();
        char prev = a.charAt(0);
        int count = 1;

        for(int i = 1; i < a.length(); i++){            
            char curr = a.charAt(i);
            if(curr == prev)
                count++;
            else {
                sb.append(count + ", ");
                prev = curr;
                count = 1;
            }

            if(i == a.length() - 1){
                sb.append(count);
            }
        }
        return sb.toString();
    }

}

Test it on ideOne: https://ideone.com/w422Du