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 |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Twilight Sparkle once got a crystal from the Crystal Mine. A crystal of size n (n is odd; n > 1) is an n × n matrix with a diamond inscribed into it.
You are given an odd integer n. You need to draw a crystal of size n. The diamond cells of the matrix should be represented by character "D". All other cells of the matrix should be represented by character "*". Look at the examples to understand what you need to draw.
Input
The only line contains an integer n (3 ≤ n ≤ 101; n is odd).
Output
Output a crystal of size n.
Examples
Input
3
Output
*D*
DDD
*D*
Input
5
Output
**D**
*DDD*
DDDDD
*DDD*
**D**
Input
7
Output
***D***
**DDD**
*DDDDD*
DDDDDDD
*DDDDD*
**DDD**
***D***
Submitted Solution:
```
print("ok")
``` | instruction | 0 | 13,670 | 7 | 27,340 |
No | output | 1 | 13,670 | 7 | 27,341 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image> | instruction | 0 | 13,706 | 7 | 27,412 |
Tags: brute force, math
Correct Solution:
```
__author__ = 'MoonBall'
import sys
# sys.stdin = open('data/D.in', 'r')
T = 1
def process():
ans = []
N = int(input())
for i in range(1, 3000000):
a = N + i * (i - 1) * (i + 1) // 6
j, mod = divmod(a, i * (i + 1) // 2)
if i > j: break
if mod: continue
ans.append((i, j))
if i != j: ans.append((j, i))
ans.sort()
print(len(ans))
for i, j in ans: print(i, j)
for _ in range(T):
process()
``` | output | 1 | 13,706 | 7 | 27,413 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image> | instruction | 0 | 13,707 | 7 | 27,414 |
Tags: brute force, math
Correct Solution:
```
n,i,t,r=int(input()),0,0,[]
while n>=0:
i+=1
n-=i*i
t+=i
m=n//t+i
r+=[(m,i),(i,m)][m==i:]*(n%t==0<=n)
for p in[(len(r),'')]+sorted(r):print("%d %s"%p)
``` | output | 1 | 13,707 | 7 | 27,415 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image> | instruction | 0 | 13,708 | 7 | 27,416 |
Tags: brute force, math
Correct Solution:
```
from collections import Counter
def mp(): return map(int,input().split())
def lt(): return list(map(int,input().split()))
def pt(x): print(x)
def ip(): return input()
def it(): return int(input())
def sl(x): return [t for t in x]
def spl(x): return x.split()
def aj(liste, item): liste.append(item)
def bin(x): return "{0:b}".format(x)
def listring(l): return ' '.join([str(x) for x in l])
def printlist(l): print(' '.join([str(x) for x in l]))
n = it()
L = []
R = []
for i in range(1,int((3*n)**(1/3))+1):
if 6*n % (i*(i+1)) == 0:
if ((6*n) // (i*(i+1)) + i - 1) % 3 == 0:
t = ((6*n) // (i*(i+1)) + i - 1) // 3
L.append([i,t])
if i < t:
R.insert(0,[t,i])
result = L + R
print(len(result))
for i in result:
printlist(i)
``` | output | 1 | 13,708 | 7 | 27,417 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image> | instruction | 0 | 13,709 | 7 | 27,418 |
Tags: brute force, math
Correct Solution:
```
__author__ = 'MoonBall'
import sys
# sys.stdin = open('data/D.in', 'r')
T = 1
def process():
ans = []
N = int(input())
for i in range(1, N + 1):
a = N + i * (i - 1) * (i + 1) // 6
j, mod = divmod(a, i * (i + 1) // 2)
if i > j: break
if mod: continue
ans.append((i, j))
if i != j: ans.append((j, i))
ans.sort()
print(len(ans))
for i, j in ans: print(i, j)
for _ in range(T):
process()
``` | output | 1 | 13,709 | 7 | 27,419 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image> | instruction | 0 | 13,710 | 7 | 27,420 |
Tags: brute force, math
Correct Solution:
```
s = int(input())
"""
nm + (n-1)(m-1) + ...
nm + nm -(n+m) + 1
6x
= 6mn*n - 3*(n-1)n(n+m) + (n-1)*n*(2n-1)
6x - n*(n+1)*(2n+1)+3*(n-1)n*n = (6n*n - 3*(n-1)*n)*m
"""
a, b = [], []
for n in range(1,1450000):
u = 6*s - n*(n-1)*(n+n-1)+3*(n-1)*n*n
v = 6*n*n - 3*(n-1)*n
if u % v == 0:
u //= v
if n <= u:
a += [(n, u)]
if n < u:
b += [(u, n)]
else:
break
print(len(a)+len(b))
for e in a:
print(*e)
for e in reversed(b):
print(*e)
``` | output | 1 | 13,710 | 7 | 27,421 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image> | instruction | 0 | 13,711 | 7 | 27,422 |
Tags: brute force, math
Correct Solution:
```
x = int(input()) * 6
n, equ, ans = 0, False, []
while True:
n += 1
if n * (n + 1) * (2 * n - 1) > x:
break
if x % n != 0:
continue
if x % (n + 1) != 0:
continue
m = x // n // (n + 1) + n - 1
if m % 3 != 0:
continue
m = m // 3
if n <= m:
ans.append((n, m))
if n == m:
equ = True
print(len(ans) * 2 - equ)
for p in ans:
print("%d %d" % (p[0], p[1]))
if equ:
ans.pop()
ans.reverse()
for p in ans:
print("%d %d" % (p[1], p[0]))
``` | output | 1 | 13,711 | 7 | 27,423 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image> | instruction | 0 | 13,712 | 7 | 27,424 |
Tags: brute force, math
Correct Solution:
```
def main():
x = int(input())
l = squares(x)
last = l[len(l) - 1]
if last[0] != last[1]:
print(2 * len(l))
else:
print(2 * len(l) - 1)
for pair in l:
print(pair[0], pair[1])
if last[0] != last[1]:
for pair in l[::-1]:
print(pair[1], pair[0])
else:
revL = l[::-1]
for pair in revL[1:]:
print(pair[1], pair[0])
def squares(x):
if x == 1:
return [(1, 1)]
result = []
cubeRoot = int((6 * x)**(1/3))
n = 1
while n <= cubeRoot:
#m = (y / (n * (n + 1)) + n - 1) / 3
y = 6 * x
temp = n * (n + 1)
if y % temp == 0:
y //= temp
y += n - 1
if y % 3 == 0:
m = y // 3
if m >= n:
result += [(n, m)]
n += 1
return result
#main()
main()
``` | output | 1 | 13,712 | 7 | 27,425 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
n,i,t,r=int(input()),0,0,[]
while n>=0:
i+=1
n-=i*i
t+=i
m=n//t
r+=[(m+i,i),(i,m+i)][m==0:]*(m*t==n>=0)
for p in[(len(r),'')]+sorted(r):print("%d %s"%p)
``` | instruction | 0 | 13,713 | 7 | 27,426 |
Yes | output | 1 | 13,713 | 7 | 27,427 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
n = int(input())
i = 0
s = 0
t = 0
x = 0
f = 0
res1 = []
res2 = []
while n >= 0:
i = i + 1
n = n - i * i
if ( n < 0 ):
break
t = t + i
m = n // t
if ( m * t != n ):
continue
else:
res1.append( i )
res2.append( m + i )
x = x + 1
if m == 0:
f = 1
print ( str(int(2 * x - f)) )
for i in range(x):
print( str(int(res1[i])) + " " + str(int(res2[i])))
res1.reverse()
res2.reverse()
for i in range(x):
if ( res1[i] != res2[i] ):
print( str(int(res2[i])) + " " + str(int(res1[i])))
``` | instruction | 0 | 13,714 | 7 | 27,428 |
Yes | output | 1 | 13,714 | 7 | 27,429 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
from itertools import chain, combinations
from functools import reduce
from collections import defaultdict
def res(m,n):
k = min(m,n)
return (1+k)*(k+2*k**2-3*k*(m+n)+6*m*n) // 6
def powerset(iterable):
s = list(iterable)
return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
def prod(it):
r = 1
for elem in it:
r *= elem
return r
def factorGenerator(n):
res = defaultdict(lambda: 0)
for p in range(2,10**6+1):
while n % p == 0:
res[p] += 1
n = n // p
return res
def divisorGen(n):
factors = list(factorGenerator(n).items())
nfactors = len(factors)
f = [0] * nfactors
while True:
yield reduce(lambda x, y: x*y, [factors[x][0]**f[x] for x in range(nfactors)], 1)
i = 0
while True:
f[i] += 1
if f[i] <= factors[i][1]:
break
f[i] = 0
i += 1
if i >= nfactors:
return
def res2(x):
r = []
x6 = 6 * x
divisors = set(divisorGen(x6))
for m in divisors:
a = x6 // m
if a % (m+1) != 0:
continue
b = a // (m+1)
c = b + m - 1
if c % 3 != 0:
continue
n = c // 3
if n < m:
continue
if res(m,n) != x:
continue
r.append((m,n))
return r
x = int(input())
r = res2(x)
r = r + [(n,m) for m,n in r]
r = sorted(set(r))
print(len(r))
for (m,n) in r:
print("%d %d"%(m, n))
``` | instruction | 0 | 13,715 | 7 | 27,430 |
Yes | output | 1 | 13,715 | 7 | 27,431 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
x = int(input())
def solve(x):
count = 0
lst = []
x6 = x * 6
for n in range(1, x + 1):
t, r = divmod(x6, n*(n+1))
if t < 2*n + 1:
break
if r:
continue
m, r = divmod(t + n - 1, 3)
if r:
continue
count += 2
lst.append((n, m))
nn, mm = lst[-1]
if nn == mm:
count -= 1
print(count)
for n, m in lst:
print(n, m)
if nn != mm:
print(mm, nn)
lst.reverse()
for n, m in lst[1:]:
print(m, n)
solve(x)
``` | instruction | 0 | 13,716 | 7 | 27,432 |
Yes | output | 1 | 13,716 | 7 | 27,433 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
pr=stdout.write
import heapq
raw_input = stdin.readline
def ni():
return int(raw_input())
def li():
return list(map(int,raw_input().split()))
def pn(n):
stdout.write(str(n)+'\n')
def pa(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return (map(int,stdin.read().split()))
range = xrange # not for python 3.0+
# main code
x=ni()
y=1
n=1
ans=[]
while x>=y*n:
if x%y==0:
ans.append((x/y,n))
if ans[-1][0]!=ans[-1][1]:
ans.append((n,x/y))
n+=1
x+=(n**2-n)/2
y+=n
pn(len(ans))
for i in ans:
pa(i)
``` | instruction | 0 | 13,717 | 7 | 27,434 |
No | output | 1 | 13,717 | 7 | 27,435 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
sum = int(input())
a = []
b = []
def func(sum,m):
return 2*(sum - (m*m*m - m)//3)/(m*(m+1)) + m - 1
if (sum == 1):
print(1)
print('1 1')
else:
k = 1
for i in range (1, sum ):
z = func(sum, i)
if z % 1 == 0 and (z - i +1)*i*(i+1)//2 + (i*i*i - i)//3 == sum:
if (len(a)) > 0 and i == a[len(a)-1]:
k = 0
break
if (k == 0):
break
a.append(str(i) + ' ' + str(int(z)))
b.append(str(int(z)) + ' ' + str(i))
if k == 0:
break
if a[len(a)-1] != b[len(a)-1] :
print(2*len(a))
for i in range (len(a)):
print(a[i])
for i in range (len(a)):
print(b[len(a)-1-i])
else:
print(2*len(a)-1)
for i in range (len(a)):
print(a[i])
for i in range (len(a)-1):
print(b[len(a)-1-i])
``` | instruction | 0 | 13,718 | 7 | 27,436 |
No | output | 1 | 13,718 | 7 | 27,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
from collections import Counter
def mp(): return map(int,input().split())
def lt(): return list(map(int,input().split()))
def pt(x): print(x)
def ip(): return input()
def it(): return int(input())
def sl(x): return [t for t in x]
def spl(x): return x.split()
def aj(liste, item): liste.append(item)
def bin(x): return "{0:b}".format(x)
def listring(l): return ' '.join([str(x) for x in l])
def printlist(l): print(' '.join([str(x) for x in l]))
n = it()
L = []
R = []
for i in range(1,int((3*n)**(1/3))+1):
if 6*n % (i*(i+1)) == 0:
if ((6*n) // (i*(i+1)) + i - 1) % 3 == 0:
t = ((6*n) // (i*(i+1)) + i - 1) // 3
L.append([i,t])
R.insert(0,[t,i])
result = L + R
for i in result:
printlist(i)
``` | instruction | 0 | 13,719 | 7 | 27,438 |
No | output | 1 | 13,719 | 7 | 27,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
x = int(input())
res = []
ok = -1
for i in range(1, 1000001):
m = i
tmp = (m-1)*(m+1)*m//6 + x
if (tmp*2) % (m*(m+1)) == 0:
n = int((tmp*2) // (m*(m+1)))
if n > m:
res.append([i, n])
if n == m and ok == -1:
ok = len(res)
res.append([i, i])
d = 0 if ok == -1 else 1
print (len(res) * 2 - d)
for i in range(len(res)):
print (str(res[i][0]) + " " + str(res[i][1]))
for i in range(len(res)):
if i != ok:
print (str(res[len(res)-i-1][1]) + " " + str(res[len(res)-i-1][0]))
``` | instruction | 0 | 13,720 | 7 | 27,440 |
No | output | 1 | 13,720 | 7 | 27,441 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
__author__ = 'Utena'
k=int(input())
n=1
m=[]
if k==999999999999999999:
print("6\n1 999999999999999999\n13 10989010989010993\n37 1422475106685645\n1422475106685645 37\n10989010989010993 13\n999999999999999999 1")
exit(0)
while True:
t=((k-int(n*(n+1)*(2*n+1)/6))/(int(n*(n+1)/2)))
if t>=0 and t%1==0:
m.append([n,n+t])
if n>100000:break
n+=1
u=len(m)
if m[-1][0]==m[-1][1]:
print(2*u-1)
for i in range(u):
print("%d %d"%(m[i][0],m[i][1]))
for i in range(u-1):
print("%d %d"%(m[u-i-2][1],m[u-i-2][0]))
else:
print(2*u)
for i in range(u):
print("%d %d"%(m[i][0],m[i][1]))
for i in range(u):
print("%d %d"%(m[u-i-1][1],m[u-i-1][0]))
``` | instruction | 0 | 13,721 | 7 | 27,442 |
No | output | 1 | 13,721 | 7 | 27,443 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample. | instruction | 0 | 13,800 | 7 | 27,600 |
Tags: dfs and similar, graphs, greedy, trees
Correct Solution:
```
from collections import deque
n = int(input())
g = []
visited = []
color = []
max_child_color = []
parent = []
def initialize():
for i in range(n+10):
g.append([])
visited.append(False)
color.append(0)
max_child_color.append(0)
parent.append(0)
for i in range(n-1):
u, v = map(int, input().split())
g[u] += [v]
g[v] += [u]
# print(g)
def get_color(u):
for i in range(max_child_color[u]+1, n+1):
if i != color[parent[u]] and i != color[u]:
max_child_color[u] = i
# print(f'Setting max child color of node = {u} to color {i}')
return i
def bfs(start):
visited[start] = True
color[start] = 1
q = deque()
q.append(start)
while q:
u = q.popleft()
for v in g[u]:
parent[v] = u
if not visited[v]:
visited[v] = True
color[v] = get_color(u)
q.append(v)
if __name__ == '__main__':
initialize()
bfs(1)
print(max(color))
c_string = ""
for i in range(1, n+1):
c_string += str(color[i]) + " "
print(c_string)
``` | output | 1 | 13,800 | 7 | 27,601 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample. | instruction | 0 | 13,801 | 7 | 27,602 |
Tags: dfs and similar, graphs, greedy, trees
Correct Solution:
```
import sys
sys.setrecursionlimit(200000)
n = int(input())
arr = [[] for i in range(n)]
for i in range(n - 1):
a, b = map(int, input().split())
arr[a - 1].append(b - 1)
arr[b - 1].append(a - 1)
s = max([len(p) for p in arr]) + 1
print(s)
colored = [0] * n
def dfs(v, c, d):
colored[v] = p = c
for u in arr[v]:
if not colored[u]:
c = c + 1 if c < s else 1
if c == d:
c = c + 1 if c < s else 1
dfs(u, c, p)
if s > 3:
dfs(0, 1, 0)
else:
i = 0
c = 1
while len(arr[i]) != 1:
i += 1
for j in range(n):
colored[i] = c
c = c + 1 if c < s else 1
if j < n - 1:
i = arr[i][0] if not colored[arr[i][0]] else arr[i][1]
print(" ".join(map(str, colored)))
``` | output | 1 | 13,801 | 7 | 27,603 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample. | instruction | 0 | 13,802 | 7 | 27,604 |
Tags: dfs and similar, graphs, greedy, trees
Correct Solution:
```
import collections
def doit():
N = int(input())
graph = dict()
for n in range(N) :
graph[n] = list()
for n in range(N - 1):
a, b = map(int, input().split())
graph[a-1].append(b-1)
graph[b-1].append(a-1)
msize = 0
for k in graph:
msize = max(msize, len(graph[k]))
print(msize+1)
root = 0
colors = [0 for x in range(N)]
colors[root] = 1
parents = [0 for x in range(N)]
parents[root] = root
def colorgenerator(c1, c2):
colorindex = 0
while colorindex < msize + 1:
colorindex += 1
if colorindex == c1 or colorindex == c2:
continue
yield colorindex
queue = collections.deque([root])
while queue:
vertex = queue.popleft()
color = colorgenerator(colors[vertex], colors[parents[vertex]])
for neighbour in graph[vertex]:
if neighbour == parents[vertex]:
continue
parents[neighbour] = vertex
colors[neighbour] = next(color)
queue.append(neighbour)
print(" ".join(map(str, colors)))
doit()
``` | output | 1 | 13,802 | 7 | 27,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample. | instruction | 0 | 13,803 | 7 | 27,606 |
Tags: dfs and similar, graphs, greedy, trees
Correct Solution:
```
###### ### ####### ####### ## # ##### ### #####
# # # # # # # # # # # # # ###
# # # # # # # # # # # # # ###
###### ######### # # # # # # ######### #
###### ######### # # # # # # ######### #
# # # # # # # # # # #### # # #
# # # # # # # ## # # # # #
###### # # ####### ####### # # ##### # # # #
# mandatory imports
import os
import sys
from io import BytesIO, IOBase
from math import log2, ceil, sqrt, gcd, log
# optional imports
# from itertools import permutations
# from functools import cmp_to_key # for adding custom comparator
# from fractions import Fraction
# from collections import *
# from bisect import *
# from __future__ import print_function # for PyPy2
# from heapq import *
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
g = lambda : input().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
rr = lambda x : reversed(range(x))
mod = int(1e9)+7
inf = float("inf")
n, = gil()
adj = [[] for _ in range(n+1)]
for _ in range(n-1):
x, y = gil()
adj[x].append(y)
adj[y].append(x)
used = set()
clr = [0]*(n+1)
maxVal = 1
toClr = []
st = [1]
vis = [0]*(n+1)
while st:
i = st.pop()
if vis[i]:continue
vis[i] = 1
ptr = 1
used.add(clr[i])
if clr[i] == 0:
toClr.append(i)
for y in adj[i]:
if clr[y]:
used.add(clr[y])
else:
st.append(y)
toClr.append(y)
# print(toClr, used, end=' ')
while toClr:
while ptr in used:
ptr += 1
used.add(ptr)
clr[toClr.pop()] = ptr
maxVal = max(maxVal, ptr)
ptr += 1
# print(clr)
used.clear()
print(maxVal)
print(*clr[1:])
``` | output | 1 | 13,803 | 7 | 27,607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample. | instruction | 0 | 13,804 | 7 | 27,608 |
Tags: dfs and similar, graphs, greedy, trees
Correct Solution:
```
from collections import deque
n = int(input())
dic = {}
for i in range(n):
dic[i]=[]
for i in range(n-1):
a,b = map(int,input().split())
dic[a-1].append(b-1)
dic[b-1].append(a-1)
color = {}
prevcolor = {}
color[0] = 1
prevcolor[0] = 1
lis = deque()
lis.append(0)
visited = {}
while(len(lis)!=0):
t = lis.popleft()
col = 0
visited[t] = 1
prev = prevcolor[t]
for i in dic[t]:
try:
z = visited[i]
except:
while(col==prev or col==color[t] or col==prevcolor[t]):
col+=1
color[i] = col
prevcolor[i] = color[t]
lis.append(i)
prev = col
print(max(color.values())+1)
for i in range(n):
print(color[i]+1,end=" ")
``` | output | 1 | 13,804 | 7 | 27,609 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample. | instruction | 0 | 13,805 | 7 | 27,610 |
Tags: dfs and similar, graphs, greedy, trees
Correct Solution:
```
from sys import stdin
from collections import deque
def main():
n = int(input()) + 1
g = [[] for _ in range(n)]
for s in stdin.read().splitlines():
u, v = map(int, s.split())
g[u].append(v)
g[v].append(u)
cc, palette, q = [0] * n, [True] * n, deque(((1, 0, 1),))
cc[1] = 1
while q:
u, a, b = q.popleft()
palette[a] = palette[b] = False
c = 1
for v in g[u]:
if not cc[v]:
while not palette[c]:
c += 1
cc[v] = c
q.append((v, b, c))
c += 1
palette[a] = palette[b] = True
print(max(cc))
print(' '.join(map(str, cc[1:])))
if __name__ == '__main__':
main()
``` | output | 1 | 13,805 | 7 | 27,611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample. | instruction | 0 | 13,806 | 7 | 27,612 |
Tags: dfs and similar, graphs, greedy, trees
Correct Solution:
```
from collections import deque
n = int(input())
ans = [0]*n
g = [[]for _ in range(n)]
for _ in range(n - 1):
u, v = map(int, input().split())
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
col = 1
q = deque()
vis = [False]*n
q.append((0, 0))
vis[0] = True
ans[0] = 1
p_top = 0
while q:
top, p_top = q.popleft()
col = 1
for viz in g[top]:
if not vis[viz]:
vis[viz] = True
q.append((viz, top))
while ans[top] == col or ans[p_top] == col:
col += 1
ans[viz] = col
col += 1
print(max(ans))
print(" ".join(map(str, ans)))
``` | output | 1 | 13,806 | 7 | 27,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample. | instruction | 0 | 13,807 | 7 | 27,614 |
Tags: dfs and similar, graphs, greedy, trees
Correct Solution:
```
from collections import defaultdict,deque
class Graph:
def __init__(self,n):
self.graph = defaultdict(list)
self.parentColor = [-1] * (n+1)
self.color = [-1] * (n+1)
self.visited = [False] * (n+1)
self.n = n
def addEdge(self,fr,to):
self.graph[fr].append(to)
self.graph[to].append(fr)
def BFS(self,root):
queue = deque()
queue.append(root)
self.color[root] = 1
self.parentColor[root] = 0
while(queue):
s = queue.popleft()
Set = defaultdict(bool)
Set[self.color[s]] = True
Set[self.parentColor[s]] = True
culur = 1
for i in self.graph[s]:
if(self.visited[i] == False):
queue.append(i)
self.parentColor[i] = self.color[s]
while(1):
if(not Set[culur]):
self.color[i] = culur
culur+=1
break
culur+=1
self.visited[s] = True
def show(self):
print(max(self.color))
print(*self.color[1:])
n = int(input())
G = Graph(n)
for _ in range(n-1):
a,b = map(int,input().split())
G.addEdge(a,b)
G.BFS(1)
G.show()
``` | output | 1 | 13,807 | 7 | 27,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample.
Submitted Solution:
```
from sys import stdin
input = stdin.readline
def put():
return map(int, input().split())
def dfs():
s = [(0,0)]
tree[0].append(1)
while s:
i,p = s.pop()
c = 1
for j in tree[i]:
if j!=p:
s.append((j,i))
while c in [color[i], color[p]]:
c+=1
color[j]=c
c+=1
n = int(input())
tree = [[] for i in range(n+1)]
color= [0]*(n+1)
for _ in range(n-1):
x,y = put()
tree[x].append(y)
tree[y].append(x)
ans = 0
for i in range(1,n+1):
ans = max(ans, len(tree[i])+1)
dfs()
print(ans)
print(*color[1:])
``` | instruction | 0 | 13,808 | 7 | 27,616 |
Yes | output | 1 | 13,808 | 7 | 27,617 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample.
Submitted Solution:
```
import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math,datetime,functools,itertools,operator,bisect,fractions,statistics
from collections import deque,defaultdict,OrderedDict,Counter
from fractions import Fraction
from decimal import Decimal
from sys import stdout
from heapq import heappush, heappop, heapify ,_heapify_max,_heappop_max,nsmallest,nlargest
# sys.setrecursionlimit(111111)
INF=999999999999999999999999
alphabets="abcdefghijklmnopqrstuvwxyz"
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
class SegTree:
def __init__(self, n):
self.N = 1 << n.bit_length()
self.tree = [0] * (self.N<<1)
def update(self, i, j, v):
i += self.N
j += self.N
while i <= j:
if i%2==1: self.tree[i] += v
if j%2==0: self.tree[j] += v
i, j = (i+1) >> 1, (j-1) >> 1
def query(self, i):
v = 0
i += self.N
while i > 0:
v += self.tree[i]
i >>= 1
return v
def SieveOfEratosthenes(limit):
"""Returns all primes not greater than limit."""
isPrime = [True]*(limit+1)
isPrime[0] = isPrime[1] = False
primes = []
for i in range(2, limit+1):
if not isPrime[i]:continue
primes += [i]
for j in range(i*i, limit+1, i):
isPrime[j] = False
return primes
def main():
mod=1000000007
# InverseofNumber(mod)
# InverseofFactorial(mod)
# factorial(mod)
starttime=datetime.datetime.now()
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
###CODE
tc = 1
for _ in range(tc):
n=ri()
col=[0]*(n+1)
col[0]=INF
col[1]=1
par=[0]*(n+1)
graph=[[] for i in range(n+1)]
for i in range(n-1):
x,y=ria()
graph[x].append(y)
graph[y].append(x)
def dfs():
mxc=1
visited= [False] * (n+1)
start=1
stack = [start]
while stack:
start = stack[-1]
# push unvisited children into stack
if not visited[start]:
visited[start] = True
a,b=col[par[start]],col[start]
ind=1
for child in graph[start]:
if not visited[child]:
par[child]=start
while ind!=len(graph[start])+2:
if ind!=a and ind!=b:
col[child]=ind
mxc=max(mxc,ind)
ind+=1
break
ind+=1
stack.append(child)
else:
stack.pop()
return mxc
wi(dfs())
wia(col[1:])
#<--Solving Area Ends
endtime=datetime.datetime.now()
time=(endtime-starttime).total_seconds()*1000
if(os.path.exists('input.txt')):
print("Time:",time,"ms")
class FastReader(io.IOBase):
newlines = 0
def __init__(self, fd, chunk_size=1024 * 8):
self._fd = fd
self._chunk_size = chunk_size
self.buffer = io.BytesIO()
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self, size=-1):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
class FastWriter(io.IOBase):
def __init__(self, fd):
self._fd = fd
self.buffer = io.BytesIO()
self.write = self.buffer.write
def flush(self):
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class FastStdin(io.IOBase):
def __init__(self, fd=0):
self.buffer = FastReader(fd)
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
class FastStdout(io.IOBase):
def __init__(self, fd=1):
self.buffer = FastWriter(fd)
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.flush = self.buffer.flush
if __name__ == '__main__':
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()
``` | instruction | 0 | 13,809 | 7 | 27,618 |
Yes | output | 1 | 13,809 | 7 | 27,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample.
Submitted Solution:
```
import sys
sys.setrecursionlimit(200000)
n=int(input())
g=[[] for i in range(n)]
for i in range(n-1):
a,b=map(int, input().split())
g[a-1].append(b-1)
g[b-1].append(a-1)
s = max([len(p) for p in g]) + 1
print(s)
r=[0]*n
def dfs(v,c,d):
r[v]=p=c
for u in g[v]:
if not r[u]:
c=c+1 if c<s else 1
if c==d:
c=c+1 if c<s else 1
dfs(u,c,p)
if s>3:
dfs(0, 1, 0)
else:
i=0
c=1
while len(g[i])!=1:
i+=1
for j in range(n):
r[i]=c
c=c+1 if c<s else 1
if j<n-1:
i=g[i][0] if not r[g[i][0]] else g[i][1]
print(" ".join(map(str, r)))
``` | instruction | 0 | 13,810 | 7 | 27,620 |
Yes | output | 1 | 13,810 | 7 | 27,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample.
Submitted Solution:
```
from sys import stdin
input=lambda : stdin.readline().strip()
from math import ceil,sqrt,factorial,gcd
from collections import deque
n=int(input())
graph={i:set() for i in range(n)}
for i in range(n-1):
a,b=map(int,input().split())
graph[a-1].add(b-1)
graph[b-1].add(a-1)
ma=0
for i in graph:
if len(graph[i])+1>ma:
ma=len(graph[i])+1
x=i
print(ma)
ans=[0 for i in range(n)]
stack=[x]
papa=[0 for i in range(n)]
while stack:
x=stack.pop()
# z=set(s)
a=1
if ans[x]==0:
ans[x]=1
z=[1]
else:
z=[]
z.append(ans[x])
z.append(ans[papa[x]])
for j in graph[x]:
while 1:
if a in z:
a+=1
else:
ans[j]=a
a+=1
break
stack.append(j)
graph[j].remove(x)
papa[j]=x
print(*ans)
``` | instruction | 0 | 13,811 | 7 | 27,622 |
Yes | output | 1 | 13,811 | 7 | 27,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample.
Submitted Solution:
```
import collections
n = int(input())
g = collections.defaultdict(set)
for i in range(n-1):
u,v = map(int,input().split())
g[u].add(v)
g[v].add(u)
ans = [0,0]
for i in g:
ans = max(ans,[len(g[i])+1,len(g[i])+1,i])
maxC = ans[0]
visited = [0] * (n+1)
queue = collections.deque()
queue.append(ans)
colors = [1 for i in range(n+1)]
while queue:
color,carry,cur = queue.popleft()
colors[cur] = color
visited[cur] = 1
rem = set(list(range(1,maxC+1)))
# print(color,carry,cur)
try:
rem.remove(color)
rem.remove(carry)
except:
pass
# print(g[cur],rem)
for i,c in zip(list(g[cur]),list(rem)):
if not visited[i]:
queue.append([c,color,i])
print(ans[0])
print(" ".join([str(i) for i in colors[1:]]))
``` | instruction | 0 | 13,812 | 7 | 27,624 |
No | output | 1 | 13,812 | 7 | 27,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample.
Submitted Solution:
```
n=int(input())
L=[[] for i in range(n)]
out=[0 for i in range(n)]
oy=[[] for i in range(n)]
for i in range(n-1) :
a,b=map(int,input().split())
L[a-1].append(b-1)
L[b-1].append(a-1)
visited=[False for i in range(n)]
kil=len(max(L,key=lambda x :len(x)))+1
q=[0]
out[0]=1
visited[0]=True
while (len(q)>0) :
b=q[0]
k=0
oy[b].append(out[b]-1)
for x in L[b] :
if visited[x]==False :
while( k in oy[b]) :
k+=1
oy[x].append(b)
visited[x]=True
out[x]=k+1
q.append(x)
k+=1
del(q[0])
print(kil)
print(' '.join(map(str,out)))
``` | instruction | 0 | 13,813 | 7 | 27,626 |
No | output | 1 | 13,813 | 7 | 27,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample.
Submitted Solution:
```
n=int(input())
L=[[] for i in range(n)]
out=[0 for i in range(n)]
oy=[[] for i in range(n)]
for i in range(n-1) :
a,b=map(int,input().split())
L[a-1].append(b-1)
L[b-1].append(a-1)
visited=[False for i in range(n)]
kil=len(max(L,key=lambda x :len(x)))+1
q=[0]
out[0]=1
oy[0].append(0)
visited[0]=True
while (len(q)>0) :
b=q[0]
k=0
oy[b].append(out[b]-1)
for x in L[b] :
if visited[x]==False :
while( k in oy[b]) :
k+=1
oy[x].append(b)
visited[x]=True
out[x]=k+1
q.append(x)
k+=1
else :
k+=1
del(q[0])
print(kil)
print(' '.join(map(str,out)))
``` | instruction | 0 | 13,814 | 7 | 27,628 |
No | output | 1 | 13,814 | 7 | 27,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample.
Submitted Solution:
```
from sys import stdin
input=stdin.readline
n=int(input())
adjList=[[] for i in range(n+1)]
for i in range(n-1):
a,b=list(map(int, input().split(" ")))
adjList[a].append(b)
adjList[b].append(a)
color=[0 for i in range(n+1)]
def dfs(start, adjList, color):
stack=[start]
color[start]=1
while stack!=[]:
v=stack[-1]
advancing=False
# print("from: ", v, color)
if len(stack)>1:
for ind, neig in enumerate(adjList[v]):
if neig==stack[-2]:
del adjList[v][ind]
break
for ind, neig in enumerate(adjList[v]):
# print(ind, neig)
if not color[neig]:
stack.append(neig)
advancing=True
for col in range(1, n+1):
if len(stack)>2 and color[stack[-2]]!=col+ind and color[stack[-3]]!=col+ind:
color[neig]=col+ind
break
if len(stack)==2 and color[stack[-2]]!=col+ind:
color[neig]=col+ind
break
# print("change: ", color[neig])
# print(color[stack[-2]], color[neig])
# print("x", stack)
break
if not advancing:
stack.pop()
root=None
for v in range(1, n+1):
if len(adjList[v])==1:
root=v
print(root)
dfs(v, adjList, color)
print(max(color))
print(" ".join(map(str, color[1:])))
``` | instruction | 0 | 13,815 | 7 | 27,630 |
No | output | 1 | 13,815 | 7 | 27,631 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9. | instruction | 0 | 14,170 | 7 | 28,340 |
Tags: brute force, implementation, math
Correct Solution:
```
import sys
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()
y,b,r = get_ints()
for i in range(r,0,-1):
if(r-1<=b and r-2<=y):
break
else:
r=r-1
print(3*r-3)
``` | output | 1 | 14,170 | 7 | 28,341 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9. | instruction | 0 | 14,171 | 7 | 28,342 |
Tags: brute force, implementation, math
Correct Solution:
```
a = input()
a = a.split()
x= int(a[0])
y=int(a[1])
z=int(a[2])
m=x
n=y-1
o=z-2
print (min(m, n, o)*3+3)
``` | output | 1 | 14,171 | 7 | 28,343 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9. | instruction | 0 | 14,172 | 7 | 28,344 |
Tags: brute force, implementation, math
Correct Solution:
```
import sys
y,b,r = map(int, input().split())
ans = 0
for i in range(1,y+1):
if b > i and r > i + 1:
ans = max(ans, 3 * i + 3)
print(ans)
``` | output | 1 | 14,172 | 7 | 28,345 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9. | instruction | 0 | 14,173 | 7 | 28,346 |
Tags: brute force, implementation, math
Correct Solution:
```
import math
y, b, r = [int(s) for s in input().split(" ")]
ans = 0
for i in range(1, y+1):
if i+1 > b:
break
if i+2 > r:
break
ans = 3*i + 3
print(ans)
``` | output | 1 | 14,173 | 7 | 28,347 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9. | instruction | 0 | 14,174 | 7 | 28,348 |
Tags: brute force, implementation, math
Correct Solution:
```
a,b,c=map(int,input().split())
if b>=c-1:
if a>=c-2:
print((c*3)-3)
else:
print(a*3+3)
else:
if a>=b-1:
print(b*3)
else:
print(a*3+3)
``` | output | 1 | 14,174 | 7 | 28,349 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9. | instruction | 0 | 14,175 | 7 | 28,350 |
Tags: brute force, implementation, math
Correct Solution:
```
max_y, max_b, max_r= map(int, input().split(" "))
y = min(max_y, max_b-1, max_r-2)
b = y + 1
r = y + 2
print(y+b+r)
``` | output | 1 | 14,175 | 7 | 28,351 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9. | instruction | 0 | 14,176 | 7 | 28,352 |
Tags: brute force, implementation, math
Correct Solution:
```
aa = [int(x) for x in input().split()]
y = aa[0]
b = aa[1]
r = aa[2]
max = 0
if y + 1 <= b and y + 2 <= r:
max = y + y + 1 + y + 2
elif b - 1 <= y and b + 1 <= r:
max = b - 1 + b + b + 1
else:
max = r + r - 1 + r - 2
print(max)
``` | output | 1 | 14,176 | 7 | 28,353 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9. | instruction | 0 | 14,177 | 7 | 28,354 |
Tags: brute force, implementation, math
Correct Solution:
```
y, b, r = map(int, input().split())
ans = 6
for i in range(1, 100):
if y > i and b > i + 1 and r > i + 2:
ans += 3
else:
break
print(ans)
``` | output | 1 | 14,177 | 7 | 28,355 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9.
Submitted Solution:
```
y, b, r = map(int, input().split())
res = min(y + 1, b, r - 1)
print(res*3)
#y < b > r
``` | instruction | 0 | 14,178 | 7 | 28,356 |
Yes | output | 1 | 14,178 | 7 | 28,357 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9.
Submitted Solution:
```
y, b, r = map(int, input().split())
ans = 0
for i in range(1, y+1):
if i+1 < b and i+2 < r:
ans = max(ans, i + i+1 + i+2)
for j in range(1, b+1):
if j-1 <= y and j+1 < r:
ans = max(ans, j-1 + j + j+1)
for k in range(1, r+1):
if k-2 <= y and k-1 <= b:
ans = max(ans, k + k-1 + k-2)
print(ans)
``` | instruction | 0 | 14,179 | 7 | 28,358 |
Yes | output | 1 | 14,179 | 7 | 28,359 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9.
Submitted Solution:
```
y , b, r = map(int, input().split())
k = 0
for i in range(1000):
if i <= y and i + 1 <= b and i + 2 <= r:
k = i
print(3*k + 3)
``` | instruction | 0 | 14,180 | 7 | 28,360 |
Yes | output | 1 | 14,180 | 7 | 28,361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9.
Submitted Solution:
```
y,b,r=map(int,input().split())
x=min(y,b-1,r-2)
print(x*3+3)
``` | instruction | 0 | 14,181 | 7 | 28,362 |
Yes | output | 1 | 14,181 | 7 | 28,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9.
Submitted Solution:
```
y,b,r = [int(x) for x in input().split()]
while y>=1 and b>=2 and r>=3:
if b>=y+1:
b = y+1
if r>=b+1:
r = b+1
print(y+b+r)
break
else:
print(r-1+r-2+r)
break
elif y==b and y==r:
print(r+r-1+r-2)
break
elif b==r:
print(r+r-1+r-2)
break
else:
print(b-1+b+b+1)
break
``` | instruction | 0 | 14,182 | 7 | 28,364 |
No | output | 1 | 14,182 | 7 | 28,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9.
Submitted Solution:
```
y,b,r=input().split()
y=int(y)
b=int(b)
r=int(r)
if y<b<r:
print(y+y+1+y+2)
if y>b<r:
print(b-1+b+1+b)
if y<b>r and (r-1==y or y>r):
print(r+r-1+r-2)
if y==b==r:
print(y+y-1+y-2)
if y==b>r:
print(y-1+y+y+1)
if y==r>b:
print(b-1+b+b+1)
if y>b==r:
print(b-1+b-2+b)
if y<b>r and y<r and r-1!=y:
print(y+2+y+1+y)
if r==y<b:
print(y-1+y-2+y)
if r==b<y:
print(b+b-1+b+1)
``` | instruction | 0 | 14,183 | 7 | 28,366 |
No | output | 1 | 14,183 | 7 | 28,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9.
Submitted Solution:
```
y ,b ,r = map(int,input().split())
def s(y,b,r):
for i in range(1,b+1):
if(i >= y and i<r):
b = i
return b
if(y <= r):
print(3*(s(y,b,r)))
else:
y = r-1
print(3*s(y,b,r))
``` | instruction | 0 | 14,184 | 7 | 28,368 |
No | output | 1 | 14,184 | 7 | 28,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are decorating a Christmas Tree.
Alice wants only 3 types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have y yellow ornaments, b blue ornaments and r red ornaments.
In Bob's opinion, a Christmas Tree will be beautiful if:
* the number of blue ornaments used is greater by exactly 1 than the number of yellow ornaments, and
* the number of red ornaments used is greater by exactly 1 than the number of blue ornaments.
That is, if they have 8 yellow ornaments, 13 blue ornaments and 9 red ornaments, we can choose 4 yellow, 5 blue and 6 red ornaments (5=4+1 and 6=5+1).
Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.
In the example two paragraphs above, we would choose 7 yellow, 8 blue and 9 red ornaments. If we do it, we will use 7+8+9=24 ornaments. That is the maximum number.
Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree!
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Input
The only line contains three integers y, b, r (1 ≤ y ≤ 100, 2 ≤ b ≤ 100, 3 ≤ r ≤ 100) — the number of yellow, blue and red ornaments.
It is guaranteed that it is possible to choose at least 6 (1+2+3=6) ornaments.
Output
Print one number — the maximum number of ornaments that can be used.
Examples
Input
8 13 9
Output
24
Input
13 3 6
Output
9
Note
In the first example, the answer is 7+8+9=24.
In the second example, the answer is 2+3+4=9.
Submitted Solution:
```
a = [int(x) for x in input().split()]
for i in range(a[0]):
if((i+1)>=a[1] or (i+2)>=a[2]):
break
sum=3*(i+1)
print(sum)
``` | instruction | 0 | 14,185 | 7 | 28,370 |
No | output | 1 | 14,185 | 7 | 28,371 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a square grid of size n × n. Some cells are colored in black, all others are colored in white. In one operation you can select some rectangle and color all its cells in white. It costs min(h, w) to color a rectangle of size h × w. You are to make all cells white for minimum total cost.
The square is large, so we give it to you in a compressed way. The set of black cells is the union of m rectangles.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^{9}, 0 ≤ m ≤ 50) — the size of the square grid and the number of black rectangles.
Each of the next m lines contains 4 integers x_{i1} y_{i1} x_{i2} y_{i2} (1 ≤ x_{i1} ≤ x_{i2} ≤ n, 1 ≤ y_{i1} ≤ y_{i2} ≤ n) — the coordinates of the bottom-left and the top-right corner cells of the i-th black rectangle.
The rectangles may intersect.
Output
Print a single integer — the minimum total cost of painting the whole square in white.
Examples
Input
10 2
4 1 5 10
1 4 10 5
Output
4
Input
7 6
2 1 2 1
4 2 4 3
2 5 2 5
2 3 5 3
1 2 1 2
3 2 5 3
Output
3
Note
The examples and some of optimal solutions are shown on the pictures below.
<image> | instruction | 0 | 14,227 | 7 | 28,454 |
Tags: flows, graph matchings, graphs
Correct Solution:
```
import sys
from collections import defaultdict
class MaxFlow(object):
def __init__(self):
self.edges = defaultdict(lambda: defaultdict(lambda: 0))
def add_edge(self, u, v, capacity=float('inf')):
self.edges[u][v] = capacity
def bfs(self, s, t):
open_q = [s]
visited = set()
parent = dict()
while open_q:
close_q = []
for node in open_q:
for v, capacity in self.edges[node].items():
if v not in visited and capacity > 0:
close_q.append(v)
parent[v] = node
visited.add(v)
if v == t:
result = []
n2 = v
n1 = node
while n1 != s:
result.append((n1, n2))
n2 = n1
n1 = parent[n1]
result.append((n1, n2))
return result
open_q = close_q
return None
def solve(self, s, t):
flow = 0
route = self.bfs(s, t)
while route is not None:
new_flow = float('inf')
for _, (n1, n2) in enumerate(route):
new_flow = min(new_flow, self.edges[n1][n2])
for _, (n1, n2) in enumerate(route):
self.edges[n1][n2] -= new_flow
self.edges[n2][n1] += new_flow
flow += new_flow
route = self.bfs(s, t)
return flow
def __str__(self):
result = "{ "
for k, v in self.edges.items():
result += str(k) + ":" + str(dict(v)) + ", "
result += "}"
return result
def main():
(n, m) = tuple([int(x) for x in input().split()])
r = []
xs = set()
ys = set()
for i in range(m):
(x1, y1, x2, y2) = tuple(int(x) for x in input().split())
r.append((x1, y1, x2, y2))
xs.add(x1)
xs.add(x2 + 1)
ys.add(y1)
ys.add(y2 + 1)
xx = sorted(xs)
yy = sorted(ys)
xsize = len(xs)
ysize = len(ys)
grid = []
for i in range(ysize):
grid.append([False] * xsize)
for rect in r:
x1 = rect[0]
y1 = rect[1]
x2 = rect[2]
y2 = rect[3]
for i, y in enumerate(yy):
for j, x in enumerate(xx):
if x1 <= x and y1 <= y and x2 >= x and y2 >= y:
grid[i][j] = True
f = MaxFlow()
for i in range(len(yy)):
for j in range(len(xx)):
if grid[i][j]:
f.add_edge(1 + i, len(yy) + 1 + j, float('inf'))
for i in range(len(yy) - 1):
f.add_edge(0, i + 1, yy[i + 1] - yy[i])
for i in range(len(xx) - 1):
f.add_edge(len(yy) + 1 + i, len(xx) + len(yy) + 1, xx[i + 1] - xx[i])
# print(xx)
# print(yy)
# print(f)
print(f.solve(0, len(xx) + len(yy) + 1))
if __name__ == '__main__':
main()
``` | output | 1 | 14,227 | 7 | 28,455 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.