Problem:
 Score : 200 points    Problem Statement You are given three strings A, B and C . Each of these is a string of length N consisting of lowercase English letters.  Our objective is to make all these three strings equal. For that, you can repeatedly perform the following operation:   Operation: Choose one of the strings A, B and C , and specify an integer i between 1 and N (inclusive). Change the i -th character from the beginning of the chosen string to some other lowercase English letter.   What is the minimum number of operations required to achieve the objective?      Constraints  1 \leq N \leq 100  Each of the strings A, B and C is a string of length N .  Each character in each of the strings A, B and C is a lowercase English letter.         Input Input is given from Standard Input in the following format:  N  A  B  C       Output Print the minimum number of operations required.        Sample Input 1 4
west
east
wait      Sample Output 1 3  In this sample, initially A =  west 、 B =  east 、 C =  wait . We can achieve the objective in the minimum number of operations by performing three operations as follows:   Change the second character in A to a . A is now wast .  Change the first character in B to w . B is now wast .  Change the third character in C to s . C is now wast .        Sample Input 2 9
different
different
different      Sample Output 2 0  If A, B and C are already equal in the beginning, the number of operations required is 0 .       Sample Input 3 7
zenkoku
touitsu
program      Sample Output 3 13

Solution (Python):
n=int(input())
a= list(input())
b= list(input())
c= list(input())

alphabet = [chr(i) for i in range(97, 97+26)]

ans = 0
for i in range(n):
    cnt = 200
    for j in range(26):
        cnt_tmp = 0
        if (a[i] != alphabet[j]):
            cnt_tmp += 1
        if (b[i] != alphabet[j]):
            cnt_tmp += 1
        if (c[i] != alphabet[j]):
            cnt_tmp += 1
        cnt = min(cnt, cnt_tmp)
    ans += cnt

print(ans)
    
        
        

'''
west
east
wait
'''

Solution (Python):
N = int(input())
A = input()
B = input()
C = input()

l = [[a, b, c] for a, b, c in zip(A, B, C)]

cnt = 0
for i in range(N):
    l_set = set(l[i])
    if len(l_set) == 1:
        pass
    elif len(l_set) == 2:
        cnt += 1
    else:
        cnt += 2

print(cnt)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7


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


def main():
    N = int(input())
    A = input()
    B = input()
    C = input()

    ans = 0
    for i in range(N):
        if A[i] == B[i] == C[i]:
            continue
        elif A[i] == B[i] or B[i] == C[i] or C[i] == A[i]:
            ans += 1
        else:
            ans += 2

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
a = list(input())
b = list(input())
c = list(input())
ans = 0
for i in range(n):
  if len(set([a[i],b[i],c[i]])) == 1:
    continue
  elif len(set([a[i],b[i],c[i]])) == 2:
    ans += 1
  else:
    ans += 2
print(ans)

Solution (Python):
N=int(input())
A=input()
B=input()
C=input()

ans=0
for i in range(N):
  t=0
  if A[i]!=B[i]:
    t+=1
  if C[i]!=A[i] and C[i]!=B[i]:
    t+=1
  ans+=t
print(ans)

Solution (Python):
N = int(input())
A = input()
B = input()
C = input()

ans = 0
for i in range(N):
  if A[i] == B[i] == C[i]:
    ans += 0

  elif A[i] == B[i]:
    ans += 1

  elif A[i] == C[i]:
    ans += 1

  elif B[i] == C[i]:
    ans += 1

  elif A[i] != B[i] and B[i] != C[i]:
    ans += 2

print(ans)

Solution (Python):
def main():
    n = int(input())
    a = list(input())
    b = list(input())
    c = list(input())
    cnt = 0
    for i in range(n):
        if a[i] == b[i] == c[i]:
            continue
        if a[i] == b[i] or b[i] == c[i] or a[i] == c[i]:
            cnt += 1
            continue
        cnt += 2
    print(cnt)

if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
A, B, C = input(), input(), input()
ans = 0
for i in range(N):
  ans += len(set([A[i], B[i], C[i]])) - 1
print(ans)

