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):
import sys
from math import ceil, floor, sqrt, sin, cos, pi
from itertools import accumulate, permutations, combinations
from fractions import gcd 
from collections import deque, Counter
from operator import itemgetter
from heapq import heappop,heappush
sys.setrecursionlimit(10**7)
def lcm(x, y): return ((x * y) // gcd(x, y)) 


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

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

ans=0
n=len(S)

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

print(ans)

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

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

print(ans)

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

Solution (Python):
s = input()
t = s[::-1]
res = 0
for ss, tt in zip(s, t):
    if ss != tt:
        res += 1
res //= 2
print(res)

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

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

Solution (Python):
S = input()

ret = 0

n = len(S)//2 + len(S)%2

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

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):
N=list(input())
L=int(len(N)/2)
count=0

for i in range(L):
    if N[i]==N[len(N)-(i+1)]:
        count+=1


print(L-count)

Solution (Python):
s = input()
num = int(len(s) / 2)
ans = 0

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

Solution (Python):


S = input()
s_str = list(S)
s_rev = s_str[::-1]

num = len(s_str)

j = 0
for i in range(num):
  if (s_str[i] == s_rev[i]):
    pass
  else:
    j = j + 1

print (int(j/2))

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

print(cnt)

Solution (Python):

S = input()

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

if length % 2 == 0:
    tail = S[half:]
else:
    tmp = half + 1
    tail = S[tmp:]

tail = tail[::-1]

count = 0
for i in range(half):
    if head[i] != tail[i]:
        count += 1

print(count)

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

