message stringlengths 2 28.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 21 109k | cluster float64 7 7 | __index_level_0__ int64 42 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1 | instruction | 0 | 33,501 | 7 | 67,002 |
Tags: constructive algorithms, dp, graphs, greedy, math
Correct Solution:
```
t=int(input())
for i in range(t):
n=int(input())
b=list(map(int,input().split()))
a=[]
if min(b)==max(b):
a=[1]*(n)
print(1)
print(*a)
elif n%2==0:
for j in range(n):
if j % 2 == 0:
a.append(1)
else:
a.append(2)
print(2)
print(*a)
else:
a=[]
t=0
for j in range(n):
if b[j-1]==b[j]:
t=1
break
if t==0:
for j in range(n-1):
if j % 2 == 0:
a.append(1)
else:
a.append(2)
a.append(3)
print(3)
print(*a)
elif b[-1]==b[0]:
for j in range(n):
if j % 2 == 0:
a.append(1)
else:
a.append(2)
print(2)
print(*a)
else:
j=0
h=0
while(j<n):
if j<(n-1) and b[j+1]==b[j] and h==0:
if j%2==0:
a.append(1)
a.append(1)
else:
a.append(2)
a.append(2)
h=1
j+=2
elif h==0:
if j % 2 == 0:
a.append(1)
else:
a.append(2)
j+=1
else:
if j % 2 == 0:
a.append(2)
else:
a.append(1)
j+=1
print(2)
print(*a)
``` | output | 1 | 33,501 | 7 | 67,003 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1 | instruction | 0 | 33,502 | 7 | 67,004 |
Tags: constructive algorithms, dp, graphs, greedy, math
Correct Solution:
```
import sys
def input():
return sys.stdin.readline()[:-1]
q = int(input())
for _ in range(q):
n = int(input())
t = list(map(int, input().split()))
if len(set(t)) == 1:
print(1)
print(*[1 for _ in range(n)])
continue
t.append(t[0])
diffs = 0
succ = False
for i in range(n):
if t[i] != t[i+1]:
diffs ^= 1
elif not succ:
succ = True
change_ind = i
if diffs == 0:
print(2)
ans = [1]
cur = 0
for i in range(1, n):
if t[i] != t[i-1]:
cur ^= 1
ans.append(cur+1)
print(*ans)
elif not succ:
print(3)
ans = [1]
cur = 0
first = True
for i in range(1, n):
if first:
if t[i] == t[i-1]:
ans.append(1)
else:
ans.append(3)
cur = 2
first = False
elif cur == 2:
if t[i] == t[i-1]:
ans.append(3)
else:
ans.append(2)
cur = 1
else:
if t[i] != t[i-1]:
cur ^= 1
ans.append(cur+1)
print(*ans)
else:
print(2)
t[change_ind] = 200001
ans = [1]
cur = 0
for i in range(1, n):
if t[i] != t[i-1]:
cur ^= 1
ans.append(cur+1)
print(*ans)
``` | output | 1 | 33,502 | 7 | 67,005 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1 | instruction | 0 | 33,503 | 7 | 67,006 |
Tags: constructive algorithms, dp, graphs, greedy, math
Correct Solution:
```
# from math import factorial as fac
from collections import defaultdict
# from copy import deepcopy
import sys, math
f = None
try:
f = open('q1.input', 'r')
except IOError:
f = sys.stdin
if 'xrange' in dir(__builtins__):
range = xrange
# print(f.readline())
sys.setrecursionlimit(10**2)
def print_case_iterable(case_num, iterable):
print("Case #{}: {}".format(case_num," ".join(map(str,iterable))))
def print_case_number(case_num, iterable):
print("Case #{}: {}".format(case_num,iterable))
def print_iterable(A):
print (' '.join(A))
def read_int():
return int(f.readline().strip())
def read_int_array():
return [int(x) for x in f.readline().strip().split(" ")]
def rns():
a = [x for x in f.readline().split(" ")]
return int(a[0]), a[1].strip()
def read_string():
return list(f.readline().strip())
def ri():
return int(f.readline().strip())
def ria():
return [int(x) for x in f.readline().strip().split(" ")]
def rns():
a = [x for x in f.readline().split(" ")]
return int(a[0]), a[1].strip()
def rs():
return list(f.readline().strip())
def bi(x):
return bin(x)[2:]
from collections import deque
import math
# NUMBER = 10**9 + 7
NUMBER = 998244353
def factorial(n) :
M = NUMBER
f = 1
for i in range(1, n + 1):
f = (f * i) % M # Now f never can
# exceed 10^9+7
return f
def mult(a,b):
return (a * b) % NUMBER
def minus(a , b):
return (a - b) % NUMBER
def plus(a , b):
return (a + b) % NUMBER
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a):
m = NUMBER
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def choose(n,k):
if n < k:
assert false
return mult(factorial(n), modinv(mult(factorial(k),factorial(n-k))))
from collections import deque, defaultdict
import heapq
def solution(a,n):
if len(set(a)) == 1:
return '1\n' + '1 ' *n
if n % 2 == 0:
return '2\n' + '1 2 '*(n//2)
if a[-1] == a[0]:
return '2\n' + '1 2 '*(n//2)+'1'
sol = [1]
done = False
for i in range(1,n):
if a[i] == a[i-1] and not done:
sol.append(sol[-1])
done = True
continue
sol.append(3-sol[-1])
if done == True:
return '2\n' + ' '.join(map(str,sol))
return '3\n' + '1 2 '*(n//2)+'3'
def main():
T = ri()
for i in range(T):
n = ri()
# n,k = ria()
a=ria()
x = solution(a,n)
if 'xrange' not in dir(__builtins__):
print(x)
else:
print >>output,str(x)# "Case #"+str(i+1)+':',
if 'xrange' in dir(__builtins__):
print(output.getvalue())
output.close()
if 'xrange' in dir(__builtins__):
import cStringIO
output = cStringIO.StringIO()
#example usage:
# for l in res:
# print >>output, str(len(l)) + ' ' + ' '.join(l)
if __name__ == '__main__':
main()
``` | output | 1 | 33,503 | 7 | 67,007 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1 | instruction | 0 | 33,504 | 7 | 67,008 |
Tags: constructive algorithms, dp, graphs, greedy, math
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
ans=[1]*(n)
f=1
ind=0
if a[0]==a[1]:
ind=1
for i in range(1,n):
if a[i]==a[i-1]:
ans[i]=ans[i-1]
else:
ans[i]=3-ans[i-1]
f=2
if a[i]==a[(i+1)%n]:
ind=(i+1)%n
if a[0]!=a[-1] and ans[-1]==ans[0]:
ans[-1]=3
f=3
# print(ind)
if f==3 and ind:
for i in range(ind,n):
ans[i]=3-ans[i]
ans[-1]=3-ans[0]
print(len(set(ans)))
# if f:
# print(3)
# else:
# print(2)
print(*ans)
``` | output | 1 | 33,504 | 7 | 67,009 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1 | instruction | 0 | 33,505 | 7 | 67,010 |
Tags: constructive algorithms, dp, graphs, greedy, math
Correct Solution:
```
q = int(input())
res = []
def flip(x):
if x == 1:
return 2
else:
return 1
for k in range(q):
n = int(input())
T = [int(x) for x in input().split()]
swapable = False
painted = [-1] * n
painted[0] = 1
used = 1
for i in range(1, n - 1):
if T[i] == T[i - 1]:
swapable = True
swap_index = i
painted[i] = painted[i - 1]
else:
used = 2
painted[i] = flip(painted[i - 1])
if used == 1:
if T[n - 1] == T[0]:
painted[n - 1] = 1
else:
painted[n - 1] = 2
used = 2
elif T[n - 1] == T[0]:
painted[n - 1] = flip(painted[n - 2])
elif T[n - 1] == T[n - 2]:
painted[n - 1] = flip(painted[0])
elif painted[n - 2] == 1:
painted[n - 1] = 2
elif swapable:
for i in range(swap_index, n - 1):
painted[i] = flip(painted[i])
painted[n - 1] = flip(painted[n - 2])
else:
painted[n - 1] = 3
used = 3
res.append(used)
res.append(painted)
for i in range(q):
print(res[(i * 2)])
for item in res[i * 2 + 1]:
print(item, end = ' ')
print()
``` | output | 1 | 33,505 | 7 | 67,011 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1 | instruction | 0 | 33,506 | 7 | 67,012 |
Tags: constructive algorithms, dp, graphs, greedy, math
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = input().split()
if len(set(a)) == 1:
print(1)
for i in range(n):
print(1, end=" ")
elif n % 2 == 0:
print(2)
for i in range(n // 2):
print(1, end=" ")
print(2, end=" ")
else:
p = 0
prev = a[0]
for i in range(1, n):
if a[i] == prev:
p = i
break
prev = a[i]
if p != 0:
x = True
else:
x = False
if x:
print(2)
for i in range(n):
if i == p - 1:
if x:
print(1, end=" ")
else:
print(2, end=" ")
elif i == p:
if x:
print(1, end=" ")
x = False
else:
print(2, end=" ")
x = True
elif x:
x = False
print(1, end=" ")
else:
x = True
print(2, end=" ")
elif a[0] == a[-1]:
print(2)
for i in range((n - 1) // 2):
print(1, end=" ")
print(2, end=" ")
print(1, end=" ")
else:
print(3)
for i in range((n - 1) // 2):
print(1, end=" ")
print(2, end=" ")
print(3, end=" ")
print()
``` | output | 1 | 33,506 | 7 | 67,013 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1
Submitted Solution:
```
def solve():
n = int(input())
a = list(map(int, input().split()))
s = [1] * n
flag = True
for i in range(n):
if i > 0:
if a[i] == a[i - 1]:
s[i] = s[i - 1]
else:
s[i] = 3 - s[i - 1]
if s[i] != 1:
flag = False
if s[0] != s[-1] or a[0] == a[-1]:
if flag:
return 1, s
else:
return 2, s
for i in range(n):
if i > 0 and a[i] == a[i - 1]:
s[i - 1] = 1
s[i] = 2
for j in range(i - 2, -1, -1):
if a[j] == a[j + 1]:
s[j] = s[j + 1]
else:
s[j] = 3 - s[j + 1]
for j in range(i + 1, n, 1):
if a[j] == a[j - 1]:
s[j] = s[j - 1]
else:
s[j] = 3 - s[j - 1]
break
if s[0] != s[-1] or a[0] == a[-1]:
return 2, s
s[-1] = 3
return 3, s
T = int(input())
for _ in range(T):
k, s = solve()
print(k)
print(*s)
``` | instruction | 0 | 33,507 | 7 | 67,014 |
Yes | output | 1 | 33,507 | 7 | 67,015 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1
Submitted Solution:
```
from collections import defaultdict as d
t = int(input())
for _ in range(t):
n = int(input())
arr = list(map(int, input().split()))
if len(set(arr)) == 1:
print(1)
print("1 " * n)
elif n % 2 == 0:
print(2)
for i in range(n):
print((i % 2) + 1, "", end="")
print()
else:
b = 0
j = 0
index = 0
tab = [0] * n
for i in range(n):
tab[i] = (i % 2) + 1
if arr[i] == arr[(i+1)%n]:
b = 1
j = tab[i]
index = (i + 1) % n
break
if b:
j += 1
for i in range(index, n):
if tab[i] == 0:
tab[i] = (j % 2) + 1
j += 1
else:
tab[-1] = 3
print(2 if b else 3)
print(*tab)
``` | instruction | 0 | 33,508 | 7 | 67,016 |
Yes | output | 1 | 33,508 | 7 | 67,017 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1
Submitted Solution:
```
import atexit
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER
@atexit.register
def write():
sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
####################################################
def line():
return map(int, input().split())
def num():
return int(input())
from itertools import repeat, groupby
q = num()
for _ in repeat(None, q):
n = num()
ts = list(line())
l = len(list(groupby(ts)))
alert = l%2 and ts[0]!=ts[-1]
w = ts[0]
c = 1
ans = [1]
cls = 1
for t in ts[1:]:
if alert or t!=w:
cls = 2
if t==w:
alert=0
c = 3-c
ans.append(c)
w = t
if alert:
cls=3
ans[0]=3
print(cls)
print(' '.join(map(str, ans)))
``` | instruction | 0 | 33,509 | 7 | 67,018 |
Yes | output | 1 | 33,509 | 7 | 67,019 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1
Submitted Solution:
```
import sys
input = sys.stdin.readline
Q = int(input())
Query = []
for _ in range(Q):
N = int(input())
A = list(map(int, input().split()))
Query.append((N, A))
for N, A in Query:
if len(set(A)) == 1:
la = 1
ans = ["1"]*N
else:
if N%2 == 0:
la = 2
ans = [str(i%2+1) for i in range(N)]
else:
ind = -1
for i in range(N):
if A[i-1] == A[i]:
ind = i
if ind == -1:
la = 3
ans = [str(i%2+1) for i in range(N)]
ans[-1] = "3"
else:
la = 2
ans = [str(i%2+1) if i < ind else str((i+1)%2+1) for i in range(N)]
print(la)
print(" ".join(ans))
``` | instruction | 0 | 33,510 | 7 | 67,020 |
Yes | output | 1 | 33,510 | 7 | 67,021 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1
Submitted Solution:
```
def solve(t):
l = len(t)
if t.count(t[0]) == l:
print(1)
print('1 ' * l)
return
res = []
pr = 1
cnt = 0
for i in range(l - 1):
if t[i] != t[i+1] or cnt > 1:
res.append(pr)
pr = 2 if pr == 1 else 1
cnt = 0
else:
res.append(pr)
cnt += 1
if t[0] != t[-1] and res[0] == pr:
res.append(3)
else:
res.append(pr)
# if res[-1] == 3:
# for i in range(l - 1):
# if res[i] == res[i+1]:
# for j in range(i + 1, l - 1):
# res[j] = 1 if res[j] == 2 else 2
# res[-1] = 2
# break
if 3 in res:
print(3)
elif 2 in res:
print(2)
else:
print(1)
print(*res)
for _ in range(int(input())):
n = int(input())
t = list(map(int, input().split()))
solve(t)
``` | instruction | 0 | 33,511 | 7 | 67,022 |
No | output | 1 | 33,511 | 7 | 67,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1
Submitted Solution:
```
import sys
I=sys.stdin.readline
for _ in range(int(I())):
n=int(I())
t=list(map(int,I().split()))
k=1
ans=[]
f=t[0]
flag=0
for i in t:
if i!=f:
flag=1
break
if flag==1:
k+=1
ans=[1]
if n%2!=0:
prev=t[0]
color=1
for i in range(1,n-1):
if t[i]==prev:
ans.append(color)
else:
if color==1:
color=2
else:
color=1
ans.append(color)
prev=t[i]
if t[0]!=t[-1] and t[0]!=t[-2] and t[-1]!=t[-2]:
ans.append(3)
k+=1
else:
if t[-1]==t[-2]:
ans.append(color)
elif t[-2]==t[0]:
if color==1:
ans.append(2)
else:
ans.append(1)
else:
ans.append(1)
else:
for i in range(1,n):
if i%2!=0:
ans.append(2)
else:
ans.append(1)
print(k)
print(*ans)
else:
print(1)
ans=[1]*n
print(*ans)
``` | instruction | 0 | 33,512 | 7 | 67,024 |
No | output | 1 | 33,512 | 7 | 67,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
ans=[1]*(n)
f=1
ind=0
for i in range(1,n):
if a[i]==a[i-1]:
ans[i]=ans[i-1]
else:
ans[i]=3-ans[i-1]
f=2
if a[i]==a[(i+1)%n] and a[i]==a[(i-1)]:
ind=i
if a[0]!=a[-1] and ans[-1]==ans[0]:
ans[-1]=3
f=3
if f==3 and ind:
for i in range(ind,n):
ans[i]=3-ans[i]
ans[-1]=3-ans[0]
print(len(set(ans)))
# if f:
# print(3)
# else:
# print(2)
print(*ans)
``` | instruction | 0 | 33,513 | 7 | 67,026 |
No | output | 1 | 33,513 | 7 | 67,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1
Submitted Solution:
```
def solve(k):
if l[0] != l[-1]:
if k[0] == k[-1]:
if k[0] == k[1]:
if k[0] == "1":
k[0] = "2"
else:
k[0] = "1"
elif k[-1] == k[-2]:
if k[-1] == k[-2]:
if k[-1] == "1":
k[-1] = "2"
else:
k[-1] = "1"
else:
k[-1] = "3"
return k
for _ in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
k = ["1"]
k1 = ["1"]
for i in range(1,n):
if l[i] == l[i-1]:
k.append(k[i-1])
else:
if k[i-1] == "1":
k.append("2")
else:
k.append("1")
if i%2==1:
k1.append("2")
else:
k1.append("1")
# print(k1)
# print(k)
k = solve(k)
l1 = len(set(k))
l2 = len(set(k1))
if n%2==0 :
if len(set(l)) == 1:
print(1)
print("1 "*len(l))
else:
print(len(set(k1)))
print(*k1)
else:
print(len(set(k)))
print(*k)
``` | instruction | 0 | 33,514 | 7 | 67,028 |
No | output | 1 | 33,514 | 7 | 67,029 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
The round carousel consists of n figures of animals. Figures are numbered from 1 to n in order of the carousel moving. Thus, after the n-th figure the figure with the number 1 follows. Each figure has its own type — the type of the animal corresponding to this figure (the horse, the tiger and so on). The type of animal of the i-th figure equals t_i.
<image> The example of the carousel for n=9 and t=[5, 5, 1, 15, 1, 5, 5, 1, 1].
You want to color each figure in one of the colors. You think that it's boring if the carousel contains two different figures (with the distinct types of animals) going one right after another and colored in the same color.
Your task is to color the figures in such a way that the number of distinct colors used is the minimum possible and there are no figures of the different types going one right after another and colored in the same color. If you use exactly k distinct colors, then the colors of figures should be denoted with integers from 1 to k.
Input
The input contains one or more test cases.
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the test. Then q test cases follow. One test case is given on two lines.
The first line of the test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of figures in the carousel. Figures are numbered from 1 to n in order of carousel moving. Assume that after the n-th figure the figure 1 goes.
The second line of the test case contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 2 ⋅ 10^5), where t_i is the type of the animal of the i-th figure.
The sum of n over all test cases does not exceed 2⋅10^5.
Output
Print q answers, for each test case print two lines.
In the first line print one integer k — the minimum possible number of distinct colors of figures.
In the second line print n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ k), where c_i is the color of the i-th figure. If there are several answers, you can print any.
Example
Input
4
5
1 2 1 2 2
6
1 2 2 1 2 2
5
1 2 1 2 3
3
10 10 10
Output
2
1 2 1 2 2
2
2 1 2 1 2 1
3
2 3 2 3 1
1
1 1 1
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
for i in arr:
stdout.write(str(i)+' ')
stdout.write('\n')
range = xrange # not for python 3.0+
for t in range(input()):
n=int(raw_input())
l=in_arr()
ans=0
d=Counter(l)
if len(d.keys())==1:
pr_num(1)
pr_arr([1]*n)
continue
ans=[0]*n
f=0
for i in range(1,n):
if l[i]!=l[i-1]:
ans[i]=int(not ans[i-1])
else:
f=1
ans[i]=ans[i-1]
if not f and l[0]!=l[-1] and ans[0]==ans[-1]:
ans=[i%3 for i in range(n)]
elif f and l[0]!=l[-1] and ans[0]==ans[-1]:
for i in range(n-1):
ans[i]=int(not(ans[i]))
if l[i]==l[i+1]:
break
for i in range(n):
ans[i]+=1
pr_num(max(ans))
pr_arr(ans)
``` | instruction | 0 | 33,515 | 7 | 67,030 |
No | output | 1 | 33,515 | 7 | 67,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a cube of size k × k × k, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of k3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
* each white cube has exactly 2 neighbouring cubes of white color;
* each black cube has exactly 2 neighbouring cubes of black color.
Input
The first line contains integer k (1 ≤ k ≤ 100), which is size of the cube.
Output
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a k × k matrix in the first k lines, showing how the first layer of the cube should be painted. In the following k lines print a k × k matrix — the way the second layer should be painted. And so on to the last k-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Examples
Input
1
Output
-1
Input
2
Output
bb
ww
bb
ww | instruction | 0 | 33,694 | 7 | 67,388 |
Tags: combinatorics, constructive algorithms
Correct Solution:
```
n=int(input())
if(n%2==1):
print(-1)
else:
for i in range(n):
for j in range(n):
s = ''
if (i // 2 + j)&1:
s = 'wwbb' * (n//4)
if n % 4 != 0:
s += 'ww'
else:
s = 'bbww' * (n//4)
if n % 4 != 0:
s += 'bb'
print(s)
``` | output | 1 | 33,694 | 7 | 67,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a cube of size k × k × k, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of k3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
* each white cube has exactly 2 neighbouring cubes of white color;
* each black cube has exactly 2 neighbouring cubes of black color.
Input
The first line contains integer k (1 ≤ k ≤ 100), which is size of the cube.
Output
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a k × k matrix in the first k lines, showing how the first layer of the cube should be painted. In the following k lines print a k × k matrix — the way the second layer should be painted. And so on to the last k-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Examples
Input
1
Output
-1
Input
2
Output
bb
ww
bb
ww | instruction | 0 | 33,695 | 7 | 67,390 |
Tags: combinatorics, constructive algorithms
Correct Solution:
```
if __name__ == "__main__":
n = int(input())
if n % 2 == 1:
print(-1)
exit()
str1 = ''.join(['bb' if i % 2 == 1 else 'ww' for i in range(n // 2)])
str2 = ''.join(['bb' if i % 2 == 0 else 'ww' for i in range(n // 2)])
for i in range(n):
str1, str2 = str2, str1
for j in range(n // 2):
print(str1 if j % 2 == 0 else str2)
print(str1 if j % 2 == 0 else str2)
print('')
``` | output | 1 | 33,695 | 7 | 67,391 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a cube of size k × k × k, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of k3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
* each white cube has exactly 2 neighbouring cubes of white color;
* each black cube has exactly 2 neighbouring cubes of black color.
Input
The first line contains integer k (1 ≤ k ≤ 100), which is size of the cube.
Output
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a k × k matrix in the first k lines, showing how the first layer of the cube should be painted. In the following k lines print a k × k matrix — the way the second layer should be painted. And so on to the last k-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Examples
Input
1
Output
-1
Input
2
Output
bb
ww
bb
ww | instruction | 0 | 33,696 | 7 | 67,392 |
Tags: combinatorics, constructive algorithms
Correct Solution:
```
n=int(input())
print(["\n".join("\n".join("".join("b" if (i//2+j//2+k)%2 else "w" for j in range(n)) for i in range(n))+"\n" for k in range(n)),-1][n%2])
``` | output | 1 | 33,696 | 7 | 67,393 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a cube of size k × k × k, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of k3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
* each white cube has exactly 2 neighbouring cubes of white color;
* each black cube has exactly 2 neighbouring cubes of black color.
Input
The first line contains integer k (1 ≤ k ≤ 100), which is size of the cube.
Output
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a k × k matrix in the first k lines, showing how the first layer of the cube should be painted. In the following k lines print a k × k matrix — the way the second layer should be painted. And so on to the last k-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Examples
Input
1
Output
-1
Input
2
Output
bb
ww
bb
ww | instruction | 0 | 33,697 | 7 | 67,394 |
Tags: combinatorics, constructive algorithms
Correct Solution:
```
k=int(input())
if k%2==1:
print(-1)
else:
for i in range(k):
for j in range(k):
a=''
for l in range(k):
a+='bw'[(i//2+j+l//2)%2]
print(a)
if i<k-1:
print()
``` | output | 1 | 33,697 | 7 | 67,395 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a cube of size k × k × k, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of k3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
* each white cube has exactly 2 neighbouring cubes of white color;
* each black cube has exactly 2 neighbouring cubes of black color.
Input
The first line contains integer k (1 ≤ k ≤ 100), which is size of the cube.
Output
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a k × k matrix in the first k lines, showing how the first layer of the cube should be painted. In the following k lines print a k × k matrix — the way the second layer should be painted. And so on to the last k-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Examples
Input
1
Output
-1
Input
2
Output
bb
ww
bb
ww | instruction | 0 | 33,698 | 7 | 67,396 |
Tags: combinatorics, constructive algorithms
Correct Solution:
```
class CodeforcesTask323ASolution:
def __init__(self):
self.result = ''
self.k = 0
def read_input(self):
self.k = int(input())
def process_task(self):
if self.k % 2:
self.result = "-1"
elif self.k == 2:
self.result = "bb\nww\n\nbb\nww"
else:
level = "b"
cube = [[[None for y in range(self.k)] for x in range(self.k)] for z in range(self.k)]
for z in range(self.k):
level = "w" if z % 2 else "b"
for k in range(self.k // 2):
# upper
for x in range(2 * (k + 1)):
cube[z][self.k // 2 - 1 - k][self.k // 2 - 1 - k + x] = level
# lower
for x in range(2 * (k + 1)):
cube[z][self.k // 2 + k][self.k // 2 - 1 - k + x] = level
# left
for y in range(2 * (k + 1)):
cube[z][self.k // 2 - 1 - k + y][self.k // 2 - 1 - k] = level
# right
for y in range(2 * (k + 1)):
cube[z][self.k // 2 - 1 - k + y][self.k // 2 + k] = level
level = "w" if level == "b" else "b"
for layer in cube:
for row in layer:
print("".join(row))
print(" ")
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask323ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
``` | output | 1 | 33,698 | 7 | 67,397 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a cube of size k × k × k, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of k3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
* each white cube has exactly 2 neighbouring cubes of white color;
* each black cube has exactly 2 neighbouring cubes of black color.
Input
The first line contains integer k (1 ≤ k ≤ 100), which is size of the cube.
Output
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a k × k matrix in the first k lines, showing how the first layer of the cube should be painted. In the following k lines print a k × k matrix — the way the second layer should be painted. And so on to the last k-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Examples
Input
1
Output
-1
Input
2
Output
bb
ww
bb
ww | instruction | 0 | 33,699 | 7 | 67,398 |
Tags: combinatorics, constructive algorithms
Correct Solution:
```
# METO Bot 0.9.9
n=int(input())
print(["\n".join("\n".join("".join("b" if (i//2+j//2+k)%2 else "w" for j in range(n)) for i in range(n))+"\n" for k in range(n)),-1][n%2])
``` | output | 1 | 33,699 | 7 | 67,399 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a cube of size k × k × k, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of k3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
* each white cube has exactly 2 neighbouring cubes of white color;
* each black cube has exactly 2 neighbouring cubes of black color.
Input
The first line contains integer k (1 ≤ k ≤ 100), which is size of the cube.
Output
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a k × k matrix in the first k lines, showing how the first layer of the cube should be painted. In the following k lines print a k × k matrix — the way the second layer should be painted. And so on to the last k-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Examples
Input
1
Output
-1
Input
2
Output
bb
ww
bb
ww | instruction | 0 | 33,700 | 7 | 67,400 |
Tags: combinatorics, constructive algorithms
Correct Solution:
```
K = int(input())
print("-1" if K & 1 else "".join(["wb\n"[2 if k == K else (min(j, k, K - 1 - j,
K - 1 - k) ^ i) & 1] for i in range(2) for j in range(K) for k in range(K +
1)]) * (K >> 1))
``` | output | 1 | 33,700 | 7 | 67,401 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a cube of size k × k × k, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of k3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
* each white cube has exactly 2 neighbouring cubes of white color;
* each black cube has exactly 2 neighbouring cubes of black color.
Input
The first line contains integer k (1 ≤ k ≤ 100), which is size of the cube.
Output
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a k × k matrix in the first k lines, showing how the first layer of the cube should be painted. In the following k lines print a k × k matrix — the way the second layer should be painted. And so on to the last k-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Examples
Input
1
Output
-1
Input
2
Output
bb
ww
bb
ww | instruction | 0 | 33,701 | 7 | 67,402 |
Tags: combinatorics, constructive algorithms
Correct Solution:
```
import sys, math
readline = sys.stdin.readline
k = int(readline())
if k % 2:
print(-1)
else:
for i in range(k):
for j in range(k):
s = ''
if (i // 2 + j)&1:
s = 'wwbb' * (k//4)
if k % 4 != 0:
s += 'ww'
else:
s = 'bbww' * (k//4)
if k % 4 != 0:
s += 'bb'
print(s)
``` | output | 1 | 33,701 | 7 | 67,403 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a cube of size k × k × k, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of k3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
* each white cube has exactly 2 neighbouring cubes of white color;
* each black cube has exactly 2 neighbouring cubes of black color.
Input
The first line contains integer k (1 ≤ k ≤ 100), which is size of the cube.
Output
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a k × k matrix in the first k lines, showing how the first layer of the cube should be painted. In the following k lines print a k × k matrix — the way the second layer should be painted. And so on to the last k-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Examples
Input
1
Output
-1
Input
2
Output
bb
ww
bb
ww
Submitted Solution:
```
k = int(input())
a1 = 'bbww\nwwbb\nbbww\nwwbb\n\n'
a2 = 'wwbb\nbbww\nwwbb\nbbww\n\n'
if k ==2:
print('bb\nww\n\nbb\nww')
elif k%2==1:
print(-1)
else:
print(a1*(k//2),a2*(k//2))
``` | instruction | 0 | 33,702 | 7 | 67,404 |
No | output | 1 | 33,702 | 7 | 67,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a cube of size k × k × k, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of k3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
* each white cube has exactly 2 neighbouring cubes of white color;
* each black cube has exactly 2 neighbouring cubes of black color.
Input
The first line contains integer k (1 ≤ k ≤ 100), which is size of the cube.
Output
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a k × k matrix in the first k lines, showing how the first layer of the cube should be painted. In the following k lines print a k × k matrix — the way the second layer should be painted. And so on to the last k-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Examples
Input
1
Output
-1
Input
2
Output
bb
ww
bb
ww
Submitted Solution:
```
n=int(input())
if(n==1):
print(-1)
else:
for i in range(n):
for j in range(n):
if(j%2==0):
print('b'*n)
else:
print('w'*n)
print()
``` | instruction | 0 | 33,703 | 7 | 67,406 |
No | output | 1 | 33,703 | 7 | 67,407 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a cube of size k × k × k, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of k3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
* each white cube has exactly 2 neighbouring cubes of white color;
* each black cube has exactly 2 neighbouring cubes of black color.
Input
The first line contains integer k (1 ≤ k ≤ 100), which is size of the cube.
Output
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a k × k matrix in the first k lines, showing how the first layer of the cube should be painted. In the following k lines print a k × k matrix — the way the second layer should be painted. And so on to the last k-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Examples
Input
1
Output
-1
Input
2
Output
bb
ww
bb
ww
Submitted Solution:
```
n=int(input())
if(n==1):
print(-1)
else:
for i in range(n):
if(i%2==0):
print('w'*n)
else:
print('b'*n)
``` | instruction | 0 | 33,704 | 7 | 67,408 |
No | output | 1 | 33,704 | 7 | 67,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a cube of size k × k × k, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of k3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
* each white cube has exactly 2 neighbouring cubes of white color;
* each black cube has exactly 2 neighbouring cubes of black color.
Input
The first line contains integer k (1 ≤ k ≤ 100), which is size of the cube.
Output
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a k × k matrix in the first k lines, showing how the first layer of the cube should be painted. In the following k lines print a k × k matrix — the way the second layer should be painted. And so on to the last k-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Examples
Input
1
Output
-1
Input
2
Output
bb
ww
bb
ww
Submitted Solution:
```
n=int(input())
if(n%2==1):
print(-1)
else:
for i in range(n):
for j in range(n):
if(j%2==0):
print('b'*n)
else:
print('w'*n)
print()
``` | instruction | 0 | 33,705 | 7 | 67,410 |
No | output | 1 | 33,705 | 7 | 67,411 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald bought two very rare paintings at the Sotheby's auction and he now wants to hang them on the wall. For that he bought a special board to attach it to the wall and place the paintings on the board. The board has shape of an a1 × b1 rectangle, the paintings have shape of a a2 × b2 and a3 × b3 rectangles.
Since the paintings are painted in the style of abstract art, it does not matter exactly how they will be rotated, but still, one side of both the board, and each of the paintings must be parallel to the floor. The paintings can touch each other and the edges of the board, but can not overlap or go beyond the edge of the board. Gerald asks whether it is possible to place the paintings on the board, or is the board he bought not large enough?
Input
The first line contains two space-separated numbers a1 and b1 — the sides of the board. Next two lines contain numbers a2, b2, a3 and b3 — the sides of the paintings. All numbers ai, bi in the input are integers and fit into the range from 1 to 1000.
Output
If the paintings can be placed on the wall, print "YES" (without the quotes), and if they cannot, print "NO" (without the quotes).
Examples
Input
3 2
1 3
2 1
Output
YES
Input
5 5
3 3
3 3
Output
NO
Input
4 2
2 3
1 2
Output
YES
Note
That's how we can place the pictures in the first test:
<image>
And that's how we can do it in the third one.
<image> | instruction | 0 | 33,802 | 7 | 67,604 |
Tags: constructive algorithms, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
read_tuple = lambda _type: map(_type, input().split(' '))
def fits(s_a, s_b, a_1, b_1):
return a_1 <= s_a and b_1 <= s_b
def rotations(a, b):
return ((a, b), (b, a))
def cuts(a, b, a_1, b_1):
return ((a - a_1, b), (a, b - b_1), (a - a_1, b - b_1))
def solve():
stand_a, stand_b = read_tuple(int)
pic_1 = tuple(read_tuple(int))
pic_2 = tuple(read_tuple(int))
for s_a, s_b in rotations(stand_a, stand_b):
for a_1, b_1 in rotations(pic_1[0], pic_1[1]):
for a_2, b_2 in rotations(pic_2[0], pic_2[1]):
if fits(s_a, s_b, a_1, b_1):
for left_a, left_b in cuts(s_a, s_b, a_1, b_1):
if fits(left_a, left_b, a_2, b_2):
return "YES"
return "NO"
if __name__ == '__main__':
print(solve())
``` | output | 1 | 33,802 | 7 | 67,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald bought two very rare paintings at the Sotheby's auction and he now wants to hang them on the wall. For that he bought a special board to attach it to the wall and place the paintings on the board. The board has shape of an a1 × b1 rectangle, the paintings have shape of a a2 × b2 and a3 × b3 rectangles.
Since the paintings are painted in the style of abstract art, it does not matter exactly how they will be rotated, but still, one side of both the board, and each of the paintings must be parallel to the floor. The paintings can touch each other and the edges of the board, but can not overlap or go beyond the edge of the board. Gerald asks whether it is possible to place the paintings on the board, or is the board he bought not large enough?
Input
The first line contains two space-separated numbers a1 and b1 — the sides of the board. Next two lines contain numbers a2, b2, a3 and b3 — the sides of the paintings. All numbers ai, bi in the input are integers and fit into the range from 1 to 1000.
Output
If the paintings can be placed on the wall, print "YES" (without the quotes), and if they cannot, print "NO" (without the quotes).
Examples
Input
3 2
1 3
2 1
Output
YES
Input
5 5
3 3
3 3
Output
NO
Input
4 2
2 3
1 2
Output
YES
Note
That's how we can place the pictures in the first test:
<image>
And that's how we can do it in the third one.
<image> | instruction | 0 | 33,803 | 7 | 67,606 |
Tags: constructive algorithms, implementation
Correct Solution:
```
def check(a1, b1, a2, b2, a3, b3):
if a2 + a3 <= a1 and b2 <= b1 and b3 <= b1:
return True
if b2 + b3 <= b1 and a2 <= a1 and a3 <= a1:
return True
return False
if __name__ == '__main__':
a1, b1 = map(int, input().split())
a2, b2 = map(int, input().split())
a3, b3 = map(int, input().split())
if check(a1, b1, a2, b2, a3, b3) or check(a1, b1, b2, a2, a3, b3) or check(a1, b1, a2, b2, b3, a3) or check(a1, b1, b2, a2, b3, a3):
print('YES')
else:
print('NO')
``` | output | 1 | 33,803 | 7 | 67,607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald bought two very rare paintings at the Sotheby's auction and he now wants to hang them on the wall. For that he bought a special board to attach it to the wall and place the paintings on the board. The board has shape of an a1 × b1 rectangle, the paintings have shape of a a2 × b2 and a3 × b3 rectangles.
Since the paintings are painted in the style of abstract art, it does not matter exactly how they will be rotated, but still, one side of both the board, and each of the paintings must be parallel to the floor. The paintings can touch each other and the edges of the board, but can not overlap or go beyond the edge of the board. Gerald asks whether it is possible to place the paintings on the board, or is the board he bought not large enough?
Input
The first line contains two space-separated numbers a1 and b1 — the sides of the board. Next two lines contain numbers a2, b2, a3 and b3 — the sides of the paintings. All numbers ai, bi in the input are integers and fit into the range from 1 to 1000.
Output
If the paintings can be placed on the wall, print "YES" (without the quotes), and if they cannot, print "NO" (without the quotes).
Examples
Input
3 2
1 3
2 1
Output
YES
Input
5 5
3 3
3 3
Output
NO
Input
4 2
2 3
1 2
Output
YES
Note
That's how we can place the pictures in the first test:
<image>
And that's how we can do it in the third one.
<image> | instruction | 0 | 33,804 | 7 | 67,608 |
Tags: constructive algorithms, implementation
Correct Solution:
```
import sys
def main():
x = []
n,m = [int(i) for i in input().split()]
a1,b1 = [int(i) for i in input().split()]
a2,b2 = [int(i) for i in input().split()]
ok = lambda a1,b1,a2,b2 : a1 + a2 <= n and max(b1,b2)<= m or b1 + b2 <= m and max(a1,a2)<= n
print('YES' if ok(a1, b1, a2, b2) or ok(a1, b1, b2, a2) or ok(b1, a1, a2, b2) or ok(b1, a1, b2, a2) else 'NO')
main()
``` | output | 1 | 33,804 | 7 | 67,609 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald bought two very rare paintings at the Sotheby's auction and he now wants to hang them on the wall. For that he bought a special board to attach it to the wall and place the paintings on the board. The board has shape of an a1 × b1 rectangle, the paintings have shape of a a2 × b2 and a3 × b3 rectangles.
Since the paintings are painted in the style of abstract art, it does not matter exactly how they will be rotated, but still, one side of both the board, and each of the paintings must be parallel to the floor. The paintings can touch each other and the edges of the board, but can not overlap or go beyond the edge of the board. Gerald asks whether it is possible to place the paintings on the board, or is the board he bought not large enough?
Input
The first line contains two space-separated numbers a1 and b1 — the sides of the board. Next two lines contain numbers a2, b2, a3 and b3 — the sides of the paintings. All numbers ai, bi in the input are integers and fit into the range from 1 to 1000.
Output
If the paintings can be placed on the wall, print "YES" (without the quotes), and if they cannot, print "NO" (without the quotes).
Examples
Input
3 2
1 3
2 1
Output
YES
Input
5 5
3 3
3 3
Output
NO
Input
4 2
2 3
1 2
Output
YES
Note
That's how we can place the pictures in the first test:
<image>
And that's how we can do it in the third one.
<image> | instruction | 0 | 33,805 | 7 | 67,610 |
Tags: constructive algorithms, implementation
Correct Solution:
```
def ok( a , b , A , B ):
return ( a <= A and b <= B ) or ( a <= B and b <= A )
if __name__ == "__main__":
A , B = [int(x) for x in input().split()]
a1 , b1 = [int(x) for x in input().split()]
a2 , b2 = [int(x) for x in input().split()]
if ok( a1 + a2 , max(b1,b2) , A , B ):
print("YES")
elif ok( a1 + b2 , max(b1,a2) , A , B ):
print("YES")
elif ok( b1 + a2 , max(a1,b2) , A , B ):
print("YES")
elif ok( b1 + b2 , max(a1,a2) , A , B ):
print("YES")
else:
print("NO")
``` | output | 1 | 33,805 | 7 | 67,611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald bought two very rare paintings at the Sotheby's auction and he now wants to hang them on the wall. For that he bought a special board to attach it to the wall and place the paintings on the board. The board has shape of an a1 × b1 rectangle, the paintings have shape of a a2 × b2 and a3 × b3 rectangles.
Since the paintings are painted in the style of abstract art, it does not matter exactly how they will be rotated, but still, one side of both the board, and each of the paintings must be parallel to the floor. The paintings can touch each other and the edges of the board, but can not overlap or go beyond the edge of the board. Gerald asks whether it is possible to place the paintings on the board, or is the board he bought not large enough?
Input
The first line contains two space-separated numbers a1 and b1 — the sides of the board. Next two lines contain numbers a2, b2, a3 and b3 — the sides of the paintings. All numbers ai, bi in the input are integers and fit into the range from 1 to 1000.
Output
If the paintings can be placed on the wall, print "YES" (without the quotes), and if they cannot, print "NO" (without the quotes).
Examples
Input
3 2
1 3
2 1
Output
YES
Input
5 5
3 3
3 3
Output
NO
Input
4 2
2 3
1 2
Output
YES
Note
That's how we can place the pictures in the first test:
<image>
And that's how we can do it in the third one.
<image> | instruction | 0 | 33,806 | 7 | 67,612 |
Tags: constructive algorithms, implementation
Correct Solution:
```
def Check(a2, b2, a3, b3):
if a1 >= a2 + a3 and b1 >= max(b2, b3) or \
a1 >= max(a2, a3) and b1 >= b2 + b3:
return True
else:
return False
a1, b1 = map(int, input().split())
a2, b2 = map(int, input().split())
a3, b3 = map(int, input().split())
a1, b1 = min(a1, b1), max(a1, b1)
a2, b2 = min(a2, b2), max(a2, b2)
a3, b3 = min(a3, b3), max(a3, b3)
r = Check(a2, b2, a3, b3) or \
Check(a2, b2, b3, a3) or \
Check(b2, a2, a3, b3) or \
Check(b2, a2, b3, a3)
if r:
print("YES")
else:
print("NO")
``` | output | 1 | 33,806 | 7 | 67,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald bought two very rare paintings at the Sotheby's auction and he now wants to hang them on the wall. For that he bought a special board to attach it to the wall and place the paintings on the board. The board has shape of an a1 × b1 rectangle, the paintings have shape of a a2 × b2 and a3 × b3 rectangles.
Since the paintings are painted in the style of abstract art, it does not matter exactly how they will be rotated, but still, one side of both the board, and each of the paintings must be parallel to the floor. The paintings can touch each other and the edges of the board, but can not overlap or go beyond the edge of the board. Gerald asks whether it is possible to place the paintings on the board, or is the board he bought not large enough?
Input
The first line contains two space-separated numbers a1 and b1 — the sides of the board. Next two lines contain numbers a2, b2, a3 and b3 — the sides of the paintings. All numbers ai, bi in the input are integers and fit into the range from 1 to 1000.
Output
If the paintings can be placed on the wall, print "YES" (without the quotes), and if they cannot, print "NO" (without the quotes).
Examples
Input
3 2
1 3
2 1
Output
YES
Input
5 5
3 3
3 3
Output
NO
Input
4 2
2 3
1 2
Output
YES
Note
That's how we can place the pictures in the first test:
<image>
And that's how we can do it in the third one.
<image> | instruction | 0 | 33,807 | 7 | 67,614 |
Tags: constructive algorithms, implementation
Correct Solution:
```
import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import *
from itertools import accumulate
inf = float("inf")
# input = sys.stdin.readline
flush = lambda: sys.stdout.flush
comb = lambda x, y: (factorial(x) // factorial(y)) // factorial(x - y)
# inputs
# ip = lambda : input().rstrip()
ip = lambda: input()
ii = lambda: int(input())
r = lambda: map(int, input().split())
rr = lambda: list(r())
a, b = r()
arr = rr()
brr = rr()
x = sum(arr)
y = sum(brr)
for i in arr:
for j in brr:
if (i + j <= a and b >= max(x - i, y - j)) or (
i + j <= b and a >= max(x - i, y - j)
):
print("YES")
exit()
for i in arr[::-1]:
for j in brr[::-1]:
if (i + j <= a and b >= max(x - i, y - j)) or (
i + j <= b and a >= max(x - i, y - j)
):
print("YES")
exit()
print("NO")
``` | output | 1 | 33,807 | 7 | 67,615 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald bought two very rare paintings at the Sotheby's auction and he now wants to hang them on the wall. For that he bought a special board to attach it to the wall and place the paintings on the board. The board has shape of an a1 × b1 rectangle, the paintings have shape of a a2 × b2 and a3 × b3 rectangles.
Since the paintings are painted in the style of abstract art, it does not matter exactly how they will be rotated, but still, one side of both the board, and each of the paintings must be parallel to the floor. The paintings can touch each other and the edges of the board, but can not overlap or go beyond the edge of the board. Gerald asks whether it is possible to place the paintings on the board, or is the board he bought not large enough?
Input
The first line contains two space-separated numbers a1 and b1 — the sides of the board. Next two lines contain numbers a2, b2, a3 and b3 — the sides of the paintings. All numbers ai, bi in the input are integers and fit into the range from 1 to 1000.
Output
If the paintings can be placed on the wall, print "YES" (without the quotes), and if they cannot, print "NO" (without the quotes).
Examples
Input
3 2
1 3
2 1
Output
YES
Input
5 5
3 3
3 3
Output
NO
Input
4 2
2 3
1 2
Output
YES
Note
That's how we can place the pictures in the first test:
<image>
And that's how we can do it in the third one.
<image> | instruction | 0 | 33,808 | 7 | 67,616 |
Tags: constructive algorithms, implementation
Correct Solution:
```
a1, b1 = map(int, input().split())
a2, b2 = map(int, input().split())
a3, b3 = map(int, input().split())
def f(a, b, c, d):
if a + c <= a1 and max(b, d) <= b1:
print("YES")
exit(0)
for _ in range(2):
f(a2, b2, a3, b3)
f(b2, a2, a3, b3)
f(a2, b2, b3, a3)
f(b2, a2, b3, a3)
a1, b1 = b1, a1
print("NO")
``` | output | 1 | 33,808 | 7 | 67,617 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald bought two very rare paintings at the Sotheby's auction and he now wants to hang them on the wall. For that he bought a special board to attach it to the wall and place the paintings on the board. The board has shape of an a1 × b1 rectangle, the paintings have shape of a a2 × b2 and a3 × b3 rectangles.
Since the paintings are painted in the style of abstract art, it does not matter exactly how they will be rotated, but still, one side of both the board, and each of the paintings must be parallel to the floor. The paintings can touch each other and the edges of the board, but can not overlap or go beyond the edge of the board. Gerald asks whether it is possible to place the paintings on the board, or is the board he bought not large enough?
Input
The first line contains two space-separated numbers a1 and b1 — the sides of the board. Next two lines contain numbers a2, b2, a3 and b3 — the sides of the paintings. All numbers ai, bi in the input are integers and fit into the range from 1 to 1000.
Output
If the paintings can be placed on the wall, print "YES" (without the quotes), and if they cannot, print "NO" (without the quotes).
Examples
Input
3 2
1 3
2 1
Output
YES
Input
5 5
3 3
3 3
Output
NO
Input
4 2
2 3
1 2
Output
YES
Note
That's how we can place the pictures in the first test:
<image>
And that's how we can do it in the third one.
<image> | instruction | 0 | 33,809 | 7 | 67,618 |
Tags: constructive algorithms, implementation
Correct Solution:
```
a,b=[int(x) for x in input().split()]
c,d=[int(x) for x in input().split()]
e,f=[int(x) for x in input().split()]
def do(a,b,c,d,e,f):
for i in range(1,5):
if (c+e<=a and d<=b and f<=b) or (d+f<=b and c<=a and e<=a):
return "YES"
if i%2: c,d=d,c
e,f=f,e
return "NO"
print(do(a,b,c,d,e,f))
``` | output | 1 | 33,809 | 7 | 67,619 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image> | instruction | 0 | 34,382 | 7 | 68,764 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import math
n = int(input())
x = n
for i in range(2, int(n**0.5)+1):
if n%i==0:
x = math.gcd(x, i)
x = math.gcd(x,int(n/i))
print(x)
``` | output | 1 | 34,382 | 7 | 68,765 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image> | instruction | 0 | 34,383 | 7 | 68,766 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import math
a = []
def primeFactors(n):
while n % 2 == 0:
# print(2)
a.append(2)
n = int(n / 2)
for i in range(3, int(math.sqrt(n))+1, 2):
while n % i == 0:
# print(i)
a.append(i)
n = int(n / i)
if n > 2:
# print(n)
a.append(n)
n = int(input())
if(n == 1):
print(1)
else:
primeFactors(n)
# print(a)
if(a[0] == a[len(a)-1]):
print(a[0])
else:
print(1)
``` | output | 1 | 34,383 | 7 | 68,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image> | instruction | 0 | 34,384 | 7 | 68,768 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
# |
# _` | __ \ _` | __| _ \ __ \ _` | _` |
# ( | | | ( | ( ( | | | ( | ( |
# \__,_| _| _| \__,_| \___| \___/ _| _| \__,_| \__,_|
import sys
import math
def read_line():
return sys.stdin.readline()[:-1]
def read_int():
return int(sys.stdin.readline())
def read_int_line():
return [int(v) for v in sys.stdin.readline().split()]
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
def factors(p):
fac = []
for i in range(2,int(math.sqrt(n)+1)):
if p%i==0:
fac.append(i)
fac.append(p//i)
return fac
n = read_int()
f = factors(n)
if len(f)>=1:
ans = f[0]
for i in f:
ans = gcd(ans,i)
print(ans)
else:
print(n)
``` | output | 1 | 34,384 | 7 | 68,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image> | instruction | 0 | 34,385 | 7 | 68,770 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
#Problem 3
num = int(input())
#check prime
count = 0
cond = 0
for i in range(2,int(num**0.5)+1):
if num % i == 0:
count +=1
prim = i
break
if count == 0:
print(num)
else:
for j in range(1,40):
if prim**j == num:
print(prim)
cond += 1
break
if cond == 0:
print(1)
``` | output | 1 | 34,385 | 7 | 68,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image> | instruction | 0 | 34,386 | 7 | 68,772 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import sys
input = sys.stdin.readline
import math
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
def main():
N = int(input())
if N == 1:
print(1)
exit()
x = make_divisors(N)
if len(x) == 2:
print(N)
elif len(x) == 3:
print(x[1])
else:
mi = float("inf")
for i in range(1, len(x) - 2):
mi = min(mi, math.gcd(x[i], x[i + 1]))
if mi == 1:
break
print(mi)
if __name__ == '__main__':
main()
``` | output | 1 | 34,386 | 7 | 68,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image> | instruction | 0 | 34,387 | 7 | 68,774 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
n = int(input())
min_del = 0
i = 2
while i * i <= n:
if n % i == 0:
if min_del == 0:
min_del = i
elif i % min_del != 0:
print(1)
exit()
while n % i == 0:
n //= i
i += 1
if n > 1 and min_del != 0:
print(1)
elif min_del == 0:
print(n)
else:
print(min_del)
``` | output | 1 | 34,387 | 7 | 68,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image> | instruction | 0 | 34,388 | 7 | 68,776 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
from math import sqrt, floor
def sieve(n):
primes = [True] * (n + 1)
primes[0] = False
primes[1] = False
for i in range(2, n + 1):
if i*i > n:
break
# if primes[i] == True:
if primes[i] == False:
continue
# for j in range(2*i, n + 1):
for j in range(2*i, n + 1, i):
# if j == 5:
# print('i: ', i)
primes[j] = False
return primes
def run_testcase():
number = int(input())
# print(sieve(number))
# print(zip(range(number), sieve(number)))
# print(list(zip(range(number), sieve(number))))
# print(list(zip(range(number + 1), sieve(number))))
# prime_divisors_count = 0
# # while number % 2 == 0:
# # prime_divisors_count += 1
# last_prime_divisor = 2
# # def sieve():
# if number % last_prime_divisor == 0:
# prime_divisors_count += 1
# while number % last_prime_divisor == 0:
# # number /= last_prime_divisor
# number = number // last_prime_divisor
# num_sqrt = sqrt(number)
# # primes = [True] * (int(sqrt) + 1)
# # primes = [True] * int(sqrt)
# # primes = [True] * (int(sqrt) + 1)
# # primes = [True] * (floor(num_sqrt) + 1)
# primes = [True] * (floor(num_sqrt) + 2)
# primes[0] = False
# primes[1] = False
# # print(len(primes))
# # for i in range(len(primes)):
# # for i in range(len(2, primes)):
# for i in range(2, len(primes)):
# # for j in range(i)
# if i*i >= num_sqrt:
# break
# # if prime[i] == True:
# if primes[i] == True:
# continue
# # j = 0
# j = 2 * i
# while j < len(primes):
# # print(j)
# primes[j] = False
# j += i
# print('test')
num_sqrt = sqrt(number)
# primes = sieve(num_sqrt)
primes = sieve(floor(num_sqrt))
prime_divisors_count = 0
last_prime_divisor = 0
for value, prime in enumerate(primes):
if prime:
if number % value == 0:
last_prime_divisor = value
prime_divisors_count += 1
if prime_divisors_count >= 2:
return 1
while number % value == 0:
number = number // value
if number == 1:
return value
else:
return 1
# for value, prime in primes:
for value, prime in enumerate(primes):
if prime:
# print(value)
if number % value == 0:
last_prime_divisor = value
prime_divisors_count += 1
if prime_divisors_count >= 2:
return 1
# return last_prime_divisor
# return last_prime_divisor if last_prime_divisor != 0 else number
# print(last_prime_divisor)
# if number == 2:
# return 2
# if last_prime_divisor ** 2 == number:
# return last_prime_divisor
if last_prime_divisor == 0:
return number
elif last_prime_divisor ** 2 == number:
return last_prime_divisor
else:
return 1
return last_prime_divisor if last_prime_divisor != 0 else number
# testcase_count = int(input())
# for i in range(testcase_count):
# print(str(run_testcase()))
# run_testcase()
# run_testcase()
print(str(run_testcase()))
``` | output | 1 | 34,388 | 7 | 68,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image> | instruction | 0 | 34,389 | 7 | 68,778 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
#!/usr/bin/env python3
import sys
from fractions import gcd
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
def divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
n = int(input())
if n == 1:
print(1)
exit()
div = divisors(n)
ans = div[1]
for item in div[1:]:
ans = gcd(ans, item)
print(ans)
``` | output | 1 | 34,389 | 7 | 68,779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image>
Submitted Solution:
```
import sys
import math
def primeFactors(n):
x=[]
if(n%2==0):
x.append(2)
while (n % 2 == 0):
# x.append(2)
n=n//2
for i in range(3,int(math.sqrt(n))+1,2):
if(n%i==0):
x.append(i)
while (n % i== 0):
n=n//i
if n > 2:
x.append(n)
return x
# t=int(sys.stdin.readline())
t=1
for i in range(t):
n=int(sys.stdin.readline())
# a=list(map(int,sys.stdin.readline().strip().split()))
x=primeFactors(n)
# print(x)
if(len(x)==1):
print(x[0])
else:
print(1)
``` | instruction | 0 | 34,390 | 7 | 68,780 |
Yes | output | 1 | 34,390 | 7 | 68,781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image>
Submitted Solution:
```
import math
def isprime(n):
for i in range(2, int(n**.5+1)):
if n%i == 0:
return False
return True
def isPower (num, base):
if base == 1 and num != 1: return False
if base == 1 and num == 1: return True
if base == 0 and num != 1: return False
power = int (math.log (num, base) + 0.5)
return base ** power == num
n = int(input())
ans = 1
if isprime(n):
ans = n
# if n is power of prime, ans = prime
for i in range(2, int(n**.5+1)):
if isPower(n, i):
if isprime(i):
ans = i
print(ans)
``` | instruction | 0 | 34,391 | 7 | 68,782 |
Yes | output | 1 | 34,391 | 7 | 68,783 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image>
Submitted Solution:
```
n=int(input())
if n==1:
print(1)
exit()
s=set()
xx=n
ans=[]
for i in range(2,int(n**0.5)+1):
if xx%i==0:
ans.append(i)
s.add(i)
while xx%i==0:
xx=xx//i
if xx>1:
ans.append(xx)
s.add(xx)
if len(s)>1:
print(1)
else:
print(ans[0])
``` | instruction | 0 | 34,392 | 7 | 68,784 |
Yes | output | 1 | 34,392 | 7 | 68,785 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image>
Submitted Solution:
```
n=int(input())
f=[]
for i in range(2,int(n**(0.5))+1):
if n%i==0:
while n%i==0:
n=n//i
f.append(i)
if n>1:
f.append(n)
if len(f)==1:
print(f[0])
else:
print(1)
``` | instruction | 0 | 34,393 | 7 | 68,786 |
Yes | output | 1 | 34,393 | 7 | 68,787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image>
Submitted Solution:
```
def abs(n):
return n if n >= 0 else -n
n = int(input())
sup = n ** (1 / 2)
i = 2
while ( n % i != 0 ):
if ( i > sup ):
i = n
break
i += 1
print(i)
``` | instruction | 0 | 34,394 | 7 | 68,788 |
No | output | 1 | 34,394 | 7 | 68,789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image>
Submitted Solution:
```
n = int(input())
count = 1
mod = 2
if n ==1:
count = 1
else:
count = 2
while n%mod > 0:
count += 1
mod += 1
print(count)
``` | instruction | 0 | 34,395 | 7 | 68,790 |
No | output | 1 | 34,395 | 7 | 68,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image>
Submitted Solution:
```
import sys
import math
import itertools
import collections
def divs(n, start=1):
r = []
for i in range(start, int(math.sqrt(n) + 1)):
if (n % i == 0):
if (n / i == i):
r.append(i)
else:
r.extend([i, n // i])
return r
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def wr(arr): return ' '.join(map(str, arr))
def revn(n): return int(str(n)[::-1])
def prime(n):
if n == 2: return True
if n % 2 == 0 or n <= 1: return False
sqr = int(math.sqrt(n)) + 1
for d in range(3, sqr, 2):
if n % d == 0: return False
return True
def convn(number, base=3):
newnumber = ''
while number > 0:
newnumber = str(number % base) + newnumber
number //= base
return newnumber
k = ii()
if k == 1:
print(1)
elif prime(k):
print(k)
else:
a = divs(k)
a.sort(reverse=True)
for n in a:
if prime(n):
exit(print(n))
``` | instruction | 0 | 34,396 | 7 | 68,792 |
No | output | 1 | 34,396 | 7 | 68,793 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.