Problem:
 Score : 600 points    Problem Statement Let us consider the following operations on a string consisting of A and B :   Select a character in a string. If it is A , replace it with BB . If it is B , replace with AA .  Select a substring that is equal to either AAA or BBB , and delete it from the string.   For example, if the first operation is performed on ABA and the first character is selected, the string becomes BBBA .
If the second operation is performed on BBBAAAA and the fourth through sixth characters are selected, the string becomes BBBA .  These operations can be performed any number of times, in any order.  You are given two string S and T , and q queries a_i, b_i, c_i, d_i .
For each query, determine whether S_{a_i} S_{{a_i}+1} ... S_{b_i} , a substring of S , can be made into T_{c_i} T_{{c_i}+1} ... T_{d_i} , a substring of T .      Constraints  1 \leq |S|, |T| \leq 10^5  S and T consist of letters A and B .  1 \leq q \leq 10^5  1 \leq a_i \leq b_i \leq |S|  1 \leq c_i \leq d_i \leq |T|         Input Input is given from Standard Input in the following format:  S  T  q  a_1  b_1  c_1  d_1  ...  a_q  b_q  c_q  d_q       Output Print q lines. The i -th line should contain the response to the i -th query. If S_{a_i} S_{{a_i}+1} ... S_{b_i} can be made into T_{c_i} T_{{c_i}+1} ... T_{d_i} , print YES . Otherwise, print NO .        Sample Input 1 BBBAAAABA
BBBBA
4
7 9 2 5
7 9 1 4
1 7 2 5
1 7 2 4      Sample Output 1 YES
NO
YES
NO  The first query asks whether the string ABA can be made into BBBA .
As explained in the problem statement, it can be done by the first operation.  The second query asks whether ABA can be made into BBBB , and the fourth query asks whether BBBAAAA can be made into BBB .
Neither is possible.  The third query asks whether the string BBBAAAA can be made into BBBA .
As explained in the problem statement, it can be done by the second operation.       Sample Input 2 AAAAABBBBAAABBBBAAAA
BBBBAAABBBBBBAAAAABB
10
2 15 2 13
2 13 6 16
1 13 2 20
4 20 3 20
1 18 9 19
2 14 1 11
3 20 3 15
6 16 1 17
4 18 8 20
7 20 3 14      Sample Output 2 YES
YES
YES
YES
YES
YES
NO
NO
NO
NO

Solution (Python):
from itertools import accumulate
import sys

S = input()
T = input()

ns = len(S)
nt = len(T)
SA = [0] * (ns + 1)
SB = [0] * (ns + 1)
TA = [0] * (nt + 1)
TB = [0] * (nt + 1)
for i, s in enumerate(S, 1):
    if s == "A":
        SA[i] = 1
    else:
        SB[i] = 1
for i, t in enumerate(T, 1):
    if t == "A":
        TA[i] = 1
    else:
        TB[i] = 1
SA = list(accumulate(SA))
SB = list(accumulate(SB))
TA = list(accumulate(TA))
TB = list(accumulate(TB))


q = int(input())
for _ in range(q):
    a, b, c, d = map(int, input().split())
    sa = SA[b] - SA[a - 1]
    sb = SB[b] - SB[a - 1]
    ta = TA[d] - TA[c - 1]
    tb = TB[d] - TB[c - 1]
    
    sb += 2 * sa
    tb += 2 * ta
    if abs(sb - tb) % 3 == 0:
        print("YES")
    else:
        print("NO")

Solution (Python):
s=input()
S=[0]
d=0
for i in s:
  if i=='A':
    d+=1
  else:
    d+=2
  S.append(d)
t=input()
T=[0]
d=0
for i in t:
  if i=='A':
    d+=1
  else:
    d+=2
  T.append(d)
q=int(input())
for i in range(q):
  a,b,c,d=map(int, input().split())
  x=S[b]-S[a-1]
  y=T[d]-T[c-1]
  if (x-y)%3==0:
    print('YES')
  else:
    print('NO')

Solution (Python):
import sys
from itertools import accumulate


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


def acc(li, n):
    res = [0] * (n + 1)
    for i in range(n):
        if li[i] == "A":
            res[i + 1] = 1
        elif li[i] == "B":
            res[i + 1] = 2
    return list(accumulate(res))


def restore(x, y, li):
    return (li[y] - li[x - 1]) % 3


S = input()
T = input()
N = len(S)
M = len(T)

acc_S = acc(S, N)
acc_T = acc(T, M)

q = int(input())
for _ in range(q):
    a, b, c, d = map(int, input().split())
    v_S = restore(a, b, acc_S)
    v_T = restore(c, d, acc_T)
    print("YES") if v_S == v_T else print("NO")