Solution (Python):
n = int(input())
A = input()
B = input()
C = input()
ans = 0
for i in range(n):
  if A[i] == B[i]:
    ans += 1
  if B[i] == C[i]:
    ans += 1
  if C[i] == A[i]:
    ans += 1
  if A[i] == B[i] == C[i]:
    ans -= 1
print(n*2-ans)

Solution (Python):
n=int(input())
ab = []
for _ in range(3):
    s=list(input())
    ab.append(s)

ans = 0

for i in range(n):
    memo = []
    for j in range(3):
        memo.append(ab[j][i])
    ans += len(set(memo))-1
    
print(ans)

Solution (Python):
n = int(input())
a = input()
b = input()
c = input()
ans = 0
for i, j, k in zip(a, b, c):
    ans += len({i, j, k}) - 1
print(ans)

Solution (Python):
n=int(input())
a=list(str(input()))
b=list(str(input()))
c=list(str(input()))
t=0
for i in range(n):
  if a[i]==b[i] and b[i]==c[i]:
    continue
  elif a[i]==b[i] or b[i]==c[i] or c[i]==a[i]:
    t+=1
  else:
    t+=2
print(t)

Solution (Python):
n = int(input())

a = input()
b = input()
c = input()

t = 0
for i in range(n):
    s = set()
    s.add(a[i])
    s.add(b[i])
    s.add(c[i])
    t += len(s) - 1
print(t)

Solution (Python):
n=int(input())
a = input()
b = input()
c = input()
ans=0
for i in range(n):
    l=[a[i],b[i],c[i]]
    ans+=len(set(l))-1
print(ans)

Solution (Python):
n = int(input())
a = input()
b = input()
c = input()
ans = 0
for i,j,k in zip(a,b,c):
  ans += len(set([i,j,k]))-1
print(ans)

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

n = int(readline())
a = list(readline().rstrip().decode())
b = list(readline().rstrip().decode())
c = list(readline().rstrip().decode())
cnt = 0
for aa, bb, cc in zip(a, b, c):
    if aa == bb == cc:
        continue
    elif aa == bb or bb == cc or aa == cc:
        cnt += 1
    else:
        cnt += 2
print(cnt)

Solution (Python):
n = int(input())
a = input()
b = input()
c = input()
res = 0
for i in range(n):
  if a[i] == b[i] and b[i] == c[i]:
    pass
  elif a[i] != b[i] and b[i] != c[i] and c[i] != a[i]:
    res += 2
  else:
    res += 1
print(res)

Solution (Python):
N=int(input())
A=input()
B=input()
C=input()
ans=0
for a,b,c in zip(A,B,C):
    if a==b==c:
        continue
    elif len(set([a,b,c]))==2:
        ans+=1
    else:
        ans+=2
print(ans)

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


N = int(input())
words = [input() for i in range(3)]
ans = 0

for i in range(N):
	dic = dict()
	
	for w in words:
		if w[i] in dic.keys():
			dic[w[i]] += 1
		else:
			dic[w[i]] = 1
	
	ans += (len(dic) - 1)

print(ans)

Solution (Python):
n = int(input())
a = input()
b = input()
c = input()

ans = 0
for x, y, z in zip(a, b, c):
    if x == y == z:
        continue
    elif x == y or y == z or z == x:
        ans += 1
    else:
        ans += 2

print(ans)

Solution (Python):
_, *a = open(0)
print(sum(len(set(i))-1 for i in zip(*a)))

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

    n = int(input())
    a = input().rstrip()
    b = input().rstrip()
    c = input().rstrip()
    res = 0
    for i in range(n):
        d = [a[i], b[i], c[i]]
        res += len(set(d))-1
    print(res)

if __name__ == '__main__':
    main()

Solution (Python):

n = int(input())
a = input()
b = input()
c = input()
ans = 0
 
for i in range(n):
  ans += len(set([a[i], b[i], c[i]])) - 1 
  
print(ans)

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    n=int(input())
    a=input()
    b=input()
    c=input()
    ans=0
    for i in range(n):
        if a[i]!=b[i]:
            if b[i]!=c[i] and a[i]!=c[i]:
                ans+=2
            elif (b[i]!=c[i] and a[i]==c[i]) or b[i]==c[i]:
                ans+=1
        else:
            if b[i]!=c[i]:
                ans+=1
    print(ans)

