input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
_ = eval(input())
seq = list(map(int,input().split()))
seq1 = seq[::2]
seq2 = seq[1::2]
if len(set(seq)) == 1:
print((min(len(seq1),len(seq2))))
exit()
def count_dictonary(seq):
ret_dict={}
for item in seq:
if item not in ret_dict:
ret_dict[item] = 1
else:
ret_dict[item]+=1
return ret_dict
seq_dict1 = sorted(list(count_dictonary(seq1).items()),key=lambda x:x[1],reverse=True)
seq_dict2 = sorted(list(count_dictonary(seq2).items()),key=lambda x:x[1],reverse=True)
min_change=len(seq)
for i1, count1 in seq_dict1:
ch1 = len(seq1) - count1
if ch1 > min_change:
continue
for i2, count2 in seq_dict2:
ch2 = len(seq2) - count2
#print(i1,i2,ch1,ch2,ch1+ch2)
change_ = ch1+ch2
if(min_change > ch1+ch2):
min_change = ch1+ch2
print(min_change) | _ = eval(input())
seq = list(map(int,input().split()))
seq1 = seq[::2]
seq2 = seq[1::2]
if len(set(seq)) == 1:
print((len(seq2)))
exit()
def count_dictonary(seq):
ret_dict={}
for item in seq:
if item not in ret_dict:
ret_dict[item] = 1
else:
ret_dict[item]+=1
return ret_dict
def modes(counting_dict):
#(11,2),(2,1),(3,3)
ret={}
for item in list(counting_dict.items()):
no, count = item
if counting_dict[no] in ret:
ret[count].append(no)
else:
ret[count]=[no]
return ret
counting1 = count_dictonary(seq1)
counting2 = count_dictonary(seq2)
modes1 = sorted(list(modes(counting1).items()),reverse=True)
modes2 = sorted(list(modes(counting2).items()),reverse=True)
min_change=len(seq)
if modes1[0][1] != modes2[0][1] or len(modes1[0][1]) >=2 or len(modes2[0][1]) >=2:
min_change = (len(seq1) - modes1[0][0]) + (len(seq2) - modes2[0][0])
else:
m01=len(seq)
m10=len(seq)
if len(modes2) !=1:
m01 = (len(seq1) - modes1[0][0]) + (len(seq2) - modes2[1][0])
if len(modes1) !=1:
m10 = (len(seq1) - modes1[1][0]) + (len(seq2) - modes2[0][0])
min_change = min(m01,m10)
print(min_change) | p03244 |
_ = eval(input())
seq = list(map(int,input().split()))
seq1 = seq[::2]
seq2 = seq[1::2]
if len(set(seq)) == 1:
print((len(seq2)))
exit()
def count_dictonary(seq):
ret_dict={}
for item in seq:
if item not in ret_dict:
ret_dict[item] = 1
else:
ret_dict[item]+=1
return ret_dict
def modes(counting_dict):
#(11,2),(2,1),(3,3)
ret={}
for item in list(counting_dict.items()):
no, count = item
if counting_dict[no] in ret:
ret[count].append(no)
else:
ret[count]=[no]
return ret
counting1 = count_dictonary(seq1)
counting2 = count_dictonary(seq2)
modes1 = sorted(list(modes(counting1).items()),reverse=True)
modes2 = sorted(list(modes(counting2).items()),reverse=True)
min_change=len(seq)
if modes1[0][1] != modes2[0][1] or len(modes1[0][1]) >=2 or len(modes2[0][1]) >=2:
min_change = (len(seq1) - modes1[0][0]) + (len(seq2) - modes2[0][0])
else:
m01=len(seq)
m10=len(seq)
if len(modes2) !=1:
m01 = (len(seq1) - modes1[0][0]) + (len(seq2) - modes2[1][0])
if len(modes1) !=1:
m10 = (len(seq1) - modes1[1][0]) + (len(seq2) - modes2[0][0])
min_change = min(m01,m10)
print(min_change) | def count_char_occurrence(seq):
# count how many times characters occur and return results as a dictionary
ret = {}
for char in seq:
if char in ret:
ret[char] += 1
else:
ret[char] = 1
return ret
def accum_char_frequency(seq):
"""
accumulate frequency of each number in a inputted sequence
Example:
in: [a,a,a,a,b,b,b,b,c]
out: { 4 times: [a,b] , 1 times: [c] }
"""
frequencies = count_char_occurrence(seq)
ret = {}
for char, count in list(frequencies.items()):
if count in ret:
ret[count].append(char)
else:
ret[count] = [char]
return ret
def main():
_ = eval(input())
seq = list(map(int, input().split()))
odd = seq[::2]
even = seq[1::2]
if len(set(seq)) == 1: # when all chars are unique, return the length of even numbered chars
print((len(even)))
return
no_freq_odd = accum_char_frequency(odd)
freq_odd = sorted(list(no_freq_odd.items()), reverse=True)
no_freq_even = accum_char_frequency(even)
freq_even = sorted(list(no_freq_even.items()), reverse=True)
if len(freq_odd[0][1]) == 1 and len(freq_even[0][1]) == 1 and freq_odd[0][1] == freq_even[0][1]:
min_change_even = len(seq)
if len(freq_even) != 1:
min_change_even = (len(odd) - freq_odd[0][0]) + (len(even) - freq_even[1][0])
min_change_odd = len(seq)
if len(freq_odd) != 1:
min_change_odd = (len(odd) - freq_odd[1][0]) + (len(even) - freq_even[0][0])
print((min(min_change_even, min_change_odd)))
return
else:
min_change = (len(odd) - freq_odd[0][0]) + (len(even) - freq_even[0][0])
print(min_change)
return
main() | p03244 |
# coding: utf-8
# hello worldと表示する
#dpでできないかな？
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi
from operator import itemgetter
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(input())) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print(('\n'.join(x)))
def printni(x): print(('\n'.join(list(map(str,x)))))
inf = 10**17
mod = 10**9 + 7
n=I()
lis=LI()
ev,od=[],[]
for i in range(n):
if i%2==0:
ev.append(lis[i])
else:
od.append(lis[i])
c=Counter(ev)
d=Counter(od)
#print(c.most_common()[0][1])
#-c.most_common()[0]-d.most_common()[0]
if c.most_common()[0][0]==d.most_common()[0][0]:
if c.most_common()[0][1]==n//2:
ans=n//2
elif c.most_common()[1][1]>=d.most_common()[1][1]:
ans=len(od)-d.most_common()[0][1]+len(ev)-c.most_common()[1][1]
elif c.most_common()[1][1]<d.most_common()[1][1]:
ans=len(od)-c.most_common()[0][1]+len(ev)-d.most_common()[1][1]
else:
ans=len(ev)+len(od)-c.most_common()[0][1]-d.most_common()[0][1]
print(ans) | # coding: utf-8
# hello worldと表示する
#float型を許すな
#numpyはpythonで
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(input())) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print(('\n'.join(x)))
def printni(x): print(('\n'.join(list(map(str,x)))))
inf = 10**17
mod = 10**9 + 7
n=I()//2
lis=LI()
lis1=[]
lis2=[]
for i in range(n):
lis1.append(lis[2*i])
lis2.append(lis[2*i+1])
x=Counter(lis1).most_common(2)
y=Counter(lis2).most_common(2)
#print(x)
#print(y)
if len(x)==1:
x.append((0,0))
if len(y)==1:
y.append((-1,0))
#print(x)
#print(y)
if x[0][0]!=y[0][0]:
print((2*n-x[0][1]-y[0][1]))
else:
cands=[]
#print(2*n-x[0][1]-y[1][]))
if x[1][0]!=y[0][0]:
cands.append(2*n-x[1][1]-y[0][1])
if x[0][0]!=y[1][0]:
cands.append(2*n-x[0][1]-y[1][1])
if x[1][0]!=y[1][0]:
cands.append(2*n-x[1][1]-y[1][1])
print((min(cands)))
| p03244 |
import collections
n = int(eval(input()))
odd = []
even = []
for i, j in enumerate(map(int, input().split())):
if i % 2 == 0:
even += [j]
else:
odd += [j]
odd = sorted(list(collections.Counter(odd).items()), reverse=True, key=lambda x: x[1])
even = sorted(list(collections.Counter(even).items()), reverse=True, key=lambda x: x[1])
if len(odd) == 1 and len(even) == 1 and odd[0][0] == even[0][0]:
print((n // 2))
elif odd[0][0] == even[0][0]:
if odd[0][1] == even[0][1]:
for i in range(2):
if odd[i][1] == even[i][1]:
continue
elif odd[i][1] > even[i][1]:
print(((n // 2 - odd[1][1]) + (n // 2 - even[0][1])))
break
elif odd[i][1] < even[i][1]:
print(((n // 2 - odd[0][1]) + (n // 2 - even[1][1])))
break
else:
print(((n // 2 - odd[0][1]) + (n // 2 - even[1][1])))
else:
print(((n // 2 - odd[0][1]) + (n // 2 - even[0][1])))
| import collections
n = int(eval(input()))
odd = []
even = []
for i,j in enumerate(map(int,input().split())):
if i % 2 == 0:
even += [j]
else:
odd += [j]
odd = sorted(list(collections.Counter(odd).items()),key=lambda x:(x[1]),reverse=True)
even = sorted(list(collections.Counter(even).items()),key=lambda x:(x[1]),reverse=True)
if len(odd) == 1 and len(even) == 1:
if odd[0][0] == even[0][0]:
print((n//2))
exit()
else:
print((0))
exit()
if odd[0][0] == even[0][0]:
if len(odd) >= 2 and len(even) >= 2:
if odd[0][1] + even[1][1] > odd[1][1] + even[0][1]:
print(((n//2 - odd[0][1]) + (n//2 - even[1][1])))
else:
print(((n//2 - odd[1][1]) + (n//2 - even[0][1])))
else:
if len(odd) == 1:
print(((n//2 - odd[0][1]) + (n//2 - even[1][1])))
else:
print(((n//2 - odd[1][1]) + (n//2 - even[0][1])))
else:
print(((n//2 - odd[0][1]) + (n//2 - even[0][1]))) | p03244 |
def main():
from collections import Counter
n = int(eval(input()))
V = list(map(int,input().split()))
odds = []
evens = []
for i,v in enumerate(V):
if i & 1:
evens.append(v)
else:
odds.append(v)
odds_counter = list(Counter(odds).items())
eves_counter = list(Counter(evens).items())
odds_counter.sort(reverse=True, key= lambda x: x[1])
eves_counter.sort(reverse=True, key= lambda x: x[1])
if odds_counter[0][0] != eves_counter[0][0]:
print((len(odds)- odds_counter[0][1] + len(evens) - eves_counter[0][1]))
else:
odds_counter.append((-1,0))
eves_counter.append((-1,0))
print((
min(
len(odds)-odds_counter[0][1] + len(evens) - eves_counter[1][1],
len(odds)-odds_counter[1][1] + len(evens) - eves_counter[0][1],
)
))
main() | def main():
from collections import Counter
n = int(eval(input()))
V = list(map(int,input().split()))
odds = []
evens = []
for i,v in enumerate(V):
if i & 1:
evens.append(v)
else:
odds.append(v)
odds_modes= Counter(odds).most_common(2)
evens_modes = Counter(evens).most_common(2)
if odds_modes[0][0] != evens_modes[0][0]:
print((len(odds)- odds_modes[0][1] + len(evens) - evens_modes[0][1]))
else:
odds_modes.append((-1,0))
evens_modes.append((-1,0))
print((
min(
len(odds)-odds_modes[0][1] + len(evens) - evens_modes[1][1],
len(odds)-odds_modes[1][1] + len(evens) - evens_modes[0][1],
)
))
main() | p03244 |
n = int(eval(input()))
v = list(map(int, input().split()))
v1 = v[0::2]
v2 = v[1::2]
m1, m2 = {}, {}
for vi in v1:
if vi in m1:
m1[vi] += 1
else:
m1[vi] = 1
for vi in v2:
c = m2[vi] if vi in m2 else 0
m2[vi] = c + 1
p1 = [(k, m1[k]) for k in list(m1.keys())]
p2 = [(k, m2[k]) for k in list(m2.keys())]
p1.sort(key=lambda x: x[1], reverse=True)
p2.sort(key=lambda x: x[1], reverse=True)
if n == 2:
if v1[0] == v2[0]:
ans = 1
else:
ans = 0
else:
if p1[0][0] == p2[0][0]:
if p1[0][1] < p2[0][1]:
ans = n - p2[0][1] - p1[1][1]
elif p1[0][1] > p2[0][1]:
ans = n - p1[0][1] - p2[1][1]
else:
h = p1[0][1]
if len(p1) == 1:
ans = n - h
else:
if p1[1][1] < p2[1][1]:
ans = n - h - p2[1][1]
else:
ans = n - h - p1[1][1]
else:
ans = n - p1[0][1] - p2[0][1]
print(ans)
| n = int(eval(input()))
v = list(map(int, input().split()))
va = v[0::2]
vb = v[1::2]
ma, mb = {None: 0}, {None: 0}
for vi in va:
c = ma[vi] if vi in ma else 0
ma[vi] = c + 1
for vi in vb:
c = mb[vi] if vi in mb else 0
mb[vi] = c + 1
# items() is [(k, m[k]) for k in m.keys()]
pa = list(ma.items())
pb = list(mb.items())
pa.sort(key=lambda x: x[1], reverse=True)
pb.sort(key=lambda x: x[1], reverse=True)
if pa[0][0] == pb[0][0]:
if pa[0][1] < pb[0][1]:
ans = n - pa[1][1] - pb[0][1]
elif pa[0][1] > pb[0][1]:
ans = n - pa[0][1] - pb[1][1]
else:
h = pa[0][1]
if pa[1][1] < pb[1][1]:
ans = n - h - pb[1][1]
else:
ans = n - h - pa[1][1]
else:
ans = n - pa[0][1] - pb[0][1]
print(ans)
| p03244 |
from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
odd = v[::2]
even = v[1::2]
c_even = Counter(even).most_common(2)
c_odd = Counter(odd).most_common(2)
if(c_even[0][0] != c_odd[0][0]):
print((n - c_even[0][1] - c_odd[0][1]))
else:
if(len(c_even) == 1):
print((n//2))
else:
# second = max[c_even[1][1], c_odd[1][1]]
# print(n - c_even[0][1] - second)
print((n - max(c_even[0][1] + c_odd[1][1], c_even[1][1] + c_odd[0][1]))) | from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
odd = v[::2]
even = v[1::2]
c_even = Counter(even).most_common(2)
c_odd = Counter(odd).most_common(2)
if(c_even[0][0] != c_odd[0][0]):
print((n - c_even[0][1] - c_odd[0][1]))
else:
if(len(c_even) == 1):
print((n//2))
else:
# second = max[c_even[1][1], c_odd[1][1]]
# print(n - c_even[0][1] - second)
print((n - max(c_odd[1][1], c_even[1][1]) - c_even[0][1])) | p03244 |
# ABC111C - /\/\/\/
from collections import Counter
def main():
N, *V = list(map(int, open(0).read().split()))
even, odd = Counter(V[::2]).most_common(2), Counter(V[1::2]).most_common(2)
if even[0][0] != odd[0][0]: # replace except the modes of both parities
ans = N - even[0][1] - odd[0][1]
else:
if len(even) == 1 or len(odd) == 1:
ans = N // 2 # replace half of the sequence
else: # replace smaller pair of even no.1 & odd 2 / even 2 & odd 1
ans = N - max(even[0][1] + odd[1][1], even[1][1] + odd[0][1])
print(ans)
if __name__ == "__main__":
main() | # ABC111C - /\/\/\/
from collections import Counter
def main():
N, *V = open(0).read().split()
N = int(N)
even, odd = Counter(V[::2]).most_common(2), Counter(V[1::2]).most_common(2)
if even[0][0] != odd[0][0]: # replace except the modes of both parities
ans = N - even[0][1] - odd[0][1]
else:
if len(even) == 1 or len(odd) == 1:
ans = N // 2 # replace half of the sequence
else: # replace smaller pair of even no.1 & odd 2 / even 2 & odd 1
ans = N - max(even[0][1] + odd[1][1], even[1][1] + odd[0][1])
print(ans)
if __name__ == "__main__":
main() | p03244 |
def main():
n = int(eval(input()))
v = input_list()
evens = []
odds = []
vs = v[:]
kind = len(set(vs))
if kind == 1:
print((n//2))
exit(0)
for i, vv in enumerate(v):
if i % 2 == 0:
evens.append(vv)
else:
odds.append(vv)
ec = collections.Counter(evens)
oc = collections.Counter(odds)
m = n//2
ans = 0
em = ec.most_common()
om = oc.most_common()
if em[0][0] == om[0][0]:
p1 = m-em[0][1] + m-om[1][1]
p2 = m-em[1][1] + m-om[0][1]
print((min(p1,p2)))
else:
print((m-em[0][1] + m-om[0][1]))
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
def gcd(*numbers):
return reduce(fractions.gcd, numbers)
def gcd_list(numbers):
return reduce(fractions.gcd, numbers)
# 2で割り切れる回数
def divide_two(arg):
c = 0
while True:
if c >= 2:
break
if arg % 2 != 0:
break
arg //= 2
c += 1
return c
import math
import fractions
import collections
from functools import reduce
main() | import math
import fractions
from functools import reduce
def main():
n = int(eval(input()))
a = input_list()
if len(set(a)) == 1:
print((n//2))
exit(0)
evens = {}
odds = {}
for i, v in enumerate(a):
if i % 2 == 0:
if v in evens:
evens[v] += 1
else:
evens[v] = 1
else:
if v in odds:
odds[v] += 1
else:
odds[v] = 1
if len(evens) == 1 and len(odds) == 1:
print((0))
exit(0)
e = sorted(list(evens.items()), key=lambda x: x[1], reverse=True)
o = sorted(list(odds.items()), key=lambda x: x[1], reverse=True)
if e[0][0] != o[0][0]:
even_ans = (n // 2) - e[0][1]
odd_ans = (n // 2) if len(o) == 1 else (n // 2) - o[0][1]
a1 = even_ans+odd_ans
even_ans = (n // 2) if len(e) == 1 else (n // 2) - e[0][1]
odd_ans = (n // 2) - o[0][1]
a2 = even_ans+odd_ans
print((min(a1, a2)))
else:
even_ans = (n // 2) - e[0][1]
odd_ans = (n // 2) if len(o) == 1 else (n // 2) - o[1][1]
a1 = even_ans + odd_ans
even_ans = (n // 2) if len(e) == 1 else (n // 2) - e[1][1]
odd_ans = (n // 2) - o[0][1]
a2 = even_ans + odd_ans
print((min(a1, a2)))
# 6
# 3 1 3 2 4 2
def input_list():
return list(map(int, input().split()))
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
def gcd(*numbers):
return reduce(fractions.gcd, numbers)
def gcd_list(numbers):
return reduce(fractions.gcd, numbers)
if __name__ == "__main__":
main()
| p03244 |
import sys
input = sys.stdin.readline
from collections import Counter
def main():
N = int(eval(input()))
V = [int(x) for x in input().split()]
a = []
b = []
for i in range(N):
if i & 1:
a.append(V[i])
else:
b.append(V[i])
ac = Counter(a)
bc = Counter(b)
acm = ac.most_common()
bcm = bc.most_common()
if acm[0][0] != bcm[0][0]:
print((N // 2 - acm[0][1] + N // 2 - bcm[0][1]))
else:
ans = float("inf")
for i in acm:
if i[0] == bcm[0][0]:
continue
ans = min(ans, N // 2 - i[1] + N // 2 - bcm[0][1])
for j in bcm:
if acm[0][0] == j[0]:
continue
ans = min(ans, N // 2 - j[1] + N // 2 - acm[0][1])
if ans == float("inf"):
print((N // 2))
else:
print(ans)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
from collections import Counter
def main():
N = int(eval(input()))
V = [int(x) for x in input().split()]
ac = Counter()
bc = Counter()
for i in range(N):
if i & 1:
ac[V[i]] += 1
else:
bc[V[i]] += 1
acm = ac.most_common()
bcm = bc.most_common()
if acm[0][0] != bcm[0][0]:
print((N // 2 - acm[0][1] + N // 2 - bcm[0][1]))
else:
ans = float("inf")
for i in acm:
if i[0] == bcm[0][0]:
continue
ans = min(ans, N // 2 - i[1] + N // 2 - bcm[0][1])
for j in bcm:
if acm[0][0] == j[0]:
continue
ans = min(ans, N // 2 - j[1] + N // 2 - acm[0][1])
if ans == float("inf"):
print((N // 2))
else:
print(ans)
if __name__ == '__main__':
main()
| p03244 |
from collections import Counter
n = int(eval(input()))
li = list(map(int,input().split()))
a = [l for i,l in enumerate(li) if i % 2 == 0]
b = [l for i,l in enumerate(li) if i % 2 == 1]
se_a = list(set(a))
se_b = list(set(b))
all_lis = []
for aa in se_a:
tmp_cnt = len(a) - Counter(a)[aa]
#print(tmp_cnt,len(a),Counter(a)[aa])
tmp_list = []
for bb in se_b:
if aa == bb:
continue
tmp_list.append(tmp_cnt+len(b) - Counter(b)[bb])
#print(tmp_list)
all_lis += tmp_list
if all_lis:
print((min(all_lis)))
else:
print((len(a))) | from collections import Counter
n = int(eval(input()))
li = list(map(int,input().split()))
a = [l for i,l in enumerate(li) if i % 2 == 0]
b = [l for i,l in enumerate(li) if i % 2 == 1]
se_a = list(set(a))
se_b = list(set(b))
if Counter(a).most_common()[0][0] != Counter(b).most_common()[0][0]:
a_change = len(a) - Counter(a).most_common()[0][1]
b_change = len(b) - Counter(b).most_common()[0][1]
print((a_change+b_change))
else:
if len(se_a) == 1 and len(se_b) == 1:
print((len(a)))
else:
x = len(a) - Counter(a).most_common()[0][1] + len(b) - Counter(b).most_common()[1][1]
y = len(a) - Counter(a).most_common()[1][1] + len(b) - Counter(b).most_common()[0][1]
print((min(x,y))) | p03244 |
n = int(eval(input()))
l = list(map(int, input().split()))
a = []
b = []
ca = []
cb = []
for i in range(n // 2):
a.append(l[i * 2])
b.append(l[i * 2 + 1])
while (len(a) > 0):
ca.append([a[0], a.count(a[0])])
a = [s for s in a if not(s == a[0])]
while (len(b) > 0):
cb.append([b[0], b.count(b[0])])
b = [s for s in b if not (s == b[0])]
ca.sort(key=lambda x: x[1], reverse=True)
cb.sort(key=lambda x: x[1], reverse=True)
ca_max = ca[0]
cb_max = cb[0]
ca_max_num = ca[0][1]
cb_max_num = cb[0][1]
if ca_max[0] == cb_max[0]:
if ca_max[1] > cb_max[1]:
if len(cb) > 1:
cb_max_num = cb[1][1]
else:
cb_max_num = 0
else:
if len(ca) > 1:
ca_max_num = ca[1][1]
else:
ca_max_num = 0
print(((n // 2) * 2 - ca_max_num - cb_max_num)) | n = int(eval(input()))
l = list(map(int, input().split()))
a = {}
b = {}
for i in range(n // 2):
key_a = l[i * 2]
key_b = l[i * 2 + 1]
if key_a in a:
a[key_a] = a[key_a] + 1
else:
a[l[i * 2]] = 1
if key_b in b:
b[key_b] = b[key_b] + 1
else:
b[key_b] = 1
a = sorted(list(a.items()), key=lambda x: x[1], reverse=True)
b = sorted(list(b.items()), key=lambda x: x[1], reverse=True)
# a = list(a.items())
# b = list(b.items())
# print(a)
# print(b)
ca_max = a[0][0]
cb_max = b[0][0]
ca_max_num = a[0][1]
cb_max_num = b[0][1]
same_num = ca_max_num + cb_max_num
if ca_max == cb_max:
if len(a) > 1:
next_ca_max = a[1][1]
else:
next_ca_max = 0
if len(b) > 1:
next_cb_max = b[1][1]
else:
next_cb_max = 0
same_num = max(ca_max_num + next_cb_max, cb_max_num + next_ca_max)
print((n - same_num)) | p03244 |
n = int(eval(input()))
l = list(map(int, input().split()))
a = {}
b = {}
for i in range(n // 2):
key_a = l[i * 2]
key_b = l[i * 2 + 1]
if key_a in a:
a[key_a] = a[key_a] + 1
else:
a[l[i * 2]] = 1
if key_b in b:
b[key_b] = b[key_b] + 1
else:
b[key_b] = 1
a = sorted(list(a.items()), key=lambda x: x[1], reverse=True)
b = sorted(list(b.items()), key=lambda x: x[1], reverse=True)
# a = list(a.items())
# b = list(b.items())
# print(a)
# print(b)
ca_max = a[0][0]
cb_max = b[0][0]
ca_max_num = a[0][1]
cb_max_num = b[0][1]
same_num = ca_max_num + cb_max_num
if ca_max == cb_max:
if len(a) > 1:
next_ca_max = a[1][1]
else:
next_ca_max = 0
if len(b) > 1:
next_cb_max = b[1][1]
else:
next_cb_max = 0
same_num = max(ca_max_num + next_cb_max, cb_max_num + next_ca_max)
print((n - same_num)) | n = int(eval(input()))
l = list(map(int, input().split()))
a = {}
b = {}
for i in range(n // 2):
key_a = l[i * 2]
key_b = l[i * 2 + 1]
if key_a in a:
a[key_a] = a[key_a] + 1
else:
a[l[i * 2]] = 1
if key_b in b:
b[key_b] = b[key_b] + 1
else:
b[key_b] = 1
a = sorted(list(a.items()), key=lambda x: x[1], reverse=True)
b = sorted(list(b.items()), key=lambda x: x[1], reverse=True)
ca_max = a[0][0]
cb_max = b[0][0]
ca_max_num = a[0][1]
cb_max_num = b[0][1]
same_num = ca_max_num + cb_max_num
if ca_max == cb_max:
if len(a) > 1:
next_ca_max = a[1][1]
else:
next_ca_max = 0
if len(b) > 1:
next_cb_max = b[1][1]
else:
next_cb_max = 0
same_num = max(ca_max_num + next_cb_max, cb_max_num + next_ca_max)
print((n - same_num)) | p03244 |
n = int(eval(input()))
V = list(map(int, input().split()))
A = V[::2]
B = V[1::2]
set_A = set(A)
set_B = set(B)
max_a = 0
max_b = 0
for a in set_A:
cnt_a = A.count(a)
max_a = max(max_a, cnt_a)
for b in set_B:
cnt_b = B.count(b)
max_b = max(max_b, cnt_b)
ans = (len(A) - max_a) + (len(B) - max_b)
if ans == 0 and A[0] == B[0]:
ans = n // 2
print(ans) | n = int(eval(input()))
V = list(map(int, input().split()))
A = {}
B = {}
for i in range(n):
if i % 2 == 0:#A
A[V[i]] = A.get(V[i], 0) + 1
else:#B
B[V[i]] = B.get(V[i], 0) + 1
A = sorted(list(A.items()), key=lambda x:x[1], reverse=True)
B = sorted(list(B.items()), key=lambda x:x[1], reverse=True)
a1, b1 = A[0][1], B[0][1]
am, bm = A[0][0], B[0][0]
ans = n - a1 - b1
if ans == 0 and V[0]==V[1]:
ans = n//2
elif am == bm and n > 4:
a2,b2 = A[1][1], B[1][1]
ans = min(n - a2 - b1, n - a1 - b2)
print(ans)
| p03244 |
n = int(eval(input()))
l = list(input().split())
ll,lr = l[::2],l[1::2]
dl,dr = {},{}
for i in ll: dl[i] = dl.get(i,0)+1
for j in lr: dr[j] = dr.get(j,0)+1
ltl = sorted(list(dl.items()),key=lambda k:-k[1])
ltr = sorted(list(dr.items()),key=lambda k:-k[1])
if ltl[0][0] != ltr[0][0]:
print((n-ltl[0][1]-ltr[0][1]))
elif len(ltl)<2:
print((n//2))
else:
print((n-ltl[0][1]-max(ltl[1][1],ltr[1][1]))) | n = int(eval(input()))
v = list(input().split())
def f(b):
h = v[b::2]
d = {0:0}
for i in h: d[i] = d.get(i,0)+1
return sorted(list(d.items()),key=lambda k:-k[1])
l,r = f(0),f(1)
print((n-l[0][1]-[r[0][1],max(l[1][1],r[1][1])][l[0][0] == r[0][0]])) | p03244 |
from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
gu = v[::2]
ki = v[1::2]
ans = 0
k,g = False,False
if v.count(v[0]) == n:#全部同じ
ans += n // 2
else:
kic = Counter(ki)
guc = Counter(gu)
k1 = kic.most_common(2)
g1 = guc.most_common(2)
if k1[0][0] == g1[0][0]:
if k1[1][1] < g1[1][1]:
k = True
else:
g = True
kic = list(kic.values())
guc = list(guc.values())
kic.sort(reverse = True)
guc.sort(reverse = True)
if len(kic) != 1:
if g:
ans += kic[0]
ans += sum(kic[2::])
else:
ans += sum(kic[1::])
if len(guc) != 1:
if k:
ans += guc[0]
ans += sum(guc[2::])
else:
ans += sum(guc[1::])
print(ans) | from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
gu = v[::2]
ki = v[1::2]
ans = 0
k,g = False,False
###全部同じなら全長の半分,
# 最頻値が同じなら2番目を比べる
if v.count(v[0]) == n:
ans += n // 2
else:
kic = Counter(ki)
guc = Counter(gu)
k1 = kic.most_common(2)
g1 = guc.most_common(2)
if k1[0][0] == g1[0][0]:
if k1[1][1] < g1[1][1]:
g = True
else:
k = True
kic = list(kic.values())
guc = list(guc.values())
kic.sort(reverse = True)
guc.sort(reverse = True)
if len(kic) != 1:
if k:
ans += kic[0]
ans += sum(kic[2::])
else:
ans += sum(kic[1::])
if len(guc) != 1:
if g:
ans += guc[0]
ans += sum(guc[2::])
else:
ans += sum(guc[1::])
print(ans) | p03244 |
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n = ni()
vvv = na()
d = {}
for i in range(n):
if vvv[i] not in list(d.keys()):
d[vvv[i]] = 1
else:
d[vvv[i]] += 1
if len(list(d.keys())) == 1:
print((n // 2))
else:
num1 = max(d, key=d.get)
d.pop(num1)
num2 = max(d, key=d.get)
ct1 = 0
ct2 = 0
now1 = num1
now2 = num2
for i in range(n):
if vvv[i] != now1:
ct1 += 1
if vvv[i] != now2:
ct2 += 1
now1, now2 = now2, now1
print((min(ct1, ct2))) | import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n = ni()
vvv = na()
even = vvv[::2]
odd = vvv[1::2]
d_even = {}
d_odd = {}
for i in range(n//2):
if even[i] not in list(d_even.keys()):
d_even[even[i]] = 1
else:
d_even[even[i]] += 1
if odd[i] not in list(d_odd.keys()):
d_odd[odd[i]] = 1
else:
d_odd[odd[i]] += 1
e_max = max(d_even, key=d_even.get)
o_max = max(d_odd, key=d_odd.get)
e1 = d_even[e_max]
o1 = d_odd[o_max]
if e_max == o_max:
d_even[e_max] = 0
d_odd[o_max] = 0
e2 = max(d_even.values())
o2 = max(d_odd.values())
ans = n - max(e1 + o2, e2 + o1)
else:
ans = n - e1 - o1
print(ans)
| p03244 |
from collections import Counter
n = int(eval(input()))
v = list(map(int ,input().split()))
o = Counter(v[::2]).most_common() # 偶数列の最頻値の順に並べる
e = Counter(v[1::2]).most_common() # 奇数列の最頻値の順に並べる
if o[0][0] == e[0][0]: # 最頻値が偶数列と奇数列で同じかどうか判定
if len(o) == 1: print((n//2)) # 値のバリエーションが最頻値のみの場合は片方の数列を書き換えて終わり
else:
# 最終的に数列上に残る値の種類は2種類のみの為、上位2種の値へ全て揃える
# 下記の2パターンで書き換える数が少ない方が回答になる
o1,o2 = e[0][1], e[1][1]
e1,e2 = o[0][1], o[1][1]
ans = min(n-e1-o2, n-e2-o1)
print(ans)
else:
print((n - o[0][1] - e[0][1])) #最頻値が異なる場合は、全体の数からそれぞれの最頻値の数を引く | from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
o = Counter(v[::2]).most_common()
e = Counter(v[1::2]).most_common()
if o[0][0] == e[0][0]:
if len(o) == 1: print((e[0][1]))
else:
o1,o2 = e[0][1], e[1][1]
e1,e2 = o[0][1], o[1][1]
ans = min(n-o1-o2, n-e1-e2)
print(ans)
else: print((n-o[0][1]-e[0][1])) | p03244 |
from collections import Counter
n = int(eval(input()))
lis = list(map(int, input().split()))
a = Counter(lis[::2])
b = Counter(lis[1::2])
aa = sorted(list(a.items()), key=lambda x:x[1], reverse=True)
bb = sorted(list(b.items()), key=lambda x:x[1], reverse=True)
if aa[0][0] == bb[0][0]:
if len(aa) > 1 and len(bb) > 1:
res = n - max(aa[0][1]+bb[1][1], aa[1][1]+bb[0][1])
elif len(aa) == 1 and len(bb) > 1:
res = n - aa[0][1] - bb[1][1]
elif len(aa) > 1 and len(bb) == 1:
res = n - aa[1][1] - bb[0][1]
else:
res = n - aa[0][1]
else:
res = n - aa[0][1] - bb[0][1]
print(res)
| from collections import Counter
n = int(eval(input()))
lis = list(map(int, input().split()))
a = Counter(lis[::2])
b = Counter(lis[1::2])
aa = sorted(list(a.items()), key=lambda x:x[1], reverse=True)
bb = sorted(list(b.items()), key=lambda x:x[1], reverse=True)
aa.append((0, 0))
bb.append((0, 0))
if aa[0][0] == bb[0][0]:
res = n - max(aa[0][1]+bb[1][1], aa[1][1]+bb[0][1])
else:
res = n - aa[0][1] - bb[0][1]
print(res)
| p03244 |
from collections import Counter
n = int(eval(input()))
v = list(map(int,input().split()))
v1 = v[0::2]
v2 = v[1::2]
count1 = Counter(v1)
count2 = Counter(v2)
count1[0] = 0
MAX = 0
for i in list(count1.keys()):
for j in list(count2.keys()):
if i != j and MAX < count1[i] + count2[j]:
MAX = count1[i] + count2[j]
print((n - MAX)) | from collections import Counter
n = int(eval(input()))
v = list(map(int,input().split()))
v1 = v[0::2]
v2 = v[1::2]
count1 = Counter(v1)
count2 = Counter(v2)
count1[0] = 0
count2[0] = 0
items1 = []
items2 = []
key1 = max(list(count1.keys()), key = count1.get)
items1.append([key1, count1[key1]])
del count1[key1]
key1 = max(list(count1.keys()), key = count1.get)
items1.append([key1, count1[key1]])
key2 = max(list(count2.keys()), key = count2.get)
items2.append([key2, count2[key2]])
del count2[key2]
key2 = max(list(count2.keys()), key = count2.get)
items2.append([key2, count2[key2]])
if items1[0][0] != items2[0][0]:
m = items1[0][1] + items2[0][1]
else:
m = max(items1[0][1] + items2[1][1], items1[1][1] + items2[0][1])
print((n - m)) | p03244 |
#!/usr/bin/env python3
#ABC111 C
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop
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()))
n = I()
v = LI()
s,t = [],[]
for i in range(n):
if i % 2:
t.append(v[i])
else:
s.append(v[i])
s = list(Counter(s).items())
s.sort(key = itemgetter(1),reverse = True)
t = list(Counter(t).items())
t.sort(key = itemgetter(1),reverse = True)
m = min(len(s),len(t))
for i in range(m):
a,b = s[i]
c,d = t[i]
if a != c:
print(((n//2 - b)+(n//2 - d)))
quit()
elif a == c:
if i + 1 < len(s) - 1:
tmp1 = s[i+1][1]
else:
tmp1 = 0
if i + 1 < len(t) - 1:
tmp2 = t[i+1][1]
else:
tmp2 = 0
print((min(((n//2 - b) + (n//2 - tmp2),((n//2 - d) + (n//2 - tmp1))))))
quit()
| #!/usr/bin/env python3
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()))
n = I()
v = LI()
a = []
b = []
for i in range(n):
if i % 2 == 0:
a.append(v[i])
else:
b.append(v[i])
a = list(Counter(a).items())
b = list(Counter(b).items())
a.sort(key = lambda x:x[1], reverse=1)
b.sort(key = lambda x:x[1], reverse=1)
if len(a) == 1 and len(b) == 1:
if a[0][0] == b[0][0]:
print((n//2))
else:
print((0))
elif len(a) > 1 and len(b) == 1:
if a[0][0] == b[0][0]:
print(((n-1)//2 + 1 - a[1][1]))
else:
print(((n-1)//2 + 1 - a[0][1]))
elif len(a) == 1 and len(b) > 1:
if a[0][0] == b[0][0]:
print((n//2 - b[1][1]))
else:
print((n//2 - b[0][1]))
else:
if a[0][0] == b[0][0]:
print((min((n-1)//2 + 1 - a[1][1] + (n // 2) - b[0][1], (n-1)//2 + 1 - a[0][1] + (n // 2) - b[1][1])))
else:
print((min((n-1)//2 + 1 - a[0][1] + (n // 2) - b[0][1], (n-1)//2 + 1 - a[0][1] + (n // 2) - b[0][1])))
| p03244 |
from collections import defaultdict
ODD = defaultdict(int)
EVEN = defaultdict(int)
ALL = set([])
N = int(eval(input()))
A = list(map(int,input().split()))
for i in range(N):
ALL.add(A[i])
if i%2 == 0:
EVEN[A[i]] += 1
else:
ODD[A[i]] += 1
if len(ALL) == 1:
ans = N//2
print(ans)
exit()
modd = max(ODD.values())
meven = max(EVEN.values())
mlodd = [];mleven = []
dicodd = sorted(list(ODD.items()), key=lambda x:x[1], reverse = True)
diceven = sorted(list(EVEN.items()), key=lambda x:x[1], reverse = True)
ans = N
for x, vx in dicodd:
for y, vy in diceven:
if x != y:
temp = N-(vx+vy)
if ans != temp:
ans = min(ans,temp)
else:
print(ans)
exit()
print(ans)
exit()
print(ans)
| from collections import defaultdict
ODD = defaultdict(int)
EVEN = defaultdict(int)
ALL = set([])
N = int(eval(input()))
A = list(map(int,input().split()))
for i in range(N):
ALL.add(A[i])
if i%2 == 0:
EVEN[A[i]] += 1
else:
ODD[A[i]] += 1
if len(ALL) == 1:
ans = N//2
print(ans)
exit()
modd = max(ODD.values())
meven = max(EVEN.values())
mlodd = [];mleven = []
dicodd = sorted(list(ODD.items()), key=lambda x:x[1], reverse = True)
diceven = sorted(list(EVEN.items()), key=lambda x:x[1], reverse = True)
ans = N
if len(dicodd) > 1:
X = [dicodd[0],dicodd[1]]
else:
X = [dicodd[0]]
if len(diceven) > 1:
Y = [diceven[0],diceven[1]]
else:
Y = [diceven[0]]
#print(X)
#print(Y)
for x,v in X:
for y,w in Y:
if x == y:
continue
temp = N-(v+w)
ans = min(ans,temp)
print(ans)
| p03244 |
from collections import defaultdict
n = int(eval(input()))
v = [int(x) for x in input().split()]
even_ocr = defaultdict(int) # v[0], v[2], ..., で各数が何回現れるか
odd_ocr = defaultdict(int) # v[1], v[3], ..., で各数が何回現れるか
for i in range(n // 2):
even_ocr[v[2 * i]] += 1
odd_ocr[v[2 * i + 1]] += 1
even_max_num = 0; even_max_ocr = 0;
odd_max_num = 0; odd_max_ocr = 0;
for (num, ocr) in list(even_ocr.items()):
if ocr > even_max_ocr:
even_max_ocr = ocr
even_max_num = num
for (num, ocr) in list(odd_ocr.items()):
if ocr > odd_max_ocr:
odd_max_ocr = ocr
odd_max_num = num
if even_max_num != odd_max_num:
ans = n - even_max_ocr - odd_max_ocr
else:
# 偶数番目に一番多く現れる数と奇数番目に一番多く現れる数が同じ
even_next_num = 0; even_next_ocr = 0;
odd_next_num = 0; odd_next_ocr = 0;
for (num, ocr) in list(even_ocr.items()):
if num != even_max_num and ocr > even_next_ocr:
even_next_ocr = ocr
even_next_num = num
for (num, ocr) in list(odd_ocr.items()):
if num != odd_max_num and ocr > odd_next_ocr:
odd_next_ocr = ocr
odd_next_num = num
if even_next_ocr + odd_max_ocr > even_max_ocr + odd_next_ocr:
# 偶数番目は二番目に多い数、奇数番目は一番多い数に揃える
ans = n - even_next_ocr - odd_max_ocr
else:
ans = n - even_max_ocr - odd_next_ocr
print(ans) | from collections import defaultdict, Counter
n = int(eval(input()))
v = [int(x) for x in input().split()]
cnt_even = Counter(v[0::2])
cnt_odd = Counter(v[1::2])
# [(要素, 出現回数), (要素, 出現回数), ....]
common_even = cnt_even.most_common()
common_odd = cnt_odd.most_common()
if len(common_even) == 1: # 1種類の数しかない
common_even.append((0, 0))
if len(common_odd) == 1:
common_odd.append((0, 0))
# 偶数番目に一番多く現れる数と奇数番目に一番多く現れる数が異なる
if common_even[0][0] != common_odd[0][0]:
ans = n - common_even[0][1] - common_odd[0][1]
else:
ans = min(n - common_even[1][1] - common_odd[0][1], \
n - common_even[0][1] - common_odd[1][1])
print(ans) | p03244 |
#!/usr/bin/env python3
import sys
from math import *
from itertools import *
from collections import *
from functools import *
try:
from math import gcd
except Exception:
from fractions import gcd
def solve(n: int, v: "List[int]"):
e = [(len(v[0::2]) - vv, k, 0) for k, vv in list(Counter(v[0::2]).items())]
o = [(len(v[1::2]) - vv, k, 1) for k, vv in list(Counter(v[1::2]).items())]
res = [(len(v[0::2]),''), (len(v[1::2]),'')]
for n, k, t in sorted(e + o):
if res[t][1] != '':
continue
if res[1 - t][1] == k:
continue
res[t] = (n, k)
if res[0][1] != '' and res[1][1] != '':
break
return res[0][0] + res[1][0]
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
n = int(next(tokens)) # type: int
v = [ int(next(tokens)) for _ in range(n) ] # type: "List[int]"
result = solve(n, v)
print(result)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
from math import *
from itertools import *
from collections import *
from functools import *
try:
from math import gcd
except Exception:
from fractions import gcd
def solve(n: int, v: "List[int]"):
e = v[0::2]
o = v[1::2]
ec = sorted([(vv, k) for k, vv in list(Counter(e).items())], reverse=True) + [(0, None)]
oc = sorted([(vv, k) for k, vv in list(Counter(o).items())], reverse=True) + [(0, None)]
ee1 = ec[0]
oo1 = oc[1] if oc[0][1] == ee1[1] else oc[0]
ret1 = len(v) - ee1[0] - oo1[0]
oo2 = oc[0]
ee2 = ec[1] if ec[0][1] == oo2[1] else ec[0]
ret2 = len(v) - ee2[0] - oo2[0]
return min(ret1, ret2)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
n = int(next(tokens)) # type: int
v = [ int(next(tokens)) for _ in range(n) ] # type: "List[int]"
result = solve(n, v)
print(result)
if __name__ == '__main__':
main()
| p03244 |
# -*- coding: utf-8 -*-
import collections
def search_b(a_char, a_count, b_most_common, fixed_count):
thres = fixed_count - a_count
for (b_char, b_count) in [b for b in b_most_common if b[1] > thres]:
if a_char != b_char:
return a_count + b_count
return fixed_count
def search(a_most_common, b_most_common):
fixed_count = -1
for (a_char, a_count) in a_most_common:
fixed_count = search_b(a_char, a_count, b_most_common, fixed_count)
return fixed_count
def main():
n = int(eval(input()))
V = list(map(int, input().split()))
a = V[::2]
b = V[1::2]
a_counter = collections.Counter(a)
b_counter = collections.Counter(b)
a_most_common = a_counter.most_common()
b_most_common = b_counter.most_common()
if len(a_most_common) == 1 and len(b_most_common) == 1 and a_most_common[0][0] == b_most_common[0][0]:
print((n // 2))
return
print((n - search(a_most_common, b_most_common)))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import collections
def search_b(a_char, a_count, b_most_common, fixed_count):
thres = fixed_count - a_count
for (b_char, b_count) in [b for b in b_most_common if b[1] > thres]:
if a_char != b_char:
return a_count + b_count
return fixed_count
def search(a_most_common, b_most_common):
fixed_count = -1
b_max = b_most_common[0][1]
for (a_char, a_count) in a_most_common:
if a_count <= fixed_count - b_max:
break
fixed_count = search_b(a_char, a_count, b_most_common, fixed_count)
return fixed_count
def main():
n = int(eval(input()))
V = list(map(int, input().split()))
a = V[::2]
b = V[1::2]
a_counter = collections.Counter(a)
b_counter = collections.Counter(b)
a_most_common = a_counter.most_common()
b_most_common = b_counter.most_common()
if len(a_most_common) == 1 and len(b_most_common) == 1 and a_most_common[0][0] == b_most_common[0][0]:
print((n // 2))
return
print((n - search(a_most_common, b_most_common)))
if __name__ == '__main__':
main()
| p03244 |
n = int(eval(input()))
v = list(map(int,input().split()))
b = []
c = []
for i, vv in enumerate(v):
if i%2 == 0:
b.append(vv)
else:
c.append(vv)
b_set = []
c_set = []
for bb in set(b):
b_set.append((b.count(bb), bb))
for cc in set(c):
c_set.append((c.count(cc), cc))
b_set.sort(reverse=True)
b_set.append((0,0))
c_set.sort(reverse=True)
c_set.append((0,0))
if b_set[0][1] != c_set[0][1]:
ans = n - b_set[0][0] - c_set[0][0]
else:
try1 = n - b_set[1][0] - c_set[0][0]
try2 = n - b_set[0][0] - c_set[1][0]
ans = min(try1,try2)
print(ans) | n = int(eval(input()))
v = list(map(int,input().split()))
b = []
c = []
for i, vv in enumerate(v):
if i%2 == 0:
b.append(vv)
else:
c.append(vv)
b_set = {}
c_set = {}
for bb in b:
if not bb in list(b_set.keys()):
b_set[bb] = 1
else:
b_set[bb] += 1
for cc in c:
if not cc in list(c_set.keys()):
c_set[cc] = 1
else:
c_set[cc] += 1
b_sorted = []
c_sorted = []
for key, value in list(b_set.items()):
b_sorted.append([value,key])
for key, value in list(c_set.items()):
c_sorted.append([value,key])
b_sorted = sorted(b_sorted, reverse=True)
b_sorted += [[0,0]]
c_sorted = sorted(c_sorted, reverse=True)
c_sorted += [[0,0]]
if b_sorted[0][1] != c_sorted[0][1]:
ans = n - b_sorted[0][0] - c_sorted[0][0]
else:
try1 = n - b_sorted[1][0] - c_sorted[0][0]
try2 = n - b_sorted[0][0] - c_sorted[1][0]
ans = min(try1,try2)
print(ans) | p03244 |
from collections import Counter
n, *v = list(map(int, open(0).read().split()))
vo = Counter(v[::2])
ve = Counter(v[1::2])
vo_mc = vo.most_common()[0]
ve_mc = ve.most_common()[0]
if vo_mc[0] == ve_mc[0]:
if vo_mc[1] > ve_mc[1]:
ans = n//2 - vo_mc[1]
if ve_mc[1] != n//2:
ans += n//2 - ve.most_common()[1][1]
else:
ans += n//2
elif vo_mc[1] < ve_mc[1]:
ans = n//2 - ve_mc[1]
if vo_mc[1] != n//2:
ans += n//2 - vo.most_common()[1][1]
else:
ans += n//2
else:
ans = n
if ve_mc[1] != n//2:
ans = min(n//2 - vo_mc[1] + n//2 - ve.most_common()[1][1], ans)
if vo_mc[1] != n//2:
ans = min(n//2 - vo.most_common()[1][1] + n//2 - ve_mc[1], ans)
ans = min(n//2 - vo_mc[1] + n//2, ans)
else:
ans = n//2 - vo_mc[1] + n//2 - ve_mc[1]
print(ans) | from collections import Counter
n, *v = list(map(int, open(0).read().split()))
vo = Counter(v[::2])
ve = Counter(v[1::2])
vo_mc = vo.most_common()[0]
ve_mc = ve.most_common()[0]
if vo_mc[0] == ve_mc[0]:
ans = n
if ve_mc[1] != n//2:
ans = min(n//2 - vo_mc[1] + n//2 - ve.most_common()[1][1], ans)
if vo_mc[1] != n//2:
ans = min(n//2 - vo.most_common()[1][1] + n//2 - ve_mc[1], ans)
ans = min(n//2 - vo_mc[1] + n//2, ans)
else:
ans = n//2 - vo_mc[1] + n//2 - ve_mc[1]
print(ans) | p03244 |
# 2019-11-10 17:11:42(JST)
import sys
import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
import operator as op
# from scipy.misc import comb # float
# import numpy as np
# import statistics
def main():
n, *v = (int(x) for x in sys.stdin.read().split())
odds, evens = [], []
for i in range(n):
if i % 2 == 0:
odds.append(v[i])
else:
evens.append(v[i])
o_c = collections.Counter(odds)
e_c = collections.Counter(evens)
o_c = sorted(list((k, v) for k, v in list(o_c.items())), key=op.itemgetter(1), reverse=True)
e_c = sorted(list((k, v) for k, v in list(e_c.items())), key=op.itemgetter(1), reverse=True)
ans = n
if o_c[0][0] != e_c[0][0]:
ans = n - o_c[0][1] - e_c[0][1]
else:
if len(o_c) == 1 and len(e_c) == 1:
ans = n - n // 2
elif len(o_c) == 1 and len(e_c) >= 2:
ans = n - e_c[1][1]
elif len(o_c) >= 2 and len(e_c) == 1:
ans = n - o_c[1][1]
else:
ans = n - max(o_c[0][1] + e_c[1][1], o_c[1][1] + e_c[0][1])
print(ans)
if __name__ == "__main__":
main()
| import sys
from collections import Counter
n, *v = list(map(int, sys.stdin.read().split()))
def main():
c1 = sorted(list(Counter(v[::2]).items()), reverse=True, key=lambda x: x[1])
c2 = sorted(list(Counter(v[1::2]).items()), reverse=True, key=lambda x: x[1])
if c1[0][0] != c2[0][0]:
return n // 2 - c1[0][1] + n // 2 - c2[0][1]
else:
if len(c1) == len(c2) == 1:
return n // 2
elif len(c1) == 1:
return n // 2 - c2[1][1]
elif len(c2) == 1:
return n // 2 - c1[1][1]
else:
return n - max(c1[0][1] + c2[1][1], c1[1][1] + c2[0][1])
if __name__ == '__main__':
ans = main()
print(ans) | p03244 |
import collections
N = int(eval(input()))
v = list(map(int, input().split()))
if len(set(v)) == 1:
print((int(len(v)/2)))
exit()
ov = [v[i] for i in range(1,len(v),2)]
ev = [v[i] for i in range(0, len(v), 2)]
cov = collections.Counter(ov)
cev = collections.Counter(ev)
mov = cov.most_common()[0][0]
mev = cev.most_common()[0][0]
ans = len(v) - cov[mov] - cev[mev]
if mov == mev:
ans1 = len(v) - cov.most_common()[1][1] - cev.most_common()[0][1]
ans2 = len(v) - cov.most_common()[0][1] - cev.most_common()[1][1]
ans = min(ans1, ans2)
print(ans) | import collections
N = int(eval(input()))
v = list(map(int, input().split()))
if len(set(v)) == 1:
print((int(len(v)/2)))
exit()
cov = collections.Counter(v[1::2])
cev = collections.Counter(v[::2])
mov = cov.most_common()[0][0]
mev = cev.most_common()[0][0]
ans = len(v) - cov[mov] - cev[mev]
if mov == mev:
ans1 = len(v) - cov.most_common()[1][1] - cev.most_common()[0][1]
ans2 = len(v) - cov.most_common()[0][1] - cev.most_common()[1][1]
ans = min(ans1, ans2)
print(ans) | p03244 |
from collections import Counter
from collections import deque
if __name__ == '__main__':
n = int(eval(input()))
vs0 = []
vs1 = []
for i,v in enumerate(map(int, input().split())):
if i % 2 == 0:
vs0.append(v)
else:
vs1.append(v)
vs0 = deque(sorted(list(Counter(vs0).items()), key=lambda t: t[1]))
vs1 = deque(sorted(list(Counter(vs1).items()), key=lambda t: t[1]))
t0 = vs0.pop()
t1 = vs1.pop()
if t0[0] != t1[0]:
vs0 = (t[1] for t in vs0)
vs1 = (t[1] for t in vs1)
print((sum(vs0) + sum(vs1)))
else:
if len(vs1) == 0:
if len(vs0) == 0:
print((t1[1]))
else:
vs0 = (t[1] for t in vs0)
print((sum(vs0)))
elif len(vs0) == 0:
vs1 = (t[1] for t in vs1)
print((sum(vs1)))
else:
t00 = vs0.pop()
t11 = vs1.pop()
a = t00[1] + t1[1]
b = t11[1] + t0[1]
vs0 = (t[1] for t in vs0)
vs1 = (t[1] for t in vs1)
print((sum(vs0) + sum(vs1) + (a if a < b else b)))
| from collections import Counter
if __name__ == '__main__':
n = int(eval(input()))
vs = [int(s) for s in input().split()]
counter0 = list(Counter(vs[0::2]).items()) + [(100001, 0)]
counter1 = list(Counter(vs[1::2]).items()) + [(100001, 0)]
v0, c0 = max(counter0, key=lambda t: t[1])
v1, c1 = max(counter1, key=lambda t: t[1])
counter0.remove((v0, c0))
counter1.remove((v1, c1))
res = 0
if v0 != v1:
res = n - c0 - c1
else:
_, c02 = max(counter0, key=lambda t: t[1])
_, c12 = max(counter1, key=lambda t: t[1])
res = n - (c0 + c12 if c12 > c02 else c1 + c02)
print(res)
| p03244 |
n = int(eval(input()))
V = list(map(int,input().split()))
a = [0]*10000000
b = [0]*10000000
v1=[]
v2=[]
if len(set(V)) == 1:
print((n//2))
else:
for i in range(n):
if i%2 == 0:
a[V[i]-1] += 1
v1.append(V[i])
else:
b[V[i]-1] += 1
v2.append(V[i])
max1 = 0
max2 = 0
for j in range(len(a)):
if max1 < a[j]:
max1 = a[j]
c1 = j
for k in range(len(b)):
if max2 < b[k]:
max2=b[k]
c2=k
if c1 != c2:
print((n-max1-max2))
else:
a.sort()
b.sort()
print((min(n-max1-b[-2],n-max2-a[-2])))
| n = int(eval(input()))
V = list(map(int,input().split()))
a = [0]*100000
b = [0]*100000
v1=[]
v2=[]
if len(set(V)) == 1:
print((n//2))
else:
for i in range(n):
if i%2 == 0:
a[V[i]-1] += 1
v1.append(V[i])
else:
b[V[i]-1] += 1
v2.append(V[i])
max1 = 0
max2 = 0
for j in range(len(a)):
if max1 < a[j]:
max1 = a[j]
c1 = j
for k in range(len(b)):
if max2 < b[k]:
max2=b[k]
c2=k
if c1 != c2:
print((n-max1-max2))
else:
a.sort()
b.sort()
print((min(n-max1-b[-2],n-max2-a[-2])))
| p03244 |
n = int(eval(input()))
V = list(map(int,input().split()))
a = [0]*100000
b = [0]*100000
v1=[]
v2=[]
if len(set(V)) == 1:
print((n//2))
else:
for i in range(n):
if i%2 == 0:
a[V[i]-1] += 1
v1.append(V[i])
else:
b[V[i]-1] += 1
v2.append(V[i])
max1 = 0
max2 = 0
for j in range(len(a)):
if max1 < a[j]:
max1 = a[j]
c1 = j
for k in range(len(b)):
if max2 < b[k]:
max2=b[k]
c2=k
if c1 != c2:
print((n-max1-max2))
else:
a.sort()
b.sort()
print((min(n-max1-b[-2],n-max2-a[-2])))
| from collections import Counter
N = int(eval(input()))
V = list(map(int,input().split()))
zero = Counter(V[::2]).most_common()
one = Counter(V[1::2]).most_common()
if zero[0][0] != one[0][0]:
print((N-zero[0][1]-one[0][1]))
else:
if len(zero) == 1 and len(one) == 1:
print((N//2))
elif len(zero) == 1:
print((N-zero[0][1]-one[1][1]))
elif len(one) == 1:
print((N-zero[1][1]-one[0][1]))
else:
print((min(N-zero[1][1]-one[0][1],N-zero[0][1]-one[1][1]))) | p03244 |
import collections
n = int(eval(input()))
v = list(map(int, input().split()))
v_odd = []
v_even = []
for i, v in enumerate(v):
if i % 2:
v_even.append(v)
else:
v_odd.append(v)
# Counterに入れて、valueの降順にソート
v_odd_c = collections.Counter(v_odd)
v_odd_c = sorted(list(v_odd_c.items()), key=lambda x: x[1], reverse=True)
v_even_c = collections.Counter(v_even)
v_even_c = sorted(list(v_even_c.items()), key=lambda x: x[1], reverse=True)
# counterに一つしかkeyがないと面倒なので0が0回出たことを明示的に示しておく
# 制約上、0はvとしてあり得ないので問題ない（必ず0は0回出る）
v_odd_c.append([0, 0])
v_even_c.append([0, 0])
# print(v_odd_c)
# print(v_even_c)
if n != 2:
o1 = v_odd_c[0]
o2 = v_odd_c[1]
e1 = v_even_c[0]
e2 = v_even_c[1]
# 最頻値が異なる場合
if o1[0] != e1[0]:
ans = n - o1[1] - e1[1]
# 最頻値が等しい場合
elif o1[0] == e1[0]:
# o1,e2を採用する場合
temp1 = n - o1[1] - e2[1]
#o2, e1を採用する場合
temp2 = n - o2[1] - e1[1]
ans = min(temp1, temp2)
elif n == 2:
if v_odd_c[0][1] != v_even_c[0][1]:
ans = 0
else:
ans = 1
print(ans)
| import collections
n = int(eval(input()))
v = list(map(int, input().split()))
v_odd = []
v_even = []
for i, v in enumerate(v):
if i % 2:
v_even.append(v)
else:
v_odd.append(v)
# Counterに入れて、valueの降順にソート
v_odd_c = collections.Counter(v_odd)
v_odd_c = sorted(list(v_odd_c.items()), key=lambda x: x[1], reverse=True)
v_even_c = collections.Counter(v_even)
v_even_c = sorted(list(v_even_c.items()), key=lambda x: x[1], reverse=True)
# counterに一つしかkeyがないと面倒なので0が0回出たことを明示的に示しておく
# 制約上、0はvとしてあり得ないので問題ない（必ず0は0回出る）
v_odd_c.append([0, 0])
v_even_c.append([0, 0])
if n != 2:
o1 = v_odd_c[0]
o2 = v_odd_c[1]
e1 = v_even_c[0]
e2 = v_even_c[1]
# 最頻値が異なる場合
if o1[0] != e1[0]:
ans = n - o1[1] - e1[1]
# 最頻値が等しい場合
elif o1[0] == e1[0]:
# o1,e2を採用する場合
temp1 = n - o1[1] - e2[1]
#o2, e1を採用する場合
temp2 = n - o2[1] - e1[1]
ans = min(temp1, temp2)
print(ans)
| p03244 |
from collections import Counter
N = int(eval(input()))
a = list(map(int,input().split()))
even = [[0,0]] + sorted([v,k] for k,v in list(Counter(a[1::2]).items()))
odd = [[0,0]] + sorted([v,k] for k,v in list(Counter(a[0::2]).items()))
if even[-1][1] != odd[-1][1]:
print((N - even[-1][0] - odd[-1][0]))
else:
print((min(N - even[-1][0] - odd[-2][0], N - even[-2][0] - odd[-1][0])))
| from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
a = [v[i] for i in range(n) if i % 2]
b = [v[i] for i in range(n) if i % 2 == 0]
aa = Counter(a)
bb = Counter(b)
ans = 0
aas = sorted(list(aa.keys()), key=lambda key:aa[key], reverse=True)
bbs = sorted(list(bb.keys()), key=lambda key:bb[key], reverse=True)
if aas[0] != bbs[0]:
ans += len(a) - aa[aas[0]]
ans += len(b) - bb[bbs[0]]
else:
if len(aa) == len(bb) and len(aa) == 1 and a[0] == b[0]:
ans += min(len(a), len(b))
else:
s = len(a) - aa[aas[0]] + len(b) - bb[bbs[1]]
t = len(a) - aa[aas[1]] + len(b) - bb[bbs[0]]
ans = min(s,t)
print(ans)
| p03244 |
import collections
def main():
n = int(eval(input()))
v = list(map(int,input().split()))
if len(set(v)) == 1:
print((n//2))
elif len(set(v)) == 2:
cnt1 = 0
cnt2 = 0
tmp1 = list(set(v))
tmp2 = [tmp1[1], tmp1[0]]
# even = v[::2]
# odd = v[1::2]
#
for i, a in enumerate(v):
if i % 2 == 0:
if a == tmp1[0]:
cnt1 += 1
if a == tmp2[0]:
cnt2 += 1
else :
if a == tmp1[1]:
cnt1 += 1
if a == tmp2[1]:
cnt2 += 1
print((n-max(cnt1,cnt2)))
else:
even = v[::2]
odd = v[1::2]
count_e = collections.Counter(even)
count_o = collections.Counter(odd)
ce = count_e.most_common()
co = count_o.most_common()
if ce[0][0] != co[0][0]:
print((n-ce[0][1] - co[0][1]))
else:
if len(ce) == 1:
print((n-co[1][1]))
elif len(co) == 1:
print((n-ce[1][1]))
else:
print((min(n-ce[0][1]-co[1][1], n-ce[1][1]-co[0][1])))
if __name__ == '__main__':
main()
| import collections
def main():
n = int(eval(input()))
v = list(map(int,input().split()))
even = v[::2]
odd = v[1::2]
count_e = collections.Counter(even)
count_o = collections.Counter(odd)
ce = count_e.most_common()
co = count_o.most_common()
if ce[0][0] != co[0][0]:
print((n-ce[0][1] - co[0][1]))
else:
if len(ce) == 1 and len(co) == 1:
print((n//2))
elif len(ce) == 1:
print((n-co[1][1]))
elif len(co) == 1:
print((n-ce[1][1]))
else:
print((min(n-ce[0][1]-co[1][1], n-ce[1][1]-co[0][1])))
if __name__ == '__main__':
main()
| p03244 |
from collections import Counter
n = int(eval(input()))
array = list(map(int,input().split()))
if len(set(array)) == 1:
print((n//2))
exit()
gu = []
ki = []
for i in range(n):
if i % 2 == 0:
gu.append(array[i])
else:
ki.append(array[i])
gu_c = Counter(gu)
ki_c = Counter(ki)
if gu_c.most_common()[0][0] != ki_c.most_common()[0][0]:
print((n-(gu_c.most_common()[0][1]+ki_c.most_common()[0][1])))
elif gu_c.most_common()[0][1] < ki_c.most_common()[0][1]:
print((n-(gu_c.most_common()[1][1]+ki_c.most_common()[0][1])))
elif gu_c.most_common()[0][1] > ki_c.most_common()[0][1]:
print((n-(gu_c.most_common()[0][1]+ki_c.most_common()[1][1])))
else:
print((n-(gu_c.most_common()[0][1]+max(gu_c.most_common()[1][1],ki_c.most_common()[1][1])))) | from collections import Counter
n = int(eval(input()))
array = list(map(int,input().split()))
if len(set(array)) == 1:
print((n//2))
exit()
gu = []
ki = []
for i in range(n):
if i % 2 == 0:
gu.append(array[i])
else:
ki.append(array[i])
gu_c = Counter(gu)
ki_c = Counter(ki)
gu_m = gu_c.most_common()
ki_m = ki_c.most_common()
if gu_m[0][0] != ki_m[0][0]:
print((n-(gu_m[0][1]+ki_m[0][1])))
elif gu_m[0][1] < ki_m[0][1]:
print((n-(gu_m[1][1]+ki_m[0][1])))
elif gu_m[0][1] > ki_m[0][1]:
print((n-(gu_m[0][1]+ki_m[1][1])))
else:
print((n-(gu_m[0][1]+max(gu_m[1][1],ki_m[1][1])))) | p03244 |
import collections
N=int(eval(input()))
V=list(map(int,input().split()))
l=N//2
V_odd=[]
V_eve=[]
for i in range(N):
if i%2==0:
V_odd.append(V[i])
else:
V_eve.append(V[i])
p_odd = list(collections.Counter(V_odd).most_common())
p_eve = list(collections.Counter(V_eve).most_common())
p_odd.append([0,0])
p_eve.append([0,0])
if p_odd[0][0]!=p_eve[0][0]:
print((N-p_odd[0][1]-p_eve[0][1]))
exit()
else:
print((min(N-p_odd[0][1]-p_eve[1][1],N-p_odd[1][1]-p_eve[0][1])))
| import collections
N=int(eval(input()))
V=list(map(int,input().split()))
l=N//2
V_odd=[]
V_eve=[]
for i in range(N):
if i%2==0:
V_odd.append(V[i])
else:
V_eve.append(V[i])
p_odd = list(collections.Counter(V_odd).most_common())
p_eve = list(collections.Counter(V_eve).most_common())
p_odd.append([0,0])
p_eve.append([0,0])
if p_odd[0][0]!=p_eve[0][0]:
print((N-p_odd[0][1]-p_eve[0][1]))
else:
print((min(N-p_odd[0][1]-p_eve[1][1],N-p_odd[1][1]-p_eve[0][1])))
| p03244 |
from collections import Counter
n = int(eval(input()))
v = list(map(int,input().split()))
v1 = v[::2]
v2 = v[1::2]
v1_n = Counter(v1)
v1_N =v1_n.most_common()
v2_n = Counter(v2)
v2_N = v2_n.most_common()
if len(v1_N) == 1 and len(v2_N) == 1 and v1_N[0][0] == v2_N[0][0]:
print((int(n/2)))
elif len(([k[0] for k in list(v1_n.items()) if k[1] == max(v1_n.values())])) == 1 and len(([k[0] for k in list(v2_n.items()) if k[1] == max(v2_n.values())])) == 1 and v1_N[0][0] == v2_N[0][0]:
print((min(n-v1_N[0][1]-v2_N[1][1],n-v1_N[1][1]-v2_N[0][1])))
else:
print((n-v1_N[0][1]-v2_N[0][1])) | from collections import Counter
n = int(eval(input()))
v = list(map(int,input().split()))
v1 = v[::2]
v2 = v[1::2]
v1_N = Counter(v1).most_common()
v2_N = Counter(v2).most_common()
if len(v1_N) == 1 and len(v2_N) == 1 and v1_N[0][0] == v2_N[0][0]:
print((int(n/2)))
elif v1_N[0] == v2_N[0]:
print((min(n-v1_N[0][1]-v2_N[1][1],n-v1_N[1][1]-v2_N[0][1])))
else:
print((n-v1_N[0][1]-v2_N[0][1])) | p03244 |
from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
v1 = sorted(list(Counter(v[::2]).items()), key=lambda x: x[1], reverse=True)
v2 = sorted(list(Counter(v[1::2]).items()), key=lambda x: x[1], reverse=True)
v1.append((0, 0))
v2.append((0, 0))
if v1[0][0] != v2[0][0]:
print((n - v1[0][1] - v2[0][1]))
else:
print((min(n - v1[0][1] - v2[1][1], n - v1[1][1] - v2[0][1]))) | from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
v1 = Counter(v[::2]).most_common()
v2 = Counter(v[1::2]).most_common()
v1.append((0, 0))
v2.append((0, 0))
if v1[0][0] != v2[0][0]:
print((n - v1[0][1] - v2[0][1]))
else:
print((min(n - v1[0][1] - v2[1][1], n - v1[1][1] - v2[0][1]))) | p03244 |
N=int(eval(input()))
*V,=list(map(int,input().split()))
from collections import*
C1=Counter(V[::2])
C1=sorted(list(C1.items()),key=lambda x:x[1])
C2=Counter(V[1::2])
C2=sorted(list(C2.items()),key=lambda x:x[1])
K1=C1[-1][0]
V1=C1[-1][1]
K2=C2[-1][0]
V2=C2[-1][1]
if V1>V2:
if K1==K2:
V2=C2[-2][1]
elif V2>V1:
if K1==K2:
V1=C1[-2][1]
else:
if K1==K2:
if len(set(V))==1:
V2=0
else:
V2=max(C1[-2][1],C2[-2][1])
print((N-V1-V2)) | N=int(eval(input()))
*V,=list(map(int,input().split()))
from collections import*
C1=Counter(V[::2]).most_common()+[(0,0)]
C2=Counter(V[1::2]).most_common()+[(0,0)]
K1=C1[0][0]
V1=C1[0][1]
K2=C2[0][0]
V2=C2[0][1]
if K1==K2:
if V1>V2:
V2=C2[1][1]
elif V2>V1:
V1=C[1][1]
else:
V2=max(C1[1][1],C2[1][1])
print((N-V1-V2)) | p03244 |
n = int(eval(input()))
vl = list(map(int,input().split()))
v1 = vl[::2]
v2 = vl[1::2]
def count(a):
d = dict()
for i in a:
if i not in d:
d[i] = 1
else:
d[i] += 1
l = []
for i in d:
l.append([d[i],i])
l.append([0,0])
l.sort(reverse=1)
return l
v1 = count(v1)
v2 = count(v2)
if v1[0][0] == v1[1][0] or v2[0][0] ==v2[1][0]:
print((n-v1[0][0]-v2[0][0]))
elif v1[0][1] != v2[0][1]:
print((n-v1[0][0]-v2[0][0]))
elif v1[1][0]+v2[0][0] > v1[0][0]+v2[1][0]:
print((n-v1[1][0]-v2[0][0]))
else:
print((n-v1[0][0]-v2[1][0])) | n = int(eval(input()))
vl = list(map(int,input().split()))
v1 = vl[::2]
v2 = vl[1::2]
def count(a):
d = dict()
for i in a:
if i not in d:
d[i] = 1
else:
d[i] += 1
l = []
for i in d:
l.append([d[i],i])
l.append([0,0])
l.sort(reverse=1)
return l
v1 = count(v1)
v2 = count(v2)
if v1[0][1] != v2[0][1]:
print((n-v1[0][0]-v2[0][0]))
elif v1[1][0]+v2[0][0] > v1[0][0]+v2[1][0]:
print((n-v1[1][0]-v2[0][0]))
else:
print((n-v1[0][0]-v2[1][0])) | p03244 |
from collections import Counter
n = int(eval(input()))
lst_v = list(map(int, input().split()))
lst_o = lst_v[::2]
lst_e = lst_v[1::2]
cnt_o = Counter(lst_o).most_common() + [(0, 0)]
cnt_e = Counter(lst_e).most_common() + [(0, 0)]
if cnt_o[0][0] == cnt_e[0][0]:
rem_number = max(cnt_o[0][1] + cnt_e[1][1], cnt_o[1][1] + cnt_e[0][1])
else:
rem_number = cnt_o[0][1] + cnt_e[0][1]
ans = n - rem_number
print(ans) | from collections import Counter
n = int(eval(input()))
ls = list(map(int, input().split()))
ac = Counter(ls[::2]).most_common(2)
bd = Counter(ls[1::2]).most_common(2)
if ac[0][0] != bd[0][0]:
print((n-ac[0][1]-bd[0][1]))
else:
if len(ac) == 1 or len(bd) == 1:
print((n//2))
else:
print((n-max(ac[0][1] + bd[1][1], ac[1][1] + bd[0][1]))) | p03244 |
import sys
input = sys.stdin.readline
from collections import Counter
from operator import itemgetter
def mpsort(m):
ary = sorted([[k, v] for (k, v) in list(m.items())], key=itemgetter(1), reverse=True)
if len(ary) == 1:
return ary[0], [0, 0]
return ary[0], ary[1]
def main():
n = int(input().strip())
v = list(map(int, input().strip().split()))
gu = [i for i in v[::2]]
ki = [i for i in v[1::2]]
gu_map = Counter(gu)
ki_map = Counter(ki)
gu_sum = sum(gu_map.values())
ki_sum = sum(ki_map.values())
# print(gu_map)
gu_f, gu_s = mpsort(gu_map)
ki_f, ki_s = mpsort(ki_map)
if gu_f[0] == ki_f[0]:
print((min(gu_sum - gu_s[1] + ki_sum - ki_f[1],
gu_sum - gu_f[1] + ki_sum - ki_s[1])))
else:
print((gu_sum - gu_f[1] + ki_sum - ki_f[1]))
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
from collections import Counter
from operator import itemgetter
def mpsort(m):
ary = sorted([[k, v] for (k, v) in list(m.items())], key=itemgetter(1), reverse=True)
if len(ary) == 1:
return ary[0], [0, 0]
return ary[0], ary[1]
def main():
n = int(input().strip())
v = list(map(int, input().strip().split()))
gu = [i for i in v[::2]]
ki = [i for i in v[1::2]]
gu_map = Counter(gu)
ki_map = Counter(ki)
s = n//2
# print(gu_map)
gu_f, gu_s = mpsort(gu_map)
ki_f, ki_s = mpsort(ki_map)
if gu_f[0] == ki_f[0]:
print((min(s - gu_s[1] + s - ki_f[1],
s - gu_f[1] + s - ki_s[1])))
else:
print((s - gu_f[1] + s - ki_f[1]))
if __name__ == '__main__':
main()
| p03244 |
#!/usr/bin/env python3
n = int(eval(input()))
a = list(map(int,input().split()))
cnt_odd = [0]*(10**5+1)# a[2k]での個数
cnt_even = [0]*(10**5+1)
for i in range(n):
if i %2: cnt_odd[a[i]] += 1
else: cnt_even[a[i]] += 1
odd,idx_odd=list(zip(*sorted(zip(cnt_odd,list(range(10**5+1))))))
even,idx_even=list(zip(*sorted(zip(cnt_even,list(range(10**5+1))))))
#print(odd[-1],even[-2],odd[-2],even[-1])
if idx_even[-1]!=idx_odd[-1]:
print((n - odd[-1] - even[-1]))
else:
print((n - max(odd[-1]+even[-2],odd[-2]+even[-1])))
#ちゃんとテストケース書かないと落ちる
| n = int(eval(input()))
v = list(map(int, input().split()))
freq_odd = [0] * (10 ** 5 + 1)
freq_even = [0] * (10 ** 5 + 1)
for i in range(n // 2):
freq_odd[v[2 * i]] += 1
freq_even[v[2 * i + 1]] += 1
# print(freq_odd[:10], freq_even[:10])
freq_even, id_even = list(zip(*sorted(zip(freq_even, list(range(10 ** 5 + 1))))))
freq_odd, id_odd = list(zip(*sorted(zip(freq_odd, list(range(10 ** 5 + 1))))))
# print(freq_odd[-2:], freq_even[-2:])
# print(id_even[-1], id_odd[-1])
if id_even[-1] != id_odd[-1]:
print((n - freq_even[-1] - freq_odd[-1]))
else:
print((min(n - freq_even[-2] - freq_odd[-1], n - freq_even[-1] - freq_odd[-2])))
| p03244 |
n=int(eval(input()))
V=list(map(int,input().split()))
from collections import Counter
V_1=V[::2]
V_2=V[1::2]
V_1_counter=Counter(V_1).most_common()
V_2_counter=Counter(V_2).most_common()
c1 = V_1_counter
c2 = V_2_counter
if c1[0][0]!=c2[0][0]:
print((n-c1[0][1]-c2[0][1]))
if c1[0][0]==c2[0][0]:
if len(c1)==len(c2)==1:
print((n//2))
if len(c1)==1 and len(c2)!=1:
print((n-c1[0][1]-c2[1][1]))
if len(c2)==1 and len(c1)!=1:
print((n-c1[1][1]-c2[0][1]))
if len(c1)>1 and len(c2)>1:
print((n-max(c1[1][1]+c2[0][1],c1[0][1]+c2[1][1]))) | N=int(eval(input()))
V=list(map(int,input().split()))
from collections import Counter
V_1=V[::2]
V_2=V[1::2]
V_1_counter=Counter(V_1).most_common()
V_2_counter=Counter(V_2).most_common()
# print(V_1_counter,V_2_counter)
V_1_max_1 = V_1_counter[0]
V_1_max_2=(0,0)
if len(V_1_counter)>1:
V_1_max_2 = V_1_counter[1]
V_2_max_1=V_2_counter[0]
V_2_max_2=(0,0)
if len(V_2_counter)>1:
V_2_max_2 = V_2_counter[1]
if V_1_max_1[0] != V_2_max_1[0]:
ans = N-V_1_max_1[1]-V_2_max_1[1]
else:
ans=N-max(V_1_max_1[1]+V_2_max_2[1],V_1_max_2[1]+V_2_max_1[1])
print(ans) | p03244 |
N=int(eval(input()))
lv=list(map(int,input().split()))
dev={}
dod={}
#cev=0#devの種類数
#cod=0#dodの種類数
max1_ev=[0,0]#数字,個数
max2_ev=[0,0]
max1_od=[0,0]#数字,個数
max2_od=[0,0]
for i in range(N):
if i%2==0:#even
#max1_ev=[0,0]#数字,個数
#max2_ev=[0,0]
#毎回初期化していた！！
if lv[i] in dev:#辞書の更新
dev[lv[i]]+=1
else:
dev[lv[i]]=1
#maxの更新
#cev+=1
#if cev==1:
# max1_ev=[i,lv[i]]
#elif cev==2:
# max2_ev=[i,lv[i]]
##3種目以降
#最大個数の更新
if dev[lv[i]]>max1_ev[1]:
max1_ev=[lv[i],dev[lv[i]]]
#elif dev[lv[i]]>max2_ev[1]:
elif dev[lv[i]]>=max2_ev[1]:
max2_ev=[lv[i],dev[lv[i]]]
#print("dev[lv[i]]",dev[lv[i]])
#print("max1__ev[1]",max1_ev[1])
#print("max1_ev",max1_ev)
#print("max2_ev",max2_ev)
#if i==0:
# max1=[0,1]
#elif i==1:
# max2
else:#odd
#max1_od=[0,0]
#max2_od=[0,0]
if lv[i] in dod:
dod[lv[i]]+=1
else:
dod[lv[i]]=1
if dod[lv[i]]>max1_od[1]:
max1_od=[lv[i],dod[lv[i]]]
#elif dod[lv[i]]>max2_od[1]:
elif dod[lv[i]]>=max2_od[1]:
max2_od=[lv[i],dod[lv[i]]]
#print("dev",dev)#ok
#print("dod",dod)#ok
#print("max1_ev",max1_ev)
#print("max2_ev",max2_ev)
#if len(dev)==1 and len(dod)==1:
# print(int(N/2))
#elif len(dev)==1:
#for i in range(len(dod)):
# if i==0:
# max1_od=
# if max1_ev[0]!=max1_od[0]:
# print(N-max1_ev[1]-max1_od[1])
## print(max)
if max1_ev[0]!=max1_od[0]:
print((N-max1_ev[1]-max1_od[1]))
elif len(dev)==1 and len(dod)==1:
print((int(N/2)))
elif len(dev)==1:
print((int(N/2)-max2_od[1]))
elif len(dod)==1:
print((int(N/2)-max2_ev[1]))
else:
#print(max(N-max1_ev[1]-max2_od[1],N-max2_ev[1]-max1_od[1]))#minをmaxとしていた
print((min(N-max1_ev[1]-max2_od[1],N-max2_ev[1]-max1_od[1])))
| N=int(eval(input()))
lv=list(map(int,input().split()))
dev={}
dod={}
for i in range(N):
if i%2==0:#even
if lv[i] in dev:
dev[lv[i]]+=1
else:
dev[lv[i]]=1
else:#odd
if lv[i] in dod:
dod[lv[i]]+=1
else:
dod[lv[i]]=1
max1_ev=[0,0]
max2_ev=[0,0]
max1_od=[0,0]
max2_od=[0,0]
#for i in range(len(dev)):
for v in dev:#max even
if dev[v]>max1_ev[1]:
a=max1_ev
max1_ev=[v,dev[v]]
max2_ev=a
elif dev[v]>max2_ev[1]:
max2_ev=[v,dev[v]]
for v in dod:#max odd
if dod[v]>max1_od[1]:
a=max1_od
max1_od=[v,dod[v]]
max2_od=a
elif dod[v]>max2_od[1]:
max2_od=[v,dod[v]]
if max1_ev[0]!=max1_od[0]:
print((N-max1_ev[1]-max1_od[1]))
else:
print((min(N-max1_ev[1]-max2_od[1],N-max2_ev[1]-max1_od[1])))
| p03244 |
import collections
N = int(eval(input()))
V = [int(x) for x in input().split()]
Va, Vb = [], []
for i in range(N):
if i % 2 == 0:
Va.append(V[i])
else:
Vb.append(V[i])
Va_most = collections.Counter(Va).most_common()
Vb_most = collections.Counter(Vb).most_common()
if N == collections.Counter(V).most_common()[0][1]:
print((N//2))
exit()
if Va_most[0][0] == Vb_most[0][0]:
typea = 10 ** 10
if len(Vb_most) >= 2:
typea = (len(Va) - Va_most[0][1]) + (len(Vb) - Vb_most[1][1])
typeb = 10 ** 10
if len(Va_most) >= 2:
typeb = (len(Va) - Va_most[1][1]) + (len(Vb) - Vb_most[0][1])
print((min(typea, typeb)))
exit()
print(((len(Va) - Va_most[0][1]) + (len(Vb) - Vb_most[0][1]))) | import itertools
from collections import Counter
N = int(eval(input()))
V = [int(x) for x in input().split()]
EV_cnt = Counter(V[::2])
OD_cnt = Counter(V[1::2])
EV_cnt[-1] = 0
OD_cnt[-2] = 0
EV = EV_cnt.most_common(2)
OD = OD_cnt.most_common(2)
ans = N
for (k1,v1), (k2,v2) in itertools.product(EV,OD):
if k1 == k2:
continue
x = (N - v1 - v2)
if ans > x:
ans = x
print(ans) | p03244 |
import collections
n = int(eval(input()))
V = [int(i) for i in input().split()]
E,O = [],[]
E_cnt2,O_cnt2 = 0,0
for i in range(n):
if i%2:
E.append(V[i])
else:
O.append(V[i])
e = collections.Counter(E)
tmp = e.most_common()
E_mode,E_cnt = tmp[0][0],tmp[0][1]
if len(tmp)>=2:
E_cnt2 = tmp[1][1]
o = collections.Counter(O)
tmp = o.most_common()
O_mode,O_cnt = tmp[0][0],tmp[0][1]
if len(tmp)>=2:
O_cnt2 = tmp[1][1]
if E_mode!=O_mode:
print((len(E)-E_cnt+len(O)-O_cnt))
else:
print((min((len(E)-E_cnt+len(O)-O_cnt2),len(E)-E_cnt2+len(O)-O_cnt)))
| import collections
n = int(eval(input()))
v = [int(i) for i in input().split()]
kisu = []
gusu = []
kisu = v[::2]
gusu = v[1::2]
kisu_cnt = collections.Counter(kisu)
gusu_cnt = collections.Counter(gusu)
kisu_cnt = kisu_cnt.most_common(2)#引数にnを用意すると，出現回数の多い順にn子だけ呼び出せる
gusu_cnt = gusu_cnt.most_common(2)
kisu_most = 0
gusu_most = 0
if kisu_cnt[0][0]!=gusu_cnt[0][0]:
print((n-kisu_cnt[0][1]-gusu_cnt[0][1]))
exit()
else:
if len(kisu_cnt)==1 or len(gusu_cnt)==1:
print((n//2))
exit()
else:
print((n-max(kisu_cnt[0][1]+gusu_cnt[1][1],kisu_cnt[1][1]+gusu_cnt[0][1]))) | p03244 |
# coding: utf-8
# Your code here!
n=int(eval(input()))
v=[int(x) for x in input().split()]
if len(set(v))==1:
print((n//2))
import sys
sys.exit()
from collections import Counter
v1=[]
v2=[]
for i in range(n):
if i%2==0:
v1.append(v[i])
else:
v2.append(v[i])
v1=Counter(v1)
v2=Counter(v2)
ans=10**10
# print(v1,v2)
for i1 in v1.most_common():
for i2 in v2.most_common():
# print(n-i1[1]-i2[1],i1,i2)
ans=min(n-i1[1]-i2[1],ans)
print(ans) | # coding: utf-8
# Your code here!
n=int(eval(input()))
v=[int(x) for x in input().split()]
if len(set(v))==1:
print((n//2))
import sys
sys.exit()
from collections import Counter
v1=[]
v2=[]
for i in range(n):
if i%2==0:
v1.append(v[i])
else:
v2.append(v[i])
v1=Counter(v1)
v2=Counter(v2)
ans=10**10
# print(v1,v2)
for i1 in v1.most_common(min(len(v1),10)):
for i2 in v2.most_common(min(len(v1),10)):
# print(n-i1[1]-i2[1],i1,i2)
if i1==i2:
continue
ans=min(n-i1[1]-i2[1],ans)
print(ans) | p03244 |
from collections import Counter
n = int(input())
V = list(map(int, input().split()))
Odd, Evn = [], []
for i in range(n):
Evn.append(V[i]) if i%2 == 0 else Odd.append(V[i])
Evn = sorted( dict(Counter(Evn)).items(), key = lambda x:x[1])
Odd = sorted( dict(Counter(Odd)).items(), key = lambda x:x[1])
cnt = -1
for evn in Evn:
for odd in Odd:
if evn[0] != odd[0]:
cnt = max(cnt, evn[1]+odd[1])
print(n-cnt) if cnt > 0 else print(n//2)
| from collections import Counter
n = int(input())
V = list(map(int, input().split()))
Odd, Evn = [], []
for i in range(n):
Evn.append(V[i]) if i%2 == 0 else Odd.append(V[i])
Evn = sorted( dict(Counter(Evn)).items(), key = lambda x:x[1], reverse=True)
Odd = sorted( dict(Counter(Odd)).items(), key = lambda x:x[1], reverse=True)
cnt = -1
for evn in Evn[0:2]:
for odd in Odd[0:2]:
if evn[0] != odd[0]:
cnt = max(cnt, evn[1]+odd[1])
print(n-cnt) if cnt > 0 else print(n//2)
| p03244 |
n = int(eval(input()))
v = list(map(int,input().split()))
v_odd = []
v_even = []
for i in range(n//2):
v_odd.append(v[2*i])
v_even.append(v[2*i+1])
p1 = 0
p2 = 0
q1 = 0
q2 = 0
o_max = -1
e_max = -1
for i in range(n//2):
a = v_odd[i]
b = v_even[i]
x = v_odd.count(a)
y = v_even.count(b)
if p1 <= x:
if o_max != a:
o_max = a
p2 = p1
p1 = x
else:
if x > p2:
p2 = x
if q1 <= y:
if e_max != b:
e_max = b
q2 = q1
q1 = y
else:
if y > q2:
q2 = y
s = p1 + q1
if o_max == e_max:
s = max(p1+q2,q1+p2)
ans = n-s
print(ans) | n = int(eval(input()))
v = list(map(int,input().split()))
v_odd = []
v_even = []
d_odd = {}
d_even = {}
o = []
e = []
for i in range(n//2):
a = v[2*i]
b = v[2*i+1]
if a in d_odd:
d_odd[a] += 1
else:
d_odd[a] = 1
o.append(a)
if b in d_even:
d_even[b] += 1
else:
d_even[b] = 1
e.append(b)
O = 0
E = 0
o_max = 0
o_second = 0
e_max = 0
e_second = 0
for i in o:
x = d_odd[i]
if x >= o_max:
O = i
o_max = x
d_odd.pop(O)
o.remove(O)
for i in o:
x = d_odd[i]
if x >= o_second:
o_second = x
for i in e:
y = d_even[i]
if y >= e_max:
E = i
e_max = y
d_even.pop(E)
e.remove(E)
for i in e:
y = d_even[i]
if y >= e_second:
e_second = y
if O == E:
m = max(o_max+e_second,e_max+o_second)
else:
m = o_max + e_max
print((n-m)) | p03244 |
from collections import Counter
from operator import itemgetter
n = int(eval(input()))
v = tuple(map(int, input().split()))
evens = Counter(v[::2])
odds = Counter(v[1::2])
evens = list(sorted(list(evens.items()), key=itemgetter(1), reverse=True))
odds = list(sorted(list(odds.items()), key=itemgetter(1), reverse=True))
# 出現数降順ソート
ans = n
for even_num, even_cnt in evens[:2] + [(-1, 0)]:
for odd_num, odd_cnt in odds[:2] + [(-1, 0)]:
if even_num == odd_num: continue
ans = min(ans, n - even_cnt - odd_cnt)
# evensとoddsの書き換え先候補として、出現率上位2数を調べる
# 同じ数は使用できない
# 1111のようにevensとoddsがともに同じ数字しかない場合に備え、
# vの要素に含まれない値-1が0個あると考える(片方の-1をすべて書き換えると考える）
print(ans)
| from collections import Counter
from itertools import product
NUM = 0
CNT = 1
n = int(eval(input()))
v = tuple(map(int, input().split()))
c_odd = Counter(v[1::2])
c_even = Counter(v[0::2])
odd_12 = c_odd.most_common()[:2]
even_12 = c_even.most_common()[:2]
# [(num, cnt),(num, cnt)]
ans = n
for o, e in product(odd_12 + [(-1, 0)], even_12 + [(-1, 0)]):
# print(o, e)
if o[NUM] == e[NUM]:
continue
ans = min(ans, n - (o[CNT] + e[CNT]))
print(ans)
| p03244 |
import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline ####
int1 = lambda x: int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
INF = float('inf')
from collections import Counter
def solve():
n = II()
V = LI()
even = V[::2]
odd = V[1::2]
harf = n // 2
ec = Counter(even).most_common()
oc = Counter(odd).most_common()
#print(n)
#print(ec[:3])
#print(oc[:3])
if ec[0][0] == oc[0][0]:
# 小さい方を変える
if ec[0][1] < oc[0][1]:
ans = n - oc[0][1] - (ec[1][1] if len(ec) > 1 else 0)
elif ec[0][1] == oc[0][1]:
ans = n - ec[0][1] - max((ec[1][1] if len(ec) > 1 else 0), (oc[1][1] if len(oc) > 1 else 0))
else:
ans = n - ec[0][1] - (oc[1][1] if len(oc) > 1 else 0)
else:
ans = n - ec[0][1] - oc[0][1]
print(ans)
if __name__ == '__main__':
solve()
| import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline ####
int1 = lambda x: int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
INF = float('inf')
from collections import Counter
def solve():
n = II()
V = LI()
even = V[::2]
odd = V[1::2]
harf = n // 2
ec = Counter(even).most_common()
oc = Counter(odd).most_common()
#print(n)
#print(ec[:3])
#print(oc[:3])
e1 = ec[0][1]
o1 = oc[0][1]
if ec[0][0] == oc[0][0]:
# 小さい方を変える
e2 = ec[1][1] if len(ec) > 1 else 0
o2 = oc[1][1] if len(oc) > 1 else 0
ans = min(n - e1 - o2, n - o1 - e2)
else:
ans = n - e1 - o1
print(ans)
if __name__ == '__main__':
solve()
| p03244 |
from collections import Counter
from itertools import product
N=int(eval(input()))
V=list(map(int,input().split()))
# 出現回数
O_cnt,E_cnt=Counter(V[::2]),Counter(V[1::2])
O_cnt[-1]=0
E_cnt[-2]=0
# 出現回数順
O_key,E_key=O_cnt.most_common(2),E_cnt.most_common(2)
ans=float('inf')
for O_k,E_k in product(O_key,E_key):
if O_k[0]!=E_k[0]:
ans=min(ans,N-O_k[1]-E_k[1])
print(ans)
| from collections import Counter
N=int(eval(input()))
V=list(map(int,input().split()))
v1=V[::2]
v2=V[1::2]
cntV1,cntV2=Counter(v1),Counter(v2)
cntV1,cntV2=cntV1.most_common(2),cntV2.most_common(2)
cntV1.append((0,0))
cntV2.append((0,0))
if cntV1[0][0]!=cntV2[0][0]:
ans=N-(cntV1[0][1]+cntV2[0][1])
else:
ans=max(cntV1[0][1]+cntV2[1][1],cntV1[1][1]+cntV2[0][1])
ans=N-ans
print(ans) | p03244 |
from collections import Counter
n = int(eval(input()))
v=list(map(int,input().split()))
a=Counter(v[0::2]).most_common()
b=Counter(v[1::2]).most_common()
a.append([0,0])
b.append([0,0])
if a[0][0]!=b[0][0]:
print((n-(a[0][1]+b[0][1])))
else:
print((min(n-(a[1][1]+b[0][1]),n-(a[0][1]+b[1][1])))) |
from collections import Counter
def resolve():
N = int(eval(input()))
A = list(map(int, input().split()))
O = Counter(A[::2])
E = Counter(A[1::2])
most_O = O.most_common(2)
most_E = E.most_common(2)
# 番兵
most_O.append((0, 0))
most_E.append((0, 0))
cnt = 0
# key comp
if most_O[0][0] == most_E[0][0]:
# value
res1 = most_O[0][1] + most_E[1][1]
res2 = most_O[1][1] + most_E[0][1]
cnt = max(res1, res2)
else:
cnt = most_O[0][1] + most_E[0][1]
# 数字が少ないものを書き換える為、Nで引く
print((N - cnt))
if __name__ == "__main__":
resolve()
| p03244 |
# -*- coding: utf-8 -*-
N = int(eval(input()))
vN = list(map(int, input().split()))
even = {}
odd = {}
# 奇数番目と偶数番目に分けて集計
for i in range(N):
if i % 2 == 0:
even[vN[i]] = even.get(vN[i], 0) + 1
else:
odd[vN[i]] = odd.get(vN[i], 0) + 1
# 集計数の多い順ソート
even_sorted = sorted(list(even.items()), key=lambda x: x[1], reverse=True)
odd_sorted = sorted(list(odd.items()), key=lambda x: x[1], reverse=True)
# 1番多い数字が同じだった場合の別処理
if even_sorted[0][0] == odd_sorted[0][0]:
# 偶奇それぞれ数字が1種類しかない場合の別処理
if len(even_sorted) == 1 and len(odd_sorted) > 1:
print((N - even_sorted[0][1] - odd_sorted[1][1]))
elif len(even_sorted) > 1 and len(odd_sorted) == 1:
print((N - even_sorted[1][1] - odd_sorted[0][1]))
elif len(even_sorted) == 1 and len(odd_sorted) == 1:
print((N // 2))
else:
# 偶奇それぞれを2番目にしてみて、数の大きい方
print((N - max(even_sorted[1][1] + odd_sorted[0][1], even_sorted[0][1] + odd_sorted[1][1])))
else:
print((N - even_sorted[0][1] - odd_sorted[0][1])) | # -*- coding: utf-8 -*-
N = int(eval(input()))
vN = list(map(int, input().split()))
even = {}
odd = {}
# 奇数番目と偶数番目に分けて集計
for i in range(N):
if i % 2 == 0:
even[vN[i]] = even.get(vN[i], 0) + 1
else:
odd[vN[i]] = odd.get(vN[i], 0) + 1
# 集計数の多い順ソート
even_sorted = sorted(list(even.items()), key=lambda x: x[1], reverse=True)
odd_sorted = sorted(list(odd.items()), key=lambda x: x[1], reverse=True)
# 1番多い数字が同じだった場合の別処理
if even_sorted[0][0] == odd_sorted[0][0]:
# 偶奇それぞれ数字が1種類しかない場合は、この後の比較処理のためにダミーの0を入れておく
if len(even_sorted) == 1:
even_sorted.append((0, 0))
if len(odd_sorted) == 1:
odd_sorted.append((0, 0))
# 偶奇それぞれを2番目にしてみて、数の大きい方
print((N - max(even_sorted[1][1] + odd_sorted[0][1], even_sorted[0][1] + odd_sorted[1][1])))
else:
print((N - even_sorted[0][1] - odd_sorted[0][1])) | p03244 |
from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
v1, v2 = [], []
for i in range(n):
if i%2:
v1.append(v[i])
else:
v2.append(v[i])
vv1 = Counter(v1).most_common()
vv2 = Counter(v2).most_common()
if vv1[0] != vv2[0]:
print((n - vv1[0][1] - vv2[0][1]))
else:
if len(vv1) == len(vv2) == 1:
print((n - max(vv1[0][1], vv2[0][1])))
elif len(vv1) == 1 and len(vv2) == 2:
print((n - vv1[0][1] - vv2[1][1]))
elif len(vv1) == 2 and len(vv2) == 1:
print((n - vv1[1][1] - vv2[0][1]))
else:
print((n - max(vv1[1][1] + vv2[0][1], vv1[0][1] + vv2[1][1]))) | from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
v1, v2 = v[::2], v[1::2]
vv1 = Counter(v1).most_common()
vv2 = Counter(v2).most_common()
if len(set(v)) == 1:
print((n//2))
elif vv1[0] != vv2[0]:
print((n - vv1[0][1] - vv2[0][1]))
else:
print((n - max(vv1[1][1] + vv2[0][1], vv1[0][1] + vv2[1][1]))) | p03244 |
from collections import Counter
N = int(eval(input()))
V = list(map(int, input().split()))
if len(set(V)) == 1:
print((len(V)//2))
exit()
V_odd = [i for i in V[::2]]
V_even = [i for i in V[1::2]]
V_odd_counter = Counter(V_odd)
V_even_counter = Counter(V_even)
vodd = V_odd_counter.most_common()
veven = V_even_counter.most_common()
vlen = len(V)
while True:
if vodd[0][0] != veven[0][0]:
print((vlen - vodd[0][1] - veven[0][1]))
exit()
else:
print((min(vlen - vodd[1][1] - veven[0][1],
vlen - vodd[0][1] - veven[1][1]))) | from collections import Counter
N = int(eval(input()))
V = list(map(int, input().split()))
if len(set(V)) == 1:
print((len(V)//2))
exit()
V_odd = [i for i in V[::2]]
V_even = [i for i in V[1::2]]
V_odd_counter = Counter(V_odd)
V_even_counter = Counter(V_even)
vodd = V_odd_counter.most_common()
veven = V_even_counter.most_common()
vlen = len(V)
while True:
if vodd[0][0] != veven[0][0]:
print((vlen - vodd[0][1] - veven[0][1]))
exit()
else:
print((min(vlen - vodd[1][1] - veven[0][1],
vlen - vodd[0][1] - veven[1][1])))
exit() | p03244 |
from collections import Counter
N = int(eval(input()))
V = list(map(int, input().split()))
s1 = Counter(V).most_common(2)[0]
s2 = Counter(V).most_common(2)[0]
V1 = V[0::2]
V2 = V[1::2]
c1 = c2 = c3 = c4 = 0
Z1 = Counter(V1)
Z2 = Counter(V2)
x1, c1 = Z1.most_common(1)[0]
x2, c2 = Z2.most_common(1)[0]
if len(Z1) > 1:
x3, c3 = Counter(V1).most_common(2)[1]
if len(Z2) > 1:
x4, c4 = Counter(V2).most_common(2)[1]
if x1 == x2:
a = max(c1+c4, c2+c3)
print((N-a))
else:
print((N - c1 - c2)) | # coding: utf-8
import sys
from collections import Counter
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# 奇数番目の最頻値と偶数番目の最頻値が同じ時に注意
N = ir()
V = lr()
odd = V[::2]
even = V[1::2]
cnt_odd = Counter(odd)
cnt_even = Counter(even)
cnt_odd_most = cnt_odd.most_common()
cnt_even_most = cnt_even.most_common()
if cnt_odd_most[0][0] == cnt_even_most[0][0]:
answer = N
if len(cnt_odd_most) > 1:
temp = N - cnt_odd_most[1][1] - cnt_even_most[0][1]
answer = min(answer, temp)
if len(cnt_even_most) > 1:
temp = N - cnt_odd_most[0][1] - cnt_even_most[1][1]
answer = min(answer, temp)
if answer == N:
answer = N // 2
else:
answer = N - cnt_odd_most[0][1] - cnt_even_most[0][1]
print(answer)
| p03244 |
from bisect import bisect_left as bl
from bisect import bisect_right as br
n = int(eval(input()))
v = list(map(int, input().split()))
ev = []
od = []
for i in range(n):
if i % 2 == 0:
ev.append(v[i])
else:
od.append(v[i])
ev.sort()
od.sort()
m = 0
oo = [[0, 0]]
ii = [[0, 0]]
while True:
oo.append([ev[m], br(ev, ev[m], 0, n//2)-bl(ev, ev[m], 0, n//2)])
m += ev.count(ev[m])
if m >= n//2:
break
m = 0
while True:
ii.append([od[m], br(od, od[m], 0, n//2)-bl(od, od[m], 0, n//2)])
m += od.count(od[m])
if m >= n//2:
break
ii.sort(key=lambda x: x[1], reverse=True)
oo.sort(key=lambda x: x[1], reverse=True)
if ii[0][0] != oo[0][0]:
print((n - oo[0][1] - ii[0][1]))
else:
print((min(n - oo[1][1] - ii[0][1], n - oo[0][1] - ii[1][1]))) | n = int(eval(input()))
v = list(map(int, input().split()))
ev = [0]*(max(v)+1)
od = [0]*(max(v)+1)
for i in range(n):
if i % 2 == 0:
ev[v[i]-1] += 1
else:
od[v[i] - 1] += 1
e = sorted(ev)
o = sorted(od)
if ev.index(e[-1]) == od.index(o[-1]) and e[-2] != e[-1] and o[-2] != o[-1]:
print((n-max(e[-1]+o[-2], e[-2]+o[-1])))
else:
print((n-e[-1]-o[-1]))
| p03244 |
from collections import Counter
N = int(eval(input()))
a = list(map(int,input().split()))
E = []
O = []
for k in range(N):
if k%2 == 0:
E.append(a[k])
else:
O.append(a[k])
e = Counter(E).most_common()
o = Counter(O).most_common()
if e[0][0] != o[0][0]:
print((N-e[0][1]-o[0][1]))
else:
if len(e) >= 2 and len(o) >= 2:
print((N-e[0][1]-max(e[1][1],o[1][1])))
elif len(e) >= 2 and len(o) == 1:
print((N//2-e[1][1]))
elif len(e) == 1 and len(o) >= 2:
print((N//2-o[1][1]))
else:
print((N//2))
| from collections import Counter
n = int(eval(input()))
a = list(map(int,input().split()))
e = [a[k] for k in range(0,n,2)]
o = [a[k] for k in range(1,n,2)]
C = Counter(e).most_common()
D = Counter(o).most_common()
if C[0][0] != D[0][0]:
print((n-C[0][1]-D[0][1]))
else:
if len(C) == len(D) == 1:
print((n//2))
elif len(C) == 1 and len(D) > 1:
print((n-C[0][1]-D[1][1]))
elif len(D) == 1 and len(C) > 1:
print((n-D[0][1]-C[1][1]))
else:
print((n-max(D[0][1]+C[1][1],C[0][1]+D[1][1])))
| p03244 |
n = int(eval(input()))
li = list(map(int,input().split()))
li2 = li[::2]
li3 = li[1::2]
max2,max22,max3,max33 = [0,0,0,0]
for i in li2:
a = li2.count(i)
if a > max2:
max22 = max2
max2 = a
b = i
elif a > max22 and i != b:
max22 = a
for i in li3:
a = li3.count(i)
if a > max3:
max33 = max3
max3 = a
c = i
elif a > max33 and i != c:
max33 = a
if b == c:
print((max(n-max22-max3,n-max2-max33)))
else:
print((n-max2-max3))
| n = int(eval(input()))
v = list(map(int,input().split()))
cnt1 = {}
cnt2 = {}
for i in range(n):
if i % 2 == 0:
if v[i] in cnt1:
cnt1[v[i]] += 1
else:
cnt1[v[i]] = 1
else:
if v[i] in cnt2:
cnt2[v[i]] += 1
else:
cnt2[v[i]] = 1
sorted_cnt1 = sorted(list(cnt1.items()), key = lambda x: x[1], reverse = True)
sorted_cnt2 = sorted(list(cnt2.items()), key = lambda x: x[1], reverse = True)
sorted_cnt1.append((-1,0))
sorted_cnt2.append((-1,0))
if sorted_cnt1[0][0] != sorted_cnt2[0][0]:
print((n - sorted_cnt1[0][1] - sorted_cnt2[0][1]))
else:
print((n - max(sorted_cnt1[0][1] + sorted_cnt2[1][1], sorted_cnt1[1][1]+sorted_cnt2[0][1])))
| p03244 |
N=int(eval(input()))
*V,=list(map(int,input().split()))
import collections
import collections
c1=collections.Counter(V[0::2])
c1=sorted(list(c1.items()), key=lambda x: x[1], reverse=True)
e=c1[0][0]
c2=collections.Counter(V[1::2])
c2=sorted(list(c2.items()), key=lambda x: x[1], reverse=True)
o=c2[0][0]
cnt=0
if e!=o:
cnt=sum(e!=i for i in V[0::2])
cnt+=sum(o!=i for i in V[1::2])
else:
if len(c1)==1 and len(c2)==1:
cnt=N//2
elif len(c1)==1:
cnt1=sum(e!=i for i in V[0::2])
cnt1+=sum(c2[1][0]!=i for i in V[1::2])
cnt2=sum(e!=i for i in V[0::2])
cnt2+=sum(c2[1][1]!=i for i in V[1::2])
cnt=min(cnt1,cnt2)
elif len(c2)==1:
cnt1=sum(c1[1][0]!=i for i in V[0::2])
cnt1+=sum(o!=i for i in V[1::2])
cnt2=sum(c1[1][1]!=i for i in V[0::2])
cnt2+=sum(o!=i for i in V[1::2])
cnt=min(cnt1,cnt2)
else:
cnt1=sum(e!=i for i in V[0::2])
cnt1+=sum(c2[1][0]!=i for i in V[1::2])
cnt2=sum(c1[1][0]!=i for i in V[0::2])
cnt2+=sum(o!=i for i in V[1::2])
cnt=min(cnt1,cnt2)
print(cnt) | N=int(eval(input()))
*V,=list(map(int,input().split()))
import collections
c1=collections.Counter(V[0::2]).most_common()
c2=collections.Counter(V[1::2]).most_common()
c1.append([0,0])
c2.append([0,0])
if c1[0][0]!=c2[0][0]:
print((N-c1[0][1]-c2[0][1]))
else:
print((min(N-c1[0][1]-c2[1][1],N-c1[1][1]-c2[0][1]))) | p03244 |
import sys
from collections import Counter
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip() # input string
ni = lambda: int(readline().rstrip()) # input int
nm = lambda: list(map(int, readline().split())) # input multiple int
nl = lambda: list(map(int, readline().split())) # input multiple int to list
n = ni()
v = nl()
odd = Counter(v[0::2])
even = Counter(v[1::2])
odd["$"] = 0
even["#"] = 0
ans = 0
if odd.most_common()[0][0] == even.most_common()[0][0]:
if odd.most_common()[1][1] > even.most_common()[1][1]:
ans = n - odd.most_common()[1][1] - even.most_common()[0][1]
else:
ans = n - odd.most_common()[0][1] - even.most_common()[1][1]
else:
ans = n - odd.most_common()[0][1] - even.most_common()[0][1]
"""if len(odd) == 1:
pass
else:
for v in odd.values():
max_odd = max(max_odd, v)
ans += len(odd) - max_odd
if len(even) == 1:
pass
else:
for v in even.values():
max_even = max(max_even, v)
ans += len(even) - max_even"""
print(ans) | from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
odd = Counter(v[0::2])
even = Counter(v[1::2])
odd["$"] = 0
even["#"] = 0
ans = 0
if odd.most_common()[0][0] == even.most_common()[0][0]:
if odd.most_common()[1][1] > even.most_common()[1][1]:
ans = n - odd.most_common()[1][1] - even.most_common()[0][1]
else:
ans = n - odd.most_common()[0][1] - even.most_common()[1][1]
else:
ans = n - odd.most_common()[0][1] - even.most_common()[0][1]
print(ans) | p03244 |
import collections
def main():
n = int(eval(input()))
*v, = list(map(int, input().split()))
v0 = count(v[::2])
v1 = count(v[1::2])
if len(v0) == 1 and len(v1) == 1:
if v0[0][0] == v1[0][0]:
print((n // 2))
else:
print((0))
return
l0 = max(2, len(v0))
l1 = max(2, len(v1))
INF = 10 ** 9
score = [[0] * l1 for _ in range(l0)]
for i in range(l0):
for j in range(l1):
score[i][j] = sum_v(v0, i) + sum_v(v1, j)
if i >= l0 - 1 or j >= l1 - 1 or v0[i][0] == v1[j][0]:
score[i][j] = INF
print((min([min(s) for s in score])))
def count(v):
return collections.Counter(v).most_common()
def sum_v(v, ii):
return sum([vv[1] for i, vv in enumerate(v) if i != ii])
main()
| import collections
def main():
n = int(eval(input()))
*v, = list(map(int, input().split()))
v0 = count(v[::2])
v1 = count(v[1::2])
if len(v0) == 1 and len(v1) == 1:
if v0[0][0] == v1[0][0]:
print((n // 2))
else:
print((0))
return
l0 = min(2, len(v0))
l1 = min(2, len(v1))
INF = 10 ** 9
score = [[0] * l1 for _ in range(l0)]
for i in range(l0):
for j in range(l1):
score[i][j] = sum_v(v0, i) + sum_v(v1, j)
if i >= l0 or j >= l1 or v0[i][0] == v1[j][0]:
score[i][j] = INF
print((min([min(s) for s in score])))
def count(v):
return collections.Counter(v).most_common()
def sum_v(v, ii):
return sum([vv[1] for i, vv in enumerate(v) if i != ii])
main()
| p03244 |
import math,fractions
from collections import Counter
n = int(eval(input()))
v = [int(i) for i in input().split()]
a = [v[i] for i in range(n) if i%2]
b = [v[i] for i in range(n) if i%2==0]
cnt_a = Counter(a)
cnt_b = Counter(b)
max_a = cnt_a.most_common()[0][1]
max_b = cnt_b.most_common()[0][1]
str_a = cnt_a.most_common()[0][0]
str_b = cnt_b.most_common()[0][0]
max_2a = 0
max_2b = 0
for i in cnt_a:
if str_a != i and cnt_a[i] > max_2a:
max_2a = cnt_a[i]
for i in cnt_b:
if str_b != i and cnt_b[i] > max_2b:
max_2b = cnt_b[i]
if str_a != str_b:
print((n//2 - max_a + n//2 - max_b))
else:
tmp_a = n//2 - max_2a + n//2 - max_b
tmp_b = n//2 - max_a + n//2 - max_2b
print((min(tmp_a,tmp_b))) | import math,fractions
from collections import Counter
n = int(eval(input()))
v = [int(i) for i in input().split()]
a = Counter(v[1::2]).most_common()
b = Counter(v[0::2]).most_common()
a.append((0,0))
b.append((0,0))
if a[0][0] != b[0][0]:
print((n//2 - a[0][1] + n//2 - b[0][1]))
else:
tmp_x = n//2 - a[1][1] + n//2 - b[0][1]
tmp_y = n//2 - a[0][1] + n//2 - b[1][1]
print((min(tmp_x, tmp_y)))
| p03244 |
import collections as coll
n = int(eval(input()))
v = list(map(int,input().split()))
even = []
odd = []
for i in range(n):
if i % 2 == 0:
even.append(v[i])
else:
odd.append(v[i])
oddc = coll.Counter(odd).most_common()[:2]
evenc = coll.Counter(even).most_common()[:2]
if(len(oddc) == 1):
oddc.append((0,0))
if(len(evenc) == 1):
evenc.append((0,0))
if(oddc[0][0] != evenc[0][0]):
print((n - oddc[0][1] - evenc[0][1]))
else:
print((min(n-oddc[0][1]-evenc[1][1],n-oddc[1][1]-evenc[0][1]))) | import collections as coll
n = int(eval(input()))
v = list(map(int,input().split()))
even = v[0::2]
odd = v[1::2]
oddc = coll.Counter(odd).most_common()[:2]
evenc = coll.Counter(even).most_common()[:2]
if(len(oddc) == 1):
oddc.append((0,0))
if(len(evenc) == 1):
evenc.append((0,0))
if(oddc[0][0] != evenc[0][0]):
print((n - oddc[0][1] - evenc[0][1]))
else:
print((min(n-oddc[0][1]-evenc[1][1],n-oddc[1][1]-evenc[0][1]))) | p03244 |
import itertools
from collections import Counter
N = int(eval(input()))
V = [int(x) for x in input().split()]
EV_counter = Counter(V[::2])
OD_counter = Counter(V[1::2])
# 1種類しかないとき対策
EV_counter[-1] = 0
OD_counter[-2] = 0
# 上位2種しか使う必要がない
EV = EV_counter.most_common(2)
OD = OD_counter.most_common(2)
answer = N
for (k1,v1), (k2,v2) in itertools.product(EV,OD):
if k1 == k2:
continue
x = (N - v1 - v2)
if answer > x:
answer = x
print(answer)
| from collections import Counter
n=int(eval(input()))
v=list(map(int,input().split()))
a=Counter(v[0::2]).most_common()
b=Counter(v[1::2]).most_common()
a.append([0,0])
b.append([0,0])
if a[0][0]!=b[0][0]:
print((n-(a[0][1]+b[0][1])))
else:
print((min(n-(a[1][1]+b[0][1]),n-(a[0][1]+b[1][1]))))
| p03244 |
# -*- coding: utf-8 -*-
from collections import defaultdict
from operator import itemgetter
def solve():
n = int(eval(input()))
V = list(map(int, input().split()))
l = defaultdict(int)
u = defaultdict(int)
for i in range(0,n,2):
l[V[i]] += 1
u[V[i+1]] += 1
l = sorted(list(l.items()),key=itemgetter(1))[::-1]
u = sorted(list(u.items()),key=itemgetter(1))[::-1]
if len(l) == len(u) == 1:
if l[0][0] != u[0][0]:
res = 0
else:
res = min(l[0][1], u[0][1])
else:
if l[0][0] != u[0][0]:
res = sum(map(itemgetter(1), l[1:])) + sum(map(itemgetter(1), u[1:]))
elif len(u) == 1 or (len(l) > 1 and l[1][1]+u[0][1] > l[0][1]+u[1][1]):
res = l[0][1] + sum(map(itemgetter(1), l[2:])) + sum(map(itemgetter(1), u[1:]))
else:
res = u[0][1] + sum(map(itemgetter(1), l[1:])) + sum(map(itemgetter(1), u[2:]))
return str(res)
if __name__ == '__main__':
print((solve()))
| # -*- coding: utf-8 -*-
from collections import Counter
from operator import itemgetter
def solve():
eval(input())
V = list(map(int, input().split()))
l = sorted(list(Counter(V[::2]).items())+[(0,0)], key=itemgetter(1), reverse=True)
u = sorted(list(Counter(V[1::2]).items())+[(0,0)], key=itemgetter(1), reverse=True)
res = sum(map(itemgetter(1), l+u)) - (max(l[0][1]+u[1][1], l[1][1]+u[0][1]) if l[0][0]==u[0][0] else (l[0][1]+u[0][1]))
return str(res)
if __name__ == '__main__':
print((solve()))
| p03244 |
import itertools
import math
import fractions
import functools
import copy
n = int(eval(input()))
v = list(map(int, input().split()))
kisu = [0]*(10**6)
gusu = [0]*(10**6)
for i in range(n):
if i % 2 == 0:
gusu[v[i]] += 1
else:
kisu[v[i]] += 1
count = 0
gusu_m = gusu.index(max(gusu))
kisu_m = kisu.index(max(kisu))
if gusu_m == kisu_m:
gusu[gusu_m] = 0
kisu[kisu_m] = 0
if max(gusu) > max(kisu):
gusu_m = gusu.index(max(gusu))
else:
kisu_m = kisu.index(max(kisu))
for i in range(n):
if i % 2 == 0 and gusu_m != v[i]:
count += 1
if i % 2 != 0 and kisu_m != v[i]:
count += 1
print(count)
|
n = int(eval(input()))
v = list(map(int, input().split()))
kisu = [0]*(10**6)
gusu = [0]*(10**6)
for i in range(n):
if i % 2 == 0:
gusu[v[i]] += 1
else:
kisu[v[i]] += 1
count = 0
gusu_m = gusu.index(max(gusu))
kisu_m = kisu.index(max(kisu))
if gusu_m == kisu_m:
gusu[gusu_m] = 0
kisu[kisu_m] = 0
if max(gusu) > max(kisu):
gusu_m = gusu.index(max(gusu))
else:
kisu_m = kisu.index(max(kisu))
for i in range(n):
if i % 2 == 0 and gusu_m != v[i]:
count += 1
if i % 2 != 0 and kisu_m != v[i]:
count += 1
print(count)
| p03244 |
n = int(eval(input()))
v = list(map(int, input().split()))
kisu = [0]*(10**6)
gusu = [0]*(10**6)
for i in range(n):
if i % 2 == 0:
gusu[v[i]] += 1
else:
kisu[v[i]] += 1
count = 0
gusu_m = gusu.index(max(gusu))
kisu_m = kisu.index(max(kisu))
if gusu_m == kisu_m:
gusu[gusu_m] = 0
kisu[kisu_m] = 0
if max(gusu) > max(kisu):
gusu_m = gusu.index(max(gusu))
else:
kisu_m = kisu.index(max(kisu))
for i in range(n):
if i % 2 == 0 and gusu_m != v[i]:
count += 1
if i % 2 != 0 and kisu_m != v[i]:
count += 1
print(count)
| def main():
n = int(eval(input()))
# n, k = map(int, input().split())
v = list(map(int, input().split()))
# s = input()
even = [0] * (10 ** 5 + 100)
odd = [0] * (10 ** 5 + 100)
for i in range(n):
if i % 2 == 0:
even[v[i]] += 1
else:
odd[v[i]] += 1
max_even = even.index(max(even))
max_odd = odd.index(max(odd))
if max_even == max_odd:
even[max_even] = 0
odd[max_odd] = 0
if max(even) < max(odd):
max_odd = odd.index(max(odd))
else:
max_even = even.index(max(even))
ans = 0
for i in range(n):
if i % 2 == 0 and max_even != v[i]:
ans += 1
if i % 2 != 0 and max_odd != v[i]:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| p03244 |
from collections import Counter
import heapq
N = int(eval(input()))
Vs = list(map(int,input().split()))
if len(set(Vs)) == 1:
print((N//2))
exit()
Veve, Vodd = [],[]
idx = 0
for v in Vs:
if idx%2 == 0: Veve.append(v)
else: Vodd.append(v)
idx += 1
Veve_cnt, Vodd_cnt = [], []
[heapq.heappush(Veve_cnt, [-num,val]) for val, num in list(Counter(Veve).items())]
[heapq.heappush(Vodd_cnt, [-num,val]) for val, num in list(Counter(Vodd).items())]
neg_num, val = heapq.heappop(Veve_cnt)
eve_val = val
eve_num = -neg_num
neg_num, val = heapq.heappop(Vodd_cnt)
odd_val = val
odd_num = -neg_num
if eve_val != odd_val:
print((N-eve_num-odd_num))
else:
if len(Vodd_cnt) != 0:odd_num2 = -heapq.heappop(Vodd_cnt)[0]
else:odd_num2 = -float('inf')
if len(Veve_cnt) != 0:eve_num2 = -heapq.heappop(Veve_cnt)[0]
else:eve_num2 = -float('inf')
print((min(N-eve_num2-odd_num,N-eve_num-odd_num2))) | N = int(eval(input()))
V = list(map(int, input().split()))
even_idx_cnt = {}
odd_idx_cnt = {}
for idx, v in enumerate(V):
if idx % 2 == 0:
if v not in even_idx_cnt:
even_idx_cnt[v] = 0
even_idx_cnt[v] += 1
else:
if v not in odd_idx_cnt:
odd_idx_cnt[v] = 0
odd_idx_cnt[v] += 1
if len(even_idx_cnt) == 1 and len(odd_idx_cnt) == 1:
if list(even_idx_cnt.keys()) == list(odd_idx_cnt.keys()):
print((N - even_idx_cnt[V[0]]))
else:
print((0))
exit()
even_idx_cnt = sorted(list(even_idx_cnt.items()), key=lambda x:x[1], reverse=True)
odd_idx_cnt = sorted(list(odd_idx_cnt.items()), key=lambda x:x[1], reverse=True)
if even_idx_cnt[0][0] != odd_idx_cnt[0][0]:
print((N - even_idx_cnt[0][1] - odd_idx_cnt[0][1]))
else:
ans = []
if len(odd_idx_cnt) >= 2:
ans.append(N - even_idx_cnt[0][1] - odd_idx_cnt[1][1])
if len(even_idx_cnt) >= 2:
ans.append(N - even_idx_cnt[1][1] - odd_idx_cnt[0][1])
print((min(ans)))
| p03244 |
N = int(eval(input()))
V = list(map(int,input().split()))
from collections import Counter
def get_counter(X):
counter = Counter(X)
X = sorted(list(counter.items()), key = lambda x:x[1], reverse = True)
X.append((0,0))
return X
V1 = get_counter(V[::2])
V2 = get_counter(V[1::2])
if V1[0][0] != V2[0][0]:
print((N - (V1[0][1] + V2[0][1])))
else:
print((N - max(V1[0][1] + V2[1][1],V1[1][1] + V2[0][1])))
| N = int(eval(input()))
V = list(map(int,input().split()))
from collections import Counter
def get_counter(X):
counter = Counter(X)
X = counter.most_common()
X.append((0,0))
return X
V1 = get_counter(V[::2])
V2 = get_counter(V[1::2])
if V1[0][0] != V2[0][0]:
print((N - (V1[0][1] + V2[0][1])))
else:
print((N - max(V1[0][1] + V2[1][1],V1[1][1] + V2[0][1])))
| p03244 |
from collections import*
n,*v=list(map(int,open(0).read().split()))
a,b=[Counter(i).most_common()+[(0,0)]for i in(v[::2],v[1::2])]
i,j=a[0][1],b[0][1]
print((min(n-i-b[1][1],n-a[1][1]-j)*(a[0][0]==b[0][0])or n-i-j)) | from collections import*;n,*v=list(map(int,open(0).read().split()));a,b=[Counter(v[i::2]).most_common()+[(0,0)]for i in(0,1)];i,x=a[0];j,y=b[0];print((n-[x+y,max(x+b[1][1],y+a[1][1])][i==j])) | p03244 |
import collections
import itertools
n = int(eval(input()))
v = list(map(int,input().split()))
#n = len(v)
c = collections.Counter(v).most_common()
if len(c) == 1:
print((n//2))
exit()
values, counts = list(zip(*c))
k = sorted(list(set(counts)),reverse=True)[:2]
pairs = []
for vcnt in c:
val = vcnt[0]
cnt = vcnt[1]
#print(val,cnt)
if cnt in k:
pairs.append(val)
#print(pairs)
P = list(itertools.combinations(pairs,2))
#print(P)
ans = float('inf')
for pair in P:
#print(pair)
mc = pair[0]
sc = pair[1]
tmp = 0
for i in range(n):
if i % 2 == 0 and v[i] != mc:
tmp += 1
elif i % 2 == 1 and v[i] != sc:
tmp += 1
ttmp = 0
for i in range(n):
if i % 2 == 0 and v[i] != sc:
ttmp += 1
elif i % 2 == 1 and v[i] != mc:
ttmp += 1
ans = min(ans,min(tmp,ttmp))
print(ans) | from collections import Counter
n = int(eval(input()))
v = list(map(int,input().split()))
o = Counter(v[::2]).most_common()
o.append((0,0))
e = Counter(v[1::2]).most_common()
e.append((0,0))
if o[0][0] == e[0][0]:
ans = min(n - o[0][1] - e[1][1], n - o[1][1] - e[0][1])
else:
ans = n - o[0][1] - e[0][1]
print(ans) | p03244 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
N = ii()
A = li()
d_o = defaultdict(int)
d_e = defaultdict(int)
for i in range(N):
if i % 2:
d_o[A[i]] += 1
else:
d_e[A[i]] += 1
l_d = sorted(list(d_o.items()), key=lambda x:x[1], reverse=True)
l_e = sorted(list(d_e.items()), key=lambda x:x[1], reverse=True)
if l_d[0][0] != l_e[0][0]:
print((N - l_d[0][1] - l_e[0][1]))
elif len(l_d) == len(l_e) == 1:
print((N - max(l_d[0][1], l_e[0][1])))
elif len(l_d) == 1:
ans = min(N - l_d[0][1] - l_e[1][1], N - l_e[0][1])
print(ans)
elif len(l_e) == 1:
ans = min(N - l_d[1][1] - l_e[0][1], N - l_d[0][1])
print(ans)
else:
ans = min(N-l_d[1][1]-l_e[0][1], N-l_d[0][1]-l_e[1][1])
print(ans) | import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
N = ii()
A = li()
d_o = defaultdict(int)
d_e = defaultdict(int)
for i in range(N):
if i % 2:
d_o[A[i]] += 1
else:
d_e[A[i]] += 1
l_d = sorted(list(d_o.items()), key=lambda x:x[1], reverse=True)
l_e = sorted(list(d_e.items()), key=lambda x:x[1], reverse=True)
if l_d[0][0] != l_e[0][0]:
print((N - l_d[0][1] - l_e[0][1]))
elif len(l_d) == len(l_e) == 1:
print((N - max(l_d[0][1], l_e[0][1])))
elif len(l_d) == 1:
#ans = min(N - l_d[0][1] - l_e[1][1], N - l_e[0][1])
#print(ans)
print((N - l_d[0][1] - l_e[1][1]))
elif len(l_e) == 1:
#ans = min(N - l_d[1][1] - l_e[0][1], N - l_d[0][1])
#print(ans)
print((N - l_d[1][1] - l_e[0][1]))
else:
ans = min(N-l_d[1][1]-l_e[0][1], N-l_d[0][1]-l_e[1][1])
print(ans) | p03244 |
from collections import Counter
n = int(eval(input()))
V = list(map(int,input().split()))
E = []
O = []
for i,v in enumerate(V):
if i%2==0:
O.append(v)
else:
E.append(v)
cO = Counter(O).most_common(); cO.append((-1,0))
cE = Counter(E).most_common(); cE.append((-1,0))
if cO[0][0]==cE[0][0]:
ans = min(n-cO[0][1]-cE[1][1], n-cO[1][1]-cE[0][1])
else:
ans = n-cO[0][1]-cE[0][1]
print(ans) | from collections import Counter
n = int(eval(input()))
V = list(map(int,input().split()))
cv1 = Counter(V[::2]).most_common()
cv2 = Counter(V[1::2]).most_common()
cv1.append((-1,0)); cv2.append((-1,0))
if cv1[0][0] != cv2[0][0]:
print((n-cv1[0][1]-cv2[0][1]))
else:
print((min(n-cv1[1][1]-cv2[0][1], n-cv1[0][1]-cv2[1][1]))) | p03244 |
from collections import Counter
N = int(eval(input()))
V = list(map(int,input().split()))
c1 = Counter(V[::2])
c2 = Counter(V[1::2])
m1 = c1.most_common()
m2 = c2.most_common()
t2 = N//2
t1 = N - t2
if len(m1) == len(m2) == 1:
print((N//2 if m1[0][0] == m2[0][0] else 0))
elif len(m1) == 1:
if m1[0][0] != m2[0][0]:
print((t1 - m2[0][1]))
else:
print((t1 - m2[1][1]))
elif len(m2) == 1:
if m1[0][0] != m2[0][0]:
print((t2 - m1[0][1]))
else:
print((t2 - m1[1][1]))
else:
if m1[0][0] != m2[0][0]:
print((N - m1[0][1] - m2[0][1]))
else:
ans = N - m1[1][1] - m2[1][1]
if m1[0][0] != m2[1][0]:
ans = min(ans, N - m1[0][1] - m2[1][1])
if m1[1][0] != m2[0][0]:
ans = min(ans, N - m1[1][1] - m2[0][1])
print(ans) | from collections import Counter
N = int(eval(input()))
V = list(map(int,input().split()))
c1 = Counter(V[::2])
c2 = Counter(V[1::2])
n1 = N//2 + N%2
n2 = N//2
if len(c1)==1 and len(c2)==1:
if V[0]==V[1]:
print(n2)
else:
print((0))
elif len(c1)==1:
mc = c2.most_common()
if mc[0][0] == V[0]:
print((n2 - mc[1][1]))
else:
print((n2 - mc[0][1]))
elif len(c2)==1:
mc = c1.most_common()
if mc[0][0] == V[1]:
print((n1 - mc[1][1]))
else:
print((n1 - mc[0][1]))
else:
mc1 = c1.most_common()
mc2 = c2.most_common()
if mc1[0][0] != mc2[0][0]:
print((N - mc1[0][1] - mc2[0][1]))
else:
ans = N
if mc1[0][0] != mc2[1][0]:
ans = min(ans, N - mc1[0][1] - mc2[1][1])
if mc1[1][0] != mc2[0][0]:
ans = min(ans, N - mc1[1][1] - mc2[0][1])
print(ans) | p03244 |
import collections
n = int(eval(input()))
v = list(map(int, input().split()))
a = v[::2]
b = v[1::2]
ac = collections.Counter(a)
bc = collections.Counter(b)
ac = sorted(list(ac.items()), key=lambda x: x[1], reverse=True)
bc = sorted(list(bc.items()), key=lambda x: x[1], reverse=True)
if ac[0][0] == bc[0][0]:
if len(ac) == len(bc) and len(ac) == 1:
print((ac[0][1]))
exit()
i = 0
while ac[i][1] == bc[i][1]:
i += 1
if i == len(ac) - 1 or i == len(bc) - 1:
break
if ac[i][1] > bc[i][1]:
ac.remove(ac[i])
bc.remove(bc[0])
elif ac[i][1] < bc[i][1]:
ac.remove(ac[0])
bc.remove(bc[i])
else:
ac.remove(ac[0])
bc.remove(bc[1])
else:
ac.remove(ac[0])
bc.remove(bc[0])
ans = 0
for i in range(len(ac)):
ans += ac[i][1]
for i in range(len(bc)):
ans += bc[i][1]
print(ans)
| import collections
n = int(eval(input()))
v = list(map(int, input().split()))
a = v[::2]
b = v[1::2]
ac = collections.Counter(a).most_common(2)
bc = collections.Counter(b).most_common(2)
if ac[0][0] != bc[0][0]:
print((n - ac[0][1] - bc[0][1]))
else:
if len(ac) == 1:
print((n // 2))
else:
print((n - max(ac[0][1] + bc[1][1], ac[1][1] + bc[0][1]))) | p03244 |
#python3
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
odd = [a[i] for i in range(n) if i%2==0]
even = [a[i] for i in range(n) if i%2!=0]
cntOdd = Counter(odd).most_common(2)
cntEven = Counter(even).most_common(2)
if cntOdd[0][0] != cntEven[0][0]:
print((n - cntOdd[0][1] - cntEven[0][1]))
else:
if len(cntEven) == 1 and len(cntEven):
print((n//2))
else:
ans1 = n - cntOdd[1][1] - cntEven[0][1]
ans2 = n - cntOdd[0][1] - cntEven[1][1]
print((min(ans1, ans2)))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import Counter
from collections import defaultdict
def main():
n = int(readline())
a = [int(i) for i in readline().split()]
odd = Counter(a[::2]).most_common(2)
even = Counter(a[1::2]).most_common(2)
odd.append((-1, 0))
even.append((-1, 0))
if odd[0][0] == even[0][0]:
print((min(n-odd[1][1]-even[0][1], n-odd[0][1]-even[1][1])))
else:
print((n-odd[0][1]-even[0][1]))
if __name__ == '__main__':
main()
| p03244 |
from collections import Counter
n = int(eval(input()))
*v, = list(map(int, input().split()))
odds = v[1::2]
evens = v[::2]
o = Counter(odds)
e = Counter(evens)
omx, *ol = sorted(list(o.items()), reverse=True, key=lambda x: x[1])
emx, *el = sorted(list(e.items()), reverse=True, key=lambda x: x[1])
if omx[0] != emx[0]:
ans = n - omx[1] - emx[1]
else:
if ol:
ol = ol[0]
else:
ol = (0, 0)
if el:
el = el[0]
else:
el = (0, 0)
a = n - omx[1] - el[1]
b = n - emx[1] - ol[1]
ans = min(a, b)
print(ans) | from collections import Counter
from itertools import product
n = int(eval(input()))
*v, = list(map(int, input().split()))
o = Counter(v[1::2])
e = Counter(v[::2])
o[0] = 0
e[0] = 0
o_ls = o.most_common(2)
e_ls = e.most_common(2)
ans = n
for (k1, v1), (k2, v2) in product(o_ls, e_ls):
if k1 == k2:
continue
x = n - v1 - v2
if ans > x:
ans = x
print(ans) | p03244 |
from collections import *
N = int(eval(input()))
v_list = input().split()
if len(set(v_list)) == 1:
print((len(v_list) // 2))
exit()
v1_list = v_list[::2]
v2_list = v_list[1::2]
v1_count_list = Counter(v1_list).most_common()
v2_count_list = Counter(v2_list).most_common()
if v1_count_list[0][0] != v2_count_list[0][0]:
print((len(v_list) - v1_count_list[0][1] - v2_count_list[0][1]))
else:
countor1 = len(v_list) - v1_count_list[1][1] - v2_count_list[0][1]
countor2 = len(v_list) - v1_count_list[0][1] - v2_count_list[1][1]
print((min(countor1, countor2))) | from collections import *
N = int(eval(input()))
v_list = input().split()
if len(set(v_list)) == 1:
print((len(v_list) // 2))
exit()
v1_count_list = Counter(v_list[::2]).most_common()
v2_count_list = Counter(v_list[1::2]).most_common()
if v1_count_list[0][0] != v2_count_list[0][0]:
leave_value = v1_count_list[0][1] + v2_count_list[0][1]
else:
leave_value = max(v1_count_list[1][1] + v2_count_list[0][1], v1_count_list[0][1] + v2_count_list[1][1])
print((len(v_list) - leave_value)) | p03244 |
from collections import *
N = int(eval(input()))
v_list = input().split()
if len(set(v_list)) == 1:
print((len(v_list) // 2))
exit()
v1_count_list = Counter(v_list[::2]).most_common()
v2_count_list = Counter(v_list[1::2]).most_common()
if v1_count_list[0][0] != v2_count_list[0][0]:
leave_value = v1_count_list[0][1] + v2_count_list[0][1]
else:
leave_value = max(v1_count_list[1][1] + v2_count_list[0][1], v1_count_list[0][1] + v2_count_list[1][1])
print((len(v_list) - leave_value)) | from collections import *
N = eval(input())
v_list = input().split()
if len(set(v_list)) == 1:
print((len(v_list) // 2))
exit()
v1_count_list = Counter(v_list[::2]).most_common(2)
v2_count_list = Counter(v_list[1::2]).most_common(2)
if v1_count_list[0][0] != v2_count_list[0][0]:
leave_value = v1_count_list[0][1] + v2_count_list[0][1]
else:
leave_value = max(v1_count_list[1][1] + v2_count_list[0][1], v1_count_list[0][1] + v2_count_list[1][1])
print((len(v_list) - leave_value)) | p03244 |
def main():
n, *v = list(map(int, open(0).read().split()))
be = [0] * int(1e5)
bo = [0] * int(1e5)
for e, o in zip(*[iter(v)] * 2):
be[e - 1] += 1
bo[o - 1] += 1
if be.index(max(be)) == bo.index(max(bo)):
ve = max(be)
vo = max(bo)
be[be.index(ve)] = 0
bo[bo.index(vo)] = 0
print((min(n - ve - max(bo), n - vo - max(be))))
else:
print((n - max(be) - max(bo)))
return
main()
| def main():
n, *v = list(map(int, open(0).read().split()))
be = [0] * int(1e5)
bo = [0] * int(1e5)
for e, o in zip(*[iter(v)] * 2):
be[e - 1] += 1
bo[o - 1] += 1
ve = max(be)
vo = max(bo)
ke = be.index(ve)
ko = bo.index(vo)
if ke == ko:
be[ke] = 0
bo[ko] = 0
print((min(n - ve - max(bo), n - vo - max(be))))
else:
print((n - ve - vo))
return
main()
| p03244 |
from collections import Counter
n = int(eval(input()))
s = list(map(int, input().split()))
evenL = []
oddL = []
for i, v in enumerate(s):
if i % 2 == 0:
evenL.append(v)
else:
oddL.append(v)
evenLc = Counter(evenL)
oddLc = Counter(oddL)
evenLcs = sorted(list(evenLc.items()), key=lambda x: -x[1])
oddLcs = sorted(list(oddLc.items()), key=lambda x: -x[1])
if evenLcs[0][0] != oddLcs[0][0]:
print((n - evenLcs[0][1] - oddLcs[0][1]))
else:
if len(evenLc) == 1 and len(oddLc) == 1:
print((n - len(evenL)))
exit()
if evenLcs[0][1] > oddLcs[0][1]:
print((n - evenLcs[0][1] - oddLcs[1][1]))
elif evenLcs[0][1] < oddLcs[0][1]:
print((n - evenLcs[1][1] - oddLcs[0][1]))
else:
print((n - evenLcs[0][1] - max(evenLcs[1][1], oddLcs[1][1]))) | from collections import Counter as C
n = int(eval(input()))
V = list(input().split())
V1 = C(V[::2]).most_common()
V2 = C(V[1::2]).most_common()
if V1[0][0] != V2[0][0]:
ans = n - (V1[0][1] + V2[0][1])
else:
l = V1[0][1] + V2[1][1] if len(V2) > 1 else V1[0][1]
r = V1[1][1] + V2[0][1] if len(V1) > 1 else V2[0][1]
if l >= r:
ans = n - l
else:
ans = n - r
print(ans) | p03244 |
n = int(eval(input()))
V = list(map(int, input().split()))
E = {}
O = {}
n = 1
for i, v in enumerate(V):
if n:
if v in list(E.keys()):
E[v] += 1
else:
E[v] = 1
else:
if v in list(O.keys()):
O[v] += 1
else:
O[v] = 1
n = 1 - n
E = sorted(list(E.items()), key=lambda x: -x[1])
O = sorted(list(O.items()), key=lambda x: -x[1])
if E[0][0] != O[0][0]:
ans = sum([x[1] for x in E])-E[0][1]
ans += sum([x[1] for x in O])-O[0][1]
print(ans)
else:
if len(E) == 1 and len(O) == 1:
print((E[0][1]))
elif len(E) == 1:
ans = sum([x[1] for x in E])-E[0][1]
ans += sum([x[1] for x in O])-O[1][1]
print(ans)
elif len(O) == 1:
ans = sum([x[1] for x in E])-E[1][1]
ans += sum([x[1] for x in O])-O[0][1]
print(ans)
else:
ans1 = sum([x[1] for x in E])-E[0][1]
ans1 += sum([x[1] for x in O])-O[1][1]
ans2 = sum([x[1] for x in E])-E[1][1]
ans2 += sum([x[1] for x in O])-O[0][1]
print((min(ans1, ans2))) | n = int(eval(input()))
V = list(map(int, input().split()))
E = {}
O = {}
now = 1
for i, v in enumerate(V):
if now:
if v in list(E.keys()):
E[v] += 1
else:
E[v] = 1
else:
if v in list(O.keys()):
O[v] += 1
else:
O[v] = 1
now = 1 - now
E = sorted(list(E.items()), key=lambda x: -x[1])
O = sorted(list(O.items()), key=lambda x: -x[1])
if E[0][0] != O[0][0]:
print((n - E[0][1] - O[0][1]))
else:
if len(E) == 1 and len(O) == 1:
print((E[0][1]))
elif len(E) == 1:
print((n-E[0][1]-O[1][1]))
elif len(O) == 1:
print((n-E[1][1]-O[0][1]))
else:
print((min(n-E[0][1]-O[1][1], n-E[1][1]-O[0][1]))) | p03244 |
import collections
N = int(eval(input()))
V = [int(_) for _ in input().split()]
def calc(vs):
r = dict(collections.Counter(vs))
r[0] = 0
ri = list(r.items())
return sorted(ri, key=lambda x:-x[1])
ve = calc(V[::2])
vo = calc(V[1::2])
result = 0
if ve[0][0] != vo[0][0]:
result = N - ve[0][1] - vo[0][1]
else:
result = min(N - ve[0][1] - vo[1][1], N - ve[1][1] - vo[0][1])
print(result)
| import collections
N = int(eval(input()))
V = [int(_) for _ in input().split()]
def calc(vs):
cs = collections.Counter(vs)
cs[0] = 0
return cs.most_common()
ve = calc(V[::2])
vo = calc(V[1::2])
result = 0
if ve[0][0] != vo[0][0]:
result = N - ve[0][1] - vo[0][1]
else:
result = N - max(ve[0][1] + vo[1][1], ve[1][1] + vo[0][1])
print(result)
| p03244 |
import sys
def input(): return sys.stdin.readline().rstrip()
from collections import Counter
from operator import itemgetter
def main():
n=int(eval(input()))
V=[int(_) for _ in input().split()]
even=V[0::2]
odd=V[1::2]
even_c=Counter(even)
odd_c=Counter(odd)
even_ci,odd_ci=list(even_c.items()),list(odd_c.items())
even_ci.sort(key=itemgetter(1),reverse=True)
odd_ci.sort(key=itemgetter(1),reverse=True)
if even_ci[0][0]==odd_ci[0][0]:
if len(even_ci)>1 and len(odd_ci)>1:
print((min(sum(even_c.values())-even_ci[1][1]+sum(odd_c.values())-odd_ci[0][1],
sum(even_c.values())-even_ci[0][1]+sum(odd_c.values())-odd_ci[1][1])))
elif len(even_ci)>1 and len(odd_ci)==1:
print((sum(even_c.values())-even_ci[1][1]))
elif len(even_ci)==1 and len(odd_ci)>1:
print((sum(odd_c.values())-odd_ci[0][1]))
else:
print((n//2))
else:
print((sum(even_c.values())-even_ci[0][1]+sum(odd_c.values())-odd_ci[0][1]))
if __name__=='__main__':
main() | import sys
def input(): return sys.stdin.readline().rstrip()
from collections import Counter
from operator import itemgetter
def main():
n=int(eval(input()))
V=[int(_) for _ in input().split()]
even,odd=V[0::2],V[1::2]
even_c,odd_c=Counter(even),Counter(odd)
even_ci,odd_ci=list(even_c.items()),list(odd_c.items())
even_ci.sort(key=itemgetter(1),reverse=True)
odd_ci.sort(key=itemgetter(1),reverse=True)
if even_ci[0][0]==odd_ci[0][0]:
if len(even_ci)>1 and len(odd_ci)>1:
print((min(sum(even_c.values())-even_ci[1][1]+sum(odd_c.values())-odd_ci[0][1],
sum(even_c.values())-even_ci[0][1]+sum(odd_c.values())-odd_ci[1][1])))
elif len(even_ci)>1 and len(odd_ci)==1:
print((sum(even_c.values())-even_ci[1][1]))
elif len(even_ci)==1 and len(odd_ci)>1:
print((sum(odd_c.values())-odd_ci[0][1]))
else:
print((n//2))
else:
print((sum(even_c.values())-even_ci[0][1]+sum(odd_c.values())-odd_ci[0][1]))
if __name__=='__main__':
main() | p03244 |
import collections
n = int(eval(input()))
v = list(map(int, input().split()))
even_odd_length = n / 2
replace_total = 0
list_odd = v[0::2]
list_even = v[1::2]
dict_c_odd = dict(collections.Counter(list_odd))
dict_c_even = dict(collections.Counter(list_even))
dict_c_even_bk = dict_c_even.copy()
dict_c_odd_bk = dict_c_odd.copy()
replace_total_tmp = 0
replace_total_tmp2 = 0
max_count_c_odd = max(dict_c_odd.values())
max_count_c_even = max(dict_c_even.values())
max_count_c_even_bk = max_count_c_even
max_c_odd_keys = [k for k, v in list(dict_c_odd.items()) if v == max_count_c_odd]
max_c_even_keys = [k for k, v in list(dict_c_even.items()) if v == max_count_c_even]
if len(set(v)) == 1:
print((int(even_odd_length)))
else:
if max_c_odd_keys[0] in dict_c_even:
del dict_c_even[max_c_odd_keys[0]]
max_count_c_even = max(dict_c_even.values())
replace_total_tmp = (n - max_count_c_odd - max_count_c_even)
dict_c_even = dict_c_even_bk
max_count_c_even = max_count_c_even_bk
if max_c_even_keys[0] in dict_c_odd:
del dict_c_odd[max_c_even_keys[0]]
max_count_c_odd = max(dict_c_odd.values())
replace_total_tmp2 = (n - max_count_c_odd - max_count_c_even)
if replace_total_tmp >= replace_total_tmp2:
replace_total = replace_total_tmp2
else:
replace_total = replace_total_tmp
print(replace_total) | import collections
n = int(eval(input()))
v = list(map(int, input().split()))
even_odd_length = n / 2
replace_total = 0
list_odd = v[0::2]
list_even = v[1::2]
dict_c_odd = dict(collections.Counter(list_odd))
dict_c_even = dict(collections.Counter(list_even))
dict_c_even_bk = dict_c_even.copy()
replace_total_tmp = 0
replace_total_tmp2 = 0
max_count_c_odd = max(dict_c_odd.values())
max_count_c_even = max(dict_c_even.values())
max_count_c_even_bk = max_count_c_even
max_c_odd_keys = [k for k, v in list(dict_c_odd.items()) if v == max_count_c_odd]
max_c_even_keys = [k for k, v in list(dict_c_even.items()) if v == max_count_c_even]
if len(set(v)) == 1:
print((int(even_odd_length)))
else:
if max_c_odd_keys[0] in dict_c_even:
del dict_c_even[max_c_odd_keys[0]]
max_count_c_even = max(dict_c_even.values())
replace_total_tmp = (n - max_count_c_odd - max_count_c_even)
dict_c_even = dict_c_even_bk
max_count_c_even = max_count_c_even_bk
if max_c_even_keys[0] in dict_c_odd:
del dict_c_odd[max_c_even_keys[0]]
max_count_c_odd = max(dict_c_odd.values())
replace_total_tmp2 = (n - max_count_c_odd - max_count_c_even)
if replace_total_tmp >= replace_total_tmp2:
replace_total = replace_total_tmp2
else:
replace_total = replace_total_tmp
print(replace_total) | p03244 |
from collections import Counter
n=int(eval(input()))
l=list(map(int,input().split()))
f=l[0::2]
s=l[1::2]
ans=[]
if len(list(Counter(l).values())) == 1:
ans.append(len(f))
elif len(list(Counter(f).values())) == len(list(Counter(s).values())) == 1:
ans.append(0)
else:
for fk,fv in list(Counter(f).items()):
fdk=fk
a=sum(Counter(f).values())-fv
for sk,sv in list(Counter(s).items()):
if fk != sk:
ans.append(a+sum(Counter(s).values())-sv)
print((min(ans))) | from collections import Counter
n=int(eval(input()))
l=list(map(int,input().split()))
f=l[0::2]
s=l[1::2]
fn=sorted(list(Counter(f).items()),key=lambda x:x[1],reverse=True) + [(0, 0)]
sn=sorted(list(Counter(s).items()),key=lambda x:x[1],reverse=True) + [(0, 0)]
if fn[0][0]!=sn[0][0]:
ans=n-fn[0][1]-sn[0][1]
else:
ans=n-max(fn[1][1]+sn[0][1],fn[0][1]+sn[1][1])
print(ans) | p03244 |
n = int(eval(input()))
v = list(map(int, input().split()))
va, ve = v[0::2], v[1::2]
add, even = va[0], ve[0]
for a in set(va):
add = a if va.count(add) < va.count(a) else add
for e in set(ve):
even = e if ve.count(even) < ve.count(e) else even
print((len(v)-va.count(add)-ve.count(even) if add!=even else len(v)-va.count(add))) | n = int(eval(input()))
v = list(map(int, input().split()))
va, ve = v[0::2], v[1::2]
da, de = {}, {}
for a in va:
da[a] = da.get(a, 0)+1
for e in ve:
de[e] = de.get(e, 0)+1
add = sorted([(k,v) for k,v in list(da.items())], key=lambda x:-x[1])+[(0,0)]
even = sorted([(k,v) for k,v in list(de.items())], key=lambda x:-x[1])+[(0,0)]
if add[0][0] == even[0][0]:
if add[1][1] <= even[1][1]:
even.pop(0)
else:
add.pop(0)
print((n-add[0][1]-even[0][1])) | p03244 |
from collections import Counter
iN = int(eval(input()))
aV = [int(_) for _ in input().split()]
oV0 = Counter(aV[0::2]).most_common(2)
oV1 = Counter(aV[1::2]).most_common(2)
oV0 += [(0,0)]
oV1 += [(0,0)]
if oV0[0][0] != oV1[0][0] :
print((iN - oV0[0][1] - oV1[0][1]))
else:
print((iN - max(oV0[0][1],oV1[0][1]) - max(oV0[1][1],oV1[1][1])))
| from collections import Counter
def fParse(iN,aV):
oV0 = Counter(aV[0::2]).most_common(2)
oV1 = Counter(aV[1::2]).most_common(2)
oV0 += [(0,0)]
oV1 += [(0,0)]
if oV0[0][0] != oV1[0][0] :
return iN - oV0[0][1] - oV1[0][1]
else:
return iN - max(oV0[0][1],oV1[0][1]) - max(oV0[1][1],oV1[1][1])
if __name__ == "__main__":
iN = int(eval(input()))
aV = [int(_) for _ in input().split()]
print((fParse(iN,aV)))
| p03244 |
N = int(eval(input()))
V = list(map(int,input().split()))
even = [0]*(10**5+10)
odd = [0]*(10**5+10)
for v in V[::2]:
odd[v] += 1
for v in V[1::2]:
even[v] += 1
omax = max(odd)
emax = max(even)
if(even.index(emax) != odd.index(omax)):
print((N - emax - omax))
else:
even.sort()
odd.sort()
print((min(N - even[-1] - odd[-2], N - even[-2] - odd[-1]))) | def ans():
N = int(eval(input()))
V = list(map(int,input().split()))
even = [0]*100001
odd = [0]*100001
for v in V[1::2]:
even[v] += 1
for v in V[::2]:
odd[v] += 1
me = max(even)
mo = max(odd)
if(even.index(me) != odd.index(mo)):
print((N - me - mo))
else:
even.sort()
odd.sort()
print((min(N-even[-1]-odd[-2], N-even[-2]-odd[-1])))
ans() | p03244 |
from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
v_former = sorted([(v, k) for k, v in list(Counter(v[::2]).items())], reverse=True) + [(0, 0)]
v_latter = sorted([(v, k) for k, v in list(Counter(v[1::2]).items())], reverse=True) + [(0, 0)]
if v_former[0][1] != v_latter[0][1]:
print((n - v_former[0][0] - v_latter[0][0]))
else:
print((n - max(v_former[0][0] + v_latter[1][0], v_former[1][0] + v_latter[0][0])))
| from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
v_former = Counter(v[::2]).most_common() + [(0, 0)]
v_latter = Counter(v[1::2]).most_common() + [(0, 0)]
if v_former[0][0] != v_latter[0][0]:
print((n - v_former[0][1] - v_latter[0][1]))
else:
print((n - max(v_former[0][1] + v_latter[1][1], v_former[1][1] + v_latter[0][1])))
| p03244 |
'''
問題文
数列 a1,a2,...,anが以下の条件を満たすとき、 /\/\/\/ と呼ぶことにします。
・各 i=1,2,...,n−2について、ai=ai+2
・数列に現れる数はちょうど 2種類
偶数長の数列 v1,v2,...,vnが与えられます。 要素をいくつか書き換えることでこの数列を /\/\/\/ にしたいです。
書き換える要素の数は最小でいくつになるか求めてください。
制約
2≤n≤105
nは偶数
1≤vi≤105
viは整数
'''
n=int(eval(input()))
v=input().split()
vodd=[]
veven=[]
for i in range(n):
if i%2:
veven.append(int(v[i]))
else:
vodd.append(int(v[i]))
voddNum=[vodd[0]]
voddCnt=[0]
j=0
for i,odd in enumerate(vodd):
if voddNum[j]!=odd:
for k,num in enumerate(voddNum):
if num==odd:
j=k
break
else:
j=k+1
voddNum.append(odd)
voddCnt.append(0)
voddCnt[j]+=1
voddSet=list(zip(voddCnt, voddNum))
#voddSet=list(reversed(sorted(voddSet,key=lambda x:x[0])))
voddSet.sort(key=lambda x:x[0])
voddSet.reverse()
# print(vodd)
# print(voddNum)
# print(voddCnt)
# print(voddSet)
vevenNum=[veven[0]]
vevenCnt=[0]
j=0
for i,even in enumerate(veven):
if vevenNum[j]!=even:
for k,num in enumerate(vevenNum):
if num==even:
j=k
break
else:
j=k+1
vevenNum.append(even)
vevenCnt.append(0)
vevenCnt[j]+=1
vevenSet=list(zip(vevenCnt, vevenNum))
#vevenSet=list(reversed(sorted(vevenSet,key=lambda x:x[0])))
vevenSet.sort(key=lambda x:x[0])
vevenSet.reverse()
# print()
# print(veven)
# print(vevenNum)
# print(vevenCnt)
# print(vevenSet)
changeCnt=len(vodd)+len(veven)
if voddSet[0][1]==vevenSet[0][1]:
if len(voddSet)==1 & len(vevenSet)==1:
changeCnt-=len(vodd)
elif len(voddSet)==1:
changeCnt-=vevenSet[0][0]
elif len(vevenSet)==1:
changeCnt-=voddSet[0][0]
else:
if voddSet[1][0]>vevenSet[1][0]:
changeCnt=changeCnt-voddSet[1][0]-vevenSet[0][0]
else:
changeCnt+=-voddSet[0][0]-vevenSet[1][0]
else:
changeCnt+=-voddSet[0][0]-vevenSet[0][0]
print(changeCnt)
#'''
| n=int(eval(input()))
v=list(map(int,input().split()))
vodd={-1:0}
veven={-1:0}
for i,vi in enumerate(v):
if i%2:
if(vi in veven):
veven[vi]+=1
else:
veven[vi]=1
else:
if(vi in vodd):
vodd[vi]+=1
else:
vodd[vi]=1
veven=list(veven.items())
veven.sort(key=lambda x:-x[1])
vodd=list(vodd.items())
vodd.sort(key=lambda x:-x[1])
if veven[0][0]==vodd[0][0]:
a=veven[0][1]+vodd[1][1]
b=veven[1][1]+vodd[0][1]
changeCnt=n-a if a>b else n-b
else:
changeCnt=n-veven[0][1]-vodd[0][1]
print(changeCnt) | p03244 |
from collections import Counter
n = int(eval(input()))
lst_v = list(map(int, input().split()))
if len(set(lst_v)) == 1:
ans = n // 2
else:
lst_odd = lst_v[::2]
lst_even = lst_v[1::2]
cnt_odd = sorted(list(Counter(lst_odd).items()), key=lambda x: -x[1])
cnt_even = sorted(list(Counter(lst_even).items()), key=lambda x :-x[1])
if cnt_odd[0][0] == cnt_even[0][0]:
rem_number = max(cnt_odd[0][1] + cnt_even[1][1], cnt_odd[1][1] + cnt_even[0][1])
else:
rem_number = cnt_odd[0][1] + cnt_even[0][1]
sum_odd = sum(t[1] for t in cnt_odd)
sum_even = sum(t[1] for t in cnt_even)
ans = sum_odd + sum_even - rem_number
print(ans)
| # C
import collections
n = int(eval(input()))
lst = list(map(int, input().split()))
lst1 = lst[::2]
lst2 = lst[1::2]
dct1 = sorted(list(dict(collections.Counter(lst1)).items()), key=lambda x:-x[1])
dct2 = sorted(list(dict(collections.Counter(lst2)).items()), key=lambda x:-x[1])
ans = 0
if (len(dct1) == 1 and len(dct2) == 1):
if (dct1[0][0] == dct2[0][0]):
ans = dct1[0][1]
else:
ans = 0
elif (len(dct1) == 1 and len(dct2) > 1):
if (dct1[0][0] == dct2[0][0]):
ans = n // 2 - dct2[1][1]
else:
ans = n // 2 - dct2[0][1]
elif (len(dct2) == 1 and len(dct1) > 1):
if (dct1[0][0] == dct2[0][0]):
ans = n // 2 - dct1[1][1]
else:
ans = n // 2 - dct1[0][1]
elif (len(dct1) > 1 and len(dct2) > 1):
if (dct1[0][0] == dct2[0][0]):
ans = n - max(dct1[0][1] + dct2[1][1], dct1[1][1] + dct2[0][1])
else:
ans = n - dct1[0][1] - dct2[0][1]
print(ans) | p03244 |
from collections import Counter
n=int(eval(input()))
V=list(map(int,input().split()))
V_1=[(0,0)]+sorted(list(Counter([V[i] for i in range(n) if i%2==0]).items()), key=lambda x:x[1])
V_2=[(0,0)]+sorted(list(Counter([V[j] for j in range(n) if j%2==1]).items()), key=lambda x:x[1])
a,b=V_1[-1][0],V_2[-1][0]
if a==b:
if V_1[-2][1]>V_2[-2][1]:a=V_1[-2][0]
else:b=V_2[-2][0]
cnt=0
for i in range(n):
if i%2==0:
if V[i]!=a:cnt +=1
else:
if V[i]!=b:cnt +=1
print(cnt) | from collections import Counter
n=int(eval(input()))
V=list(map(int,input().split()))
even=[(0,0)]+sorted(list(Counter(V[::2]).items()), key=lambda x:x[1])
odd=[(0,0)]+sorted(list(Counter(V[1::2]).items()), key=lambda x:x[1])
if even[-1][0]==odd[-1][0]:
if even[-2][1]>odd[-2][1]:even=even[-2][0];odd=odd[-1][0]
else:even=even[-1][0];odd=odd[-2][0]
else:even=even[-1][0];odd=odd[-1][0]
cnt=0
for i,j in enumerate(V):
if i%2==0 and j!=even:cnt +=1
elif i%2==1 and j!=odd:cnt +=1
print(cnt) | p03244 |
from collections import Counter
n = eval(input())
V = list(map(int, input().split(" ")))
v1 = V[0::2]
v2 = V[1::2]
f1 = Counter(v1).most_common(2)
f2 = Counter(v2).most_common(2)
ans = 0
if len(set(v1)) == len(set(v2)) == 1:
if v1 == v2:
ans = min(len(v1), len(v2))
else:
if f1[0][0] != f2[0][0]:
ans = (len(v1) - f1[0][1]) + (len(v2) - f2[0][1])
else:
ans1 = (len(v1) - f1[0][1]) + (len(v2) - f2[1][1])
ans2 = (len(v1) - f1[1][1]) + (len(v2) - f2[0][1])
ans = min(ans1, ans2)
print(ans)
| from collections import Counter
n = eval(input())
V = list(map(int, input().split(" ")))
"""
9
1 1 1 1 2 2 2 4
1 1 1 1 3 3 4 4
"""
#V = [1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 2, 3, 2, 4, 4, 4]
v1 = V[0::2]
v2 = V[1::2]
f1 = Counter(v1).most_common(2)
f2 = Counter(v2).most_common(2)
ans = 0
if len(set(v1)) == len(set(v2)) == 1:
if v1 == v2:
ans = min(len(v1), len(v2))
else:
if f1[0][0] != f2[0][0]:
ans = (len(v1) - f1[0][1]) + (len(v2) - f2[0][1])
else:
if f1[1][1] < f2[1][1]:
ans = (len(v1) - f1[0][1]) + (len(v2) - f2[1][1])
else:
ans = (len(v1) - f1[1][1]) + (len(v2) - f2[0][1])
print(ans)
| p03244 |
from collections import Counter
n = int(eval(input()))
v = [int(x) for x in input().split()]
odd = sorted(list(Counter(v[0:n:2]).items()), reverse=True, key=lambda x: x[1])
even = sorted(list(Counter(v[1:n+1:2]).items()), reverse=True, key=lambda x: x[1])
if odd[0][0] != even[0][0]:
res = n - odd[0][1] - even[0][1]
elif len(odd) == 1:
res = odd[0][1]
else:
if odd[0][1] == even[0][1]:
if odd[1][1] >= even[1][1]:
res = n - odd[1][1] - even[0][1]
else:
res = n - odd[0][1] - even[1][1]
elif odd[0][1] > even[0][1]:
res = n - odd[0][1] - even[1][1]
else:
res = n - odd[1][1] - even[0][1]
print(res)
| from collections import Counter
n = int(eval(input()))
v = [int(x) for x in input().split()]
v1 = Counter(v[0::2]).most_common() + [(0, 0)]
v2 = Counter(v[1::2]).most_common() + [(0, 0)]
if v1[0] != v2[0]:
res = n - v1[0][1] - v2[0][1]
else:
res = min(n - v1[0][1] - v2[1][1], n - v1[1][1] - v2[0][1])
print(res)
| p03244 |
from collections import Counter
n = int(eval(input()))
v_tmp = input().split()
v = [int(_) for _ in v_tmp]
v_count = Counter(v_tmp)
# print(v_count)
if len(v_count) == 1:
print((n//2))
else:
# print("hoge")
v_keys = list(v_count.keys())
tmps = []
# print(v_keys)
for _ in v_keys:
for _2 in v_keys:
tmp = []
# print(_, _2)
if _ == _2:
continue
else:
for i in range(n):
if i % 2 == 0:
tmp.append(_)
else:
tmp.append(_2)
# print("tmp", tmp)
if tmp == []:
continue
else:
tmps.append(tmp)
sols = []
for _ in tmps:
sol_tmp = 0
for i in range(n):
if _[i] != v_tmp[i]:
sol_tmp += 1
sols.append(sol_tmp)
print((min(sols)))
| from collections import Counter
n = int(eval(input()))
v = [int(_) for _ in input().split()]
v1 = []
v2 = []
for i in range(n):
if i % 2 == 0:
v1.append(v[i])
else:
v2.append(v[i])
v_count = Counter(v)
v1_count = Counter(v1)
v2_count = Counter(v2)
# print("v1_count", v1_count)
# print("v2_count", v2_count)
v1_comm = v1_count.most_common(1)
v2_comm = v2_count.most_common(1)
sols = []
# print("v1_comm", v1_comm)
# print("v2_comm", v2_comm)
if len(v_count) == 1:
print((n//2))
else:
key1 = v1_comm[0][1]
# print("v1_comm[0][0]", v1_comm[0][0])
# print("v2_comm[0][0]", v2_comm[0][0])
if v1_comm[0][0] == v2_comm[0][0]:
# print("hoge")
v2_comm = v2_count.most_common(2)
key2 = v2_comm[1][1]
else:
key2 = v2_comm[0][1]
sols.append(n-key1-key2)
key1 = v2_comm[0][1]
if v1_comm[0][0] == v2_comm[0][0]:
v1_comm = v1_count.most_common(2)
key2 = v1_comm[1][1]
else:
key2 = v1_comm[0][1]
sols.append(n-key1-key2)
print((min(sols)))
| p03244 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.