Solution (Python):
from itertools import accumulate
import sys
readlines = sys.stdin.readlines
input = sys.stdin.readline
S = tuple(accumulate(map(lambda x: 1 if x == 'A' else 2, input().rstrip())))
T = tuple(accumulate(map(lambda x: 1 if x == 'A' else 2, input().rstrip())))
input()
for line in readlines():
    a, b, c, d = map(lambda x: int(x)-1, line.split())
    s = S[b]-S[a-1] if a else S[b]
    t = T[d]-T[c-1] if c else T[d]
    print('YES' if s % 3 == t % 3 else 'NO')

Solution (Python):
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))
def getArray(intn):
    return [int(input()) for i in range(intn)]
def input():
    return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
    return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
    return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
  ns = []
  while len(ns) < rantime:
    n = random.randint(ran1, ran2)
    if not n in ns:
      ns.append(n)
  return sorted(ns)

def rand_query(ran1, ran2, rantime):
  r_query = []
  while len(r_query) < rantime:
    n_q = rand_ints_nodup(ran1, ran2, 2)
    if not n_q in r_query:
      r_query.append(n_q)
  return sorted(r_query)

from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
from heapq import heapify, heappop, heappush
from math import sqrt
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce
from bisect import bisect_left, bisect_right

import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7





S = input()
T = input()
Q = getN()
que = [getList() for i in range(Q)]








imos_s = [0]
for i in range(len(S)):
    if S[i] == 'A':
        imos_s.append(imos_s[i] + 1)
    else:
        imos_s.append(imos_s[i] + 2)
imos_t = [0]
for i in range(len(T)):
    if T[i] == 'A':
        imos_t.append(imos_t[i] + 1)
    else:
        imos_t.append(imos_t[i] + 2)

for i in range(Q):
    a, b, c, d = que[i]
    opt_1 = (imos_s[b] - imos_s[a - 1]) % 3
    opt_2 = (imos_t[d] - imos_t[c - 1]) % 3
    if opt_1 == opt_2:
        print('YES')
    else:
        print('NO')

Solution (Python):
s=input()
t=input()
n=len(s)
m=len(t)
sl=[0]
for i in s:
    sl.append(sl[-1])
    if i=="A":sl[-1]+=1
    else:sl[-1]+=2
    sl[-1]%=3
tl=[0]
for i in t:
    tl.append(tl[-1])
    if i=="A":tl[-1]+=1
    else:tl[-1]+=2
    tl[-1]%=3
q=int(input())
for _ in range(q):
    a,b,c,d=map(int,input().split())
    a-=1
    c-=1
    ss=sl[b]-sl[a]
    tt=tl[d]-tl[c]
    if ss%3==tt%3:print("YES")
    else:print("NO")

