message stringlengths 2 65.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 0 108k | cluster float64 14 14 | __index_level_0__ int64 0 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then. | instruction | 0 | 37,359 | 14 | 74,718 |
Tags: implementation
Correct Solution:
```
l, b = list(map(int,input().strip().split(' ')))
years = 0
while l <= b:
l = l * 3
b = b * 2
years+=1
print(years)
``` | output | 1 | 37,359 | 14 | 74,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then. | instruction | 0 | 37,360 | 14 | 74,720 |
Tags: implementation
Correct Solution:
```
a, b = map(int, input().split())
count = 0
while a <= b:
b, a = b * 2, a * 3
count += 1
print(count)
``` | output | 1 | 37,360 | 14 | 74,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then. | instruction | 0 | 37,361 | 14 | 74,722 |
Tags: implementation
Correct Solution:
```
a, b = map(int, input().split())
i = 0
while True:
if a > b:
break
a *= 3
b *= 2
i += 1
print(i)
``` | output | 1 | 37,361 | 14 | 74,723 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then. | instruction | 0 | 37,362 | 14 | 74,724 |
Tags: implementation
Correct Solution:
```
x=[int(y) for y in input().split()]
f=0
while(True):
if(x[0]>x[1]):
break
x[0]=x[0]*3
x[1]=x[1]*2
f+=1
print(f)
``` | output | 1 | 37,362 | 14 | 74,725 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then. | instruction | 0 | 37,363 | 14 | 74,726 |
Tags: implementation
Correct Solution:
```
'''3**x*a > 2**x*b => (3/2)**x > (b/a) => x > log (3/2) (b/a)'''
import math
a,b=(int(x) for x in input().split())
print(math.floor(math.log(b/a,3/2)+1)) #Need +1 since its possible math.log(b/a,3/2) is integer in which case we need
#year for it be strictly greater
``` | output | 1 | 37,363 | 14 | 74,727 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then. | instruction | 0 | 37,364 | 14 | 74,728 |
Tags: implementation
Correct Solution:
```
l,b=map(int,input().split())
c = 0
if(l == b or l >= b):
print("1")
elif(l <= b):
while(l <= b):
l *= 3
b *= 2
c += 1
print(c)
``` | output | 1 | 37,364 | 14 | 74,729 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then. | instruction | 0 | 37,365 | 14 | 74,730 |
Tags: implementation
Correct Solution:
```
l, b = map(int,input().split())
x = 0
while l<=b:
l *= 3
b *= 2
x += 1
print(x)
``` | output | 1 | 37,365 | 14 | 74,731 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then. | instruction | 0 | 37,366 | 14 | 74,732 |
Tags: implementation
Correct Solution:
```
from math import floor
from math import log
a=input().split()
l=int(a[0])
b=int(a[1])
print(floor(log(b/l,1.5))+1)
``` | output | 1 | 37,366 | 14 | 74,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.
Submitted Solution:
```
a,b=[int(x) for x in input().split()]
s=0
while 1:
a=a*3
b=b*2
s=s+1
if a>b:
break
print(s)
``` | instruction | 0 | 37,367 | 14 | 74,734 |
Yes | output | 1 | 37,367 | 14 | 74,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.
Submitted Solution:
```
a,b=map(int,input().split())
res=0;
while a<=b:
a*=3
b*=2
res+=1
print(res)
``` | instruction | 0 | 37,368 | 14 | 74,736 |
Yes | output | 1 | 37,368 | 14 | 74,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.
Submitted Solution:
```
a,b=map(int,input().split())
count=0
while(a<=b):
count+=1
a=a*3
b=b*2
print(count)
``` | instruction | 0 | 37,369 | 14 | 74,738 |
Yes | output | 1 | 37,369 | 14 | 74,739 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.
Submitted Solution:
```
a,b=map(int,input().strip().split())
c=0
while(a<=b):
a=a*3
b=b*2
c+=1
print(c)
``` | instruction | 0 | 37,370 | 14 | 74,740 |
Yes | output | 1 | 37,370 | 14 | 74,741 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.
Submitted Solution:
```
a,b=map(int,input().split())
x=0
while(a<b):
a=a*3
b=b*2
x=x+1
print(x)
``` | instruction | 0 | 37,371 | 14 | 74,742 |
No | output | 1 | 37,371 | 14 | 74,743 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.
Submitted Solution:
```
def prova(limak, bob):
if not limak <= bob: return
i=0
while limak <= bob:
bob=bob*2
limak = limak*3
i+=1
return int(i)
``` | instruction | 0 | 37,372 | 14 | 74,744 |
No | output | 1 | 37,372 | 14 | 74,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.
Submitted Solution:
```
g = input()
l = int(g[0])
b = int(g[-1])
count = 0
while b >= l:
l *= 3
b *= 2
count += 1
print(count)
``` | instruction | 0 | 37,373 | 14 | 74,746 |
No | output | 1 | 37,373 | 14 | 74,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Tue Dec 22 01:24:28 2020
@author: pinky
"""
aori,bori=map(int,input().split())
a=aori
b=bori
while True:
a=3*a
b=2*b
if a>b:
print((a//(aori))//3)
break
``` | instruction | 0 | 37,374 | 14 | 74,748 |
No | output | 1 | 37,374 | 14 | 74,749 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three. | instruction | 0 | 37,475 | 14 | 74,950 |
Tags: brute force, constructive algorithms
Correct Solution:
```
n = int(input())
s = input()
if s == "1" or ("000" not in s and "11" not in s and (len(s) > 1 and not(s[0] == "0" and s[1] == "0") and not(s[-1] == "0" and s[-2] == "0"))):
print("YES")
else:
print("NO")
``` | output | 1 | 37,475 | 14 | 74,951 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three. | instruction | 0 | 37,476 | 14 | 74,952 |
Tags: brute force, constructive algorithms
Correct Solution:
```
n = int(input())
result = "Yes"
seat = input()
if n == 1:
if seat[0] == "0":
result = "No"
else:
if seat[0] == "1":
if seat[1] == 1:
result = "No"
else:
if seat[1] == "0":
result = "No"
if seat[n - 1] == "1":
if seat[n - 2] == "1":
result = "No"
else:
if seat[n - 2] == "0":
result = "No"
for i in range(1, n - 1):
if seat[i] == "0":
if seat[i - 1] == "0" and seat[i + 1] == "0":
result = "No"
break
else:
if seat[i - 1] == "1" or seat[i + 1] == "1":
result = "No"
break
print(result)
``` | output | 1 | 37,476 | 14 | 74,953 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three. | instruction | 0 | 37,477 | 14 | 74,954 |
Tags: brute force, constructive algorithms
Correct Solution:
```
n = int(input())
c = input()
for i in range(1,n):
if c[i] == c[i - 1] and c[i] != "0":
print("No")
exit()
for i in range(n):
if c[i] == '0' and (i == 0 or c[i - 1] == '0') and (i == n - 1 or c[i + 1] == '0'):
print("No")
exit()
print("Yes")
``` | output | 1 | 37,477 | 14 | 74,955 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three. | instruction | 0 | 37,478 | 14 | 74,956 |
Tags: brute force, constructive algorithms
Correct Solution:
```
n = int(input())
s = input()
flag = True
if(n==1 and not s=='1'):
flag = False
else:
temp = [0 for i in range(n)]
for i in range(n):
if(s[i]=='1'):
temp[i]+=2
if(i-1>=0):
temp[i-1]+=1
if(i+1<n):
temp[i+1]+=1
# print(temp)
for i in range(n):
if(temp[i]!=2 and temp[i]!=1):
flag = False
if(flag):
print("Yes")
else:
print("No")
``` | output | 1 | 37,478 | 14 | 74,957 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three. | instruction | 0 | 37,479 | 14 | 74,958 |
Tags: brute force, constructive algorithms
Correct Solution:
```
n=int(input())
a=str(input())
flag=0
if(len(a)==1):
if(a[0]=='1'):
print('YES')
else:
print('NO')
elif(len(a)==2):
if(a[0]==a[1]=='1' or (a[0]==a[1]=='0')):
print('NO')
else:
print('YES')
else:
for i in range(0,len(a)):
if(i==0 and a[i]=='1'):
if(a[i+1]=='1'):
flag=1
break
elif(i==len(a)-1 and a[i]=='1'):
if(a[i-1]=='1'):
flag=1
break
elif(a[i]=='1'):
if(a[i+1]=='1' or a[i-1]=='1'):
flag=1
break
for i in range(0,len(a)-2):
if(a[i]==a[i+1]==a[i+2]=='0'):
flag=1
break
if(a[-1]==a[-2]=='0' or a[0]==a[1]=='0'):
flag=1
if(flag==0):
print('YES')
else:
print('NO')
``` | output | 1 | 37,479 | 14 | 74,959 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three. | instruction | 0 | 37,480 | 14 | 74,960 |
Tags: brute force, constructive algorithms
Correct Solution:
```
def main():
n = int(input())
print(proc(maxk(input())))
def maxk(inp):
if inp == "0":
return False
if "11" in inp:
return False
if "000" in inp:
return False
if inp[0:2] == "00":
return False
n = len(inp)
if inp[n - 2:n] == "00":
return False
return True
def proc(x):
if x:
return "Yes"
return "No"
if __name__ == "__main__":
main()
``` | output | 1 | 37,480 | 14 | 74,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three. | instruction | 0 | 37,481 | 14 | 74,962 |
Tags: brute force, constructive algorithms
Correct Solution:
```
n = int(input())
s = input()
i = 0
res = True
count = 0
while(i<n):
if s[i]=='1':
if count>2 or (i!=0 and count==0):
res = False
break
count=0
else:
count+=1
i+=1
if (n==1 and s[0]=='0') or (n>1 and s[0]=='0' and s[1]=='0'):
res = False
if count>=2:
res = False
if res:
print('Yes')
else:
print('No')
``` | output | 1 | 37,481 | 14 | 74,963 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three. | instruction | 0 | 37,482 | 14 | 74,964 |
Tags: brute force, constructive algorithms
Correct Solution:
```
n = int(input())
s = input()
if n == 1:
if s == '0':
print('No')
else:
print('Yes')
elif n == 2:
if s == '00' or s == '11':
print('No')
else:
print('Yes')
else:
if s.find('11') + 1 or s.find('000') + 1:
print('No')
elif s.find('00') == 0 or s.rfind('00') == n - 2:
print('No')
else:
print('Yes')
``` | output | 1 | 37,482 | 14 | 74,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three.
Submitted Solution:
```
n = int(input())
s = input()
f = True
if '000' in s or '11' in s:
f = False
if n > 1:
if s[0] == s[1] or s[n-1] == s[n-2]:
f = False
elif s[0] == '0':
f = False
if f:
print("yes")
else:
print("no")
``` | instruction | 0 | 37,483 | 14 | 74,966 |
Yes | output | 1 | 37,483 | 14 | 74,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three.
Submitted Solution:
```
input()
s = input()
ok = True
for i in range(len(s)):
l = r = True
if i > 0:
l = s[i-1] == '0'
if i < len(s)-1:
r = s[i+1] == '0'
if s[i] == '0' and l and r:
ok = False
if s[i] == '1' and (not l or not r):
ok = False
if not ok:
break
print('Yes' if ok else 'No')
``` | instruction | 0 | 37,484 | 14 | 74,968 |
Yes | output | 1 | 37,484 | 14 | 74,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three.
Submitted Solution:
```
n = int(input())
a = input()
for i in range(n - 1):
if a[i] == '1' and a[i + 1] == '1':
print('No')
exit()
for i in range(n - 1, 0, -1):
if a[i] == '1' and a[i - 1] == '1':
print('No')
exit()
c = 0
for i in range(n):
if (i == n - 1 and a[i] == '0' and a[i - 1] == '0') or (i == 0 and a[i] == '0' and a[i + 1] == '0'):
print('No')
exit()
if a[i] == '0':
c += 1
else:
if c >= 3:
print('No')
exit()
c = 0
print('Yes')
``` | instruction | 0 | 37,485 | 14 | 74,970 |
Yes | output | 1 | 37,485 | 14 | 74,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three.
Submitted Solution:
```
n = int(input())
s = input()[:n]
for i in range(len(s)):
if s[i] == '1':
if i - 1 >= 0 and s[i - 1] != '0':
print("No")
exit()
if i + 1 < len(s) and s[i + 1] != '0':
print("No")
exit()
elif s[i] == '0':
if (i - 1 < 0 or s[i - 1] == '0') and (i + 1 >= len(s) or s[i + 1] == '0'):
print("No")
exit()
print("Yes")
``` | instruction | 0 | 37,486 | 14 | 74,972 |
Yes | output | 1 | 37,486 | 14 | 74,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three.
Submitted Solution:
```
n=int(input())
#a=list(map(int,input().split()))
s=list(input())
f=1
for i in range(len(s)-1):
if s[i]=='1' and s[i]==s[i+1]:
f=0
break
if f!=0:
j=0
while j<len(s):
if s[j]=='1': j+=1
else:
k=0
while j<len(s) and s[j]=='0':
j+=1
k+=1
if k>2:
f=0
break
if f==0:
print("NO")
else:
print("YES")
``` | instruction | 0 | 37,487 | 14 | 74,974 |
No | output | 1 | 37,487 | 14 | 74,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three.
Submitted Solution:
```
n=int(input())
s=input()
z=s[0]
ans="Yes"
for i in range(1,n):
if z=='1':
if s[i]=='1':
ans="No"
break
z='0'
else:
if s[i]=='0':
ans="No"
break
z='1'
print(ans)
``` | instruction | 0 | 37,488 | 14 | 74,976 |
No | output | 1 | 37,488 | 14 | 74,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three.
Submitted Solution:
```
n=input()
s=input()
if '000' in s or '11' in s:
print ('No')
else:
print ('Yes')
``` | instruction | 0 | 37,489 | 14 | 74,978 |
No | output | 1 | 37,489 | 14 | 74,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three.
Submitted Solution:
```
import sys
def main():
#sys.stdin = open("D:\\Sublime\\in.txt", "r")
#sys.stdout = open("D:\\Sublime\\out.txt", "w")
n = int(sys.stdin.readline().strip('\n'))
s = sys.stdin.readline().strip('\n')
if n == 1 or (n == 2 and s == '00'):
print('NO')
else:
for i in range(n):
if i <= n - 2 and s[i] + s[i + 1] == '11':
print('NO')
break
if i <= n - 3 and s[i] + s[i + 1] + s[i + 2] == '000':
print('NO')
break
if i == n - 1:
print('YES')
if __name__ == '__main__':
main()
``` | instruction | 0 | 37,490 | 14 | 74,980 |
No | output | 1 | 37,490 | 14 | 74,981 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7. | instruction | 0 | 37,751 | 14 | 75,502 |
Tags: greedy, math
Correct Solution:
```
a = [[], []]
_ = ([[a[i].append(int(x)) for i, x in enumerate(input().split())] for _ in range(int(input()))], [x.sort() for x in a], print(len(a[0]) + sum(max(x, y) for x, y in zip(*a))))
``` | output | 1 | 37,751 | 14 | 75,503 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7. | instruction | 0 | 37,752 | 14 | 75,504 |
Tags: greedy, math
Correct Solution:
```
n = int(input())
a = []
b = []
for _ in range(n):
x = list(map(int,input().split(' ')))
a.append(x[0])
b.append(x[1])
a.sort()
b.sort()
sum = 0
for _ in range(n):
sum += max(a[_],b[_])
print(sum+n)
``` | output | 1 | 37,752 | 14 | 75,505 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7. | instruction | 0 | 37,753 | 14 | 75,506 |
Tags: greedy, math
Correct Solution:
```
#!/usr/bin/env python3
import sys
def rint():
return map(int, sys.stdin.readline().split())
#lines = stdin.readlines()
n = int(input())
r = [0]*n
l = [0]*n
for i in range(n):
r[i], l[i] = rint()
r.sort()
l.sort()
ans = 0
for i in range(n):
ans += max(r[i], l[i])
print(ans + n)
``` | output | 1 | 37,753 | 14 | 75,507 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7. | instruction | 0 | 37,754 | 14 | 75,508 |
Tags: greedy, math
Correct Solution:
```
n=int(input())
ans=n
l=[]
r=[]
for i in range(n):
x,y=map(int,input().split())
l.append(x)
r.append(y)
l.sort()
r.sort()
for i in range(n):
ans+=max(l[i],r[i])
print(ans)
``` | output | 1 | 37,754 | 14 | 75,509 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7. | instruction | 0 | 37,755 | 14 | 75,510 |
Tags: greedy, math
Correct Solution:
```
from collections import defaultdict, deque
from heapq import heappush, heappop
from math import inf
ri = lambda : map(int, input().split())
def solve():
n = int(input())
left = []
right = []
for _ in range(n):
l , r = ri()
left.append(l)
right.append(r)
left.sort()
right.sort()
ans = 0
for i in range(n):
ans += max(left[i], right[i])
ans += n
print(ans)
t = 1
#t = int(input())
while t:
t -= 1
solve()
``` | output | 1 | 37,755 | 14 | 75,511 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7. | instruction | 0 | 37,756 | 14 | 75,512 |
Tags: greedy, math
Correct Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
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")
#-------------------------------------------------------------------------
#mod = 9223372036854775807
class SegmentTree:
def __init__(self, data, default=-10**6, func=lambda a, b: max(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
class SegmentTree1:
def __init__(self, data, default=10**6, func=lambda a, b: min(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
MOD=10**9+7
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod=10**9+7
omod=998244353
#-------------------------------------------------------------------------
prime = [True for i in range(200001)]
pp=[0]*200001
def SieveOfEratosthenes(n=200000):
# Create a boolean array "prime[0..n]" and initialize
# all entries it as true. A value in prime[i] will
# finally be false if i is Not a prime, else true.
p = 2
while (p * p <= n):
# If prime[p] is not changed, then it is a prime
if (prime[p] == True):
# Update all multiples of p
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
#---------------------------------running code------------------------------------------
n=int(input())
ans=n
l=[]
r=[]
for i in range(n):
x,y=map(int,input().split())
l.append(x)
r.append(y)
l.sort()
r.sort()
for i in range(n):
ans+=max(l[i],r[i])
print(ans)
``` | output | 1 | 37,756 | 14 | 75,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7. | instruction | 0 | 37,757 | 14 | 75,514 |
Tags: greedy, math
Correct Solution:
```
n=int(input())
x=[]
r=0
for i in range(n):
a,b=map(int,input().split())
x.append((a,b))
x1=sorted(x,key=lambda y:y[0],reverse=True)
x2=sorted(x,key=lambda y:y[1],reverse=True)
for i in range(n):
r+=max(x1[i][0],x2[i][1])+1
print(r)
``` | output | 1 | 37,757 | 14 | 75,515 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7. | instruction | 0 | 37,758 | 14 | 75,516 |
Tags: greedy, math
Correct Solution:
```
from collections import defaultdict
import io, os, math
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
rr = lambda: input()
rri = lambda: int(input())
rrm = lambda: list(map(int, input().split()))
INF=float('inf')
def solve(N, pairs):
chairs = N
left = [v[0] for v in pairs]
right = [v[1] for v in pairs]
left.sort()
right.sort()
for i in range(N):
chairs += max(left[i],right[i])
return chairs
N = rri()
pairs = []
for _ in range(N):
pairs.append(rrm())
print(solve(N,pairs))
``` | output | 1 | 37,758 | 14 | 75,517 |
Provide tags and a correct Python 2 solution for this coding contest problem.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7. | instruction | 0 | 37,759 | 14 | 75,518 |
Tags: greedy, math
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
for i in arr:
stdout.write(str(i)+' ')
stdout.write('\n')
range = xrange # not for python 3.0+
n=int(raw_input())
l1,l2=[],[]
for i in range(n):
x,y=in_arr()
l1.append(x)
l2.append(y)
l1.sort()
l2.sort()
ans=n
for x,y in zip(l1,l2):
ans+=max(x,y)
pr_num(ans)
``` | output | 1 | 37,759 | 14 | 75,519 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7.
Submitted Solution:
```
n=int(input())
l,r=[],[]
for i in range(n):
a,b=map(int,input().split())
l.append(a)
r.append(b)
l.sort(reverse=True)
r.sort(reverse=True)
count=0
for i in range(n):
count+=max(l[i],r[i])+1
print(count)
``` | instruction | 0 | 37,760 | 14 | 75,520 |
Yes | output | 1 | 37,760 | 14 | 75,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7.
Submitted Solution:
```
qtd = int(input())
esquerdas = []
direitas = []
totalCadeiras1Circulo = 0
totalCadaUmCirculo = 0
for gfdsga in range(qtd):
l, r = (list(map(int, input().split())))
esquerdas.append(l)
direitas.append(r)
esquerdasOrdenadas = sorted(esquerdas)
direitasOrdenadas = sorted(direitas)
for x in range(qtd):
totalCadaUmCirculo += 1 + max(esquerdas[x], direitas[x])
totalCadeiras1Circulo += 1 + max(esquerdasOrdenadas[x], direitasOrdenadas[x])
print(min(totalCadeiras1Circulo, totalCadaUmCirculo))
``` | instruction | 0 | 37,761 | 14 | 75,522 |
Yes | output | 1 | 37,761 | 14 | 75,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7.
Submitted Solution:
```
n = int(input())
a = [0] * n
b = [0] * n
for i in range(n):
l, r = map(int, input().split())
a[i] = l
b[i] = r
a.sort()
b.sort()
res = n
for i in range(n):
res += max(a[i], b[i])
print(res)
``` | instruction | 0 | 37,762 | 14 | 75,524 |
Yes | output | 1 | 37,762 | 14 | 75,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7.
Submitted Solution:
```
import itertools
l1=[]
l2=[]
for _ in range(int(input())):
x,y=map(int,input().split())
l1.append(x)
l2.append(y)
l1.sort()
l2.sort()
sum1=0
for a,b in zip(l1,l2):
sum1+=max(a,b)
print(sum1+len(l1))
``` | instruction | 0 | 37,763 | 14 | 75,526 |
Yes | output | 1 | 37,763 | 14 | 75,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7.
Submitted Solution:
```
def solve():
n = int(input())
res = 0
for _ in range(n):
l, r = map(int, input().split())
res += l + r
if l == 0 or r == 0:
res += 1
return res if n > 1 else max(int(l), int(r)) + 1
print (solve())
``` | instruction | 0 | 37,764 | 14 | 75,528 |
No | output | 1 | 37,764 | 14 | 75,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7.
Submitted Solution:
```
n=int(input())
l=[]
r=[]
for i in range(n):
a,b=map(int,input().split())
l.append(a)
r.append(b)
r=sorted(r)
ss=n
vis=[0]*(n)
for i in range(n):
if l[i]==r[i]:
vis[i]=1
ss+=l[i]
rr=[]
for i in range(n):
rr.append([vis[i],r[i]])
rr=sorted(rr,key=lambda item:item[1])
for i in range(n):
if rr[i][0]==0:
ss+=max(l[i],rr[i][1])
print(ss)
``` | instruction | 0 | 37,765 | 14 | 75,530 |
No | output | 1 | 37,765 | 14 | 75,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7.
Submitted Solution:
```
n = int(input())
l = r = []
for i in range(n):
x,y = map(int,input().split())
l.append(x)
r.append(y)
print(n+sum(map(max,l,r)))
``` | instruction | 0 | 37,766 | 14 | 75,532 |
No | output | 1 | 37,766 | 14 | 75,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7.
Submitted Solution:
```
n = int(input())
ans = 0
a = dict()
for _ in range(n):
l, r = map(int, input().split())
a.setdefault(str(l) + ' ' + str(r), 0)
a[str(l) + ' ' + str(r)] += 1
for i in a.keys():
j = ' '.join(i.split()[::-1])
t = a[i]
if j in a and a[j] and a[i]:
t = (a[i])//2 if i == j else min(a[j], a[i])
ans += (sum(map(int, j.split())) + 2) * t
a[j] -= t
a[i] -= t
b = list()
for i in a:
if a[i]: b.append(list(map(int, i.split())) * a[i])
b.sort()
n = len(b)
for i in range(n):
ans += 1 + max(b[i][1], b[(i + 1)%n][0])
print(ans)
``` | instruction | 0 | 37,767 | 14 | 75,534 |
No | output | 1 | 37,767 | 14 | 75,535 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova has won n trophies in different competitions. Each trophy is either golden or silver. The trophies are arranged in a row.
The beauty of the arrangement is the length of the longest subsegment consisting of golden trophies. Vova wants to swap two trophies (not necessarily adjacent ones) to make the arrangement as beautiful as possible — that means, to maximize the length of the longest such subsegment.
Help Vova! Tell him the maximum possible beauty of the arrangement if he is allowed to do at most one swap.
Input
The first line contains one integer n (2 ≤ n ≤ 10^5) — the number of trophies.
The second line contains n characters, each of them is either G or S. If the i-th character is G, then the i-th trophy is a golden one, otherwise it's a silver trophy.
Output
Print the maximum possible length of a subsegment of golden trophies, if Vova is allowed to do at most one swap.
Examples
Input
10
GGGSGGGSGG
Output
7
Input
4
GGGG
Output
4
Input
3
SSS
Output
0
Note
In the first example Vova has to swap trophies with indices 4 and 10. Thus he will obtain the sequence "GGGGGGGSGS", the length of the longest subsegment of golden trophies is 7.
In the second example Vova can make no swaps at all. The length of the longest subsegment of golden trophies in the sequence is 4.
In the third example Vova cannot do anything to make the length of the longest subsegment of golden trophies in the sequence greater than 0. | instruction | 0 | 37,769 | 14 | 75,538 |
Tags: greedy
Correct Solution:
```
n = int(input())
s = input()
l = []
d = []
gcnt = scnt = 0
g = False
if s[0] == 'G':
g = True
gcnt = 1
else:
g = False
scnt = 1
a = s[1:]
for i in a:
if i == 'G':
if g:
gcnt += 1
else:
d.append(scnt)
scnt = 0
gcnt = 1
g = True
else:
if not g:
scnt += 1
else:
l.append(gcnt)
gcnt = 0
scnt = 1
g = False
if gcnt: l.append(gcnt)
else: d.append(scnt)
st = 0
if s[0] == 'S':
st = d[0]
d.pop(0)
res = 0
sz = len(l)
dsz = len(d)
if l:
res = max(l)
for i in range(sz):
if i == 0:
if sz >= 2 and (st or d):
res = max(res, l[i]+1)
else:
if sz >= 2 and d:
res = max(res, l[i]+1)
if i == sz-1:
break
if d[i] == 1 and sz >= 3:
res = max(res, l[i]+l[i+1]+1)
if d[i] == 1:
res = max(res, l[i]+l[i+1])
print(res)
``` | output | 1 | 37,769 | 14 | 75,539 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.