Check Transcription
One of Arkady's friends works at a huge radio telescope. A few decades ago the telescope has sent a signal $$$s$$$ towards a faraway galaxy. Recently they've received a response $$$t$$$ which they believe to be a response from aliens! The scientists now want to check if the signal $$$t$$$ is similar to $$$s$$$.The original signal $$$s$$$ was a sequence of zeros and ones (everyone knows that binary code is the universe-wide language). The returned signal $$$t$$$, however, does not look as easy as $$$s$$$, but the scientists don't give up! They represented $$$t$$$ as a sequence of English letters and say that $$$t$$$ is similar to $$$s$$$ if you can replace all zeros in $$$s$$$ with some string $$$r_0$$$ and all ones in $$$s$$$ with some other string $$$r_1$$$ and obtain $$$t$$$. The strings $$$r_0$$$ and $$$r_1$$$ must be different and non-empty.Please help Arkady's friend and find the number of possible replacements for zeros and ones (the number of pairs of strings $$$r_0$$$ and $$$r_1$$$) that transform $$$s$$$ to $$$t$$$.
In the first example, the possible pairs $$$(r_0, r_1)$$$ are as follows:  "a", "aaaaa"  "aa", "aaaa"  "aaaa", "aa"  "aaaaa", "a"  The pair "aaa", "aaa" is not allowed, since $$$r_0$$$ and $$$r_1$$$ must be different.In the second example, the following pairs are possible:   "ko", "kokotlin"  "koko", "tlin" 
The first line contains a string $$$s$$$ ($$$2 \le |s| \le 10^5$$$) consisting of zeros and ones — the original signal.The second line contains a string $$$t$$$ ($$$1 \le |t| \le 10^6$$$) consisting of lowercase English letters only — the received signal.It is guaranteed, that the string $$$s$$$ contains at least one '0' and at least one '1'.
Print a single integer — the number of pairs of strings $$$r_0$$$ and $$$r_1$$$ that transform $$$s$$$ to $$$t$$$.In case there are no such pairs, print $$$0$$$.
s = input()
t = input()
(n, m) = (len(s), len(t))
a = s.count('0')
b = len(s) - a
pow = [1] * m
h = [0] * (m + 1)
(p, mod) = (31, 10 ** 9 + 9)
for i in range(1, m):
    pow[i] = pow[i - 1] * p % mod
for i in range(m):
    h[i + 1] = (h[i] + (ord(t[i]) - ord('a') + 1) * pow[i]) % mod

def get_hash(i, j):
    hash_value = (h[j] - h[i] + mod) % mod
    hash_value = hash_value * pow[m - i - 1] % mod
    return hash_value

def check(x, y):
    index = 0
    hash_x = hash_y = -1
    for i in range(n):
        if s[i] == '0':
            if hash_x == -1:
                hash_x = get_hash(index, index + x)
            elif get_hash(index, index + x) != hash_x:
                return False
            index += x
        else:
            if hash_y == -1:
                hash_y = get_hash(index, index + y)
            elif get_hash(index, index + y) != hash_y:
                return False
            index += y
    return hash_x != hash_y
res = 0
for x in range(1, m // a + 1):
    if (m - a * x) % b == 0:
        y = (m - a * x) // b
        if y == 0:
            continue
        if check(x, y):
            res += 1
print(res)
import sys
from math import *

def minp():
    return sys.stdin.readline().strip()

def mint():
    return int(minp())

def mints():
    return map(int, minp().split())

def add(a, b):
    return (a + b) % 1000000007

def sub(a, b):
    return (a + 1000000007 - b) % 1000000007

def mul(a, b):
    return a * b % 1000000007
p = 102367
s = list(map(int, minp()))
t = list(map(ord, minp()))
h = [0] * (len(t) + 1)
pp = [1] * (len(t) + 1)
for i in range(len(t)):
    h[i + 1] = add(mul(h[i], p), t[i])
    pp[i + 1] = mul(pp[i], p)

def cmp(a, b, l):
    if a > b:
        (a, b) = (b, a)
    h1 = sub(h[a + l], mul(h[a], pp[l]))
    h2 = sub(h[b + l], mul(h[b], pp[l]))
    return h2 == h1
c = [0, 0]
idx = [-1, -1]
for i in range(len(s)):
    c[s[i]] += 1
    if idx[s[i]] < 0:
        idx[s[i]] = i
Mv = max(c)
mv = min(c)
Mi = c.index(Mv)
mi = Mi ^ 1
lt = len(t)
sp = [0, 0]
res = 0
for k in range(1, lt // Mv + 1):
    l = [0, 0]
    x = (lt - k * Mv) // mv
    if x > 0 and x * mv + k * Mv == lt:
        l[Mi] = k
        l[mi] = x
        if idx[0] < idx[1]:
            sp[0] = 0
            sp[1] = idx[1] * l[0]
        else:
            sp[1] = 0
            sp[0] = idx[0] * l[1]
        ok = True
        j = 0
        for i in range(len(s)):
            if not cmp(sp[s[i]], j, l[s[i]]):
                ok = False
                break
            j += l[s[i]]
        if l[0] == l[1] and cmp(sp[0], sp[1], l[0]):
            ok = False
        if ok:
            res += 1
print(res)
def gethash(l, r):
    return (ha[r] - ha[l] * p[r - l] % mod + mod) % mod

def check(lenx, leny):
    ha_0 = -1
    ha_1 = -1
    j = 0
    for i in range(m):
        if s[i] == '0':
            tmp = gethash(j, j + lenx)
            if ha_0 == -1:
                ha_0 = tmp
            elif ha_0 != tmp:
                return 0
            j += lenx
        else:
            tmp = gethash(j, j + leny)
            if ha_1 == -1:
                ha_1 = tmp
            elif ha_1 != tmp:
                return 0
            j += leny
    return ha_0 != ha_1
s = list(input())
t = list(input())
m = len(s)
n = len(t)
p = [1]
bas = 2333
mod = (1 << 50) - 2
for i in range(1, n + 1):
    p.append(p[i - 1] * bas % mod)
ha = [0]
for i in range(1, n + 1):
    ha.append((ha[i - 1] * bas + ord(t[i - 1])) % mod)
cnt_0 = 0
cnt_1 = 0
for x in s:
    if x == '0':
        cnt_0 += 1
    else:
        cnt_1 += 1
ans = 0
for i in range(1, n // cnt_0 + 1):
    j = n - cnt_0 * i
    if j % cnt_1 == 0 and j != 0:
        j //= cnt_1
        ans += check(i, j)
print(ans)