Solution (Python):
import bisect, copy, heapq, math, sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
def celi(a,b):
    return -(-a//b)
sys.setrecursionlimit(5000000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]


s,t=input(),input()
q=int(input())
abcd=[list(map(int,input().split())) for i in range(q)]

scnt=[(0,0)]*(len(s)+1)
tcnt=[(0,0)]*(len(t)+1)
for i in range(len(s)):
    a,b=scnt[i]
    if s[i]=="A":
        a+=1
    else:
        b+=1
    scnt[i+1]=(a,b)
for i in range(len(t)):
    a,b=tcnt[i]
    if t[i]=="A":
        a+=1
    else:
        b+=1
    tcnt[i+1]=(a,b)



for i in range(q):
    a,b,c,d=abcd[i]
    sa,sb=scnt[b],scnt[a-1]
    sa,sb=sa[0]-sb[0],sa[1]-sb[1]
    ta,tb=tcnt[d],tcnt[c-1]
    ta,tb=ta[0]-tb[0],ta[1]-tb[1]
    

    if abs((sa-sb)-(ta-tb))%3==0:
        print("YES")
    else:
        print("NO")

Solution (Python):
import sys
input = sys.stdin.readline
S = input()
T = input()
q = int(input())
abcd= [list(map(int,input().split())) for i in range(q)]


class SegmentTree:
    def __init__(self,data,op,default):
        N = len(data)
        self.N = N
        self.op = op
        self.default = default
        self.l = 2**((N-1).bit_length())
        self.data = [default]*self.l + data + [default]*(self.l-N)
        for i in range(self.l-1,0,-1):
            self.data[i] = op(self.data[2*i], self.data[2*i+1])

    def get_data(self, i=None):
        if i is None:
            return self.data[self.l:self.l + self.N]
        else:
            return self.data[self.l+i]

    def set(self,i,val):
        i += self.l
        self.data[i] = val
        i = i//2
        while i > 0:
            self.data[i] = self.op(self.data[2*i], self.data[2*i+1])
            i = i//2

    def get(self,i,j):
        i += self.l
        j += self.l
        s = self.default 
        while j-i > 0:
            if i & 1:
                s = self.op(s,self.data[i])
                i += 1
            if j & 1:
                s = self.op(s,self.data[j-1])
                j -= 1
            i, j = i//2, j//2
        return s

convert = lambda x : 1 if x == 'A' else 2
nS = list(map(convert,S))
nT = list(map(convert,T))
segS = SegmentTree(nS,lambda x,y:x+y, 0)
segT = SegmentTree(nT,lambda x,y:x+y, 0)




for a,b,c,d in abcd:
    rs = segS.get(a-1,b)
    rt = segT.get(c-1,d)
    if (rs-rt) % 3 == 0:
        print('YES')
    else:
        print('NO')

Solution (Python):
fc=lambda x:1 if x=='A' else 2
s=list(map(fc,list(input())))
t=list(map(fc,list(input())))
q=int(input())
abcd=[list(map(int,input().split())) for _ in range(q)]
cs=[0]
tmp=0
for x in s:
  tmp+=x
  cs.append(tmp)
ct=[0]
tmp=0
for x in t:
  tmp+=x
  ct.append(tmp)
for a,b,c,d in abcd:
  if (cs[b]-cs[a-1])%3==(ct[d]-ct[c-1])%3:
    print('YES')
  else:
    print('NO')

Solution (Python):






from itertools import accumulate

S = input()
T = input()
q = int(input())
abcds = [tuple(map(int, input().split())) for _ in range(q)]

S_csum = list(map(lambda x: x%3, [0] + list(accumulate(map(lambda c: 1 if c == 'A' else -1, S)))))
T_csum = list(map(lambda x: x%3, [0] + list(accumulate(map(lambda c: 1 if c == 'A' else -1, T)))))

for a, b, c, d in abcds:
    if (S_csum[b] - S_csum[a-1]) % 3 == (T_csum[d] - T_csum[c-1]) % 3:
        print("YES")
    else:
        print("NO")

Solution (Python):






from itertools import accumulate

S = input()
T = input()
q = int(input())
abcds = [tuple(map(int, input().split())) for _ in range(q)]

S_csum = list(map(lambda x: x%3, [0] + list(accumulate(map(lambda c: 1 if c == 'A' else -1, S)))))
T_csum = list(map(lambda x: x%3, [0] + list(accumulate(map(lambda c: 1 if c == 'A' else -1, T)))))

for a, b, c, d in abcds:
    if (S_csum[b] - S_csum[a-1]) % 3 == (T_csum[d] - T_csum[c-1]) % 3:
        print("YES")
    else:
        print("NO")

Solution (Python):






from itertools import accumulate

S = input()
T = input()
q = int(input())
abcds = [tuple(map(int, input().split())) for _ in range(q)]

S_csum = list(map(lambda x: x%3, accumulate(map(lambda c: 1 if c == 'A' else -1, S), initial=0)))
T_csum = list(map(lambda x: x%3, accumulate(map(lambda c: 1 if c == 'A' else -1, T), initial=0)))

for a, b, c, d in abcds:
    if (S_csum[b] - S_csum[a-1]) % 3 == (T_csum[d] - T_csum[c-1]) % 3:
        print("YES")
    else:
        print("NO")

Solution (Python):
s=input()
t=input()
sm=0
ss=[]
for i in s:
  sm+=(i=="A")*2-1
  ss.append(sm)
ss.append(0)
sm=0
ts=[]
for i in t:
  sm+=(i=="A")*2-1
  ts.append(sm)
ts.append(0)
q=int(input())
for i in range(q):
  inp=list(map(int,input().split()))
  if (ss[inp[1]-1]-ss[inp[0]-2])%3==(ts[inp[3]-1]-ts[inp[2]-2])%3:
    print("YES")
  else:
    print("NO")

Solution (Python):
s = list(input())
t = list(input())
ls, lt = len(s), len(t)
sa, sb = [0] * (ls + 1), [0] * (ls + 1)
ta, tb = [0] * (lt + 1), [0] * (lt + 1)
for i in range(1, ls + 1):
    if s[i - 1] == "A":
        sa[i] = sa[i - 1] + 1
        sb[i] = sb[i - 1]
    else:
        sa[i] = sa[i - 1]
        sb[i] = sb[i - 1] + 1
for i in range(1, lt + 1):
    if t[i - 1] == "A":
        ta[i] = ta[i - 1] + 1
        tb[i] = tb[i - 1]
    else:
        ta[i] = ta[i - 1]
        tb[i] = tb[i - 1] + 1

q = int(input())
for _ in range(q):
    ans = 0
    a, b, c, d = map(int, input().split())
    a1, b1 = sa[b] - sa[a - 1], sb[b] - sb[a - 1]
    a2, b2 = ta[d] - ta[c - 1], tb[d] - tb[c - 1]
    x, y = a1 - b1, a2 - b2
    if x * y < 0:
        x = -2 * x
    if abs(x - y) % 3 == 0:
        ans = 1
    print("YES" if ans == 1 else "NO")

Solution (Python):
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines

s = readline().strip()
t = readline().strip()
q = int(readline())
abcd = list(map(int,read().split()))

cumsum_s = [0] * (len(s)+1)
cumsum_t = [0] * (len(t)+1)
for cs,st in zip([cumsum_s,cumsum_t],[s,t]):
    for i,ch in enumerate(st,1):
        cs[i] = cs[i-1] + (1 if ch=='A' else 2)

ans = []
it = iter(abcd)
for a,b,c,d in zip(it,it,it,it):
    num1 = cumsum_s[b] - cumsum_s[a-1]
    num2 = cumsum_t[d] - cumsum_t[c-1]
    if((num1-num2)%3 == 0):
        ans.append('YES')
    else:
        ans.append('NO')

print('\n'.join(ans))

Solution (Python):
s=input()
t=input()
q=int(input())
acums=[[0,0] for _ in range(len(s)+1)]
for i in range(1,len(s)+1):
  if s[i-1]=='A':
    acums[i][0]=acums[i-1][0]+1
    acums[i][1]=acums[i-1][1]
  else:
    acums[i][0]=acums[i-1][0]
    acums[i][1]=acums[i-1][1]+1
acumt=[[0,0] for _ in range(len(t)+1)]
for i in range(1,len(t)+1):
  if t[i-1]=='A':
    acumt[i][0]=acumt[i-1][0]+1
    acumt[i][1]=acumt[i-1][1]
  else:
    acumt[i][0]=acumt[i-1][0]
    acumt[i][1]=acumt[i-1][1]+1
for _ in range(q):
  a,b,c,d=map(int,input().split())
  cnt1=(acums[b][0]-acums[a-1][0])*2+(acums[b][1]-acums[a-1][1])
  cnt2=(acumt[d][0]-acumt[c-1][0])*2+(acumt[d][1]-acumt[c-1][1])
  if (cnt1-cnt2)%3==0:
    print('YES')
  else:
    print('NO')

Solution (Python):
def main():
    s = input()
    t = input()
    a = [0]*(len(s)+1)
    b = [0]*(len(t)+1)
    for i, c in enumerate(s):
        if c == "A":
            a[i+1] = 1
        else:
            a[i+1] = 2
        a[i+1] += a[i]
    for i, c in enumerate(t):
        if c == "A":
            b[i+1] = 1
        else:
            b[i+1] = 2
        b[i+1] += b[i]
    q = int(input())
    ans = [None]*q
    for i in range(q):
        a1, a2, b1, b2 = map(int, input().split())
        x, y = a[a2] - a[a1-1], b[b2] - b[b1-1]
        if abs(x-y) % 3 == 0:
            ans[i] = "YES"
        else:
            ans[i] = "NO"
    for v in ans:
        print(v)

if __name__ == "__main__":
    main()

Solution (Python):

printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 10**18
R = 10**9 + 7


def ddprint(x):
  if DBG:
    print(x)

s = ins()
t = ins()
sacc = [0]
for c in s:
    sacc.append(((1 if c=='A' else 2)+sacc[-1])%3)
tacc = [0]
for c in t:
    tacc.append(((1 if c=='A' else 2)+tacc[-1])%3)


q = inn()
for i in range(q):
    a,b,c,d = inm()
    
    print('YES' if (sacc[b]-sacc[a-1])%3==(tacc[d]-tacc[c-1])%3 else 'NO')

Solution (Python):


import sys
read = sys.stdin.read
readline = sys.stdin.readline


s = input()
t = input()

vs = [0]
for i in s:
    if i =="A": vs.append(vs[-1]+1)
    else: vs.append(vs[-1]-1)

vt = [0]
for i in t:
    if i =="A": vt.append(vt[-1]+1)
    else: vt.append(vt[-1]-1)




q = int(input())
for _ in range(q):
    a,b,c,d = map(int,readline().split())
    rs = vs[b] - vs[a-1]
    rs %= 3

    rt = vt[d] - vt[c-1]
    rt %= 3

    if rs==rt: print("YES")
    else: print("NO")

Solution (Python):
S = input()
T = input()

cum_s = [(0, 0)]
cum_t = [(0, 0)]

for i in range(len(S)):
    p, q = cum_s[-1]
    if S[i] == 'A':
        cum_s.append((p + 1, q))
    else:
        cum_s.append((p, q + 1))

for i in range(len(T)):
    p, q = cum_t[-1]
    if T[i] == 'A':
        cum_t.append((p + 1, q))
    else:
        cum_t.append((p, q + 1))

Q = int(input())

for _ in range(Q):
    a, b, c, d = map(int, input().split())
    sp = cum_s[b][0] - cum_s[a - 1][0]
    sq = cum_s[b][1] - cum_s[a - 1][1]
    tp = cum_t[d][0] - cum_t[c - 1][0]
    tq = cum_t[d][1] - cum_t[c - 1][1]
    sp += sq * 2
    tp += tq * 2
    if sp % 3 == tp % 3:
        print('YES')
    else:
        print('NO')

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15

def main():
    S = input()
    T = input()
    Scnt = [0] * (len(S) + 1)
    for i in range(len(S)):
        if S[i] == 'A':
            Scnt[i + 1] = Scnt[i] + 1
        else:
            Scnt[i + 1] = Scnt[i] + 2
    
    Tcnt = [0] * (len(T) + 1)
    for i in range(len(T)):
        if T[i] == 'A':
            Tcnt[i + 1] = Tcnt[i] + 1
        else:
            Tcnt[i + 1] = Tcnt[i] + 2
    
    Q = int(input())
    for _ in range(Q):
        a,b,c,d = map(int,input().split())
        a -= 1
        c -= 1
        if (Scnt[b] - Scnt[a] - Tcnt[d] + Tcnt[c])%3 == 0:
            print('YES')
        else:
            print('NO')
if __name__ == '__main__':
    main()

Solution (Python):
S=[input() for i in range(2)]
q=int(input())
ABCD=[list(map(int,input().split())) for i in range(q)]
p=[[0] for i in range(2)]
for i in range(2):
    for j,s in enumerate(S[i]):
        if s=='A':
            p[i].append(p[i][-1]+1)
        else:
            p[i].append(p[i][-1]+2)
for a,b,c,d in ABCD:
    print(['NO','YES'][(p[0][b]-p[0][a-1])%3==(p[1][d]-p[1][c-1])%3])

Solution (Python):
import math

import queue
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit


ipt = stdin.readline
setrecursionlimit(10**7)

def main():
    s = input()
    t = input()
    ns = len(s)+1
    nt = len(t)+1
    ssa = [0]*ns
    ssb = [0]*ns
    sta = [0]*nt
    stb = [0]*nt
    for i,si in enumerate(s):
        if si == "A":
            da = 1
            db = 0
        else:
            da = 0
            db = 1
        ssa[i+1] = ssa[i]+da
        ssb[i+1] = ssb[i]+db
    for i,ti in enumerate(t):
        if ti == "A":
            da = 1
            db = 0
        else:
            da = 0
            db = 1
        sta[i+1] = sta[i]+da
        stb[i+1] = stb[i]+db

    q = int(ipt())
    for _ in range(q):
        a,b,c,d = map(int,ipt().split())
        da = ssa[b]-ssa[a-1]-sta[d]+sta[c-1]
        db = ssb[b]-ssb[a-1]-stb[d]+stb[c-1]
        if (da-db)%3 == 0:
            print("YES")
        else:
            print("NO")

    return

if __name__ == '__main__':
    main()

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()


S = ins()
T = ins()
conv = {"A": 1, "B": 2}


def solve():
    cums = [0] * (len(S) + 1)
    cumt = [0] * (len(T) + 1)
    for i, x in enumerate(S):
        c = conv[x]  
        cums[i + 1] = (cums[i] + c) % 3
    for i, x in enumerate(T):
        c = conv[x]  
        cumt[i + 1] = (cumt[i] + c) % 3

    q = ini()
    for i in range(q):
        a, b, c, d = inm()
        if (cums[b] - cums[a - 1]) % 3 == (cumt[d] - cumt[c - 1]) % 3:
            print("YES")
        else:
            print("NO")


solve()

Solution (Python):
S = input()
T = input()
n = len(S)
m = len(T)
L = [0]*(n+1)
R = [0]*(m+1)
for i, s in enumerate(S):
  if s == "A":
    L[i+1] = (L[i]+1)%3
  else:
    L[i+1] = (L[i]-1)%3
for i, t in enumerate(T):
  if t == "A":
    R[i+1] = (R[i]+1)%3
  else:
    R[i+1] = (R[i]-1)%3
q = int(input())
for _ in range(q):
  a, b, c, d = map(int, input().split())
  if (L[b]-L[a-1])%3 == (R[d]-R[c-1])%3:
    print("YES")
  else:
    print("NO")

Solution (Python):
import sys
input=sys.stdin.readline


def solve():
    S, T = input(), input()
    q = int(input())

    ls, lt = len(S), len(T)
    acs, act = [0]*(ls+1), [0]*(lt+1)

    for i in range(1, ls+1):
        acs[i] = acs[i-1] + (S[i-1]=="A")
    for i in range(1, lt+1):
        act[i] = act[i-1] + (T[i-1]=="A")

    for _ in range(q):
        a, b, c, d = map(int, input().split())
        print("YES" if (acs[b]-acs[a-1]+b-a+1)%3==(act[d]-act[c-1]+d-c+1)%3 else "NO")


if __name__ == "__main__":
    solve()

Solution (Python):
import sys
input=sys.stdin.readline


def solve():
    S, T = input(), input()
    q = int(input())

    ls, lt = len(S), len(T)
    acs, act = [0]*(ls+1), [0]*(lt+1)

    for i in range(1, ls+1):
        acs[i] = acs[i-1] + (S[i-1]=="A")
    for i in range(1, lt+1):
        act[i] = act[i-1] + (T[i-1]=="A")

    for _ in range(q):
        a, b, c, d = map(int, input().split())
        print("YES" if (acs[b]-acs[a-1]+b-a+1)%3==(act[d]-act[c-1]+d-c+1)%3 else "NO")

solve()

Solution (Python):
S, T = input(), input()
q = int(input())

ls, lt = len(S), len(T)
acs, act = [0]*(ls+1), [0]*(lt+1)

for i in range(1, ls+1):
    acs[i] = acs[i-1] + (S[i-1]=="A")
for i in range(1, lt+1):
    act[i] = act[i-1] + (T[i-1]=="A")

for _ in range(q):
    a, b, c, d = map(int, input().split())
    print("YES" if (acs[b]-acs[a-1]+b-a+1)%3==(act[d]-act[c-1]+d-c+1)%3 else "NO")

Solution (Python):
S, T = input(), input()
q = int(input())

ls, lt = len(S), len(T)
acs, act = [0]*(ls+1), [0]*(lt+1)

for i in range(1, ls+1):
    acs[i] = acs[i-1] + (S[i-1]=="A")
for i in range(1, lt+1):
    act[i] = act[i-1] + (T[i-1]=="A")

for _ in range(q):
    a, b, c, d = map(int, input().split())
    sa = acs[b]-acs[a-1]
    sb = b-a+1-sa
    ta = act[d]-act[c-1]
    tb = d-c+1-ta
    print("YES" if (2*sa+sb)%3==(2*ta+tb)%3 else "NO")

Solution (Python):
from operator import add
import sys
input=sys.stdin.readline


class SegTree():
    def __init__(self, N, e, operator_func=add):
        self.e = e 
        self.size = N
        self.node = [self.e] * (2*N)
        self.operator_func = operator_func 

    def set_list(self, l):
        for i in range(self.size):
            self.node[i+self.size-1] = l[i]
        for i in range(self.size-1)[::-1]:
            self.node[i] = self.operator_func(self.node[2*i+1], self.node[2*i+2])
    
    def update(self, k, x):
        k += self.size-1
        self.node[k] = x
        while k >= 0:
            k = (k - 1) // 2
            self.node[k] = self.operator_func(self.node[2*k+1], self.node[2*k+2])

    def get(self, l, r):
        
        x = self.e
        l += self.size
        r += self.size

        while l<r:
            if l&1:
                x = self.operator_func(x, self.node[l-1])
                l += 1
            if r&1:
                r -= 1
                x = self.operator_func(x, self.node[r-1])
            l >>= 1
            r >>= 1
        return x


def main():
    S = input()
    T = input()
    treeS = SegTree(len(S), 0)
    treeT = SegTree(len(T), 0)
    treeS.set_list([1 if s=="A" else 0 for s in S])
    treeT.set_list([1 if s=="A" else 0 for s in T])

    q = int(input())
    for _ in range(q):
        a, b, c, d = map(int, input().split())
        sa = treeS.get(a-1, b)
        sb = b-a+1-sa
        ta = treeT.get(c-1, d)
        tb = d-c+1-ta

        if (2*(sb-sa)+tb-ta)%3 or (sb-sa+2*(tb-ta))%3:
            print("NO")
        else:
            print("YES")

main()

Solution (Python):
S=input()
T=input()
N=int(input())
abcd = [tuple(map(int,input().split())) for _ in range(N)]

NS = len(S)
NT = len(T)
cs0 = [0]*(NS+1)
cs1 = [0]*(NS+1)
ct0 = [0]*(NT+1)
ct1 = [0]*(NT+1)
for i in range(NS):
    cs0[i+1] = cs0[i]
    cs1[i+1] = cs1[i]
    if S[i]=='A':
        cs0[i+1] += 1
    else:
        cs1[i+1] += 1
for i in range(NT):
    ct0[i+1] = ct0[i]
    ct1[i+1] = ct1[i]
    if T[i]=='A':
        ct0[i+1] += 1
    else:
        ct1[i+1] += 1

for a,b,c,d in abcd:
    anum = cs0[b] - cs0[a-1]
    bnum = cs1[b] - cs1[a-1]
    num = 0
    if anum%3 == bnum%3 == 0:
        num = 0
    elif anum > bnum:
        num = (anum-bnum)%3
    else:
        num = 2*(bnum-anum)%3
    anum2 = ct0[d] - ct0[c-1]
    bnum2 = ct1[d] - ct1[c-1]
    num2 = 0
    if anum2%3 == bnum2%3 == 0:
        num2 = 0
    elif anum2 > bnum2:
        num2 = (anum2-bnum2)%3
    else:
        num2 = 2*(bnum2-anum2)%3
    
    if num == num2:
        print('YES')
    else:
        print('NO')

Solution (Python):
import numpy as np

S = list(input())
T = list(input())

count_A_S = np.r_[[0], np.array(S) == 'A']
count_A_S = count_A_S.cumsum()
count_B_S = np.r_[[0], np.array(S) == 'B']
count_B_S = count_B_S.cumsum()
count_A_T = np.r_[[0], np.array(T) == 'A']
count_A_T = count_A_T.cumsum()
count_B_T = np.r_[[0], np.array(T) == 'B']
count_B_T = count_B_T.cumsum()

def check(a1, b1, a2, b2):
  if a1 < a2:
    if b1 < b2:
      diff1 = a2 - a1; diff2 = b2 - b1
      diff = abs(diff1 - diff2)
    else:
      diff = b1 - b2 + a2 - a1
  else:
    if b1 < b2:
      diff = a1 - a2 + b2 - b1
    else:
      diff1 = a1 - a2; diff2 = b1 - b2
      diff = abs(diff1 - diff2)
  if diff % 3 == 0:
    return 'YES'
  else:
    return 'NO'

q = int(input())
ans = []
for i in range(q):
  a, b, c, d = map(int, input().split())
  num_a_s = count_A_S[b] - count_A_S[a-1]
  num_b_s = count_B_S[b] - count_B_S[a-1]
  num_a_t = count_A_T[d] - count_A_T[c-1]
  num_b_t = count_B_T[d] - count_B_T[c-1]
  ans.append(check(num_a_s, num_b_s, num_a_t, num_b_t))

print(*ans, sep='\n')

Solution (Python):


import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))