if __name__=='__main__':
    main()

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    n=int(input())
    a=input()
    b=input()
    c=input()
    ans=0
    for i in range(n):
        if a[i]!=b[i]:
            if b[i]!=c[i] and a[i]!=c[i]:
                ans+=2
            elif (b[i]!=c[i] and a[i]==c[i]) or b[i]==c[i]:
                ans+=1
        else:
            if b[i]!=c[i]:
                ans+=1
    print(ans)

if __name__=='__main__':
    main()

Solution (Python):
n = int(input())
a = input()
b = input()
c = input()
ans = 0
for i in range(n):
    l = [a[i], b[i], c[i]]
    ans += len(set(l)) - 1
print(ans)

Solution (Python):
n = int(input())
a, b, c = input(), input(), input()
ans = 0
for i in range(n):
    if a[i] == b[i] == c[i]:
        continue
    if a[i] == b[i] or b[i] == c[i] or c[i] == a[i]:
        ans += 1
    else:
        ans += 2
print(ans)

Solution (Python):

import re
import math
import itertools
from copy import deepcopy
import random
from heapq import heappop,heappush
import time
import os
import queue
import sys
import datetime
from functools import lru_cache
readline=sys.stdin.readline
sys.setrecursionlimit(2000)

alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
week=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"]
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def is_power(a,b):
    now=b
    while now<a:
        now*=b
    if now==a:return True
    else:return False
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def facs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod_>0):A[a]%=mod_
    return A
def comb(n,r,mod_,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod_-2,mod_)*pow(fac[r],mod_-2,mod_))%mod_
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(a,b,c):
    if a:return b
    else:return  c
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s
def factorize(n,type_="dict"):
    b = 2
    list_ = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            list_.append(b)
        b+=1
    if n > 1:list_.append(n)
    if type_=="dict":
        dic={}
        for a in list_:
            if a in dic:
                dic[a]+=1
            else:
                dic[a]=1
        return dic
    elif type_=="list":
        return list_
    else:
        return None