Solution (Python):
s=input()
c=0
for n,r in zip(s[:len(s)//2],s[::-1]):
    if not n==r:
        c+=1
print(c)

Solution (Python):
S = input()

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

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):
import sys
from bisect import bisect_right as bsr
from collections import Counter as cnt
from collections import defaultdict as dd
from collections import deque
from fractions import gcd
from itertools import permutations as perm
from math import ceil, factorial, floor
from operator import itemgetter as ig

sys.setrecursionlimit(1000000)


args = None
INF = float("inf")
MOD = int(1e9 + 7)


def input(*ps):
    if type(ps[0]) is list:
        return [input(*ps[0][:-1]) for _ in range(ps[0][-1])]
    elif len(ps) == 1:
        return ps[0](next(args))
    else:
        return [p(next(args)) for p in ps]


def yesno(v, yes="Yes", no="No", upper=False):
    if upper:
        print([yes.upper(), no.upper()][not v])
    else:
        print([yes, no][not v])


def main():
    """エントリーポイント"""
    S = input(str)
    n = ceil(len(S) / 2) + 1
    ans = 0
    for x, y in zip(S[:n], S[:-n:-1]):
        ans += 1 if not x == y else 0
    print(ans)


if __name__ == '__main__':
    args = iter(sys.stdin.read().split())
    main()

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

print(cnt)

Solution (Python):
import math
b = input()
c = 0
for i in range(math.floor(int(len(b)/2))):
   if(b[i] != b[-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):
s = input()
n = len(s)
cnt = 0
for i in range(n//2):
    if s[i] == s[n-i-1]:
        continue
    cnt += 1
print(cnt)

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

Solution (Python):
S = str(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] != s[len(s)-1-i]:
        ans += 1

print(int(ans/2))

Solution (Python):
s = input()

r = s[::-1]
hug = 0
if len(s) % 2 == 0:
    mid = int(len(s)/2)
else:
    mid = int((len(s) - 1)/2)

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

print(hug)

Solution (Python):
s = list(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 math

s = input()

firstHalf = s[:math.floor(len(s) / 2)]
reversedSecondHalf = s[math.ceil(len(s) / 2):][::-1]

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

print(ans)

Solution (Python):

s = input()
s = list(s)
r = list(reversed(s))
l = len(s) // 2

count = 0
for i in range(l):
  if s[i] != r[i]:
    count += 1

print(count)

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

Solution (Python):
def q2():
    s = input()
    d,m = divmod(len(s), 2)
    s_a = s[:d]
    s_b = ''.join(reversed(s[d+m:]))
    ans = 0
    
    for i in range(d):
        if s_a[i] != s_b[i]:
            ans += 1
    print(ans)


if __name__ == '__main__':
    q2()

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

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

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

print(ans)

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

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

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):
def main():
    S = input()
    if len(S) % 2 == 0:
        l = S[:len(S)//2]
        r = S[len(S)//2:]
    else:
        l = S[:len(S)//2]
        r = S[len(S)//2 + 1:]
    r = r[::-1]
    count = 0
    for i in range(len(r)):
        if l[i] != r[i]:
            count += 1
    print(count)
main()

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

Solution (Python):
S = input()
S_re = S[::-1]
cnt = 0

for s, r in zip(S, S_re):
    if s!=r:
        cnt += 1
print(int(cnt/2))

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

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

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

n = len // 2
ans = 0

for i in range(n):
  k = (i+1) * (-1)
  if S[i] != S[k]:
    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):
string = str(input())
rev = string[::-1]
cnt=0
for i in range(len(string)//2):
	if string[i]!=rev[i]:
		cnt+=1
print(cnt)

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

Solution (Python):
S = input()
T = S[::-1]
count = 0
N = len(S)
if N % 2 == 0:
    A = int(N / 2)
else:
    A = int((N-1) / 2)

for i in range(A):
    if S[i] == T[i]:
        pass
    else:
        count += 1

print(count)

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

Solution (Python):
s = list(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):
class PalindromePhilia:
    def calculate(self, list):
        counter = 0
        n = 0
        length =len(list)
        div = length // 2
        for d in range(div):
            if list[d] != list[length - n -1]:
                counter +=1
            n += 1
        return counter

if __name__ == "__main__":
    A = input()
    list_num = [a for a in A]
    pp = PalindromePhilia()
    result = pp.calculate(list_num)
    print(str(result))

Solution (Python):
s = input()

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

Solution (Python):
import math
import fractions
import sys

def input1():
	return str(input())


def input2():
	return map(int,input().split())


def input_array():
	return list(map(str,input().split()))


s=list(str(input()))
len_s=len(s)
count=0
for i in range(len_s):
	if s[i]!=s[-(i+1)]:
		s[i]=s[-(i+1)]
		count+=1
	else:
		continue
print(count)

Solution (Python):
s = 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):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
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()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

S = input()
T = S[::-1]

cnt = 0

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

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

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

print(count)

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

print(counter)

Solution (Python):
s=input()
a=[str(c) for c in s]
m=len(a)
l=len(a)//2 

n=0
for i in range(l):
  if a[i]!=a[m-1-i]:
    n+=1
    
print(str(n))

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

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

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

Solution (Python):

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

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

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

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

Solution (Python):

import sys
import numpy as np


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

    print(h)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = next(tokens)  
    solve(S)

if __name__ == '__main__':
    main()

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 = list(input())
ans = 0
for a,b in zip(s,s[::-1]):
    if a != b:
        ans += 1
print(ans//2)

Solution (Python):
s=input()
s_rev=str()
for i in range(1,len(s)+1):
    s_rev+=s[-i]

count=0
for i in range(len(s)//2):
    if s[i]!=s_rev[i]:
        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):
S = input()
s = list(S)
num = len(s)

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

Solution (Python):
S = input()

def check(word):
    if word == word[::-1]:
        return True
    else:
        return False

count = 0

w1 = S[:len(S)//2]
w2 = S[:len(S)//2-1:-1]

for a,b in zip(w1,w2):
    if a != b:
        count += 1

print(count)

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

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()
l = len(s)
half = l // 2
ans = 0
for x,y in zip(s[:half],s[-1:half-1:-1]):
    if x != y:
        ans += 1
print(ans)

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

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

Solution (Python):
s = input()
s_len = len(s)
dum1 = s_len//2
count = 0
for i in range(dum1):
  if s[i] != s[-(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):
s = input()

ans = 0
i = 0
j = len(s)-1
while i <= j:
    if s[i] != s[j]:
        ans += 1
    i += 1
    j -= 1

print(ans)

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

Solution (Python):
S=input()

l=[]
i=0
if len(S)%2==0:
    for n in range(len(S)//2):
        l.append(S[n])
    for n in range(len(S)//2,len(S)):
        a=l.pop()
        if S[n]!=a:
            i+=1
    print(i)

else:
    for n in range(len(S)//2):
        l.append(S[n])
    for n in range(len(S)//2+1,len(S)):
        a=l.pop()
        if S[n]!=a:
            i+=1
    print(i)

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

Solution (Python):
S = input()

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

Solution (Python):
import sys


def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())

def LI(): return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]

def SR(): return sys.stdin.readline().rstrip()


p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))


s=input()

change=len(s)//2
ans=0

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

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

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

l = len(S) // 2

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

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 main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby
    
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

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

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):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby
    
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

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



if __name__ == '__main__':
    main()

Solution (Python):
S = input()

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

Solution (Python):
S = input()
a = len(S)
A = a // 2
T = S[::-1]
B = S[0:A]
C = T[0:A]

x = 0
count = 0
for b in B:
    if b != C[x]:
        count += 1
    x += 1
    
print(count)

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

Solution (Python):
S = input()

length = len(S)
count = 0

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

count = count // 2

print(count)

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

if len(s)%2!=0:
  point = int((len(s)-1)/2)
  count = 0
  for i in range(0,int((len(s)-1)/2+1)):
    if s[point-i]!=s[point+i]:
      count += 1
  print(count)
  exit()
elif len(s)%2==0:
  point1 = int(len(s)/2-1)
  point2 = int(len(s)/2)
  count = 0
  for i in range(0,int(len(s)/2)):
    if s[point1-i]!=s[point2+i]:
      count += 1
  print(count)

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

h=int(len(s)/2)

cnt=0

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

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

print(ans)

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

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

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

count = 0

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

print(count)

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

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

Solution (Python):

s = list(input())

former = s[:(len(s)//2)]
latter = s[(len(s)-len(s)//2):]
latter.reverse()

print(sum([former[i]!=latter[i] for i in range(len(former))]))

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

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

Solution (Python):
from sys import stdin

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()
S_list = [i for i in S] 
S_rev =S_list[::-1]


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

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

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

Solution (Python):


import sys














def main():
    mod = 10000007                  
    inf = float('inf')
    input = sys.stdin.readline      
    sys.setrecursionlimit(10**6)    
    def ii():  return int(input())
    def mi():  return map(int, input().rstrip().split())
    def lmi(): return list(map(int, input().rstrip().split()))
    def li():  return list(input().rstrip())
    
    
    s = input().rstrip()
    count = 0
    for i in range(len(s)//2):
        if s[i]!=s[len(s)-1-i]:
            count += 1
    print(count)

if __name__ == "__main__":
    main()

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

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

Solution (Python):
S = input()

half_len = len(S) // 2

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

print(count)

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

Solution (Python):
s = input()

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

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

Solution (Python):
a=list(str(input()))

b=list(reversed(a))

count=0
for i in range(len(a)):
  if a[i]!=b[i]:
    count+=1

print(-(-count//2))

Solution (Python):
S = input()

half = int(len(S) / 2)
S1 = S[:half]
S2 = S[::-1][:half]

count = 0
for s1, s2 in zip(S1, S2):
    if s1 != s2: count += 1

print(count)

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

Solution (Python):
import sys
import os

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A = iss()
    print(sum(A[i] != A[-i - 1] for i in range(len(A) // 2)))


if __name__ == '__main__':
    main()

Solution (Python):
import sys
import os

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A = iss()
    l, r = A[:len(A) // 2], A[len(A) // 2:]
    r = r[::-1]
    ans = 0
    for n in range(len(l)):
        if l[n] != r[n]:
            ans += 1

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
S = input()
rS = "".join([S[-i] for i in range(1,len(S)+1) ])

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

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

Solution (Python):
import sys
input = sys.stdin.readline
from collections import Counter, deque

INF = float('inf')


def main():
    S = input().rstrip()
    length = len(S)
    S_left = S[:length // 2]
    S_right = S[length // 2:][::-1]

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


if __name__ == '__main__':
    main()

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

Solution (Python):
import math
a= input()
length=math.floor(len(a)/2)
count = 0
for i in range(length):
    if a[i] is not a[-1*i -1]:
        count += 1
        
print(count)

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

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

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

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

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

Solution (Python):
S=list(input());c=i=0
while i<len(S):c+=1*(S[i]!=S[-i-1]);i+=1
print(c//2)

Solution (Python):
def kai(a):
    return a==a[::-1]
s=input()
x=0
if kai(s)==False:
    for i in range(len(s)//2):
        if s[i]!=s[-1-i]:
            x+=1
            for j in range(25):
                s[i]==chr(97+j)
print(x)

Solution (Python):
def kai(a):
    return a==a[::-1]
s=input()
x=0
if kai(s)==False:
    for i in range(len(s)):
        if s[i]!=s[-1-i]:
            x+=1
            for j in range(25):
                s[i]==chr(97+j)
                if s==s[::-1]:
                    break
print(x//2)

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

Solution (Python):




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

    count = 0

    for s1, s2 in zip(S, Sr):
        if s1 != s2:
            count += 1
    
    print(count // 2)


if __name__ == '__main__':
    main()

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

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

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

length = len(s)
length //= 2

count = 0

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

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

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

n = list(reversed(s))

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