s = input()
t = input()

sa = [0] * (len(s)+1)
sb = [0] * (len(s)+1)
ta = [0] * (len(t)+1)
tb = [0] * (len(t)+1)

ca = 0
cb = 0
for i,c in enumerate(s):
    if c=="A":
        ca += 1
    else:
        cb += 1
    sa[i+1] = ca
    sb[i+1] = cb
ca = 0
cb = 0
for i,c in enumerate(t):
    if c=="A":
        ca += 1
    else:
        cb += 1
    ta[i+1] = ca
    tb[i+1] = cb


q = int(input())
for i in range(q):
    a,b,c,d = map(lambda x: int(x)-1, input().split())
    if (((sa[b+1]-sa[a]) - (sb[b+1]-sb[a])) - ((ta[d+1]-ta[c]) - (tb[d+1]-tb[c])))%3==0:
        print("YES")
    else:
        print("NO")

Solution (Python):
S=input();T=input()
dps=[0]*len(S)
for i in range(len(S)):
    if S[i]=="A":
        dps[i]+=1
    if i!=0:
        dps[i]+=dps[i-1]

dpt=[0]*len(T)
for i in range(len(T)):
    if T[i]=="A":
        dpt[i]+=1
    if i!=0:
        dpt[i]+=dpt[i-1]
