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):
S = input()

N = len(S)
M = N // 2

res = 0

for i in range(M):
    if S[i] != S[N-1-i]:
        res += 1

print(res)

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

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

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

print(ans)

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

n=len(s)
if n%2==0:
    s_1=list(s[:n//2])
    s_2=list(s[n//2:])
    s_2=s_2[::-1]

else:
    s_1=list(s[:n//2])
    s_2=list(s[n//2+1:])
    s_2=s_2[::-1]

cnt=0
for i in range(n//2):
    if s_1[i]==s_2[i]:
        continue
    else:
        cnt+=1

print(cnt)

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

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

if __name__ == "__main__":
    main()

Solution (Python):
S = input()

count = 0

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

Solution (Python):
s = input()


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

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

m = len(S) // 2
answer = 0

string1 = s[0:m]
string2 = []
for i in range(m):
  string2.append(s[-(i+1)])

for i in range(m):
  if string1[i] == string2[i]:
    pass
  else:
    answer += 1
else:
  print(answer)

Solution (Python):
s = input()

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



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

print(count)

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

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 = input()

sc = int(len(s)/2)
c=0

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

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

Solution (Python):
s = input()

if len(s) % 2 == 0:
  s_len = len(s) // 2
else:
  s_len = len(s) // 2 + 1

cnt = 0

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

print(cnt)

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

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

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

Solution (Python):
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy




def main():
    s = input()
    t = len(s)//2
    ls = s[:t]
    rs = None
    c = 0
    if len(s)%2==0:
        rs = s[t:]
    else:
        rs = s[t+1:]
    rs = rs[::-1]
    
    for l,r in zip(ls,rs): 
        if l != r:
            c += 1
    print(c)

if __name__ == '__main__':
    main()

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

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

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

print(ans)

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

ans = 0

for i in range(len(l)//2):
    if not l[i] == l[len(l)-i-1]:
        ans+=1
print(ans)

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

s_inv = s[::-1]

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

Solution (Python):
s = input()
h = len(s) // 2

count = 0
for i in range(h) :
  a1 = s[i]
  a2 =s[-1+(-i)]
  
  if a1 != a2 : count += 1
    
print(count)

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[0:len(S)//2]
cnt = 0

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

print(cnt)

Solution (Python):

s = input()
hag = 0

l = len(s) // 2
for h, t in zip(s[0:l], (s[::-1])[0:l]):
    if h != t:
        hag += 1
print(hag)

Solution (Python):

from sys import stdin
from itertools import accumulate, dropwhile, takewhile, groupby
import bisect
import copy
import math
a = list(stdin.readline().rstrip())
num = int(len(a) / 2)
res = 0
for el in range(num):
    f = a[el]
    b = a[len(a) - 1 - el]
    if not f == b:
        res += 1
print(res)

Solution (Python):
S = input()

hagu = 0

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

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

print(hagu)

Solution (Python):
S = input()

length = len(S)
tmp = S[length // 2:]
cnt = 0
for i, e in enumerate(S[:length // 2:]):
    if tmp[::-1][i] == e:
        continue
    else:
        cnt +=1
print(cnt)

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline






















def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

def main():
	S = input()
	S = S[:-1]

	tmp = len(S)
	tmp = tmp // 2

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

	print(ans)


if __name__ == "__main__":
	main()

Solution (Python):
import math

S = input()

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

print(count)

Solution (Python):
import unittest


class TestB(unittest.TestCase):
    def test_1(self):
        self.assertEqual(think('redcoder'), 1)

    def test_2(self):
        self.assertEqual(think('vvvvv'), 0)

    def test_3(self):
        self.assertEqual(think('abcdabc'), 2)


def solve():
    s = read()
    result = think(s)
    write(result)


def read():
    return read_line()


def read_int(n):
    return read_type(int, n)


def read_float(n):
    return read_type(float, n)


def read_type(t, n):
    return list(map(lambda x: t(x), read_line().split(' ')))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(data):
    mid = len(data) // 2 - 1

    left = 0
    right = len(data) - 1
    count = 0
    while left <= mid:
        count += 0 if data[left] == data[right] else 1
        left += 1
        right -= 1
    return count


def write(result):
    print(result)


if __name__ == '__main__':
    
    solve()

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

Solution (Python):
s = input()

count = 0

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

Solution (Python):

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

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

Solution (Python):
import sys

s=input()

if len(s)==1:
    print(0)
    sys.exit()

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

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

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

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

Solution (Python):
S = input()
Srev = S[::-1]

N = len(S)
ans = 0
for i in range (0,N):
  if S[i] != Srev[i]:
    ans = ans + 1
print(int(ans/2))

Solution (Python):
S=input()

s_rev = S[::-1]

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

print(ans//2)

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

Solution (Python):
s = input()

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

Solution (Python):
import sys
from math import factorial
from fractions import Fraction
import heapq, bisect
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
MOD = 10**9 + 7

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

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

print(res)

Solution (Python):
import sys


def main():
    s = sys.stdin.readline().strip()

    n = len(s)
    
    
    
    half = n // 2 + (n % 2)

    ans = 0
    for i in range(half):
        if s[i] != s[-1-i]:
            ans += 1
    print(ans)


main()

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

mid = len(S)//2
left = S[:mid]
right = S[mid:]
ans = 0


for i in range(mid):
    
    
    if left[i] != right[-(i+1)]:
        ans += 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(cnt)

Solution (Python):






import math
import statistics
import numpy as np
import queue

s = input()
cnt = 0

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

print(cnt)

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

Solution (Python):

MOD = 10**9 + 7
INF = 10**20
I = lambda:list(map(int,input().split()))
from collections import defaultdict as dd

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

Solution (Python):

s = input()
if len(s) % 2 ==0:
    s_m = s[:int(len(s) / 2)]
    s_u = s[int(len(s) / 2):][::-1]
else:
    s_m = s[:int(len(s) / 2)]
    s_u = s[int(len(s) / 2) + 1:][::-1]
    
count = 0
for i in range(len(s_m)):
    if s_m[i] != s_u[i]:
        count += 1
print(count)

Solution (Python):
s = input().rstrip()
h = len(s) // 2

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

print(count)

Solution (Python):
s=input()
le=len(s)

cn=0

if le%2==0:
    for i in range(int(le/2)):
        if s[i]!=s[le-1-i]:
            cn=cn+1

if le%2==1:
    for i in range(int(le/2)):
        if s[i]!=s[le-1-i]:
            cn=cn+1

print(cn)

Solution (Python):
s=input()
l=len(s)

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

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):
import logging

logging.basicConfig(level=logging.INFO, format="%(message)s")


def main():
    S = input()
    logging.info("Hello!")

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

    print(counter)
    
    
if __name__ == "__main__":
    main()

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

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

Solution (Python):

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

Solution (Python):
S = input()

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

print(cnt)

Solution (Python):
s = input()

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



s3 = list()
for i in reversed(range(len(s2))):
    s3.append(s2[i])
s3 = ''.join(s3)
s2 = s3
cnt = 0

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

Solution (Python):
s = input()
hug = 0

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

print(hug)

Solution (Python):
s = input()
ans = 0

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

print(ans)

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

Solution (Python):
S = input()
S_size = len(S)

if S_size % 2 == 0:
    S_left = list(S[: S_size//2])
    S_right = list(reversed(S[S_size//2 :]))
else:
    S_left = list(S[: S_size//2])
    S_right = list(reversed(S[(S_size//2 + 1) :]))

counter = 0
for i in range(len(S_left)):
    if S_left[i] == S_right[i]:
        pass
    else:
        counter += 1

print(counter)

Solution (Python):
import sys
import math
import bisect
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop


def LI(): return [int(x) for x in sys.stdin.readline().split()]


def I(): return int(sys.stdin.readline())


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 A():
    a, b, c = LI()
    if a + b + c >= 22:
        print("bust")
    else:
        print("win")
    return



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



def C():
    return



def D():
    return



def E():
    return



def F():
    return



def resolve():
    B()
    return



if __name__ == "__main__":
    B()

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

Solution (Python):
from math import ceil
S = input()
count = 0

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

print(count)

Solution (Python):

s = input()
leng = len(s)
if leng%2==0:
    mae = s[:leng//2]
    ushi = s[leng//2:][::-1]
else:
    mae = s[:leng//2]
    ushi = s[leng//2+1:][::-1]

hagu = 0
for m, u in zip(mae, ushi):
    if m != u:
        hagu += 1
print(hagu)

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline






















def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

def main():
	S = input()
	S = S[:-1]

	tmp = len(S)
	tmp = tmp // 2

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

	print(ans)


if __name__ == "__main__":
	main()

Solution (Python):
s = input()

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

print(count)

Solution (Python):
def main():
    
    import math
    s = input()

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



    


if __name__ == '__main__':
    main()

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):
s = input()

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

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

print(count)

Solution (Python):
x = input()
ct =0
for name, name1 in zip(x, x[::-1]):
    if(name !=name1):
        ct = ct+1


print(int(ct/2))

Solution (Python):
s = input()
re_s = reversed(s)
count = 0
for si,re_si in zip(s,re_s):
    if si != re_si:
        count += 1
if count == 0:
    print(0)
else:
    print(count//2)

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

Solution (Python):
S = input()

start = 0
last = len(S)-1
count = 0

while (start < last):
  if(S[start] != S[last]):
    count += 1
  start += 1
  last -= 1
print(count)

Solution (Python):
s = input()

n = len(s)

c = 0

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

print(c)

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

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

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

Solution (Python):
S = input()
SS = S[::-1]
X = len(S)//2


cnt = 0
for i in range(X):
    if S[i] != SS[i]:
        cnt += 1
print(cnt)

Solution (Python):
S = input().strip()
R = S[::-1]

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().strip()
l = len(s)
ans = 0
for idx in range(l//2):
  if s[idx] != s[l - idx -1]:
    ans += 1
    
print(ans)

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

Solution (Python):
S = list(input())
n = int(len(S))

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

print(count)

Solution (Python):
frase = input()
tam = len(frase)//2

cont=0
for i in range(tam):
    if (frase[i] != frase[-i-1]):
        cont+=1

print(cont)

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

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

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

print(c)

Solution (Python):
s = input()
if len(s) % 2 == 0:
    l = s[:len(s)//2]
    r = s[len(s)//2:len(s)][::-1]
else:
    l = s[:len(s)//2]
    r = s[len(s)//2+1:len(s)][::-1]
cnt = 0
for li, ri in zip(l, r):
    if li != ri:
        cnt += 1
print(cnt)

Solution (Python):
S=input()
L=len(S)

N=L//2

cnt=0

for i in range(N):
    if S[i]!=S[-1*(i+1)]:
        cnt+=1
print(cnt)

Solution (Python):
import math
s = input()
count = 0

if len(s) % 2 == 0:
    x = len(s) // 2
else:
    x = math.floor(len(s) / 2)

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

print(count)

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

Solution (Python):
s = input()
cnt = 0
n = len(s)
if n % 2 == 0:
    h = n // 2
else:
    h = n // 2 + 1
for i in range(h):
    if s[i] != s[n-i-1]:
        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 = input()
n = len(s)
first = s[:int(n/2)]
latter = s[int(n/2):]
latter = latter[::-1]

diff = 0
for i in range(int(n/2)):
    diff += 1 if (first[i] != latter[i]) else 0
print(diff)

Solution (Python):
s = input()
c = 0
i, j = 0, len(s) - 1
while i < len(s)//2:
    if s[i] == s[j]:
        i += 1
        j -= 1
    else:
        c += 1
        i += 1
        j -= 1
print(c)

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

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

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):
s = list(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()
l = 0
r = len(S) - 1
ans = 0
while l < r:
    if S[l] != S[r]:
        ans += 1
    l += 1
    r -= 1
print(ans)

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

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


if __name__ == '__main__':
    main()

Solution (Python):
s = input()

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

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

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

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()
n = len(S)
_n = n//2 if n%2==0 else (n-1)//2

count = 0

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

print(count)

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

Solution (Python):
s = input()

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

print(wrong)

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

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 = list(input())
s_rev = list(reversed(s))

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

Solution (Python):
s = input()
i = 0
ib = len(s) - 1
ans = 0

while i < ib:
    if s[i] != s[ib]:
        ans += 1
    i += 1
    ib -= 1

print(ans)

Solution (Python):
s = input()
l = sum(x != y for x,y in zip(s,s[::-1]))
print((l+1)//2)

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

Solution (Python):

for i in range(1):
    
    arr=input()
    res=0
    for j in range(len(arr)//2):
        if(arr[j]!=arr[len(arr)-j-1]):
            res+=1
    print(res)

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

Solution (Python):
s = input()
ans = 0

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

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

Solution (Python):
S = list(str(input()))
re_S = S[::-1]

ans = 0

for s,r in zip(S,re_S):
    if s != r:
        ans += 0.5

print(int(ans))

Solution (Python):
s = input()

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

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

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

Solution (Python):

s = input()
n = len(s)

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

print(result)

Solution (Python):
s = input()
end = len(s)//2 + 1
ans = 0
for i in range(1, end):
    if s[i-1] == s[i*(-1)]:
        continue
    else:
        ans += 1

print(ans)

Solution (Python):
import sys


def main():
    
    S = list(input())
    rev = list(reversed(S))

    count = 0

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

    print(count//2)


if __name__ == '__main__':
    main()

Solution (Python):
a = input()

l = len(a)-1
i=0
t = 0

while l-2*i >= 1:
    if not a[i] == a[l-i]:
        t += 1
    i += 1
print(t)

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):
import sys
input = sys.stdin.readline

s = input()[:-1]

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

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

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

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

Solution (Python):

if __name__ == "__main__":
    S = input()
    length = len(S) // 2
    left = S[:length]
    right = S[-length:][::-1]
    count = 0
    for l, r in zip(left, right):
        if l != r:
            count += 1
    print(count)

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

Solution (Python):
S = input()
invert = S[::-1]

from math import floor

counter  = 0
for i in range(floor(len(S) / 2)):
	if S[i] != invert[i]:
		counter += 1

print(counter)

Solution (Python):
s = input()
lens = len(s)
cnt = 0
for i, j in zip(s[:lens//2], s[::-1][:lens//2]):
  if i != j:
    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 = input()

ans = 0

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

print(ans)

Solution (Python):
s=input()

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

print(hug_count)

Solution (Python):
import sys

read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines





def main():
	s=input().rstrip().decode('utf-8')
	n=len(s)//2
	
	a=s[:n]
	bb=s[::-1]
	b=bb[:n]
	
	ans=0
	
	for i in range(n):
		if a[i]!=b[i]:
			ans+=1
	print(ans)
	
	
	
	
if __name__ == "__main__":
	main()

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

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

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

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

print(cnt)

Solution (Python):
s = input()
f = len(s) // 2
c = 0

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

print(c)

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

Solution (Python):
S = input()
N = len(S)

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

Solution (Python):
import numpy as np


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

    print(ret)


if __name__ == '__main__':
    main()

Solution (Python):
S = input()

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

print(total)

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 count(s1, s2):
    c = 0
    for i in range(len(s1)):
        if not s1[i] == s2[i]:
            c += 1
    return c


s = input()

mid = len(s) // 2
if len(s) % 2 == 0:
    print(count(s[:mid], s[mid:][::-1]))
else:
    print(count(s[:mid], s[mid+1:][::-1]))

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

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

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

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

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

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

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

print(ans)

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

Solution (Python):
S = input()

if len(S) % 2 == 0:
    front = S[:len(S)//2]
    back = S[len(S)//2:][::-1]

else:
    front = S[:len(S)//2]
    back = S[len(S)//2+1:][::-1]

ans = 0
for i, j in zip(front, back):
    if i != j:
        ans += 1

print(ans)

Solution (Python):

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

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

Solution (Python):
s = input()

l = len(s)
ans = 0

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

print(ans)

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

Solution (Python):
S = list(str(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()

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

print(ans)

Solution (Python):
s = input()
r = 0
while len(s) > 1:
  if s[0] == s[-1]:
    pass
  else:
    r = r + 1
  
  s = s[1:]
  s = s[:-1]
  
print(r)

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

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

Solution (Python):
moji=input()

List = list(moji)

length = len(List) // 2
cnt = 0

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