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

cn = 0

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

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

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

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
def input():
    return sys.stdin.readline()[:-1]

S = list(input())

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

Solution (Python):
s = input()

num = 0
for i, j in zip(s, s[::-1]):
    if i != j:
        num += 1

print(num // 2)

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 permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
from bisect import bisect

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

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

Solution (Python):
def read_valus():
    return map(int, input().split())


def read_list():
    return list(read_valus())


def read_lists(N):
    return [read_list() for n in range(N)]


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


if __name__ == "__main__":
    main()

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

else:
    head = s[0:len(s) // 2]
    tail = list(reversed(s[len(s) // 2 + 1:]))
    for i in range(len(head)):
        if head[i] != tail[i]:
            ans += 1
    print(ans)

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

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

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

    res = 0
    for s, r in zip(S, S[::-1]):
        if s != r:
            res += 1
    print(res//2)

main()

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

Solution (Python):
S = input()


rs = reversed(S)


result = 0
for i, char in enumerate(rs):
    if S[i] != char:
        result += 1

print(int(result/2))

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush
from fractions import gcd
from copy import deepcopy
import math
import queue


Mod = 1000000007
import sys

sys.setrecursionlimit(100000) 
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

def factorial(i):
    if i == 1:
        return 1
    else:
        return i*factorial(i-1)
 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)




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

if __name__ == "__main__":
    main()

Solution (Python):
if __name__ == "__main__":
	S = input()
	count = 0
	for i in range(0, len(S) // 2):
		if S[i] != S[len(S) - 1 - i]:
			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()
leng=len(S)
cnt=0

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

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

import math

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

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

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

Solution (Python):
def examB():
    S = SI(); N =len(S)
    ans = N//2
    for i in range(N//2):
        if S[i]==S[N-1-i]:
            ans -=1
    print(ans)
    return

def examC():
    return

def examD():
    return

def examE():
    return

def examF():
    return

import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

if __name__ == '__main__':
    examB()

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

s = 0
for i in range(le // 2):
    s += S[i] != S[le - 1 - i]

print(s)

Solution (Python):
S = input()

N = len(S)//2

ans = 0

for i in range(N):
    if not S[i] == S[len(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[-(i+1)]:
        pass
    else:
        ans += 1
print(ans)

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

Solution (Python):
def main():
    S = input()
    N = len(S)
    ans = 0
    if N & 1:
        for s, t in zip(S[:(N//2)], S[(N//2)+1:][::-1]):
            if s != t:
                ans += 1
    else:
        for s, t in zip(S[:(N//2)], S[(N//2):][::-1]):
            if s != t:
                ans += 1

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
s = input()
sr = s[::-1]
hugs = sum(1 for c, cr in zip(s, sr) if c != cr) // 2
print(hugs)

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

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

if len(S)%2 == 0:
    print(ans//2)
else:
    print(ans//2+ans%2)

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

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

print(int(ans/2))

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

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

print(c)

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

S = readline().rstrip()

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

print(ans)

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

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

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

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

print(ans)

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

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

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

print(hug)

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


def solve(S: str):
    res = 0
    n = len(S)
    for i in range(n // 2):
        if S[i] == S[-1-i]:
            continue
        res += 1
    print(res)
    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):
from sys import stdout
printn = lambda x: stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True 
BIG = 999999999
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

Solution (Python):
ls=list(input())
count=0
for i,s in enumerate(ls):
    if ls[i]!=ls[-1-i]:
        ls[-1-i]=ls[i]
        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):
a=input()
n=int(len(a)//2)
m=len(a)
ans=0
for i in range(n):
    if a[i]!=a[m-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=input()
ls2=int(len(S)/2)
ans=0
for i in range(ls2):
    if S[i]!=S[len(S)-1-i]:
        ans+=1
print(ans)

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

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

Solution (Python):
import sys

inf = float("inf")


def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()

string = input()
length = len(string)
count = 0
for i in range(length//2):
    if string[i]!=string[~i]:
        count+=1
print(count)

Solution (Python):
S = input()

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

Solution (Python):

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

Solution (Python):
from sys import stdin

s = stdin.readline().rstrip()
point = 0
si = s[::-1]
for i in range(len(s)):
    if s[i] != si[i]:
        point += 1
print(point//2)

Solution (Python):

import sys
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = lambda *something : print(*something) if DEBUG else 0
DEBUG = False
def main(given = sys.stdin.readline):
    input = lambda : given().rstrip()
    LMIIS = lambda : list(map(int,input().split()))
    II = lambda : int(input())
    XLMIIS = lambda x : [LMIIS() for _ in range(x)]

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

print(ans)

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

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

Solution (Python):
S = input()

length = len(S)

ans = 0

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

print(ans)

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

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

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):
a = input()
b = "".join(reversed(a))
n = len(a)
cnt = 0

for x in range(n//2):
    if a[x] != b[x]:
        cnt += 1

print(cnt)

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

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

Solution (Python):


s = list(input())
ans = 0
a = s
b = s[::-1]

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

ans = (ans)//2
print(ans)

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

ans = 0

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

print(ans)

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

print(ans)

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

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

print(count//2)

Solution (Python):
s =  input()

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

Solution (Python):
S = input()

ans = 0

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

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

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

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

Sum = 0

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

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

Solution (Python):
S = input()

l = 0
r = len(S) - 1
answer = 0

while l < r:
    if S[l] != S[r]:
        answer += 1
    l += 1
    r -= 1

print(answer)

Solution (Python):


S=list(input())
Sr=S[::-1]

ans=0
for i in range(-(-len(S)//2)):
    if S[i]!=Sr[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 = input()

l = len(S)

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

print(cnt)

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

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

resolve()

Solution (Python):
import math

def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    
    return divisors



s = input()
n = len(s)

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

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
s=input()
if len(s)%2==0:
    ans=0
    for i in range(len(s)//2):
        if s[i]!=s[-1-i]:
            ans+=1
    print(ans)
else:
    ans=0
    for i in range(len(s)//2):
        if s[i]!=s[-1-i]:
            ans+=1
        
    print(ans)

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

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 s1, s2 in zip(S, reversed(S)):
    ans += s1 != s2
print(ans // 2)

Solution (Python):

from collections import defaultdict


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


def main():
	S = list(input())
	N = int(len(S) // 2)

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

if __name__ == '__main__':
	main()

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

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

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

Solution (Python):
s = input().strip()

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

print(ret)

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):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  s=list(S())

  a=s[:len(s)//2]
  if len(s)%2==0:
    b=s[len(s)//2:]
  else:
    b=s[len(s)//2+1:]

  
  

  ans=0
  a.reverse()

  for i in range(len(s)//2):
    x=a[i]
    y=b[i]

    if x!=y:
      ans+=1

  return ans


print(main())

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

print(int(cnt/2))

Solution (Python):
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))



def main():
    s = list(input())
    sl = list(reversed(s))
    n = len(s)
    cnt = 0
    for i in range(n):
        if s[i] == sl[i]:
            cnt+=1
    
    ans = (n-cnt)//2
    print(ans)

main()

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


def main():
    S = input().strip()

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

    print(ans)



if __name__ == '__main__':
    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()
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()
n = len(s)
ans = 0

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

print(ans)

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

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

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

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

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

print(cnt // 2)

Solution (Python):
ans = 0
s = input()
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 = input()

l = len(s)

ans = 0

a = l // 2

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

print(ans)

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

h = len(S) // 2

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

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

Solution (Python):
import math
import queue
import bisect
import heapq
import time
import itertools

mod = 1e9+7

def swap(a,b):
    return (b,a)

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

def divisors(a): 
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def is_prime(a): 
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): 
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

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

if __name__=='__main__':
    main()

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False
"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

a = list(input())

count = 0

if len(a) % 2 == 0:
    kkk = len(a)//2
    for i in range(len(a)//2):
        if a[kkk+i] != a[kkk-(i+1)]:
            count += 1
else:
    kkk = len(a)//2+1
    for i in range(len(a)//2):
        if a[kkk+i] != a[kkk-(i+2)]:
            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):
import sys
input = sys.stdin.readline


def main():
    S = input().strip()
    ans = 0
    for i in range(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):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    s = S()
    cnt = 0
    for i in range(len(s)):
        if i >= len(s)//2:
            break
        if s[i] != s[len(s)-1-i]:
            cnt += 1
    print(cnt)

main()

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

Solution (Python):
s = input()

loopnum = len(s)//2
out = 0

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

Solution (Python):
def main():
    s = list(input())
    lenth = len(s)
    ans = 0
    for i in range(lenth//2):
        if s[i]==s[len(s)-1-i]:
            pass
        else:
            ans+=1
    print(ans)
if __name__ == "__main__":
    main()

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

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys
import bisect

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

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

S = str(input())

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

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



def num_operations(s):
    res = sum(c != d for c, d in zip(s, s[::-1])) // 2
    return res


def main():
    s = input()
    res = num_operations(s)
    print(res)


if __name__ == "__main__":
    main()

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

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

l = len(S)

hug = 0

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

print(hug // 2)

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

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

Solution (Python):
s = input()
i = 0
j = len(s) - 1
c = 0

while i < j:
	if s[i] != s[j]:
		c += 1
		
	i += 1
	j -= 1
	
print(c)

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

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

cnt = 0
N = len(S)
skip = set()
for i in range(len(S)):
    if i not in skip and S[i] != S[N - 1 - i]:
        cnt += 1
        skip.add(N-1-i)

print(cnt)

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

Solution (Python):
s=input().rstrip()
x=list(s)
i=0;
O=0;
j=len(x)-1;
while(i<j):
    if x[i]!=x[j]:
        O+=1;
    i+=1;
    j-=1;
print(O)

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)

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

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

print(num)

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

Solution (Python):
import numpy as np
S = np.array(list(input()))
T = S[::-1]

print(np.count_nonzero(S != T) // 2)

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