dps=[0]+dps
dpt=[0]+dpt

q=int(input())
for i in range(q):
    a,b,c,d=map(int,input().split())
    sc=dps[b]-dps[a-1]
    sa=sc-(b-a+1-sc)
    tc=dpt[d]-dpt[c-1]
    ta=tc-(d-c+1-tc)
    if sa%3==ta%3:
        print("YES")
    else:
        print("NO")

Solution (Python):

import sys
import numpy as np

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

S = '-' + sr()
T = '-' + sr()
Q = ir()
cnt_S = np.array([[0, 0] for _ in range(len(S))])
cnt_T = np.array([[0, 0] for _ in range(len(S))])
for i, s in enumerate(S[1:], 1):
    if s == 'A':
        cnt_S[i][0] = 1
    else:
        cnt_S[i][1] = 1

for i, t in enumerate(T[1:], 1):
    if t == 'A':
        cnt_T[i][0] = 1
    else:
        cnt_T[i][1] = 1

np.add.accumulate(cnt_S, axis=0, out=cnt_S)
np.add.accumulate(cnt_T, axis=0, out=cnt_T)

answer = []
for _ in range(Q):
    a, b, c, d = lr()
    num_S = cnt_S[b][0] - cnt_S[b][1] - (cnt_S[a-1][0] - cnt_S[a-1][1])
    num_T = cnt_T[d][0] - cnt_T[d][1] - (cnt_T[c-1][0] - cnt_T[c-1][1])
    if (num_S - num_T) % 3 == 0:
        answer.append('YES')
    else:
        answer.append('NO')

