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)
cnt = 0
i = 0
j = -1
d = 0
while d != n//2:
    if s[i] != s[j]:
        cnt += 1
    i+=1
    j-=1
    d+=1

print(cnt)

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

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

Solution (Python):

def main():
    S = input()

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


if __name__ == '__main__':
    main()

Solution (Python):
A=input();print(sum(i!=j for i,j in zip(A,A[::-1]))//2)

Solution (Python):
S=input();print(sum(a!=b for a,b in zip(S,S[::-1]))//2)

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

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

Solution (Python):
S=input()
print(sum(i!=j for i,j in zip(S,S[::-1]))//2)

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

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

Solution (Python):
A=input();print(sum([A[i]!=A[::-1][i] for i in range(len(A))])//2)

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

Solution (Python):
s=input();print(sum(s[i]!=s[len(s)-i-1] for i in range(len(s)))//2)

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

Solution (Python):
S = input()
cnt = 0
N = len(S)
for i in range(N//2):
  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[len(S) - i - 1]:
        cnt += 1
print(cnt)

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):
import math
from decimal import *
import random
mod = int(1e9)+7

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

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

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

Solution (Python):
S = input()

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

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

for i in range(n//2):
  if s[i] != s[-1-i]:
    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):
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()
ans = 0
for i in range(len(s)//2):
 if s[i] != s[len(s)-1-i]:
  ans+=1

print(ans)

Solution (Python):
from sys import stdin, stdout 

def solve():
    s = input() 
    left = 0
    right = len(s) - 1
    count = 0
    while left < right:
        count += (s[left] != s[right])
        left += 1
        right -= 1
    print(count)

def main():
    solve()


if __name__ == "__main__":
    main()

Solution (Python):
S = input()
import math
half = int(math.ceil(len(S)//2))
count = 0
for a,b in zip(S[:half], S[:-half-1:-1]):
  if a != b: count += 1
print(count)

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

Solution (Python):
S=input()

def ans147(S:str):
    def_count=0
    for i in range(int(len(S)/2)):
        if S[i]!=S[-(i+1)]:
            def_count+=1
    return def_count
print(ans147(S))

Solution (Python):
s = input()

s = " " + s

ans = 0

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

print(ans)

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

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

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

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

Solution (Python):
import math

s=input()
count=0

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

print(count)

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

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

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

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

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

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

print(cnt)

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

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

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

Solution (Python):



def solve(S: str):
    return sum([a != b for a, b in zip(S, reversed(S))]) // 2


def main():
    S = input().strip()
    answer = solve(S)
    print(answer)


if __name__ == "__main__":
    main()

Solution (Python):
s = input()

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

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

print(ans)

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

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

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

Solution (Python):
S=input()
if len(S)%2==0:
	S_left=list(S)[:int(len(S)/2)]
	S_right=list(S)[int(len(S)/2):][::-1]

else:
	S_left=list(S)[:int(len(S)//2)]
	S_right=list(S)[int(len(S)/2)+1:][::-1]

ans=0
for i in range(len(S_left)):
	if S_left[i]!=S_right[i]:
		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()
cnt=0
for i in range(len(S)//2):
    cnt+=S[i]!=S[-i-1]
print(cnt)

Solution (Python):
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
    s = S()
    ans = 0


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

    print(ans)
main()

Solution (Python):
moji = str(input())
N = len(moji)
FM = moji[:N//2]
if N % 2 == 0:
    LM = moji[-1:(N//2)-1:-1]
else:
    LM = moji[-1:(N//2):-1]
ct = 0

for i in range(N//2):
    if FM[i] != LM[i]:
        ct += 1

print(ct)

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

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

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

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

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

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

Solution (Python):

from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b


def sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2


def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)


def lcm(a, b):
    g = gcd(a, b)
    return a / g * b


def solve():
    S = input()

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


def main():
    solve()


if __name__ == '__main__':
    main()

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()
t=s[::-1]
cnt=0
for i in range(len(t)//2):
    if s[i]!=t[i]: cnt+=1
print(cnt)

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

Solution (Python):
s = list(input())
n = len(s)//2
cnt = 0

L = s[:n]
R = s[-n:][::-1]

for l, r in zip(L, R):
  if l != r:
    cnt += 1
print(cnt)

Solution (Python):
from sys import exit
import math
import collections
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

s = input()

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

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

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

Solution (Python):
S = input()

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

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

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

Solution (Python):
s=list(input())
r=list(reversed(s))
c=0

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

print(c//2)

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

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

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

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

Solution (Python):
s = input()
l, r = 0, len(s)-1
c = 0

while l < r:
    if s[l] != s[r]:
        c += 1

    l += 1
    r -= 1

print(c)

Solution (Python):
s = input()

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

Solution (Python):
A = input()
import math
times = math.ceil(len(A)/2)
count = 0
for i in range(times):
  if A[i] != A[len(A)-1-i]:
    count += 1
print(count)

Solution (Python):
S = input()
length = len(S)
if length % 2 == 0:
    length = int(length / 2)
    S_half_1 = S[:length]
    S_half_2 = S[(length):]
    S_half_2 = S_half_2[::-1]
else:
    length = int(length // 2)
    S_half_1 = S[:length]
    S_half_2 = S[(length + 1) :]
    S_half_2 = S_half_2[::-1]

ans = 0
for i in range(length):
    if S_half_1[i] != S_half_2[i]:
        ans += 1
print(ans)

Solution (Python):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 1
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"

S = v()

a = len(S)

if a % 2 == 0:
    ra = a//2
else:
    ra = a//2

for i in range(ra):
    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[-1-i]:
        ans += 1
print(ans)

Solution (Python):
S = input()

N = len(S)
ans = 0
for i in range(N//2):
  if S[i] != S[N-i-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
for i in range(len(s)//2):
    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)-i-1]:
        cnt += 1
print(cnt)

Solution (Python):
S = list(input())
cn = 0
T = S[::-1]


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

print(cn)

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

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

Solution (Python):
s = input()
mid = len(s)//2
q = s[:mid]
if len(s)%2 == 0:
    t = list(s[mid:])
else:
    t = list(s[mid+1:])

t.reverse()
cnt = 0

for i in range(mid):
    cnt += s[i] != t[i]

print(cnt)

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

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

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

Solution (Python):
A = list(input())
i = 0
res = 0
while i < len(A) // 2:
  if A[i] != A[len(A) - 1 -i]:
    res += 1
  i += 1
print(res)

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

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

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(int(len(S) / 2)):
    if S[i] != S[-1-i]:
        ans += 1
print(ans)

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

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    S = input()
    n = len(S)

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

    print(ans)


if __name__ == '__main__':
    main()

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

Solution (Python):
S = input()
S1 = S[:len(S) // 2]
S2 = S[-1:(len(S)-1) // 2:-1]
ans = 0
for s1, s2 in zip(S1, S2):
    ans += s1!=s2
print(ans)

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

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

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

print(cnt)

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

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

cnt = 0
while True:
    if s1 == s2:
        break
    for i in range(len(s1)):
        if s1[i] != s2[i]:
            s1[i] = s2[i]
            cnt += 1

print(cnt)

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

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

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

Solution (Python):
s = input()

s = list(s)

L = len(s)

l = len(s)//2

c = 0

for i in range(l):
  if s[i] != s[L-1-int(i)]:
    c += 1
    
print(c)

Solution (Python):


str = input()
table = list(str)
count = 0
if len(str) % 2 == 0:
    for i in range(len(str)):
        if table[i] == table[(len(str)-1)-i]:
            continue
        else:
            count += 1
elif len(str) % 2 == 1:
    for i in range(len(str)):
        if table[i] == table[(len(str)-1)-i]:
            continue
        else:
            count +=1
if count == 0:
    print(0)
else:
    print(int(count / 2))

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

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

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

Solution (Python):



from fractions import gcd
from itertools import combinations,permutations,accumulate, product 

from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect














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


from sys import stdin
readline = stdin.readline
def readInts():
  return list(map(int,readline().split()))
def readTuples():
    return tuple(map(int,readline().split()))
def I():
  return int(readline())
s = input()
ln = len(s)
if ln%2 == 0:
    ml = ln//2 - 1
    mr = ln//2
    ans = 0
    for i in range(ml+1):
        
        if s[i] == s[-i-1]:
            pass
        else:
            ans += 1
else:
    m = ln//2
    ans = 0
    for i in range(m):
        if s[i] == s[-i-1]:
            pass
        else:
            ans += 1
print(ans)

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

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

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

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

print(ans//2)

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()
ans = 0
for i in range(len(s)):
    j = len(s)-i-1
    if i > j: break
    if s[i] != s[j]: ans += 1

print(ans)

Solution (Python):
S = input()

cnt = 0

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

print(cnt)

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

Solution (Python):

from collections import defaultdict, deque, Counter, OrderedDict
import collections, heapq, itertools, bisect
import math, fractions
import sys, copy

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline().rstrip())
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def SL(): return list(sys.stdin.readline().rstrip())
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)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007

def main():
    S = SL()
    cnt = 0
    for i in range(math.ceil(len(S)/2)):
        if S[i] != S[-i-1]:
            cnt += 1
    print(cnt)

if __name__ == '__main__':
    main()

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

print(ans)

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

ans = 0

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

Solution (Python):


from typing import *
import collections
import functools
import itertools
import math
import sys

INF = float('inf')


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


def main():

    sys.setrecursionlimit(10 ** 6)

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = next(tokens)  
    print(f'{solve(S)}')


if __name__ == '__main__':
    main()

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()
N=len(S)

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

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

Solution (Python):
S = input()
N = len(S)
ans = 0
for k in range(N//2):
    if S[k] != S[-k-1]:
        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()
ans = 0
for i in range(len(S)):
    if S[-i-1] != S[i]:
        ans += 1

print(ans//2)

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

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

    print(ans)


if __name__ == "__main__":
    main()

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

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

    print(ans // 2)


if __name__ == "__main__":
    main()

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

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

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

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()
moji = len(s)
if moji % 2 == 0:
    moji = int(moji/2)
else:
    moji = int((moji-1)/2)

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

Solution (Python):
s=input()

ans=0

tyu=len(s)//2

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

print(ans)

Solution (Python):
s = input()
reverse = s[::-1]

result = 0
while s != reverse:
    for i, c in enumerate(s):
        if c != reverse[i]:
            s = s[:i] + reverse[i] + s[i + 1:]
            reverse = s[::-1]
            result += 1
            break
print(result)

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

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()
cnt = 0


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

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 = 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 = str(input())
num = 0
for i in range(len(s)//2):
    if s[i] != s[-i-1]:
        num += 1
print(num)

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

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush

sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

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):
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy


import heapq
sys.setrecursionlimit(10**6)

INF = 10**18
import bisect
import statistics
mod = 10**9+7


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):
def main():
    s = input()
    x = len(s)//2
    count = 0
    for i in range(x):
        if s[i] != s[(i+1)*-1]:
            count += 1
    print(count)


main()

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

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

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

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy








def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

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

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

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

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

print(ans)

Solution (Python):
a = input()
hl = int(len(a)/2)
first = a[:hl]
last = a[:hl+(len(a)%2-1):-1]
ans = 0


for fi,la in zip(first,last):
    if fi != la :
        ans += 1
print(ans)

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
sys.setrecursionlimit(10**7)

def _S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())

def main():
    S = _S()
    ans = 0
    for i in range(int(len(S)/2)):
        if S[i]==S[-i-1]:
            continue
        else:
            ans +=1
    print(ans)

main()

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

for i in range(len(s)//2):
  if s[i] == s[-i-1]:
    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
sys.setrecursionlimit(10 ** 7)

S = input()

l, r = 0, len(S)-1
count = 0
while l < r:
    if S[l] != S[r]:
        count += 1
    l += 1
    r -= 1

print(count)

Solution (Python):
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("YES") if fl else print("NO")
import collections
import math
import itertools
import heapq as hq

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

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

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

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

si=s[::-1]

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


print(ne//2)

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

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

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