message stringlengths 2 48.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 318 108k | cluster float64 8 8 | __index_level_0__ int64 636 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak is a little polar bear. He plays by building towers from blocks. Every block is a cube with positive integer length of side. Limak has infinitely many blocks of each side length.
A block with side a has volume a3. A tower consisting of blocks with sides a1, a2, ..., ak has the total volume a13 + a23 + ... + ak3.
Limak is going to build a tower. First, he asks you to tell him a positive integer X — the required total volume of the tower. Then, Limak adds new blocks greedily, one by one. Each time he adds the biggest block such that the total volume doesn't exceed X.
Limak asks you to choose X not greater than m. Also, he wants to maximize the number of blocks in the tower at the end (however, he still behaves greedily). Secondarily, he wants to maximize X.
Can you help Limak? Find the maximum number of blocks his tower can have and the maximum X ≤ m that results this number of blocks.
Input
The only line of the input contains one integer m (1 ≤ m ≤ 1015), meaning that Limak wants you to choose X between 1 and m, inclusive.
Output
Print two integers — the maximum number of blocks in the tower and the maximum required total volume X, resulting in the maximum number of blocks.
Examples
Input
48
Output
9 42
Input
6
Output
6 6
Note
In the first sample test, there will be 9 blocks if you choose X = 23 or X = 42. Limak wants to maximize X secondarily so you should choose 42.
In more detail, after choosing X = 42 the process of building a tower is:
* Limak takes a block with side 3 because it's the biggest block with volume not greater than 42. The remaining volume is 42 - 27 = 15.
* The second added block has side 2, so the remaining volume is 15 - 8 = 7.
* Finally, Limak adds 7 blocks with side 1, one by one.
So, there are 9 blocks in the tower. The total volume is is 33 + 23 + 7·13 = 27 + 8 + 7 = 42. | instruction | 0 | 58,490 | 8 | 116,980 |
Tags: binary search, dp, greedy
Correct Solution:
```
def f(m, cnt, y):
global ans, x
if m == 0:
ans, x = max((ans, x), (cnt, y))
return
a = int(m ** (1/3))
k1, k2 = a ** 3, (a - 1) ** 3
f(m - k1, cnt + 1, y + k1)
f(k1 - k2 - 1, cnt + 1, y + k2)
m = int(input())
ans, x = 0, m
f(m, 0, 0)
print(ans, x)
``` | output | 1 | 58,490 | 8 | 116,981 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak is a little polar bear. He plays by building towers from blocks. Every block is a cube with positive integer length of side. Limak has infinitely many blocks of each side length.
A block with side a has volume a3. A tower consisting of blocks with sides a1, a2, ..., ak has the total volume a13 + a23 + ... + ak3.
Limak is going to build a tower. First, he asks you to tell him a positive integer X — the required total volume of the tower. Then, Limak adds new blocks greedily, one by one. Each time he adds the biggest block such that the total volume doesn't exceed X.
Limak asks you to choose X not greater than m. Also, he wants to maximize the number of blocks in the tower at the end (however, he still behaves greedily). Secondarily, he wants to maximize X.
Can you help Limak? Find the maximum number of blocks his tower can have and the maximum X ≤ m that results this number of blocks.
Input
The only line of the input contains one integer m (1 ≤ m ≤ 1015), meaning that Limak wants you to choose X between 1 and m, inclusive.
Output
Print two integers — the maximum number of blocks in the tower and the maximum required total volume X, resulting in the maximum number of blocks.
Examples
Input
48
Output
9 42
Input
6
Output
6 6
Note
In the first sample test, there will be 9 blocks if you choose X = 23 or X = 42. Limak wants to maximize X secondarily so you should choose 42.
In more detail, after choosing X = 42 the process of building a tower is:
* Limak takes a block with side 3 because it's the biggest block with volume not greater than 42. The remaining volume is 42 - 27 = 15.
* The second added block has side 2, so the remaining volume is 15 - 8 = 7.
* Finally, Limak adds 7 blocks with side 1, one by one.
So, there are 9 blocks in the tower. The total volume is is 33 + 23 + 7·13 = 27 + 8 + 7 = 42. | instruction | 0 | 58,491 | 8 | 116,982 |
Tags: binary search, dp, greedy
Correct Solution:
```
from math import *
class sqrt_decomp:
def _init_(self,val):
self.values=val
self.blockl=int(sqrt(len(val)))
self.noblocks=int(ceil(len(val)/self.blockl))
self.plusv=[0]*self.noblocks
self.sumbl=[0]*self.noblocks
for i in range(self.noblocks):
self.sumbl=sum(val[i*self.blockl:max(len(val),(i+1)*self.blockl)])
def maximize(n,X,l):
if l==0:
return 0
cur=ans[l-1]
X-=cur**3
while X+(cur+1)**3<=n:
cur+=1
#print("again",cur,X,X+cur**3,n)
Xy=cur**3
Xy+=maximize(min(n-Xy,(cur+1)**3-Xy-1),X,l-1)
ans[l-1]=cur
return Xy
n=int(input())
c=1
ans=[]
X=0
while X+c**3<=n:
while X<(c+1)**3-c**3 and X+c**3<=n:
ans+=[c]
X+=c**3
#print(c,X,ans)
c+=1
#print(c,c**3,X,n,"rofl")
X=maximize(n,X,len(ans))
print(len(ans),X)
#print(ans)
``` | output | 1 | 58,491 | 8 | 116,983 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak is a little polar bear. He plays by building towers from blocks. Every block is a cube with positive integer length of side. Limak has infinitely many blocks of each side length.
A block with side a has volume a3. A tower consisting of blocks with sides a1, a2, ..., ak has the total volume a13 + a23 + ... + ak3.
Limak is going to build a tower. First, he asks you to tell him a positive integer X — the required total volume of the tower. Then, Limak adds new blocks greedily, one by one. Each time he adds the biggest block such that the total volume doesn't exceed X.
Limak asks you to choose X not greater than m. Also, he wants to maximize the number of blocks in the tower at the end (however, he still behaves greedily). Secondarily, he wants to maximize X.
Can you help Limak? Find the maximum number of blocks his tower can have and the maximum X ≤ m that results this number of blocks.
Input
The only line of the input contains one integer m (1 ≤ m ≤ 1015), meaning that Limak wants you to choose X between 1 and m, inclusive.
Output
Print two integers — the maximum number of blocks in the tower and the maximum required total volume X, resulting in the maximum number of blocks.
Examples
Input
48
Output
9 42
Input
6
Output
6 6
Note
In the first sample test, there will be 9 blocks if you choose X = 23 or X = 42. Limak wants to maximize X secondarily so you should choose 42.
In more detail, after choosing X = 42 the process of building a tower is:
* Limak takes a block with side 3 because it's the biggest block with volume not greater than 42. The remaining volume is 42 - 27 = 15.
* The second added block has side 2, so the remaining volume is 15 - 8 = 7.
* Finally, Limak adds 7 blocks with side 1, one by one.
So, there are 9 blocks in the tower. The total volume is is 33 + 23 + 7·13 = 27 + 8 + 7 = 42. | instruction | 0 | 58,492 | 8 | 116,984 |
Tags: binary search, dp, greedy
Correct Solution:
```
#!/usr/bin/env python3
import sys
# 1 8 27 64 125 216 343 512 729 1000
# 1-7: blocks of size 1
# 8-15: 1 block of size 2, blocks of size 1
# 16-23: 2 blocks of size 2, blocks of size 1
# 24-26: 3 blocks of size 2, blocks of size 1
# 27-34: 1 block of size 3, blocks of size 1
# Maximum will always be when you have the max number of size 1 blocks
def cube_root(x):
v = max(int(x ** (1.0 / 3.0)) - 1, 0)
while (v + 1) ** 3 <= x:
v += 1
return v
def solution(x):
# returns (n_blocks, volume)
#print("solution {}".format(x))
if x <= 7:
return (x, x)
next_smaller = cube_root(x) ** 3
candidate = solution(x - next_smaller)
candidate = (candidate[0] + 1, candidate[1] + next_smaller)
prenext_smaller = cube_root(next_smaller - 1) ** 3
if next_smaller - prenext_smaller > x - next_smaller:
candidate2 = solution(next_smaller - 1)
else:
candidate2 = candidate
if candidate >= candidate2:
return candidate
else:
return candidate2
n = int(input())
s = solution(n)
print(s[0], s[1])
``` | output | 1 | 58,492 | 8 | 116,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He plays by building towers from blocks. Every block is a cube with positive integer length of side. Limak has infinitely many blocks of each side length.
A block with side a has volume a3. A tower consisting of blocks with sides a1, a2, ..., ak has the total volume a13 + a23 + ... + ak3.
Limak is going to build a tower. First, he asks you to tell him a positive integer X — the required total volume of the tower. Then, Limak adds new blocks greedily, one by one. Each time he adds the biggest block such that the total volume doesn't exceed X.
Limak asks you to choose X not greater than m. Also, he wants to maximize the number of blocks in the tower at the end (however, he still behaves greedily). Secondarily, he wants to maximize X.
Can you help Limak? Find the maximum number of blocks his tower can have and the maximum X ≤ m that results this number of blocks.
Input
The only line of the input contains one integer m (1 ≤ m ≤ 1015), meaning that Limak wants you to choose X between 1 and m, inclusive.
Output
Print two integers — the maximum number of blocks in the tower and the maximum required total volume X, resulting in the maximum number of blocks.
Examples
Input
48
Output
9 42
Input
6
Output
6 6
Note
In the first sample test, there will be 9 blocks if you choose X = 23 or X = 42. Limak wants to maximize X secondarily so you should choose 42.
In more detail, after choosing X = 42 the process of building a tower is:
* Limak takes a block with side 3 because it's the biggest block with volume not greater than 42. The remaining volume is 42 - 27 = 15.
* The second added block has side 2, so the remaining volume is 15 - 8 = 7.
* Finally, Limak adds 7 blocks with side 1, one by one.
So, there are 9 blocks in the tower. The total volume is is 33 + 23 + 7·13 = 27 + 8 + 7 = 42.
Submitted Solution:
```
def c(n):
if n<8: return n,n
t1=int(n**(1/3)+0.00000000001)
t2=t1-1
v1=c(n-t1*t1*t1)
v1=v1[0]+1,v1[1]+t1*t1*t1
v2=c(t1*t1*t1-1-t2*t2*t2)
v2=v2[0]+1,v2[1]+t2*t2*t2
if v2>v1: v1=v2
return v1
print(' '.join(map(str,c(int(input())))))
``` | instruction | 0 | 58,493 | 8 | 116,986 |
Yes | output | 1 | 58,493 | 8 | 116,987 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He plays by building towers from blocks. Every block is a cube with positive integer length of side. Limak has infinitely many blocks of each side length.
A block with side a has volume a3. A tower consisting of blocks with sides a1, a2, ..., ak has the total volume a13 + a23 + ... + ak3.
Limak is going to build a tower. First, he asks you to tell him a positive integer X — the required total volume of the tower. Then, Limak adds new blocks greedily, one by one. Each time he adds the biggest block such that the total volume doesn't exceed X.
Limak asks you to choose X not greater than m. Also, he wants to maximize the number of blocks in the tower at the end (however, he still behaves greedily). Secondarily, he wants to maximize X.
Can you help Limak? Find the maximum number of blocks his tower can have and the maximum X ≤ m that results this number of blocks.
Input
The only line of the input contains one integer m (1 ≤ m ≤ 1015), meaning that Limak wants you to choose X between 1 and m, inclusive.
Output
Print two integers — the maximum number of blocks in the tower and the maximum required total volume X, resulting in the maximum number of blocks.
Examples
Input
48
Output
9 42
Input
6
Output
6 6
Note
In the first sample test, there will be 9 blocks if you choose X = 23 or X = 42. Limak wants to maximize X secondarily so you should choose 42.
In more detail, after choosing X = 42 the process of building a tower is:
* Limak takes a block with side 3 because it's the biggest block with volume not greater than 42. The remaining volume is 42 - 27 = 15.
* The second added block has side 2, so the remaining volume is 15 - 8 = 7.
* Finally, Limak adds 7 blocks with side 1, one by one.
So, there are 9 blocks in the tower. The total volume is is 33 + 23 + 7·13 = 27 + 8 + 7 = 42.
Submitted Solution:
```
def kil(n):
if n<8: return (n,n)
m=2
while m*m*m<=n: m+=1
m-=1
k1,v1=kil(n-m*m*m)
k2,v2=kil(m*m*m-1-(m-1)*(m-1)*(m-1))
return (k1+1,v1+m*m*m) if (k1,v1+m*m*m)>(k2,v2+(m-1)*(m-1)*(m-1)) else (k2+1,v2+(m-1)*(m-1)*(m-1))
n=int(input())
print(*kil(n))
``` | instruction | 0 | 58,494 | 8 | 116,988 |
Yes | output | 1 | 58,494 | 8 | 116,989 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He plays by building towers from blocks. Every block is a cube with positive integer length of side. Limak has infinitely many blocks of each side length.
A block with side a has volume a3. A tower consisting of blocks with sides a1, a2, ..., ak has the total volume a13 + a23 + ... + ak3.
Limak is going to build a tower. First, he asks you to tell him a positive integer X — the required total volume of the tower. Then, Limak adds new blocks greedily, one by one. Each time he adds the biggest block such that the total volume doesn't exceed X.
Limak asks you to choose X not greater than m. Also, he wants to maximize the number of blocks in the tower at the end (however, he still behaves greedily). Secondarily, he wants to maximize X.
Can you help Limak? Find the maximum number of blocks his tower can have and the maximum X ≤ m that results this number of blocks.
Input
The only line of the input contains one integer m (1 ≤ m ≤ 1015), meaning that Limak wants you to choose X between 1 and m, inclusive.
Output
Print two integers — the maximum number of blocks in the tower and the maximum required total volume X, resulting in the maximum number of blocks.
Examples
Input
48
Output
9 42
Input
6
Output
6 6
Note
In the first sample test, there will be 9 blocks if you choose X = 23 or X = 42. Limak wants to maximize X secondarily so you should choose 42.
In more detail, after choosing X = 42 the process of building a tower is:
* Limak takes a block with side 3 because it's the biggest block with volume not greater than 42. The remaining volume is 42 - 27 = 15.
* The second added block has side 2, so the remaining volume is 15 - 8 = 7.
* Finally, Limak adds 7 blocks with side 1, one by one.
So, there are 9 blocks in the tower. The total volume is is 33 + 23 + 7·13 = 27 + 8 + 7 = 42.
Submitted Solution:
```
import math
import sys
def get_next(x):
t = (-3 + math.sqrt(12 * x - 3)) / 6.0
t = math.floor(t)
for i in range(max(t - 6, 1), t + 7):
nx = x + i ** 3
if nx < (i + 1) ** 3:
return nx
assert(False)
min_by_level = [0, 1]
for i in range(2, 20):
min_by_level.append(get_next(min_by_level[-1]))
high = int(input())
level = 1
while min_by_level[level] <= high:
level += 1
level -= 1
ans_level = level
ans_number = 0
for i in range(level - 1, -1, -1):
le = 1
rg = 10 ** 5 + 1
while rg - le > 1:
mid = (rg + le) // 2
if high - mid ** 3 >= min_by_level[i]:
le = mid
else:
rg = mid
ans_number += le ** 3
high = min(high - le ** 3, (le + 1) ** 3 - 1 - le ** 3)
print(ans_level, ans_number)
``` | instruction | 0 | 58,495 | 8 | 116,990 |
Yes | output | 1 | 58,495 | 8 | 116,991 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He plays by building towers from blocks. Every block is a cube with positive integer length of side. Limak has infinitely many blocks of each side length.
A block with side a has volume a3. A tower consisting of blocks with sides a1, a2, ..., ak has the total volume a13 + a23 + ... + ak3.
Limak is going to build a tower. First, he asks you to tell him a positive integer X — the required total volume of the tower. Then, Limak adds new blocks greedily, one by one. Each time he adds the biggest block such that the total volume doesn't exceed X.
Limak asks you to choose X not greater than m. Also, he wants to maximize the number of blocks in the tower at the end (however, he still behaves greedily). Secondarily, he wants to maximize X.
Can you help Limak? Find the maximum number of blocks his tower can have and the maximum X ≤ m that results this number of blocks.
Input
The only line of the input contains one integer m (1 ≤ m ≤ 1015), meaning that Limak wants you to choose X between 1 and m, inclusive.
Output
Print two integers — the maximum number of blocks in the tower and the maximum required total volume X, resulting in the maximum number of blocks.
Examples
Input
48
Output
9 42
Input
6
Output
6 6
Note
In the first sample test, there will be 9 blocks if you choose X = 23 or X = 42. Limak wants to maximize X secondarily so you should choose 42.
In more detail, after choosing X = 42 the process of building a tower is:
* Limak takes a block with side 3 because it's the biggest block with volume not greater than 42. The remaining volume is 42 - 27 = 15.
* The second added block has side 2, so the remaining volume is 15 - 8 = 7.
* Finally, Limak adds 7 blocks with side 1, one by one.
So, there are 9 blocks in the tower. The total volume is is 33 + 23 + 7·13 = 27 + 8 + 7 = 42.
Submitted Solution:
```
def f(m, cnt, y):
global ans, x
if m == 0:
ans, x = max((ans, x), (cnt, y))
return
a = 1
while (a + 1) ** 3 <= m: a += 1
f(m - a ** 3, cnt + 1, y + a ** 3)
if a >= 1: f(a ** 3 - (a - 1) ** 3 - 1, cnt + 1, y + (a - 1) ** 3)
m = int(input())
ans, x = 0, m
f(m, 0, 0)
print(ans, x)
``` | instruction | 0 | 58,496 | 8 | 116,992 |
Yes | output | 1 | 58,496 | 8 | 116,993 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He plays by building towers from blocks. Every block is a cube with positive integer length of side. Limak has infinitely many blocks of each side length.
A block with side a has volume a3. A tower consisting of blocks with sides a1, a2, ..., ak has the total volume a13 + a23 + ... + ak3.
Limak is going to build a tower. First, he asks you to tell him a positive integer X — the required total volume of the tower. Then, Limak adds new blocks greedily, one by one. Each time he adds the biggest block such that the total volume doesn't exceed X.
Limak asks you to choose X not greater than m. Also, he wants to maximize the number of blocks in the tower at the end (however, he still behaves greedily). Secondarily, he wants to maximize X.
Can you help Limak? Find the maximum number of blocks his tower can have and the maximum X ≤ m that results this number of blocks.
Input
The only line of the input contains one integer m (1 ≤ m ≤ 1015), meaning that Limak wants you to choose X between 1 and m, inclusive.
Output
Print two integers — the maximum number of blocks in the tower and the maximum required total volume X, resulting in the maximum number of blocks.
Examples
Input
48
Output
9 42
Input
6
Output
6 6
Note
In the first sample test, there will be 9 blocks if you choose X = 23 or X = 42. Limak wants to maximize X secondarily so you should choose 42.
In more detail, after choosing X = 42 the process of building a tower is:
* Limak takes a block with side 3 because it's the biggest block with volume not greater than 42. The remaining volume is 42 - 27 = 15.
* The second added block has side 2, so the remaining volume is 15 - 8 = 7.
* Finally, Limak adds 7 blocks with side 1, one by one.
So, there are 9 blocks in the tower. The total volume is is 33 + 23 + 7·13 = 27 + 8 + 7 = 42.
Submitted Solution:
```
import math
m = int(input())
def compose(X):
counter = 0
while X != 0:
c = math.floor(X ** (1 / 3.0))
X -= c ** 3
counter += 1
return counter
gaps = 0
prev = 0
cur_max = 0
cur_max_src = 0
for X in range(m, 0, -1):
next = compose(X)
if next > prev:
gaps += 1
prev = next
if next > cur_max:
cur_max = next
cur_max_src = X
if gaps >= 3:
break
print(cur_max, cur_max_src)
``` | instruction | 0 | 58,497 | 8 | 116,994 |
No | output | 1 | 58,497 | 8 | 116,995 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He plays by building towers from blocks. Every block is a cube with positive integer length of side. Limak has infinitely many blocks of each side length.
A block with side a has volume a3. A tower consisting of blocks with sides a1, a2, ..., ak has the total volume a13 + a23 + ... + ak3.
Limak is going to build a tower. First, he asks you to tell him a positive integer X — the required total volume of the tower. Then, Limak adds new blocks greedily, one by one. Each time he adds the biggest block such that the total volume doesn't exceed X.
Limak asks you to choose X not greater than m. Also, he wants to maximize the number of blocks in the tower at the end (however, he still behaves greedily). Secondarily, he wants to maximize X.
Can you help Limak? Find the maximum number of blocks his tower can have and the maximum X ≤ m that results this number of blocks.
Input
The only line of the input contains one integer m (1 ≤ m ≤ 1015), meaning that Limak wants you to choose X between 1 and m, inclusive.
Output
Print two integers — the maximum number of blocks in the tower and the maximum required total volume X, resulting in the maximum number of blocks.
Examples
Input
48
Output
9 42
Input
6
Output
6 6
Note
In the first sample test, there will be 9 blocks if you choose X = 23 or X = 42. Limak wants to maximize X secondarily so you should choose 42.
In more detail, after choosing X = 42 the process of building a tower is:
* Limak takes a block with side 3 because it's the biggest block with volume not greater than 42. The remaining volume is 42 - 27 = 15.
* The second added block has side 2, so the remaining volume is 15 - 8 = 7.
* Finally, Limak adds 7 blocks with side 1, one by one.
So, there are 9 blocks in the tower. The total volume is is 33 + 23 + 7·13 = 27 + 8 + 7 = 42.
Submitted Solution:
```
n=int(input())
c=1
ans=0
X=0
while X+c**3<=n:
while X<(c+1)**3-c**3 and X+c**3<=n:
ans+=1
X+=c**3
c+=1
print(ans,X)
``` | instruction | 0 | 58,498 | 8 | 116,996 |
No | output | 1 | 58,498 | 8 | 116,997 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He plays by building towers from blocks. Every block is a cube with positive integer length of side. Limak has infinitely many blocks of each side length.
A block with side a has volume a3. A tower consisting of blocks with sides a1, a2, ..., ak has the total volume a13 + a23 + ... + ak3.
Limak is going to build a tower. First, he asks you to tell him a positive integer X — the required total volume of the tower. Then, Limak adds new blocks greedily, one by one. Each time he adds the biggest block such that the total volume doesn't exceed X.
Limak asks you to choose X not greater than m. Also, he wants to maximize the number of blocks in the tower at the end (however, he still behaves greedily). Secondarily, he wants to maximize X.
Can you help Limak? Find the maximum number of blocks his tower can have and the maximum X ≤ m that results this number of blocks.
Input
The only line of the input contains one integer m (1 ≤ m ≤ 1015), meaning that Limak wants you to choose X between 1 and m, inclusive.
Output
Print two integers — the maximum number of blocks in the tower and the maximum required total volume X, resulting in the maximum number of blocks.
Examples
Input
48
Output
9 42
Input
6
Output
6 6
Note
In the first sample test, there will be 9 blocks if you choose X = 23 or X = 42. Limak wants to maximize X secondarily so you should choose 42.
In more detail, after choosing X = 42 the process of building a tower is:
* Limak takes a block with side 3 because it's the biggest block with volume not greater than 42. The remaining volume is 42 - 27 = 15.
* The second added block has side 2, so the remaining volume is 15 - 8 = 7.
* Finally, Limak adds 7 blocks with side 1, one by one.
So, there are 9 blocks in the tower. The total volume is is 33 + 23 + 7·13 = 27 + 8 + 7 = 42.
Submitted Solution:
```
def calc(n):
ans=0
while n:
t=int(n**(1/3)+0.0000000000001)
n-=t*t*t
ans+=1
return ans
n=int(input())
print(' '.join(map(str,max([(calc(i),i) for i in range(n,max(n-10000,0),-1)]))))
``` | instruction | 0 | 58,499 | 8 | 116,998 |
No | output | 1 | 58,499 | 8 | 116,999 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He plays by building towers from blocks. Every block is a cube with positive integer length of side. Limak has infinitely many blocks of each side length.
A block with side a has volume a3. A tower consisting of blocks with sides a1, a2, ..., ak has the total volume a13 + a23 + ... + ak3.
Limak is going to build a tower. First, he asks you to tell him a positive integer X — the required total volume of the tower. Then, Limak adds new blocks greedily, one by one. Each time he adds the biggest block such that the total volume doesn't exceed X.
Limak asks you to choose X not greater than m. Also, he wants to maximize the number of blocks in the tower at the end (however, he still behaves greedily). Secondarily, he wants to maximize X.
Can you help Limak? Find the maximum number of blocks his tower can have and the maximum X ≤ m that results this number of blocks.
Input
The only line of the input contains one integer m (1 ≤ m ≤ 1015), meaning that Limak wants you to choose X between 1 and m, inclusive.
Output
Print two integers — the maximum number of blocks in the tower and the maximum required total volume X, resulting in the maximum number of blocks.
Examples
Input
48
Output
9 42
Input
6
Output
6 6
Note
In the first sample test, there will be 9 blocks if you choose X = 23 or X = 42. Limak wants to maximize X secondarily so you should choose 42.
In more detail, after choosing X = 42 the process of building a tower is:
* Limak takes a block with side 3 because it's the biggest block with volume not greater than 42. The remaining volume is 42 - 27 = 15.
* The second added block has side 2, so the remaining volume is 15 - 8 = 7.
* Finally, Limak adds 7 blocks with side 1, one by one.
So, there are 9 blocks in the tower. The total volume is is 33 + 23 + 7·13 = 27 + 8 + 7 = 42.
Submitted Solution:
```
import math
m = int(input())
def compose(X):
counter = 0
while X != 0:
c = math.floor(X ** (1 / 3.0))
if (c + 1) ** 3 <= X:
X -= (c + 1) ** 3
else:
X -= c ** 3
counter += 1
return counter
gaps = 0
prev = 0
cur_max = 0
cur_max_src = 0
for X in range(m, 0, -1):
next = compose(X)
if next > prev:
gaps += 1
#print("Gap on", X, next)
prev = next
if next > cur_max:
cur_max = next
cur_max_src = X
if gaps >= 20000:
break
print(cur_max, cur_max_src)
``` | instruction | 0 | 58,500 | 8 | 117,000 |
No | output | 1 | 58,500 | 8 | 117,001 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8. | instruction | 0 | 58,596 | 8 | 117,192 |
Tags: brute force, implementation
Correct Solution:
```
##a = list(map(int, input().split()))
##print(' '.join(map(str, res)))
def list_input():
return list(map(int, input().split()))
n = int(input())
c = list()
for i in range(n):
c.append(list_input())
s = set()
for i in range(n):
for x in c[i]:
s.add(x)
if n >= 2:
for i in range(n):
for j in range(n):
if i == j:
continue
for x in c[i]:
for y in c[j]:
if x != 0:
s.add(x*10+y)
if n >= 3:
for i in range(n):
for j in range(n):
if i == j:
continue
for k in range(n):
if i == k or j == k:
continue
for x in c[i]:
for y in c[j]:
for z in c[k]:
if x != 0:
s.add(x*100+y*10+z)
if 0 in s:
s.remove(0)
res = 0
for x in s:
if x == res+1:
res += 1
else:
print(res)
exit(0)
print(res)
``` | output | 1 | 58,596 | 8 | 117,193 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8. | instruction | 0 | 58,597 | 8 | 117,194 |
Tags: brute force, implementation
Correct Solution:
```
import itertools
def main():
n = int(input())
# cubes = [[int(x) for x in input().split()] for _ in range(n)]
# c1 = [int(x) for x in input().split()]
# c2 = [int(x) for x in input().split()] if n > 1 else []
# c3 = [int(x) for x in input().split()] if n > 2 else []
l7 = [(int(x), i) for i in range(1, n+1) for x in input().split()]
l7ily = set()
for p in range(1, n+1):
for x in itertools.permutations(l7, p):
count = set()
s = ""
for xi in x:
s += str(xi[0])
count.add(xi[1])
if len(count) == p:
l7ily.add(int(s))
for lah in range(1, 1000):
if not lah in l7ily:
print(lah-1)
return
else:
print(999)
if __name__ == "__main__":
main()
``` | output | 1 | 58,597 | 8 | 117,195 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8. | instruction | 0 | 58,600 | 8 | 117,200 |
Tags: brute force, implementation
Correct Solution:
```
import itertools
n = int(input())
cubes = []
for i in range(n):
cubes.append(input().split())
canMake = set()
for positions in itertools.combinations_with_replacement([0, 1, 2, 3, 4, 5], n):
words = []
for truePos in itertools.permutations(positions):
word = ''
for i in range(n):
word += cubes[i][truePos[i]]
words.append(word)
for word in words:
for i in range(n):
for comb in itertools.permutations(word, i+1):
canMake.add(int(''.join(comb)))
for i in range(1, 1000):
if i not in canMake:
break
print(i-1)
``` | output | 1 | 58,600 | 8 | 117,201 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8. | instruction | 0 | 58,601 | 8 | 117,202 |
Tags: brute force, implementation
Correct Solution:
```
import sys
import math
import bisect
def solve(A):
n = len(A)
s = set()
if n >= 1:
for i in range(n):
for a in A[i]:
s.add(a)
if n >= 2:
for i in range(n):
for j in range(n):
if i != j:
for a in A[i]:
for b in A[j]:
s.add(a * 10 + b)
if n == 3:
for i in range(n):
for j in range(n):
for k in range(n):
if i != j and j != k and k != i:
for a in A[i]:
for b in A[j]:
for c in A[k]:
s.add(a * 100 + b * 10 + c)
#print('s: %s' % (str(s)))
for i in range(1, 10 ** 18):
if i not in s:
return i - 1
return -1
def main():
n = int(input())
A = []
for i in range(n):
A.append(list(map(int, input().split())))
ans = solve(A)
print(ans)
if __name__ == "__main__":
main()
``` | output | 1 | 58,601 | 8 | 117,203 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8. | instruction | 0 | 58,602 | 8 | 117,204 |
Tags: brute force, implementation
Correct Solution:
```
import itertools
n = int(input())
A = [[] for i in range(n)]
for i in range(n):
a = list(map(int, input().split()))
A[i] = a
if n == 1:
num = 1
for i in range(10):
if num not in A[0]:
break
num += 1
print(num - 1)
elif n == 2:
num = 1
while num in A[0] or num in A[1]:
num += 1
if num == 10:
while ((num // 10) in A[0] and (num % 10) in A[1]) \
or ((num // 10) in A[1] and (num % 10) in A[0]):
num += 1
print(num - 1)
else:
num = 1
while num in A[0] or num in A[1] or num in A[2]:
num += 1
if num == 10:
R = [0, 1, 2]
while True:
flag = False
for i, j in list(itertools.combinations(R, 2)):
if (num // 10) in A[i] and (num % 10) in A[j] or (num // 10) in A[j] and (num % 10) in A[i]:
flag = True
if not flag:
break
else:
num += 1
print(num - 1)
``` | output | 1 | 58,602 | 8 | 117,205 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8.
Submitted Solution:
```
import sys
n = int(input())
a = []
b= []
for i in range(n):
tem =list(map(int,input().strip().split()))
a.append(tem)
b.extend(tem)
k =0
for i in range(1,10):
if i in b:
k = k +1
else:
print(k)
sys.exit()
k = a
if n == 2:
k.append(a[0])
else:
k.append(a[0])
k.append(a[1])
for i in range(10,100):
t1 = i//10
t2 = i%10
looped = False
for j in range(len(k)//2 + 1):
if n==2:
if (t1 in k[j]) and (t2 in k[j+1]):
looped = True
else:
if (t1 in k[j]) and ((t2 in k[j+1]) or (t2 in k[j+2])):
looped = True
if (looped == False):
print(i- 1)
sys.exit()
print(0)
``` | instruction | 0 | 58,604 | 8 | 117,208 |
Yes | output | 1 | 58,604 | 8 | 117,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8.
Submitted Solution:
```
if __name__ == '__main__':
n = int(input().strip())
arrs = [[] for i in range(n)]
for _ in range(n):
arrs[_] = [int(i) for i in input().strip().split(" ")]
h = []
for i in arrs:
h.append((max(i)))
dic = {}
for i in range(n):
for j in arrs[i]:
if j in dic:
dic[j].append(i + 1)
else:
dic[j] = [i + 1]
highest = int("".join([str(i) for i in sorted(h)][::-1]))
answer = 0
stop = False
for i in range(1, highest + 1):
temp = set()
lis = list(str(i))
for j in lis:
if int(j) not in dic:
stop = True
else:
temp = temp.union(set(dic[int(j)]))
if stop:
break
if len(temp) >= len(str(i)) and not stop:
answer = i
else:
stop = True
if stop:
break
print(answer)
``` | instruction | 0 | 58,605 | 8 | 117,210 |
Yes | output | 1 | 58,605 | 8 | 117,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8.
Submitted Solution:
```
# 887B
cubes_sets = [set(), set(), set()]
def myor(smlist):
buff_list = [0, 0, 0]
for x in smlist:
for y in range(3):
buff_list[y] = max(x[y], buff_list[y])
# print(smlist, buff_list)
return buff_list
def mycount(strnum):
global cubes_sets
buff_cubes = cubes_sets
buffl = [[0, 0, 0]] * len(strnum)
for x, y in enumerate(list(strnum)):
# print(y, buff_cubes)
if y in buff_cubes[0]:
buffl[x][0] = 1
if y in buff_cubes[1]:
buffl[x][1] = 1
if y in buff_cubes[2]:
buffl[x][2] = 1
if not (y in buff_cubes[2] or y in buff_cubes[1] or y in buff_cubes[0]):
return [[0, 0, 0]] * len(strnum)
return buffl
def can_make(num):
buff_num = str(num)
global cubes_sets
buff_cubes = cubes_sets
if len(buff_num) == 1:
if buff_num in cubes_sets[0] or buff_num in cubes_sets[1] or buff_num in cubes_sets[2]:
return True
elif len(buff_num) == 2:
inn = mycount(buff_num)
if sum(myor(inn)) >= 2:
return True
elif len(buff_num) == 3:
inn = inn = mycount(buff_num)
if sum(myor(inn)) == 3:
return True
return False
def main():
global cubes_sets
n = int(input())
for x in range(n):
cubes_sets[x] = set(input().split())
lastn = 0
for x in range(1, 1000):
if can_make(x):
lastn = x
continue
else:
return lastn
if __name__ == "__main__":
print(main())
``` | instruction | 0 | 58,606 | 8 | 117,212 |
Yes | output | 1 | 58,606 | 8 | 117,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8.
Submitted Solution:
```
from itertools import permutations
#C = comb
from math import *
n = int(input())
mat = [list(map(int, input().split())) for _ in range(n)]
mp = {}
for vk in mat:
for el in vk:
mp[str(el)] = True
def app(a):
for per in permutations(a):
if per[0] != 0:
s = ''
for p in per: s += str(p)
mp[s] = True
if len(s) > 2:
mp[s[:-1]] = mp[s[1:]] = True
def rec(a, i, n):
if i == n:
app(a)
return
a.append(0)
for j in range(len(mat[i])):
a[-1] = mat[i][j]
rec(a, i+1, n)
a.pop()
rec([], 0, n)
res = 0
for i in range(1, 1000):
if str(i) not in mp:
res = i-1
break
print(res)
``` | instruction | 0 | 58,607 | 8 | 117,214 |
Yes | output | 1 | 58,607 | 8 | 117,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8.
Submitted Solution:
```
from itertools import permutations
n = int(input())
lst = list()
for i in range(n):
lst.append(list(input().split()))
per = permutations(lst)
for x in range(1,1000):
l = str(x)
for i in per:
for d,c in zip(l,i):
if d not in c:
break
else:
break
else:
break
print(x-1)
``` | instruction | 0 | 58,608 | 8 | 117,216 |
No | output | 1 | 58,608 | 8 | 117,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8.
Submitted Solution:
```
n = int(input().strip())
n_array = []
for x in range(n):
n_array.append(input().strip().split())
vals = {}
for x in range(len(n_array)):
for y in range(6):
vals[int(n_array[x][y])] = 1
if n == 2:
for p in range(6):
for y in range(6):
num = str(n_array[0][p])
num += str(n_array[1][y])
vals[int(num)] = 1
num = str(n_array[1][y])
num += str(n_array[0][p])
vals[int(num)] = 1
elif n == 3:
for p in range(6):
for y in range(6):
num = str(n_array[0][p])
num += str(n_array[1][y])
vals[int(num)] = 1
num = str(n_array[1][y])
num += str(n_array[0][p])
vals[int(num)] = 1
num = str(n_array[0][p])
num += str(n_array[2][y])
vals[int(num)] = 1
num = str(n_array[2][y])
num += str(n_array[0][p])
vals[int(num)] = 1
num = str(n_array[1][p])
num += str(n_array[2][y])
vals[int(num)] = 1
num = str(n_array[2][y])
num += str(n_array[1][p])
vals[int(num)] = 1
for p in range(6):
for y in range(6):
for z in range(6):
num = str(n_array[0][p])
num += str(n_array[1][y])
num += str(n_array[2][z])
vals[int(num)] = 1
num = str(n_array[0][p])
num += str(n_array[2][y])
num += str(n_array[1][z])
vals[int(num)] = 1
num = str(n_array[1][p])
num += str(n_array[0][y])
num += str(n_array[2][z])
vals[int(num)] = 1
num = str(n_array[1][p])
num += str(n_array[2][y])
num += str(n_array[0][z])
vals[int(num)] = 1
num = str(n_array[2][p])
num += str(n_array[1][y])
num += str(n_array[0][z])
vals[int(num)] = 1
num = str(n_array[2][p])
num += str(n_array[0][y])
num += str(n_array[1][z])
vals[int(num)] = 1
for x in range(999):
if x not in vals:
print(x-1)
break
``` | instruction | 0 | 58,609 | 8 | 117,218 |
No | output | 1 | 58,609 | 8 | 117,219 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8.
Submitted Solution:
```
from collections import deque
from math import log,sqrt,ceil
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def li(): return list(mi())
n=ii()
if(n==1):
a=li()
for i in range(1,8):
if not i in a:
print(i-1)
break
elif(n==2):
a=li()
b=li()
f=0
for i in range(1,10):
if i not in(a+b):
print(i-1)
f=1
break
if(f==0):
m={}
f1=0
for i in range(10):
if i in a and i in b:
m[i]=3
if i in a and i not in b:
m[i]=1
if i in b and i not in a:
m[i]=2
for i in range(1,10):
if(m[i]==3):
continue
if(m[i]==1):
for j in range(10):
if j not in b:
s=i*10+(j-1)
f1=1
break
else:
for j in range(10):
if j not in b:
s=i*10+(j-1)
f1=1
break
if(f1==1):
break
print(s)
else:
a=li()
b=li()
c=li()
f=0
for i in range(1,10):
if i not in(a+b+c):
print(i-1)
f=1
break
if(f==0):
m={}
f1=0
for i in range(10):
if i in a and i in b :
m[i]=3
if i in b and i in c:
m[i]=3
if i in a and i in c :
m[i]=3
if i in a and i not in b and i not in c:
m[i]=1
if i in b and i not in a and i not in c:
m[i]=2
if i in c and i not in a and i not in b:
m[i]=0
for i in range(1,10):
if(m[i]==3):
continue
if(m[i]==1):
for j in range(10):
if j not in (b+c):
s=i*10+(j-1)
f1=1
break
elif(m[i]==2):
for j in range(10):
if j not in a+c:
s=i*10+(j-1)
f1=1
break
else:
for j in range(10):
if j not in a+b:
s=i*10+(j-1)
f1=1
break
if(f1==1):
break
print(s)
``` | instruction | 0 | 58,610 | 8 | 117,220 |
No | output | 1 | 58,610 | 8 | 117,221 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
Input
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers aij (0 ≤ aij ≤ 9) — number on j-th face of i-th cube.
Output
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
Examples
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
Note
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8.
Submitted Solution:
```
n = int(input())
cubes = [[int(elem) for elem in input().strip().split(' ')] for i in range(n)]
def f(cubes):
dic = {}
pos = {}
for i in range(n):
for j, elem in enumerate(cubes[i]):
if elem in dic:
dic[elem] += 1
pos[elem].add(i)
else:
dic[elem] = 1
pos[elem] = set((i, ))
for i in range(1, 10):
if not i in dic:
return i - 1
if not 0 in dic:
return 9
for i in range(1, 10):
for j in range(10):
print(i, j)
print(pos[i].union(pos[j]))
print(pos[i], pos[j])
if len(pos[i].union(pos[j])) == 1:
return 10 * i + j - 1
print(f(cubes))
``` | instruction | 0 | 58,611 | 8 | 117,222 |
No | output | 1 | 58,611 | 8 | 117,223 |
Provide a correct Python 3 solution for this coding contest problem.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0 | instruction | 0 | 58,650 | 8 | 117,300 |
"Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
mx=l[0]
an=0
for i in range(1,n):
if l[i]<mx:
an+=mx-l[i]
else:
mx=l[i]
print(an)
``` | output | 1 | 58,650 | 8 | 117,301 |
Provide a correct Python 3 solution for this coding contest problem.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0 | instruction | 0 | 58,651 | 8 | 117,302 |
"Correct Solution:
```
N = int(input())
A = list(map(int,input().split()))
H = A[0]
ans = 0
for a in A:
if a<H:
ans+=H-a
else:
H = a
print(ans)
``` | output | 1 | 58,651 | 8 | 117,303 |
Provide a correct Python 3 solution for this coding contest problem.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0 | instruction | 0 | 58,652 | 8 | 117,304 |
"Correct Solution:
```
N=int(input())
A=list(map(int,input().split()))
h=0
for i in range(1,N):
a=A[i]-A[i-1]
if a<0:
h-=a
A[i]-=a
print(h)
``` | output | 1 | 58,652 | 8 | 117,305 |
Provide a correct Python 3 solution for this coding contest problem.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0 | instruction | 0 | 58,653 | 8 | 117,306 |
"Correct Solution:
```
n=int(input())
a= list(map(int, input().split()))
ans=0
cnt=a[0]
for i in range(1,n):
cnt=max(cnt,a[i])
ans+=cnt-a[i]
print(ans)
``` | output | 1 | 58,653 | 8 | 117,307 |
Provide a correct Python 3 solution for this coding contest problem.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0 | instruction | 0 | 58,654 | 8 | 117,308 |
"Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
mx = a[0]
ans = 0
for x in a:
if x > mx:
mx = x
ans += mx
print(ans-sum(a))
``` | output | 1 | 58,654 | 8 | 117,309 |
Provide a correct Python 3 solution for this coding contest problem.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0 | instruction | 0 | 58,655 | 8 | 117,310 |
"Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
ans = 0
h = a[0]
for x in a:
ans += max(0,h-x)
h = max(h,x)
print(ans)
``` | output | 1 | 58,655 | 8 | 117,311 |
Provide a correct Python 3 solution for this coding contest problem.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0 | instruction | 0 | 58,656 | 8 | 117,312 |
"Correct Solution:
```
N = int(input())
A = list(map(int, input().split()))
ans = 0
mx = 0
for a in A:
ans += max(0, mx - a)
mx = max(mx, a)
print(ans)
``` | output | 1 | 58,656 | 8 | 117,313 |
Provide a correct Python 3 solution for this coding contest problem.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0 | instruction | 0 | 58,657 | 8 | 117,314 |
"Correct Solution:
```
n = int(input())
A = [*map(int, input().split())]
s = maxA = 0
for a in A:
maxA = max(maxA, a)
s += maxA - a
print(s)
``` | output | 1 | 58,657 | 8 | 117,315 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0
Submitted Solution:
```
N = int(input())
li = list(map(int,input().split()))
ans = 0
h = li[0]
for l in li[1:]:
h = max(h,l)
ans += h-l
print(ans)
``` | instruction | 0 | 58,658 | 8 | 117,316 |
Yes | output | 1 | 58,658 | 8 | 117,317 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0
Submitted Solution:
```
n=int(input())
A=list(map(int,input().split()))
now=0
ans=0
for a in A:
if now>a:
ans+=now-a
else:
now=a
print(ans)
``` | instruction | 0 | 58,659 | 8 | 117,318 |
Yes | output | 1 | 58,659 | 8 | 117,319 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0
Submitted Solution:
```
n=int(input())
ans=0
pre=0
for i in list(map(int,input().split())):
if i<pre:
ans+=pre-i
else:pre=i
print(ans)
``` | instruction | 0 | 58,660 | 8 | 117,320 |
Yes | output | 1 | 58,660 | 8 | 117,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0
Submitted Solution:
```
N=int(input())
A=list(map(int,input().split()))
x=0
dx=0
for i in A:
if i>x:
x=i
else:
dx+=(x-i)
print(dx)
``` | instruction | 0 | 58,661 | 8 | 117,322 |
Yes | output | 1 | 58,661 | 8 | 117,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0
Submitted Solution:
```
n = int(input())
list = list(map(int,input().split()))
ans = 0
maxV = max(list)
maxI = list.index(maxV)
sumV = sum(list[maxI+1, len(list)])
maxM = maxV * (len(list)-1-maxI)
ans += maxM - sumV
if maxI != 0:
for i in range(0,maxI):
if i != maxI:
x = list[i] - list[i+1]
if x > 0:
ans += x
print(ans)
``` | instruction | 0 | 58,662 | 8 | 117,324 |
No | output | 1 | 58,662 | 8 | 117,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0
Submitted Solution:
```
N = int(input())
lst = list(map(int, input().split()))
lst2 = sorted(lst, reverse=True)
l_count = N
count = 0
for i in lst2:
k_index = lst.index(i)
if k_index >= l_count:
continue
else:
count = count + (l_count - k_index) * i
l_count = k_index
if k_index == 0:
break
print(count-sum(lst))
``` | instruction | 0 | 58,663 | 8 | 117,326 |
No | output | 1 | 58,663 | 8 | 117,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0
Submitted Solution:
```
#!/usr/bin/env python3
# atcoder
# Türkler var mı?
# Herkese memnün oldum
import sys
readline = sys.stdin.buffer.readline
iimr = lambda: map(int, sys.stdin.buffer.readline().rstrip().split())
#sys.setrecursionlimit(10 ** 8)
def debug(*x):
print(*x, file=sys.stderr)
class atcoder():
def __init__(self):
pass
def çözmek(self):
N = int(input())
A = list(map(int, sys.stdin.buffer.readline().split()))
res = []
res.append(self.関数(N, A))
print(*res, "\n")
def 関数(self, n, Aliste):
res = 0
for i in range(1, n):
if Aliste[i - 1] > Aliste[i]:
res += Aliste[i - 1] - Aliste[i]
Aliste[i] = Aliste[i - 1]
return res
if __name__ == "__main__":
ima = atcoder()
ima.çözmek()
``` | instruction | 0 | 58,664 | 8 | 117,328 |
No | output | 1 | 58,664 | 8 | 117,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N persons are standing in a row. The height of the i-th person from the front is A_i.
We want to have each person stand on a stool of some heights - at least zero - so that the following condition is satisfied for every person:
Condition: Nobody in front of the person is taller than the person. Here, the height of a person includes the stool.
Find the minimum total height of the stools needed to meet this goal.
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 \ldots A_N
Output
Print the minimum total height of the stools needed to meet the goal.
Examples
Input
5
2 1 5 4 3
Output
4
Input
5
3 3 3 3 3
Output
0
Submitted Solution:
```
def main():
N = int(input())
A = list(map(int, input().split()))
count = 0
max_height = 0
for height in A:
if max_height < height:
max_height = height
else:
count += max_height - height
print(count)
if __name__ == '__
``` | instruction | 0 | 58,665 | 8 | 117,330 |
No | output | 1 | 58,665 | 8 | 117,331 |
Provide a correct Python 3 solution for this coding contest problem.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243 | instruction | 0 | 58,715 | 8 | 117,430 |
"Correct Solution:
```
n,a,b,c = map(int,input().split())
li = [int(input()) for _ in range(n)]
inf = 1000000
def cost(N,x,y,z):
if N == n:
if x*y*z == 0:
return inf
return abs(x-a) + abs(y-b) + abs(z-c)
cost1 = cost(N+1,x,y,z)
cost2 = cost(N+1,x+li[N],y,z) + 10
cost3 = cost(N+1,x,y+li[N],z) + 10
cost4 = cost(N+1,x,y,z+li[N]) + 10
return min(cost1,cost2,cost3,cost4)
print(cost(0,0,0,0)-30)
``` | output | 1 | 58,715 | 8 | 117,431 |
Provide a correct Python 3 solution for this coding contest problem.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243 | instruction | 0 | 58,716 | 8 | 117,432 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
n,a,b,c = map(int,input().split())
la = [a,b,c]
lt = [int(input()) for i in range(n)]
import itertools as it
ans = 3000
for p in it.product(range(4),repeat=n):
ll = [0]*4
lc = [0]*4
for i in range(n):
ll[p[i]] += lt[i]
lc[p[i]] += 1
if lc[0]*lc[1]*lc[2] > 0:
mp = 10*(sum(lc[:3])-3) + sum(abs(ll[i]-la[i]) for i in range(3))
ans = min(ans, mp)
print(ans)
``` | output | 1 | 58,716 | 8 | 117,433 |
Provide a correct Python 3 solution for this coding contest problem.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243 | instruction | 0 | 58,717 | 8 | 117,434 |
"Correct Solution:
```
n,A,B,C=map(int,input().split())
l=[int(input()) for _ in range(n)]
t=10**9
def dfs(level,a,b,c):
if level==n:
return abs(a-A)+abs(b-B)+abs(c-C)-30 if min(a,b,c)>0 else t
k1=dfs(level+1,a,b,c)
k2=dfs(level+1,a+l[level],b,c)+10
k3=dfs(level+1,a,b+l[level],c)+10
k4=dfs(level+1,a,b,c+l[level])+10
return min(k1,k2,k3,k4)
print(dfs(0,0,0,0))
``` | output | 1 | 58,717 | 8 | 117,435 |
Provide a correct Python 3 solution for this coding contest problem.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243 | instruction | 0 | 58,718 | 8 | 117,436 |
"Correct Solution:
```
n,A,B,C=map(int,input().split())
l=[]
for _ in range(n):
l.append(int(input()))
def solve(cur,a,b,c):
if cur==n:
#base case
return abs(a-A)+abs(b-B)+abs(c-C)-30 if min(a,b,c)>0 else float('INF')
ret0=solve(cur+1,a,b,c)
ret1=solve(cur+1,a+l[cur],b,c)+10
ret2=solve(cur+1,a,b+l[cur],c)+10
ret3=solve(cur+1,a,b,c+l[cur])+10
return min(ret0,ret1,ret2,ret3)
print(solve(0,0,0,0))
``` | output | 1 | 58,718 | 8 | 117,437 |
Provide a correct Python 3 solution for this coding contest problem.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243 | instruction | 0 | 58,719 | 8 | 117,438 |
"Correct Solution:
```
n,A,B,C=map(int,input().split())
L=[int(input()) for i in range(n)]
INF=10**9
def dfs(cnt,a,b,c):
if cnt==n:
if min(a,b,c)>0:
return abs(A-a)+abs(B-b)+abs(C-c)-30
else:
return INF
else:
res0=dfs(cnt+1,a,b,c)
res1=dfs(cnt+1,a+L[cnt],b,c)+10
res2=dfs(cnt+1,a,b+L[cnt],c)+10
res3=dfs(cnt+1,a,b,c+L[cnt])+10
return min(res0,res1,res2,res3)
print(dfs(0,0,0,0))
``` | output | 1 | 58,719 | 8 | 117,439 |
Provide a correct Python 3 solution for this coding contest problem.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243 | instruction | 0 | 58,720 | 8 | 117,440 |
"Correct Solution:
```
N,A,B,C = map(int,input().split(" "))
l = [int(input()) for x in range(N)]
b = []
for x in range(4**N):
o = []
s = -30
for y in range(N):
o.append((x//(4**y))%4)
if (0 in o) and (1 in o) and (2 in o):
a = [A,B,C]
for y in range(N):
if o[y] != 3:
a[o[y]] -= l[y]
s += 10
b.append(sum(map(lambda x: x if x > 0 else -x,a))+s)
print(min(b))
``` | output | 1 | 58,720 | 8 | 117,441 |
Provide a correct Python 3 solution for this coding contest problem.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243 | instruction | 0 | 58,721 | 8 | 117,442 |
"Correct Solution:
```
from itertools import product
N, *ABC = map(int, input().split())
L = []
for _ in range(N):
L.append(int(input()))
ans = 10**9
for X in product((0, 1, 2, 3), repeat=N):
cnt, K, temp = [0]*4, [0]*4, 0
for i in range(N):
cnt[X[i]] += 1
K[X[i]] += L[i]
if min(cnt[1:]) == 0:
continue
for i in range(3):
temp += abs(ABC[i] - K[i+1])
temp += 10 * max(cnt[i+1]-1, 0)
ans = min(ans, temp)
print(ans)
``` | output | 1 | 58,721 | 8 | 117,443 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243
Submitted Solution:
```
N,*T = map(int,input().split())
L = [int(input()) for i in range(N)]
ans = 3000
for x in range(4**N):
l = [0]*4
t = [0]*4
n = 4
i = 0
for i in range(N):
l[x%n] += L[i]
t[x%n] += 1
x//=n
if 0 in l[:3]:
continue
cost = 0
for i in range(3):
cost += (t[i]-1)*10
cost += abs(l[i]-T[i])
ans = min(ans, cost)
print(ans)
``` | instruction | 0 | 58,722 | 8 | 117,444 |
Yes | output | 1 | 58,722 | 8 | 117,445 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243
Submitted Solution:
```
N, A, B, C = map(int, input().split())
from itertools import product
l = [int(input()) for i in range(N)]
ans = []
for i in product(range(4), repeat=N):
a = 0
b = 0
c = 0
d = 0
for j in range(N):
if i[j]:
d += 1
if i[j] == 1:
a += l[j]
elif i[j] == 2:
b += l[j]
else:
c += l[j]
if a * b * c:
ans += [abs(A - a) + abs(B - b) + abs(C - c) + (d - 3) * 10]
print(min(ans))
``` | instruction | 0 | 58,723 | 8 | 117,446 |
Yes | output | 1 | 58,723 | 8 | 117,447 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243
Submitted Solution:
```
n,A,B,C = map(int,input().split())
l = [int(input()) for i in range(n)]
INF = 10**9
def dfs(cur,a,b,c):
if cur == n:
return abs(a - A) + abs(b - B) + abs(c - C) - 30 if min(a, b, c) > 0 else INF
ret0 = dfs(cur+1,a,b,c)
ret1 = dfs(cur+1,a+l[cur],b,c) + 10
ret2 = dfs(cur+1,a,b+l[cur],c) + 10
ret3 = dfs(cur+1,a,b,c+l[cur]) + 10
return min(ret0,ret1,ret2,ret3)
print(dfs(0,0,0,0))
``` | instruction | 0 | 58,724 | 8 | 117,448 |
Yes | output | 1 | 58,724 | 8 | 117,449 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.