print('\n'.join(answer))

Solution (Python):

import sys
import numpy as np

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

S = '-' + sr()
T = '-' + sr()
Q = ir()
cnt_S = np.array([[0, 0] for _ in range(len(S))])
cnt_T = np.array([[0, 0] for _ in range(len(S))])
for i, s in enumerate(S[1:], 1):
    if s == 'A':
        cnt_S[i][0] = 1
    else:
        cnt_S[i][1] = 1

for i, t in enumerate(T[1:], 1):
    if t == 'A':
        cnt_T[i][0] = 1
    else:
        cnt_T[i][1] = 1

np.add.accumulate(cnt_S, axis=0, out=cnt_S)
np.add.accumulate(cnt_T, axis=0, out=cnt_T)

for _ in range(Q):
    a, b, c, d = lr()
    num_S = cnt_S[b][0] - cnt_S[b][1] - (cnt_S[a-1][0] - cnt_S[a-1][1])
    num_T = cnt_T[d][0] - cnt_T[d][1] - (cnt_T[c-1][0] - cnt_T[c-1][1])
    if (num_S - num_T) % 3 == 0:
        print('YES')
    else:
        print('NO')

Solution (Python):
import sys

input=sys.stdin.readline

S=input()
T=input()
SAdata=[int(S[i]=="A") for i in range(len(S))]
SBdata=[int(S[i]=="B") for i in range(len(S))]
for i in range(1,len(S)):
    SAdata[i]+=SAdata[i-1]