def floor_(n,x=1):
    return x*(n//x)
def ceil_(n,x=1):
    return x*((n+x-1)//x)


import re
import math
import itertools
from copy import deepcopy
import random
from heapq import heappop,heappush
import time
import os
import queue
import sys
import datetime
from functools import lru_cache
readline=sys.stdin.readline
sys.setrecursionlimit(2000)

alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def is_power(a,b):
    now=b
    while now<a:
        now*=b
    if now==a:return True
    else:return False
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def get_facs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(a,b,c):
    if a:return b
    else:return  c
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s
def factorize(n,type_="dict"):
    b = 2
    list_ = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            list_.append(b)
        b+=1
    if n > 1:list_.append(n)
    if type_=="dict":
        dic={}
        for a in list_:
            if a in dic:
                dic[a]+=1
            else:
                dic[a]=1
        return dic
    elif type_=="list":
        return list_
    else:
        return None
def floor_(n,x=1):
    return x*(n//x)
def ceil_(n,x=1):
    return x*((n+x-1)//x)

def main():
    N=int(input())
    A=input()
    B=input()
    C=input()
    ans=0
    for a in range(N):
        s=A[a]+B[a]+C[a]
        length=len(set(s))
        ans+=length-1
    print(ans)


main()

Solution (Python):
n = int(input())
A = input()
B = input()
C = input()
ans = 0
for abc in zip(A, B, C):
    ans += len(set(abc)) - 1
print(ans)

Solution (Python):
N = int(input())
A = input()
B = input()
C = input()
ans = 0
for x, y, z in zip(A, B, C):
    x, y, z = sorted([x, y, z])
    if x != y and y != z:
        ans += 2
    elif x == y and y != z:
        ans += 1
    elif x != y and y == z:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
al = list(input())
bl = list(input())
cl = list(input())

ans = 0
for a, b, c in zip(al, bl, cl):
    ans += len(set([a, b, c])) - 1
print(ans)

Solution (Python):
n = int(input())
a = list(input())
b = list(input())
c = list(input())

ans = 0
for i in range(n):
  aa = a[i]
  bb = b[i]
  cc = c[i]
  if len(set([aa,bb,cc])) == 1:
    continue
  elif len(set([aa,bb,cc])) == 2:
    ans += 1
  else:
    ans += 2
print(ans)

Solution (Python):
N = int(input())
A = input()
B = input()
C = input()

ans = 0
for a,b,c in zip(A,B,C):
    ans += len(set([a,b,c])) - 1

print(ans)

Solution (Python):



N = int(input())
A = list(input())
B = list(input())
C = list(input())


min_count = 0
cur_char = ''


for i in range(N):
    tmp = []
    tmp.append(A[i])
    tmp.append(B[i])
    tmp.append(C[i])
    tmp = set(tmp)

    if len(tmp)>=3:
        min_count += 2
    elif len(tmp)==2:
        min_count += 1


print(min_count)

Solution (Python):


import sys
from io import StringIO

from collections import Counter, deque







import sys
sys.setrecursionlimit(10 ** 5 + 10)


def resolve():
    N=int(input())
    A=list(input())
    B=list(input())
    C=list(input())

    W=[[None]*3 for i in range(N)]
    for j in range(N):
        for i,k in zip([A,B,C],[0,1,2]):
            W[j][k]=i[j]

    val=0
    for k in W:
        mc=Counter(k).most_common()[0][1]
        val+=3-mc

    print(val)





resolve()

Solution (Python):
n = int(input())
a = input()
b = input()
c = input()
cnt = 0
for i in range(n):
    c1,c2,c3=0,0,0

    if b[i] ==a[i] and c[i]==b[i]:
        pass

    elif b[i] ==a[i] or c[i]==b[i] or c[i] ==a[i]:

        cnt+=1
    else:
        cnt+=2

print(cnt)

Solution (Python):
n = int(input())
a = input()
b = input()
C = input()
ans = 0
c  ={}
for i in range(n):
    if a[i] not in c:  c[a[i]] = 1
    else:c[a[i] ] +=1
    if b[i] not in c:  c[b[i]] = 1
    else:c[b[i] ] +=1
    if C[i] not in c:  c[C[i]] = 1
    else:c[C[i]] +=1
    ans += len(c)-1
    c = {}
print(ans)

Solution (Python):
n = int(input())
a = input()
b = input()
c = input()
ans = 0
for i in range(n):
    if (a[i] == b[i] and a[i] != c[i]) or\
        (a[i] == c[i] and a[i] != b[i]) or\
        (b[i] == c[i] and b[i] != a[i]):
        ans += 1
    elif a[i] == b[i] == c[i]:
        continue
    else:
        ans += 2
print(ans)

Solution (Python):
n=int(input())
a=input()
b=input()
c=input()
a=list(a)
b=list(b)
c=list(c)
ans=0
for aa,bb,cc in zip(a,b,c):
    t=set()
    t.add(aa)
    t.add(bb)
    t.add(cc)
    ans+=len(t)-1
print(ans)

Solution (Python):
from collections import Counter
N = int(input())
A = list(input())
B = list(input())
C = list(input())

ans = 0
for c in zip(A, B, C):
    char_cnt = Counter(c)
    max_val = 0
    for val in char_cnt.values():
        if val > max_val:
            max_val = val
    ans += 3 - max_val

print(ans)

Solution (Python):
N=int(input())
A=input()
B=input()
C=input()
S=""
count=0
for i in range(N):
	S=[A[i],B[i],C[i]]
	if len(set(S))==3:
		count+=2
	elif len(set(S))==2:
		count+=1
print(count)

Solution (Python):
n = int(input())
s1 = input()
s2 = input()
s3 = input()
ans = 0
for i in range(n):
    if s1[i] == s2[i] and s2[i] == s3[i] and s3[i] == s1[i]:
        True
    elif s1[i] != s2[i] and s2[i] != s3[i] and s3[i] != s1[i]:
        ans += 2
    else:
        ans += 1
print(ans)

Solution (Python):
N = int(input())
a = list(input())
b = list(input())
c = list(input())
count = 0
for i in range(N):
    if a[i]==b[i] or b[i]==c[i] or c[i]==a[i]:
        if a[i]==b[i] and b[i]==c[i]:
            continue
        else:
            count += 1
    else:
        count += 2
print(count)

Solution (Python):
def main():
    N = int(input())
    A = [input() for i in range(3)]
    ans = 0
    for i in range(N):
        cur = {A[0][i], A[1][i], A[2][i]}
        
        ans += (len(cur) - 1)
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
A = input()
B = input()
C = input()

ans = 0
for i in range(N):
    ans += len(set((A[i], B[i], C[i]))) - 1
print(ans)

Solution (Python):
N = int(input())
A = input()
B = input()
C = input()
ans = 0
for a,b,c in zip(A,B,C):
    if a==b==c: continue
    if a==b or b==c or c==a:
        ans += 1
    else:
        ans += 2
print(ans)

Solution (Python):
n=int(input())
a=input()
b=input()
c=input()
ans=0
for i in range(n):
    d=set([a[i],b[i],c[i]])
    x=len(d)
    if x==3:
        ans+=2
    elif x==2:
        ans+=1
print(ans)

Solution (Python):
import sys
def main():
    input = sys.stdin.read
    N,A,B,C=input().rstrip().split()
    ans = 0
    for S in zip(A,B,C):
        s = len(set(S))
        if s == 3: ans += 2
        elif s == 2: ans += 1
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
a = str(input())
b = str(input())
c = str(input())

ans = 0
for i in range(n):
    l = [a[i], b[i], c[i]]
    s = set(l)
    if len(s) == 3:
        ans += 2
    elif len(s) == 2:
        ans += 1
    else:
        pass
print(ans)

Solution (Python):
N = int(input())
A = list(input())
B = list(input())
C = list(input())

ans = 0
for i in range(N):
  if A[i] == B[i] == C[i]: continue
  elif A[i] == B[i] or A[i] == C[i] or B[i] == C[i]:
    ans += 1
  else:
    ans += 2
print(ans)

Solution (Python):
N = int(input())
S = [input() for _ in range(3)]
ans = 0
for i in range(N):
    char = set()
    for j in range(3):
        char.add(S[j][i])
    ans += len(char) - 1
print(ans)

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 0, 1, -1, 1, -1, -1, 1]
dy = [1, -1, 0, 0, 1, -1, 1, -1]

n = INT()
a = STR()
b = STR()
c = STR()
ans = 0
for i in range(n):
    if a[i] != b[i]:
        ans += 1
    if c[i] != b[i] and c[i] != a[i]:
        ans += 1
print(ans)

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    n = I()
    a = input()
    b = input()
    c = input()
    ans = 0
    for i in range(n):
        if a[i] == b[i] == c[i]:
            continue
        if a[i] == b[i] or b[i] == c[i] or a[i] == c[i]:
            ans += 1
        else:
            ans += 2
    print(ans)
    return


if __name__ == "__main__":
    solve()

Solution (Python):
N = int(input())
A = input()
B = input()
C = input()

ans = 0
for a, b, c in zip(A, B, C):
    if a == b == c:
        continue
    if len(set([a, b, c])) == 2:
        ans += 1
    else:
        ans += 2

print(ans)

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

n = ii()
A = list(input())
B = list(input())
C = list(input())

ans = 0
for i in range(n):
    num = len(set([A[i],B[i],C[i]]))
    if num == 2:
        ans += 1
    elif num == 3:
        ans += 2
print(ans)

Solution (Python):
N = int(input())
A = list(str(input()))
B = list(str(input()))
C = list(str(input()))

ans = 0
for i in range(N):
  if [A[i] == B[i], B[i] == C[i], C[i] == A[i]].count(False) == 2:
    ans +=  1
  elif [A[i] == B[i], B[i] == C[i], C[i] == A[i]].count(False) == 3:
    ans += 2
  else:
    pass
    
print(ans)

Solution (Python):
n,a,b,c = [input() for i in range(4)]
counter = 0
for i in range(int(n)):
    if a[i] == b[i] != c[i]:
        counter += 1
    elif a[i] == c[i] != b[i]:
        counter += 1
    elif a[i] != b[i] == c[i]:
        counter += 1
    elif a[i] != b[i] != c[i]:
        counter += 2
print(counter)

Solution (Python):
n = int(input())
a = input()
b = input()
c = input()
ans = 0
for i in range(n):
    ans += len(set([a[i],b[i],c[i]]))-1
print(ans)

Solution (Python):
n = int(input())
a = input()
b = input()
c = input()
ans = 0
for i in range(n):
    tmp = 0
    if a[i] == b[i]:
        tmp += 1
    if a[i] == c[i]:
        tmp += 1
    if b[i] == c[i]:
        tmp += 1
    if tmp == 1:
        ans += 1
    elif tmp == 0:
        ans += 2
print(ans)

Solution (Python):
N = int(input())
A = input()
B = input()
C = input()

ans = 0
for a, b, c in zip(A, B, C):
    if a == b == c:
        continue
    elif a == b or b == c or c == a:
        ans += 1
    else:
        ans += 2

print(ans)

Solution (Python):
n = int(input())
a = list(input())
b = list(input())
c = list(input())
def how_many_changes(p,q,r):
    if p != q and q != r and r != p:
        return 2
    if p == q != r or q == r != p or r == p != q:
        return 1
    else:
        return 0
ans = 0
for i in range(n):
    ans += how_many_changes(a[i], b[i], c[i])
print(ans)

Solution (Python):
N=int(input())
A=input()
B=input()
C=input()

ans=0
for i in range(N):
  if A[i]==B[i]==C[i]:
    ans=ans
  elif A[i]!=B[i]!=C[i]!=A[i]:
    ans=ans+2
  else:
    ans=ans+1

print(ans)

Solution (Python):
N = input()
A = input()
B = input()
C = input()
cnt = 0
for a,b,c in zip(A,B,C):
    if a == b and b == c and b == a:
        continue
    elif a != b and b != c and c != a:
        cnt += 2
    elif a == b and b != c:
        cnt += 1
    elif b == c and c != a:
        cnt += 1
    elif c == a and a != b:
        cnt += 1
    
print(cnt)

Solution (Python):
n,a,b,c=int(input()),input(),input(),input()
ans=0
for i in range(n):
    s=set()
    s.add(a[i]);s.add(b[i]);s.add(c[i])
    ans+=len(s)-1
print(ans)

Solution (Python):
N = int(input())
a = [input() for _ in range(3)]
ans = 0
for i in range(N):
    ans += len(set([a[0][i], a[1][i], a[2][i]])) - 1
print(ans)

Solution (Python):
n = int(input())
s = [input() for _ in range(3)]
ans = 2*n
for i in range(n):
  if s[0][i] == s[1][i]: ans -= 1
  if s[0][i] == s[2][i]: ans -= 1
  if s[2][i] == s[1][i]: ans -= 1
  if s[0][i] == s[1][i] and s[2][i] == s[1][i] : ans += 1
print(ans)

Solution (Python):
N = int(input())
A = list(input())
B = list(input())
C = list(input())
from collections import Counter
ans = 0
for i in range(N):
    da = [A[i],B[i],C[i]]
    c = Counter(da)
    li = list(c.values())
    li.sort()
    ans += 3-li[-1]
print(ans)

Solution (Python):

n = int(input())
a = input()
b = input()
c = input()
ans = 0
for i in range(n):
    ans += len({a[i],b[i],c[i]}) -1
print(ans)

Solution (Python):

n = int(input())
a = input()
b = input()
c = input()

ans = 0
x = {}

for i in range(n):
    ans += len({a[i],b[i],c[i]}) -1

print(ans)

Solution (Python):
n = int(input())
a = input()
b = input()
c = input()
ans = 0
for i in range(n):
    ans += len(set([a[i], b[i], c[i]])) - 1
print(ans)

Solution (Python):
import sys

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')


N = I()
A = input()
B = input()
C = input()

ans = 0
for i in range(N):
    if A[i] == B[i] == C[i]:
        continue
    if A[i] == B[i] or B[i] == C[i] or C[i] == A[i]:
        ans += 1
    else:
        ans += 2
print(ans)

Solution (Python):
def main():
    length = int(input())
    words = [input() for _ in range(3)]
    answer = 0
    for i in range(length):
        l = [words[0][i], words[1][i], words[2][i]]
        answer += len(set(l)) - 1
    print(answer)


if __name__ == '__main__':
    main()

Solution (Python):
n=int(input())
a=list(input())
b=list(input())
c=list(input())
cnt=0
for i in range(n):
    if a[i]==b[i]==c[i]:
        continue
    if a[i]==b[i] or b[i]==c[i] or a[i]==c[i]:
        cnt+=1
    else:
        cnt+=2
print(cnt)

Solution (Python):
N = int(input())
A = input()
B = input()
C = input()
ans = 0
for i in range(N) :
    s = [A[i], B[i], C[i]]
    li = [s.count(s[j]) for j in range(3)]
    ans += 3 - max(li)
print(ans)

Solution (Python):
N = int(input())
A = list(input())
B = list(input())
C = list(input())
a, b, c = 0, 0, 0
cnt = 0
for i in range(N):
    if A[i] == B[i] == C[i]:
        a += 1
        b += 1
        c += 1
    elif A[i] == B[i]:
        a += 1
        b += 1
        cnt += 1
    elif B[i] == C[i]:
        b += 1
        c += 1
        cnt += 1
    elif C[i] == A[i]:
        c += 1
        a += 1
        cnt += 1
    else:
        cnt += 2
print(cnt)

Solution (Python):
count = 0
N = int(input())
A = input()
B = input()
C = input()
for i in range(N):
  if A[i] == B[i] and B[i] == C[i]:
    count = count
  elif A[i] == B[i] or B[i] == C[i] or C[i] == A[i]:
    count = count + 1
  else:
    count = count + 2
print(count)

Solution (Python):
n=int(input())
a=input()
b=input()
c=input()
ans=0
for i in range(n):
  m=len(set([a[i],b[i],c[i]]))
  ans+=m-1
print(ans)

Solution (Python):
def main():
    n = int(input())
    a = input().rstrip()
    b = input().rstrip()
    c = input().rstrip()
    ans = 0
    for i in range(n):
        if a[i] == b[i] == c[i]:
            continue
        elif a[i] == b[i] or b[i] == c[i] or c[i] == a[i]:
            ans += 1
        else:
            ans += 2
    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):
n=int(input())
a=input()
b=input()
c=input()
cnt=0
for i in range(n):
    if a[i]==b[i] and b[i]==c[i]:
        pass
    elif a[i]==b[i] or b[i]==c[i] or a[i]==c[i]:
        cnt+=1
    else:
        cnt+=2
print(cnt)

Solution (Python):
from collections import defaultdict

n=int(input())
a=list(input())
b=list(input())
c=list(input())

ans=0
for i in range(n):
    d=defaultdict(int)
    d[a[i]]+=1
    d[b[i]]+=1
    d[c[i]]+=1
    ans+=3-max(d.values())
print(ans)

Solution (Python):
n = int(input())
a = input()
b = input()
c = input()
res = 0
for i in range(n):
    x,y,z = a[i], b[i], c[i]
    if x==y==z:
        res += 0
    elif x==y or y==z or z==x:
        res += 1
    else:
        res += 2
print(res)

Solution (Python):
N = int(input())
A, B, C = input(), input(), input()
ans = 0
for i in range(N):
  ans += len(set([A[i], B[i], C[i]])) - 1
print(ans)

Solution (Python):
N=int(input())
A=input()
B=input()
C=input()
l=[]
c=0

for i in range(N):
    l=[A[i],B[i],C[i]]
    c=c+len(set(l))-1
print(c)

Solution (Python):
N = int(input())
A = input()
B = input()
C = input()
ans = 0
for i in range(N):
  a = {A[i], B[i], C[i]}
  if len(a) == 2:
    ans += 1
  if len(a) == 3:
    ans += 2
print(ans)