Problem:
 Score : 200 points    Problem Statement  Takahashi loves palindromes. Non-palindromic strings are unacceptable to him. Each time he hugs a string, he can change one of its characters to any character of his choice.  Given is a string S . Find the minimum number of hugs needed to make S palindromic.      Constraints   S is a string consisting of lowercase English letters.  The length of S is between 1 and 100 (inclusive).         Input  Input is given from Standard Input in the following format:  S       Output  Print the minimum number of hugs needed to make S palindromic.        Sample Input 1 redcoder      Sample Output 1 1  For example, we can change the fourth character to o and get a palindrome redooder .       Sample Input 2 vvvvvv      Sample Output 2 0  We might need no hugs at all.       Sample Input 3 abcdabc      Sample Output 3 2

Solution (Python):

MOD = 10 ** 9 + 7

import math



def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default


def main():


    s=list(input())
    a = [s[i] for i in range(0,len(s)//2)]
    b = [s[i] for i in range(len(s)-1,(len(s)-1)//2,-1)]
    count=0
    for i in range(len(a)):
        if a[i]!=b[i]:
            count+=1
    print(count)









            

if __name__ == "__main__":
    main()

Solution (Python):
s = input()
ls = len(s)
ans = 0
for i in range(ls//2):
    if s[i] != s[-1-i]:
        ans += 1
print(ans)

Solution (Python):
s = input().rstrip()
sum = 0
for i in range(0, len(s) // 2):
  if s[i] == s[- (i + 1)]:
    pass
  else:
    sum += 1
print(sum)

Solution (Python):
S = input()
L = len(S)
C = 0
for i in range(L):
  if S[i] != S[L-1-i]:
    C += 1
print(int(C/2))

Solution (Python):
S = input()
N = len(S)-1
i=0
C=0
while i < N-i:
	if S[i]!=S[N-i]:
		C+=1
	i+=1

print(C)

Solution (Python):
s = list(input())
ans = 0
sl = len(s)
for i in range(sl//2):
    if s[i] != s[sl - i-1]:
        ans+=1
print(ans)

Solution (Python):
S = input()
cnt = 0

if len(S) % 2 == 0:
    n = len(S) // 2
    s1 = S[:n]
    s2 = S[:n-1:-1]
else:
    n = len(S) // 2 + 1
    s1 = S[:n-1]
    s2 = S[:n-1:-1]

for i in range(len(S)//2):
    if s1[i] != s2[i]:
        cnt += 1

print(cnt)

Solution (Python):

S = input()

mid = len(S) // 2

ans = 0

for i in range(mid):
    if S[i] != S[-i-1]:
        ans += 1

print(ans)

Solution (Python):
S = list(input())
A = list(reversed(S))
LEN=len(S)
ans=0
if LEN%2==0:
    for i in range(LEN//2):
        if S[i]!=A[i]:
            ans+=1
else:
    for i in range((LEN-1)//2):
        if S[i]!=A[i]:
            ans+=1
print(ans)

Solution (Python):
import sys

INPUT = lambda: sys.stdin.readline().rstrip()

sys.setrecursionlimit(10 ** 9)


def main():
    S = INPUT()

    cnt = 0
    for i in range(len(S)//2):
        if S[i] != S[-1-i]: cnt += 1

    print(cnt)


if __name__ == '__main__':
    main()

Solution (Python):
S = input()



mid = len(S)//2

if len(S) % 2 == 0:
    pre = S[:mid]
    aft = S[mid:]
else:
    pre = S[:mid]
    aft = S[mid+1:]


result = 0
for i in range(mid):
    
    if pre[i] != aft[mid-1 - i]:
        result += 1

print(result)

Solution (Python):
import sys

S = sys.stdin.readline().strip()

R = S[::-1]


cnt =0
for i in range(len(S)):
    if S[i] !=R[i]:
        cnt +=1
print(cnt//2)

Solution (Python):
s_list=list(input())

if len(s_list) % 2 == 1:
    index_max = (len(s_list) - 1)//2 - 1
else:
    index_max = len(s_list)//2 - 1

count = 0
for i in range(index_max + 1):
    if s_list[i] != s_list[-(i + 1)]:
        count += 1
print(count)

Solution (Python):
word = list(input())
word_t = word[::-1]
count = 0
wordhalf = int(len(word)/2)
for i in range(wordhalf):
    if word[i] != word[-(i+1)]:
        count += 1
print(count)

Solution (Python):

s = input()

len = len(s)

cnt = 0

for i in range(len//2):
  
  if( s[i] != s[len-1-i] ):
    cnt += 1
    
  else:
    continue
    
print(cnt)

Solution (Python):
s = list(input())
ans=0
if len(s)%2 == 0:
  for i in range(len(s)//2):
    if s[i] != s[len(s)-1-i]:
      ans = ans+1
else:
  for i in range((len(s)-1)//2):
    if s[i] != s[len(s)-1-i]:
      ans = ans+1
print(ans)

Solution (Python):
s=input()
n=len(s)
m=n%2
d=n//2
cnt=0
s1=s[:d]
s2=s[d:]
for i in range(d):
  if s1[i]!=s2[-i-1]:
    cnt+=1
print(cnt)

Solution (Python):
def palindrome_philia(S: str)->int:
    ans = 0
    for i in range(len(S)//2):
        if S[i] != S[-(i+1)]:
            ans += 1
    return ans


if __name__ == "__main__":
    S = input()
    ans = palindrome_philia(S)
    print(ans)

Solution (Python):
s=input()
p=len(s)
q = p//2
count = 0
for i in range(q):
  if not s[i] == s[p-i-1]:
    count += 1
print(count)

Solution (Python):


s = input()
n = len(s)
count = 0
for i in range(0, n // 2):
    if s[i] != s[n-i-1]:
        count += 1
print(count)

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

length = len(S)
cnt = 0
if length %2  == 0:
    for i in range(int(length/2)):
      if S[i] != S[-(i+1)]:
        cnt += 1
      else:
        continue
    print(cnt)
else:
    for i in range(int(length/2)+1):
      if S[i] != S[-(i+1)]:
        cnt += 1
      else:
        continue
    print(cnt)

Solution (Python):
S=input()
if len(S)%2==0:
    S1=S[:len(S)//2]
    S2=S[len(S)//2:][::-1]
else:
    S1=S[:len(S)//2]
    S2=S[len(S)//2+1:][::-1]

ans=0
for i in range(len(S1)):
    if S1[i]!=S2[i]:
        ans+=1
print(ans)

Solution (Python):
S = input()
l = len(S)
h = l // 2

ans = 0
for i in range(h):
    if S[i] != S[l - i - 1]:
        ans += 1
print(ans)

Solution (Python):
s = input()
if len(s) % 2 == 1:
  sl = s[:int((len(s) - 1) / 2)]
  sr = s[int((len(s) +1 ) / 2):]
else:
  sl = s[:int(len(s)/ 2)]
  sr = s[int(len(s) / 2):]

err = 0
for i, c in enumerate(sl):
  err += 1 if c != sr[- i - 1] else 0 

print(err)

Solution (Python):
string = input()
ans = 0
for i in range(len(string) // 2):
    if string[i] != string[-i - 1]:
        ans += 1
print(ans)

Solution (Python):
S = list(input())
ans = 0

for i in range(len(S)):
    if S[i] == S[len(S)-1-i]:
        ans += 0
    else:
        ans +=1

print(int(ans/2))

Solution (Python):
S = input()
S2 = list(reversed(S))
count = 0
for i in range((len(S) // 2)):
    if S[i] != S2[i]:
        count += 1
print(count)

Solution (Python):
S = input()

n = 0
for i in range(int(len(S)/2)):
    if S[i] != S[-1-i]:
        n += 1

print(n)

Solution (Python):
target = input()

N = len(target) // 2

num = 0
for i in range(N):
    if target[i] != target[-(1+i)]:
        num += 1
print(num)

Solution (Python):
s = input()
cnt = 0
for i in range(1,len(s)//2+1):
    if s[i-1] != s[-i]:
        
        cnt += 1
print(cnt)

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

length = len(S)

a = 0

for i in range(length // 2):
    if S[i] != S[-(i + 1)]:
        a += 1

print(a)

Solution (Python):


def solve():
    S = input()
    res = 0
    for i in range(len(S)):
        res += S[i]!=S[-i-1]
    return res//2

if __name__ == '__main__':
    print(solve())

Solution (Python):

S = input()

count = 0
for i in range(len(S) // 2):
    if S[i] != S[len(S) - i - 1]:
        count += 1

print(count)

Solution (Python):
a = list(input())
cnt = 0
for i in range(len(a)//2):
  if a[i] != a[(i+1)*-1]:
    cnt += 1
    
print(cnt)

Solution (Python):
s = input()
l = len(s)
count = 0
for i in range(l//2):
  if s[i] != s[l-1-i]:
    count += 1
print(count)

Solution (Python):
S = input()
count=0

mid = len(S)//2

for i in range(mid):
  if S[i] != S[-i-1]:
    count+=1
print(count)

Solution (Python):

"""
Created on Thu Jul 25 23:46:59 2019

@author: over-
"""


S=input()
L=len(S)
if L%2 ==1:
    L-=1
    S=S[:int(L/2)]+S[int(L/2)+1:]

N=int(L/2)
count=0
for i in range(N):
    if S[i]!=S[-i-1]:
        count+=1
        
print(count)

Solution (Python):
S=str(input())
num=len(S)
ans=0
for i in range(num):
    if(i>num-1-i):
        break
    if(S[i]!=S[num-1-i]):
        ans+=1
print(ans)

Solution (Python):
s = input()
l = len(s)
if l%2==0:
    b = s[:l//2]
    e = s[l//2:]
else:
    b = s[:l//2]
    e = s[l//2+1:]

ee = list(reversed(e))



c = 0
for i,j in zip(b,ee):
    if i!=j:
        c+=1

print(c)

Solution (Python):
S=input()

count=0

for i in range(len(S)//2):
    if S[i]==S[len(S)-1-i]:
        pass
    else:
        count+=1
print(count)

Solution (Python):
s = [ i for i in input() ]

r = list(reversed(s))
cnt = 0
for i in range(len(s)):
  if  s[i] == r[i]:
    pass
  else:
    cnt += 1
    
print(int(cnt/2))

Solution (Python):
s = str(input())
l = len(s)
ans = int(0)
r = l // 2
if l % 2 == 0:
    for i in range(r):
        if s[i] != s[l - i - 1]:
            ans += 1
else:
    for j in range(r):
        if s[j] != s[l - j - 1]:
            ans += 1
print(ans)

Solution (Python):
s = input()

size = len(s)
if size % 2 != 0:
    size += 1

size = size // 2

ans = 0
for i in range(size):
    ans += 0 if s[i] == s[-(i+1)] else 1

print(ans)

Solution (Python):
S = input()

cnt = 0
for i in range(len(S) // 2):
  
  if S[i] != S[-(i + 1)]:
    cnt += 1

print(str(cnt))

Solution (Python):
hug = 0
s = input()
for i in range(len(s)//2):
  if s[i] != s[-i-1]:
    hug += 1
    
print(hug)

Solution (Python):
S = input()

mid = len(S) // 2

count = 0
for i in range(0, mid):
        if S[i] != S[-1 -i]:
                count += 1


print(count)

Solution (Python):
S=input()
counter=0
if len(S)%2==0:
    for i in range(int(len(S)/2)):
        if S[i]!=S[-i-1]:
            counter+=1
else:
    for i in range(int((len(S)-1)/2)):
        if S[i]!=S[-i-1]:
            counter+=1
print(counter)

Solution (Python):
import sys
from collections import *
from heapq import *
from fractions import gcd
import itertools
import math

sys.setrecursionlimit(10**6)

def InMap(): return list(map(int, input().split(' ')))
def In(): return int(input())
def InS(): return input()

S = InS()

if(len(S) % 2 == 0):
    S1 = S[0:int(len(S) / 2)]
    S2 = S[int(len(S) / 2)::]
else:
    S1 = S[0:int(len(S) / 2)]
    S2 = S[int(len(S) / 2) + 1::]
res = 0
for i in range(int(len(S) / 2)):
    if(S1[i] != S2[-(i+1)]):
        res += 1


print(res)

Solution (Python):
s = input()

n = len(s)
count = 0
for i in range(n):
    if s[i] != s[n-i-1]:
        count += 1

print(count//2)

Solution (Python):
S = input()
a = 0
b = len(S)
for i in range(b//2):
    if S[i] != S[b-1-i]:
        a = a+1

print(a)

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

count=0
for i in range(len(S)//2):
    if S[i] != S[-(i+1)]:
        count+=1

print(count)

Solution (Python):
s = input()

s1 = s[0:len(s)//2]
s2 = s[len(s)-len(s)//2:len(s)]
s2 = s2[::-1]

count = 0

for i in range(len(s1)) :
  if s1[i:i+1] != s2[i:i+1] :
    count += 1

print(count)

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

c=0
for i in range(int(len(S)/2)):
  if S[i]!=S[len(S)-i-1]:
    c=c+1
print(c)

Solution (Python):
if __name__ == '__main__':
    s = input()
    ans = 0
    for i in range(len(s)):
        a = s[i]
        h = len(s)//2
        if i <= h-1:
            if a != s[len(s)-i-1]:
                ans = ans+1
        else:
            break
    print(ans)

Solution (Python):
s = input()

length = len(s)
ans = 0
for i in range(int(length/2)):
    if(s[i] != s[-1*i-1]):
        ans += 1
print(ans)

Solution (Python):
S = input()
N = len(S)
mid = N//2
left = ""
for i in range(mid):
    left += S[i]
right = ""
right_mid = mid
if N % 2 == 1:
    right_mid += 1
for i in range(N-1,mid-1,-1):
    right += S[i]
ret = 0
for i in range(mid):
    if left[i] != right[i]:
        ret += 1
print(ret)

Solution (Python):
s = input()
h_len = int(len(s)/2)

cnt = 0
for i in range(h_len):
    if s[i] != s[-1-i]: cnt += 1

print(cnt)

Solution (Python):
S = input()

cnt = 0

for i in range(len(S) // 2):
    if S[i] != S[-(i + 1)]:
        cnt += 1

print(cnt)

Solution (Python):
s = str(input())

cnt = 0
for i in range(len(s) // 2):
  if s[i] != s[len(s) - i - 1]:
    cnt += 1

print(cnt)

Solution (Python):
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    S = input()

    diff = 0
    for s1, s2 in zip(S, S[::-1]):
        diff += s1 != s2
    print(diff // 2)


main()

Solution (Python):
s = list(input())
count = 0
for i in range(len(s)):
  if s[i] == s[len(s)-1-i]:
    continue
  count += 1
print(count//2)

Solution (Python):
s=list(input())
sr=list(reversed(s))
n=len(s)//2
counter=0
for i in range(n):
	if s[i]!=sr[i]:
		counter+=1
print(counter)

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

center = len(S) // 2
if len(S) % 2 == 0:
    head, tail = S[:center], S[center:]
else:
    head, tail = S[:center], S[center + 1:]

c = 0
for t, z in zip(head, tail[::-1]):
    if t != z:
        c += 1
print(c)

Solution (Python):
s=list(input())
n=0
for i in range(len(s)//2):
  if s[i]!=s[len(s)-1-i]:
    n+=1
print(n)

Solution (Python):
S = input()

N = len(S)
ans = 0
for i in range(N//2):
    s = S[i]
    a = S[-(i+1)]
    if a != s:
        ans += 1
print(ans)

Solution (Python):
N = str(input())
count = 0
for i in range(int(len(N)/2)):
  if N[i] != N[-(i+1)]:
    count += 1
    
print(count)

Solution (Python):
a = input()
aLen = len(a)
c = 0
for i in range(len(a)//2):
    if a[i] != a[aLen-i-1]:
        c += 1
print(c)

Solution (Python):
N = input()

count = 0
for i in range(len(N) // 2):
    if N[i] != N[- i - 1]:
        count += 1

print(count)

Solution (Python):
S = input()

l = len(S)

nhug = 0
for i in range(l//2):
    if S[i] != S[l-1-i]:
        nhug += 1

print(nhug)

Solution (Python):
s=input()
n=len(s)
c=0
for i in range(n-1):
    if i >= n-1-i:
        break
    if s[i] != s[n-1-i]:
        c+=1
print(c)

Solution (Python):
S = list(input())
left = 0
right = len(S) - 1
ans = 0

while left < right:
    if S[left] != S[right]:
        ans += 1
    left += 1
    right -= 1

print(ans)

Solution (Python):
a=input()
if len(a)%2==0:
    v=int(len(a)/2)
else:
    v=int((len(a)-1)/2)
c=0
for i in range(v):
    if a[i]!=a[-i-1]:
        c+=1
print(c)

Solution (Python):
s = input()
if s == s[::-1]:
    print('0')
else:
    left = s[:len(s) // 2]
    right = s[len(s) // 2 + (1 if len(s) % 2 else 0):][::-1]
    res = 0
    for a, b in zip(left, right):
        if a != b:
            res += 1
    print(res)

Solution (Python):
s=input()
n=len(s)//2
c=0
for i in range(n):
  if s[i]!=s[-i-1]:
    c+=1
print(c)

Solution (Python):
a = input()

cnt = 0
for i in range(len(a)//2):
    if a[i] != a[-(i+1)]:
        cnt += 1
print(cnt)

Solution (Python):
s = str(input())

rev_s = s[::-1]

cnt = 0
for i in range(len(s)):
    
    if rev_s[i] != s[i]:
        cnt += 1


print(cnt//2)

Solution (Python):
from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys
import random
import itertools
import math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt


def LI(): return list(map(int, input().split()))


def LF(): return list(map(float, input().split()))


def LI_(): return list(map(lambda x: int(x)-1, input().split()))


def II(): return int(input())


def IF(): return float(input())


def LS(): return list(map(list, input().split()))


def S(): return list(input().rstrip())


def IR(n): return [II() for _ in range(n)]


def LIR(n): return [LI() for _ in range(n)]


def FR(n): return [IF() for _ in range(n)]


def LFR(n): return [LI() for _ in range(n)]


def LIR_(n): return [LI_() for _ in range(n)]


def SR(n): return [S() for _ in range(n)]


def LSR(n): return [LS() for _ in range(n)]


def gcd(x, y):
    if y == 0:
        return x
    return gcd(y, x % y)


def my_index_multi(l, x):
    return [i for i, _x in enumerate(l) if _x == x]


def sosu(x):
    for i in range(2, int(sqrt(x)+1)):
        if x % i == 0:
            return False
    return True


mod = 1000000007
inf = float('INF')


def A():
    v1, v2, v3 =LI()
    v=v1+v2+v3
    if(v>=22):
        print('bust')
    else:
        print('win')
    return




def B():
    S = input()
    S=S[:-1]
    count=0
    for i in range(len(S)//2):
        if (S[i]!=S[-1-i]):
            count+=1

    
    print(count)
    return




def C():
    A, B, X = LI()
    tmp=X//A
    
    i= tmp
    for x in range(tmp):
        
       
        if B*len(str(i))+(10**(len(str(i))-1))>X:
            i=(10**(len(str(i))-1))


        if (A*i)+(B*len(str(i)))<=X:
            if i>1000000000:
                i=1000000000
            print(i)
            return
        i-=1
    print(0)
    return
            





def D():

    a, b, x = LI()
    BIG = a*a*b/2
    if x > BIG:
        y = 2*b-(2*x/a/a)
        print(math.degrees(math.atan(y/a)))
    else:
        y = 2*x/a/b
        print(math.degrees(math.atan(b/y)))
    return




def E():
    N, K = LI()
    A = LI()
    F = LI()
    A.sort(reverse=True)
    F.sort()
    cost = []
    for i in range(len(N)):
        cost.append(A[i]*F[i])

    a = F[cost.index(max(cost))]

    return




def F():
    N, M = LI()

    value = [0] * M
    power = [0] * M
    for i in range(M):
        a, b = LI()
        value[i] = a
        c = LI()
        L = ['0'] * N
        for k in c:
            L[k - 1] = '1'
        bint = ''.join(L)
        power[i] = int(bint, 2)
    bint = ''.join(list(['1'] * N))
    dp = [inf] * (int(bint, 2)+1)
    t = 0
    cost = 0

    dp[0] = 0
    for s in range(int(bint, 2) + 1):
        for i in range(M):
            t = s | power[i]
            cost = dp[s] + value[i]
            dp[t] = min(dp[t], cost)
    print(-1) if(dp[-1] == inf) else print(dp[-1])

    return

    



def solution(S):
    
    N = len(S)

    pass



if __name__ == '__main__':

    B()

Solution (Python):
s = input()

ite = 0
if len(s) % 2 == 0:
    ite = int(len(s) / 2)
else:
    ite = int((len(s) - 1) / 2)

count = 0
for i in range(ite):
    if s[i] == s[-i - 1]:
        continue
    count += 1

print(count)

Solution (Python):
S = input()
li = list(S)

rli = li[::-1]

ans = 0
for k in range(len(li)):
    if li[k] == rli[k]:
        pass
    else:
        ans += 1/2

print(int(ans))

Solution (Python):
import sys
import math
from itertools import permutations
from itertools import combinations


sys.setrecursionlimit(10**7)
S = input()

cnt = 0
rS = S[::-1]
if len(S)%2:
    for a, b in zip(S[:len(S)//2], rS[:len(S)//2]):
        if a != b:
            cnt += 1
else:
    for a, b in zip(S[:len(S)//2], rS[:len(S)//2]):
        if a != b:
            cnt += 1
print(cnt)

Solution (Python):
s = input()
l = len(s)
count = 0
for i in range(l//2):
    if(s[i] != s[l-1-i]):
        count +=1
print(count)

Solution (Python):
import math
S = input()
n = len(S)
print(sum([S[i] != S[-(i+1)] for i in range(math.ceil(n/2))]))

Solution (Python):
n = input()

ans = 0
for i in range(int(len(n)/2)):
    if n[i] != n[len(n) - 1 - i]:
        ans += 1
        
print(ans)

Solution (Python):


s = input()
s_reversed = s[::-1]
count=0
for i in range(len(s) // 2):
    if s[i] != s_reversed[i]:
        count+=1
        
print(count)

Solution (Python):
S = input()
l = len(S)
res = 0
for i in range(l // 2):
    if S[i] != S[l-i-1]:
        res += 1
    else:
        continue
print(res)

Solution (Python):


import sys
import math

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        
        
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    s = lines[0]

    return (s,)


def solve(s,):


    n = len(s)
    m = n // 2

    cnt = 0
    for i in range(m):
        if s[i] != s[-(i+1)]:
            cnt = cnt + 1
    
    return  cnt


def main():
    
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r, sep='')
    else:
        print("%s" % result, sep='')

if __name__ == '__main__':

    main()

Solution (Python):
S = input()
count = 0
for i in range(len(S)//2):
    if S[i]==S[-1-i]:
        continue
    else:
        count += 1
print(count)

Solution (Python):
S = input()

if len(S) % 2 == 0:
    l = len(S) // 2
    o = l
else:
    l = (len(S) // 2) + 1
    o = l - 1 
ans = 0
R = S[:o]
L = S[l:][::-1]
for i in range(o):
    if R[i] != L[i]:
        ans += 1

print(ans)

Solution (Python):
S=input()
cnt=0
for i in range(int(len(S)/2)):
    if S[i]!=S[-i-1]:
        cnt+=1
print(cnt)

Solution (Python):
S = input()

head = S[:len(S)//2]
tail = S[len(S)//2:]

rtail = list(reversed(tail))

diffcount = 0
lhead = list(head)

for i in range(len(lhead)):
    if head[i] != rtail[i]:
        diffcount += 1

print(diffcount)

Solution (Python):
S = input()

l = len(S) // 2
ans = sum(1 for i in range(l) if S[i] != S[-1-i])

print(ans)

Solution (Python):
s = input()
num = len(s)
ans = 0
stack = []
for i in range(num//2):
  stack.append(s[i])
if num % 2 == 0:
  t = num//2
else:
  t = num//2 + 1
for i in range(t, num):
  k = stack.pop()
  if k != s[i]:
    ans += 1
print(ans)

Solution (Python):
s = input()
l = len(s)
c = 0
for k in range(l//2):
	if s[k] != s[l-1-k]:
		c +=1
print(c)

Solution (Python):

s = input()
s_l = list(s)
n = len(s_l)
hugs = 0

for i in range(n):
    tail = n-1-i
    if s_l[i] != s_l[tail]:
        hugs += 1
    if (i == tail) or (tail == i + 1):
        break
    
print(hugs)

Solution (Python):


S = input()

rS = list(reversed(S))


cnt = 0
for i in range(len(S)):
    if S[i] != rS[i]:
        cnt += 1


print(cnt//2)

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

count = 0
check = len(s) //  2

for i in range(check):
    if s[i] != s[-i-1]:
        count += 1

print(count)

Solution (Python):
INF = float("inf") 

def main():
    s = input()
    n = len(s)
    ans = 0

    if n%2==0:
        s1 = s[:n//2]
        s2 = s[n//2:]
        for i in range(n//2):
            if s1[i] != s2[(n//2)-i-1]:
                ans += 1
    else:
        s1 = s[:n//2]
        s2 = s[(n//2)+1:]
        for i in range(n//2):
            if s1[i] != s2[(n//2)-i-1]:
                ans += 1

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
import math

s = input()
lists = list(s)

count = 0
for i in range(0, math.floor(len(lists)/2)):
    if lists[i] != lists[len(lists)-1-i]:
        count += 1

print(count)

Solution (Python):
S = input()

count=0

for x in range(len(S)//2):
  if S[x]!=S[-(x+1)]:
    count+=1
    
print(count)

Solution (Python):
s = input()
ans = 0
for i in range(len(s)//2):
    if s[i] != s[-i-1]:
        ans += 1
print(ans)

Solution (Python):
def palin(s):
    p1 = ans = 0
    p2 = len(s) - 1
    while p1 < p2:
        if s[p1] != s[p2]:
            ans += 1
        p1 += 1
        p2 -= 1
    print(ans)

if __name__ == "__main__":
    import sys
    in_str = ''
    for line in sys.stdin:
        in_str += line
    palin(in_str.strip())

Solution (Python):
s=input()
a=s[::-1]
r=0
for i in range(int(len(s)/2)):
    if(s[i]!=a[i]):
        r+=1
print(r)

Solution (Python):
S = input()

half = len(S) // 2

cnt = 0
for x in range(0, half):
  if S[x] != S[-x-1] :
    cnt += 1
print(cnt)

Solution (Python):
s = str(input())
s_ = ''.join(list(reversed(s)))

ans = 0
for i in range(len(s)):
  if s[i] != s_[i]:
    ans += 1
    
print(ans//2)

Solution (Python):
s = input()
c = 0
for i in range(len(s)//2):
  if s[i]!=s[-i-1]:
    c += 1
print(c)

Solution (Python):
S = input()
l = len(S)
n = l // 2
ans = 0
for i in range(n):
    if S[i] != S[l - i - 1]:
        ans += 1
print(ans)

Solution (Python):
s = input()

ans = 0
for i in range(len(s)//2):
    if s[i] != s[len(s)-i-1]:
        ans += 1

print(ans)

Solution (Python):
S = input()
count = 0

for i in range(len(S)//2):
    if S[i] != S[len(S) - 1 - i]:
        count += 1

print(count)

Solution (Python):
s = input()

if len(s)%2 == 0:
    s1 = s[:int(len(s)/2)]
    s2 = ''.join(list(reversed(s[int(len(s)/2):])))
else:
    s1 = s[:int((len(s)-1)/2)]
    s2 = ''.join(list(reversed(s[int((len(s)+1)/2):])))

count = 0
for i in range(len(s1)):
    if s1[i] != s2[i]:
        count += 1
    
print(count)

Solution (Python):




s = input()
n = len(s)
cnt = 0
for i in range(n // 2):
    if s[i] != s[n - i - 1]:
        cnt += 1
        
print(cnt)

Solution (Python):
s = list(input())
n = len(s)
a = 0
for i in range(n//2):
  if s[i] != s[-i-1]:
    a += 1
print(a)

Solution (Python):






S = list(input())




ans = 0
if len(S) % 2 == 0 :
    h = int(len(S) / 2)
    s1 = S[0:h]
    s2 =  S[::-1][0:h]
    for i in range(h) :
        if s1[i] != s2[i] :
            ans += 1

else :
    h = int((len(S) - 1) / 2)
    s1 = S[0:h]
    s2 =  S[::-1][0:h]
    for i in range(h) :
        if s1[i] != s2[i] :
            ans += 1

print(ans)

Solution (Python):
S = input()
RS = reversed(S)
n = int(len(S) / 2)

ans = 0
for c1, c2 in zip(S[:n], RS):
    if c1 != c2:
        ans += 1
print(ans)

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

def main():
    s = input().rstrip()

    if s == s[::-1]:
        print(0)
    else:
        s_len = len(s)//2
        a = s[:s_len]
        b = s[::-1][:s_len]
        ans = 0
        for x, y in zip(a, b):
            if x != y:
                ans += 1

        print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
s = input()

le = len(s)
count = 0


for i in range(le//2):
    if s[i]!=s[le-i-1]:
        count+=1
print(count)

Solution (Python):
from sys import stdin 
s = stdin.readline().rstrip()
n = len(s)
m = n // 2
a = 0
for i in range(m):
    if s[i] != s[-i-1]:
        a += 1
print(a)

Solution (Python):
s = list(input().strip())
s_re = s[::-1]
ans = 0
for i in range(len(s) // 2):
    if s[i] != s_re[i]:
        ans += 1

print(ans)

Solution (Python):
S = input()
count = 0
for i in range(len(S)//2):
    if S[i] != S[-(i+1)]:
        count += 1
print(count)

Solution (Python):

S = input()
half_S = int(len(S) / 2)
count = 0
for i in range(half_S):
    if not S[i] == S[(i * -1) - 1]:
        count += 1
print(count)

Solution (Python):
s = input()
counter = 0
for i in range(len(s)//2):
    
    if s[i] == s[len(s)-i-1]:
        pass
    else:
        counter += 1
print(counter)

Solution (Python):
s = list(input())
N = len(s)
count = 0
for i in range(N//2):
  if s[i] != s[N-1-i]:
    count += 1
print(count)

Solution (Python):
a=input()
n=len(a)
if len(a)%2==0:
    a1=a[:n//2]
    a2=a[n//2:]
    a2=a2[::-1]
else:
    a1=a[:n//2]
    a2=a[n//2+1:]
    a2=a2[::-1]
cnt=0
for i in range(len(a1)):
    if a1[i]!=a2[i]:
        cnt+=1
print(cnt)

Solution (Python):
s = input()
s_len = len(s)//2
s1 = s[:s_len]
s2 = s[::-1][:s_len]
count=0
for i,j in zip(s1,s2):
    if i!=j:
        count += 1
print(count)

Solution (Python):
S = input()
ans = 0
for i in range(len(S)):
    if S[i] != S[len(S) -1 - i]:
        ans += 1
print(ans//2)

Solution (Python):
s = input()
left = []
right = []
if len(s)%2 == 0:
    left = s[:len(s)//2]
    right = s[len(s)//2:]
else:
    left = s[:(len(s)-1)//2]
    right = s[(len(s)+1)//2:]

ans = 0
for l, r in zip(left, reversed(right)):
    if l != r:
        ans += 1

print(ans)

Solution (Python):
s = input()

cnt = 0

for i in range(len(s)):
    if s[i] != s[len(s) - i - 1]:
        cnt += 1

print(int(cnt/2))

Solution (Python):


S = input()
list_S = list(S)

hug = 0
for i in range(1, int(len(list_S)/2) + 1):
    if list_S[i-1] != list_S[-1 * i]:
        hug += 1

print(hug)

Solution (Python):
s = input()
length = len(s)
cnt = 0
if length % 2 == 0:
    f = s[:length // 2]
    l = s[length // 2:]
    lr = l[::-1]

    for i in range(len(f)):
        if f[i] != lr[i]:
            cnt += 1
else:
    f = s[:length // 2]
    l = s[length // 2 + 1:]
    lr = l[::-1]
    
    for i in range(len(f)):
        if f[i] != lr[i]:
            cnt += 1

print(cnt)

Solution (Python):
s = input()
ans = 0
for i in range(len(s)//2):
    
    if s[i] != s[len(s) - i - 1]:
        ans += 1
print(ans)

Solution (Python):



S = input()
ctr = 0

for i in range(len(S) // 2):
    if S[i] != S[len(S) - i - 1]:
        ctr += 1
print(ctr)

Solution (Python):
import sys
bbn=1000000007
	

		
def main():
	s = input()
	n=0
	for i,c in enumerate(s[:(len(s)//2)]):
		
		if c != s[-1*(i+1)]:
			n+=1
	
	print(n)
	
	

isTest=False

def pa(v):
	if isTest:
		print(v)

if __name__ == "__main__":
	if sys.platform =='ios':
		sys.stdin=open('inputFile.txt')
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

Solution (Python):
def main():
    S=input()
    l=len(S)
    if l == 0:
        print(0)
    else:
        ans = 0
        for i in range(l // 2):
            if S[i] != S[-i-1]:
                ans+=1
        print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
s = input()

n = len(s)-1
ans = 0
for i in range(len(s)//2):
	if s[i] != s[n-i]:
		ans += 1

print(ans)

Solution (Python):
S = input()
ls1 = []
ls2 = []
ans = 0
if len(S)%2 == 1:
    for i in range(0,(len(S))//2+1):
        ls1.append(S[i])
    for j in range(len(S)//2+1,len(S)):
        ls2.append(S[j])
    ls2.reverse()
    for i in range(len(ls2)):
        if ls1[i] != ls2[i]:
            ans += 1
else:
    for i in range(0,(len(S)//2)):
        ls1.append(S[i])
    for j in range((len(S)//2),len(S)):
        ls2.append(S[j])
    ls2.reverse()
    for i in range(len(ls1)):
        if ls1[i] != ls2[i]:
            ans += 1
print(ans)

Solution (Python):
s=input()
ans = 0
for i,j in zip(s,reversed(s)):
    if i != j:
        ans += 1
print(ans//2)

Solution (Python):
s = input()

l = len(s)
c = 0
for i in range(l):
    if s[i] != s[l-i-1]:
        c += 1
print(c//2)

Solution (Python):


import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def MI() : return map(int, input().split())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def chkprint(*args) : names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}; print(', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args))

S = input()

num = len(S) // 2

if num == 0:
    print(0)
else:
    A = S[0 : num]
    B = list(reversed(S[len(S) - num : ]))
    
    ans = 0

    for a, b in zip(A, B):
        if a != b:
            ans += 1
        
    print(ans)

Solution (Python):
S = input()

cnt = 0
mid = len(S) // 2

for c1, c2 in zip(S[:mid], S[-1:mid-1:-1]):
    if c1 != c2:
        cnt += 1

print(cnt)

Solution (Python):
s = input()
count = 0
for i in range(len(s)//2):
    if s[i]!=s[len(s)-i-1]:
        count += 1
print(count)

Solution (Python):



def solve(*args: str) -> str:
    s = args[0]
    hug = 0
    for i in range(len(s)//2):
        if s[i] != s[-i-1]:
            hug += 1

    return str(hug)


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))