for i in range(1,len(S)):
    SBdata[i]+=SBdata[i-1]
SAdata.append(0)
SBdata.append(0)

TAdata=[int(T[i]=="A") for i in range(len(T))]
TBdata=[int(T[i]=="B") for i in range(len(T))]
for i in range(1,len(T)):
    TAdata[i]+=TAdata[i-1]
for i in range(1,len(T)):
    TBdata[i]+=TBdata[i-1]
TAdata.append(0)
TBdata.append(0)

q=int(input())
for i in range(q):
    a,b,c,d=map(int,input().split())
    SA=SAdata[b-1]-SAdata[a-2]
    SB=SBdata[b-1]-SBdata[a-2]
    TA=TAdata[d-1]-TAdata[c-2]
    TB=TBdata[d-1]-TBdata[c-2]
    if (SA-SB)%3==(TA-TB)%3:
        print("YES")
    else:
        print("NO")

Solution (Python):
S = input()
T = input()
Q = int(input())

nS = [[0, 0]]
nT = [[0, 0]]

for i, c in enumerate(S):
  nS.append([abs(ord(c) - ord('A')), abs(ord(c) - ord('B'))])
  nS[i + 1][0] += nS[i][0]
  nS[i + 1][1] += nS[i][1]

for i, c in enumerate(T):
  nT.append([abs(ord(c) - ord('A')), abs(ord(c) - ord('B'))])
  nT[i + 1][0] += nT[i][0]
  nT[i + 1][1] += nT[i][1]

for qawsedrftgyhujikolp in range(Q):
  a, b, c, d = map(int, input().split())
  if (nS[b][0] - nS[a - 1][0] + 2 * nS[b][1] - 2 * nS[a - 1][1]) % 3 == (nT[d][0] - nT[c - 1][0] + 2 * nT[d][1] - 2 * nT[c - 1][1]) % 3:
    print("YES")
  else:
    print("NO")

Solution (Python):
s = input()
t = input()
q = int(input())
ans = ['YES']*q

scnt = [[0]*(len(s)+1) for _ in range(2)]
tcnt = [[0]*(len(t)+1) for _ in range(2)]

for i,S in enumerate(s):
    scnt[0][i+1] = scnt[0][i]
    scnt[1][i+1] = scnt[1][i]
    scnt[ord(S)-ord('A')][i+1] += 1

for i,T in enumerate(t):
    tcnt[0][i+1] = tcnt[0][i]
    tcnt[1][i+1] = tcnt[1][i]
    tcnt[ord(T)-ord('A')][i+1] += 1

for i in range(q):
    a,b,c,d = map(int,input().split())
    a -= 1
    c -= 1
    A = scnt[0][b] - scnt[0][a] - tcnt[0][d] + tcnt[0][c]
    B = scnt[1][b] - scnt[1][a] - tcnt[1][d] + tcnt[1][c]
    if (A-B)%3 != 0:
        ans[i] = 'NO'
print('\n'.join(ans))

Solution (Python):
s = input()
t = input()
n, m = len(s), len(t)
a = [0] * (n + 1)
b = [0] * (m + 1)
for i in range(n):
    a[i + 1] = a[i]
    if s[i] == 'A':
        a[i + 1] += 1
    else:
        a[i + 1] += 2
for i in range(m):
    b[i + 1] = b[i]
    if t[i] == 'A':
        b[i + 1] += 1
    else:
        b[i + 1] += 2
q = int(input())
for _ in range(q):
    i, j, k, l = map(int, input().split())
    if (a[j] - a[i - 1]) % 3 == (b[l] - b[k - 1]) % 3:
        print('YES')
    else:
        print('NO')

Solution (Python):
import sys
input = sys.stdin.readline
from itertools import accumulate
s = input()[:-1]
t = input()[:-1]
d = {"A": 1, "B": 2}
ds = [0] + list(accumulate([d[x] for x in s]))
dt = [0] + list(accumulate([d[x] for x in t]))
ans = []
append=ans.append
for _ in range(int(input())):
	a, b, c, d = map(int, input().split())
	if (ds[b]-ds[a-1])%3==(dt[d]-dt[c-1])%3:
		append("YES")
	else:
		append("NO")
print("\n".join(ans))