message stringlengths 2 59.7k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 37 108k | cluster float64 20 20 | __index_level_0__ int64 74 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider the infinite sequence of integers: 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5.... The sequence is built in the following way: at first the number 1 is written out, then the numbers from 1 to 2, then the numbers from 1 to 3, then the numbers from 1 to 4 and so on. Note that the sequence contains numbers, not digits. For example number 10 first appears in the sequence in position 55 (the elements are numerated from one).
Find the number on the n-th position of the sequence.
Input
The only line contains integer n (1 β€ n β€ 1014) β the position of the number to find.
Note that the given number is too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Output
Print the element in the n-th position of the sequence (the elements are numerated from one).
Examples
Input
3
Output
2
Input
5
Output
2
Input
10
Output
4
Input
55
Output
10
Input
56
Output
1 | instruction | 0 | 59,289 | 20 | 118,578 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
r=int((-1+((1+8*n)**.5))//2)
print(r if n-r*(r+1)//2==0 else n-r*(r+1)//2)
``` | output | 1 | 59,289 | 20 | 118,579 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The only line of the input contains a string of digits. The length of the string is between 1 and 10, inclusive.
Output
Output "Yes" or "No".
Examples
Input
373
Output
Yes
Input
121
Output
No
Input
436
Output
Yes | instruction | 0 | 59,349 | 20 | 118,698 |
Tags: *special, implementation
Correct Solution:
```
mp = [ 8, -1, -1, 3, 6, 9, 4, 7, 0, 5 ]
str = input()
for i in range( len( str ) ):
if ord( str[ i ] ) - ord( '0' ) != mp[ ord( str[ len( str ) - 1 - i ] ) - ord( '0' ) ]:
exit( print( "No" ) )
print( "Yes" )
``` | output | 1 | 59,349 | 20 | 118,699 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The only line of the input contains a string of digits. The length of the string is between 1 and 10, inclusive.
Output
Output "Yes" or "No".
Examples
Input
373
Output
Yes
Input
121
Output
No
Input
436
Output
Yes | instruction | 0 | 59,350 | 20 | 118,700 |
Tags: *special, implementation
Correct Solution:
```
n = input()
for i in range(len(n)):
if (n[i] == '1' or n[i] == '2'):
print("No")
exit(0)
elif ((n[i] == '3' or n[i] == '7') and n[-i - 1] != n[i]):
print("No")
exit(0)
elif (n[i] == '4' and n[-i - 1] != '6'):
print("No")
exit(0)
elif (n[i] == '6' and n[-i - 1] != '4'):
print("No")
exit(0)
elif (n[i] == '5' and n[-i - 1] != '9'):
print("No")
exit(0)
elif (n[i] == '9' and n[-i - 1] != '5'):
print("No")
exit(0)
elif (n[i] == '8' and n[-i - 1] != '0'):
print("No")
exit(0)
elif (n[i] == '0' and n[-i - 1] != '8'):
print("No")
exit(0)
print("Yes")
``` | output | 1 | 59,350 | 20 | 118,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The only line of the input contains a string of digits. The length of the string is between 1 and 10, inclusive.
Output
Output "Yes" or "No".
Examples
Input
373
Output
Yes
Input
121
Output
No
Input
436
Output
Yes | instruction | 0 | 59,351 | 20 | 118,702 |
Tags: *special, implementation
Correct Solution:
```
s=input()
s1=''
for i in s:
if i=='0':
s1+='8'
elif i=='1':
s1+=''
elif i=='2':
s1+=''
elif i=='3':
s1+='3'
elif i=='4':
s1+='6'
elif i=='5':
s1+='9'
elif i=='6':
s1+='4'
elif i=='7':
s1+='7'
elif i=='8':
s1+='0'
elif i=='9':
s1+='5'
if s!=s1[::-1]:
print('No')
else:
print('Yes')
#print(' '.join([str(i) for i in a]))
``` | output | 1 | 59,351 | 20 | 118,703 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The only line of the input contains a string of digits. The length of the string is between 1 and 10, inclusive.
Output
Output "Yes" or "No".
Examples
Input
373
Output
Yes
Input
121
Output
No
Input
436
Output
Yes | instruction | 0 | 59,352 | 20 | 118,704 |
Tags: *special, implementation
Correct Solution:
```
a=input()
d={"0":"8","1":"-","2":"-","3":"3","4":"6","5":"9","6":"4","7":"7","8":"0","9":"5"}
for i in range(len(a)):
if d[a[i]]!=a[len(a)-i-1]:
print("No")
exit(0)
print("Yes")
``` | output | 1 | 59,352 | 20 | 118,705 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The only line of the input contains a string of digits. The length of the string is between 1 and 10, inclusive.
Output
Output "Yes" or "No".
Examples
Input
373
Output
Yes
Input
121
Output
No
Input
436
Output
Yes | instruction | 0 | 59,353 | 20 | 118,706 |
Tags: *special, implementation
Correct Solution:
```
m={}
m['0']='8'
m['1']='x'
m['2']='x'
m['3']='3'
m['4']='6'
m['5']='9'
m['6']='4'
m['7']='7'
m['8']='0'
m['9']='5'
x = list(input())
y = list(reversed([m[c] for c in x]))
print('Yes' if x==y else 'No')
``` | output | 1 | 59,353 | 20 | 118,707 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The only line of the input contains a string of digits. The length of the string is between 1 and 10, inclusive.
Output
Output "Yes" or "No".
Examples
Input
373
Output
Yes
Input
121
Output
No
Input
436
Output
Yes | instruction | 0 | 59,354 | 20 | 118,708 |
Tags: *special, implementation
Correct Solution:
```
# β β β β β β β β β β
# 1234567890
R = [
("1", "' "),
("2", ": "),
("3", "''"),
("4", "':"),
("5", "'."),
("6", ":'"),
("7", "::"),
("8", ":."),
("9", ".'"),
("0", ".:"),
]
s = input()
for a,b in R:
s = s.replace(a,b)
print("Yes" if s==s[::-1] else "No")
``` | output | 1 | 59,354 | 20 | 118,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The only line of the input contains a string of digits. The length of the string is between 1 and 10, inclusive.
Output
Output "Yes" or "No".
Examples
Input
373
Output
Yes
Input
121
Output
No
Input
436
Output
Yes | instruction | 0 | 59,355 | 20 | 118,710 |
Tags: *special, implementation
Correct Solution:
```
a={'3':'3','4':'6','6':'4','5':'9','9':'5','7':'7','8':'0','0':'8','1':'x','2':'x'}
s=input()
f=1
for i in range(len(s)):
if s[i]!=a[s[len(s)-i-1]]:f=0
if f:print("Yes")
else:print("No")
``` | output | 1 | 59,355 | 20 | 118,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The only line of the input contains a string of digits. The length of the string is between 1 and 10, inclusive.
Output
Output "Yes" or "No".
Examples
Input
373
Output
Yes
Input
121
Output
No
Input
436
Output
Yes | instruction | 0 | 59,356 | 20 | 118,712 |
Tags: *special, implementation
Correct Solution:
```
import sys
import time
for line in sys.stdin:
ll = len(line) - 1
fail = 0
for i in range(ll):
if i == ll - 1 - i:
if int(line[i]) not in [3, 7]:
fail = 1
continue
x = int(line[i])
y = int(line[ll - 1 - i])
if (x, y) not in [(3, 3), (4, 6), (6, 4), (7, 7), (8, 0), (0, 8), (5, 9), (9, 5)]:
fail = 1
if fail:
print("No")
if not fail:
print("Yes")
``` | output | 1 | 59,356 | 20 | 118,713 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL). | instruction | 0 | 59,415 | 20 | 118,830 |
Tags: brute force, combinatorics, dp, greedy, math
Correct Solution:
```
non_representable = {
1: 46,
2: 89,
3: 128,
4: 162,
5: 190,
6: 212,
7: 228,
8: 238,
9: 244,
10: 247,
}
n = int(input())
print(49 * n + 1 - non_representable.get(n, 248))
``` | output | 1 | 59,415 | 20 | 118,831 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL). | instruction | 0 | 59,416 | 20 | 118,832 |
Tags: brute force, combinatorics, dp, greedy, math
Correct Solution:
```
def c(n):
ans = 0
if n > 15:
ans += (49 * (n - 15))
n = 15
l = set()
for i in range(max(n+1,441)):
for j in range(max(n-i+1,196)):
for k in range(n-i-j+1):
l.add(i*4+j*9+k*49)
return ans + len(l)
n = int(input())
print(c(n))
``` | output | 1 | 59,416 | 20 | 118,833 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL). | instruction | 0 | 59,417 | 20 | 118,834 |
Tags: brute force, combinatorics, dp, greedy, math
Correct Solution:
```
def answer(n):
# brute-force
sums = set()
for d1 in range(n + 1):
for d5 in range(n + 1 - d1):
for d10 in range(n + 1 - d1 - d5):
d50 = n - d1 - d5 - d10
sums.add(d1 * 1 + d5 * 5 + d10 * 10 + d50 * 50)
return len(sums)
answers = [answer(x) for x in range(31)]
n = int(input())
if n < len(answers):
answer = answers[n]
else:
# function is linear in the end
growth = answers[30] - answers[29]
answer = answers[29] + (n - 29) * growth
print(answer)
``` | output | 1 | 59,417 | 20 | 118,835 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL). | instruction | 0 | 59,418 | 20 | 118,836 |
Tags: brute force, combinatorics, dp, greedy, math
Correct Solution:
```
x=[0, 4, 10, 20, 35, 56, 83, 116, 155, 198, 244, 292]
n=int(input())
print(x[n] if n<=11 else 292+(n-11)*49)
``` | output | 1 | 59,418 | 20 | 118,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL). | instruction | 0 | 59,419 | 20 | 118,838 |
Tags: brute force, combinatorics, dp, greedy, math
Correct Solution:
```
a=[0,4,10,20,35,56,83,116,155,198,244]
n=int(input())
if n<=10:
print(a[n])
else:
print(49*n-247)
``` | output | 1 | 59,419 | 20 | 118,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL). | instruction | 0 | 59,420 | 20 | 118,840 |
Tags: brute force, combinatorics, dp, greedy, math
Correct Solution:
```
from collections import defaultdict
n = int(input())
if n > 11:
print(292 + 49 * (n - 11))
else:
d = defaultdict(list)
for L in range(n + 1):
for X in range(n + 1 - L):
for V in range(n + 1 - X - L):
I = n - X - V - L
s = L * 50 + X * 10 + V * 5 + I
d[s].append((L, X, V, I))
print(len(d))
``` | output | 1 | 59,420 | 20 | 118,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL). | instruction | 0 | 59,421 | 20 | 118,842 |
Tags: brute force, combinatorics, dp, greedy, math
Correct Solution:
```
ans = [1, 4, 10, 20, 35, 56, 83, 116, 155, 198, 244, 292, 341, 390, 439]
n = int(input())
if (n < 12):
print(ans[n])
else:
print(292 + (n - 11) * 49)
``` | output | 1 | 59,421 | 20 | 118,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL). | instruction | 0 | 59,422 | 20 | 118,844 |
Tags: brute force, combinatorics, dp, greedy, math
Correct Solution:
```
n = int(input())
if n < 20:
q = []
i = 0
while i <= n:
j = 0
while j <= n-i:
k = 0
while k <= n-i-j:
t = n - i - j - k
q.append(i*1+j*5+k*10+t*50)
k = k + 1
j = j + 1
i = i + 1
print(len(set(q)))
else:
an = int((n+1)*(n+2)*(n+3)//6)
st = int(856)
diff = int(182)
t = int(21)
cnt = int(t + n - 20 - t + 1)
su = int((diff + diff + t*(cnt-1)) * cnt // 2 + ((n-20)*(n-20+1)*(n-20+2)//6))
st = (st + su)
print((an - st))
``` | output | 1 | 59,422 | 20 | 118,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL).
Submitted Solution:
```
ans=0
def solve(nn,su,ans):
if nn==n:
s.add(su)
ans+=1
return
solve(nn+1,su+1,ans)
solve(nn+1,su+5,ans)
solve(nn+1,su+10,ans)
solve(nn+1,su+50,ans)
s = set()
n = int(input())
if n<=13:
solve(0,0,ans)
print(len(s))
else:
print(292 + 49*(n-11))
``` | instruction | 0 | 59,423 | 20 | 118,846 |
Yes | output | 1 | 59,423 | 20 | 118,847 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL).
Submitted Solution:
```
n = int(input())
if n > 20:
print(733+(n-20)*49)
else:
s = set()
for i in range(n+1):
for v in range(n-i+1):
for x in range(n-i-v+1):
l = n-i-v-x
s.add(i+5*v+10*x+50*l)
print(len(s))
``` | instruction | 0 | 59,424 | 20 | 118,848 |
Yes | output | 1 | 59,424 | 20 | 118,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL).
Submitted Solution:
```
n = int(input())
a = [0, 4, 10, 20, 35, 56, 83, 116, 155, 198, 244, 292]
if n <= 11:
print(a[n])
else:
print(a[-1] + (n - 11) * 49)
``` | instruction | 0 | 59,425 | 20 | 118,850 |
Yes | output | 1 | 59,425 | 20 | 118,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL).
Submitted Solution:
```
from sys import stdin, stdout
def count(n):
d = {}
cnt = 0
cur = 0
for i in range(n + 1):
for j in range(n - i + 1):
for z in range(n - j - i + 1):
v = i * 1 + j * 5 + z * 10 + (n - i - j - z) * 50
if not v in d:
d[v] = 1
cur += 1
else:
d[v] += 1
return cur
n = int(stdin.readline())
if n >= 20:
upp = count(20) + 49 * (n - 20)
else:
upp = count(n)
print(upp)
``` | instruction | 0 | 59,426 | 20 | 118,852 |
Yes | output | 1 | 59,426 | 20 | 118,853 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL).
Submitted Solution:
```
n = int(input())
print((n + 1) * (n + 2) * (n + 3) // 6)
``` | instruction | 0 | 59,427 | 20 | 118,854 |
No | output | 1 | 59,427 | 20 | 118,855 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL).
Submitted Solution:
```
import sys
x = int(input())
print((x+3)*(x+2)*(x+1)//6)
``` | instruction | 0 | 59,428 | 20 | 118,856 |
No | output | 1 | 59,428 | 20 | 118,857 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL).
Submitted Solution:
```
def mi():
return map(int, input().split())
import math
def fun(n):
return math.ceil(2*(n**2)/3)
a = [1,5,10,50]
n = int(input())
if n>=10:
n+=1
print (int((math.ceil(fun(n))+math.ceil(fun(n-1))+math.ceil(fun(n+1)))))
``` | instruction | 0 | 59,429 | 20 | 118,858 |
No | output | 1 | 59,429 | 20 | 118,859 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI β to 12.
Pay attention to the difference to the traditional roman system β in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 β€ n β€ 10^9) β the number of roman digits to use.
Output
Output a single integer β the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented β I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL).
Submitted Solution:
```
n = int(input())
ans = (n + 1) * (n + 2) * (n + 3) / 6
if n < 6:
print(int(round(ans)))
elif n == 6:
print(int(round(ans - 1)))
else:
x = n - 6
diff = (x*x*x + 3*x*x + 2*x + 6) / 3
ans -= diff
print(int(round(ans)))
``` | instruction | 0 | 59,430 | 20 | 118,860 |
No | output | 1 | 59,430 | 20 | 118,861 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima got into number sequences. Now he's got sequence a1, a2, ..., an, consisting of n positive integers. Also, Dima has got a function f(x), which can be defined with the following recurrence:
* f(0) = 0;
* f(2Β·x) = f(x);
* f(2Β·x + 1) = f(x) + 1.
Dima wonders, how many pairs of indexes (i, j) (1 β€ i < j β€ n) are there, such that f(ai) = f(aj). Help him, count the number of such pairs.
Input
The first line contains integer n (1 β€ n β€ 105). The second line contains n positive integers a1, a2, ..., an (1 β€ ai β€ 109).
The numbers in the lines are separated by single spaces.
Output
In a single line print the answer to the problem.
Please, don't use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 4
Output
3
Input
3
5 3 1
Output
1
Note
In the first sample any pair (i, j) will do, so the answer is 3.
In the second sample only pair (1, 2) will do. | instruction | 0 | 60,055 | 20 | 120,110 |
Tags: implementation, math
Correct Solution:
```
def f(x):
return str(bin(x)).count('1')
n = int(input())
a = list(map(int, input().split()))
ans = [f(x) for x in a]
# print(ans)
s = set(ans)
counts = {x:ans.count(x) for x in s}
# print(counts)
count = 0
for item in counts:
count += (counts[item]*(counts[item]-1))//2
print(count)
``` | output | 1 | 60,055 | 20 | 120,111 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima got into number sequences. Now he's got sequence a1, a2, ..., an, consisting of n positive integers. Also, Dima has got a function f(x), which can be defined with the following recurrence:
* f(0) = 0;
* f(2Β·x) = f(x);
* f(2Β·x + 1) = f(x) + 1.
Dima wonders, how many pairs of indexes (i, j) (1 β€ i < j β€ n) are there, such that f(ai) = f(aj). Help him, count the number of such pairs.
Input
The first line contains integer n (1 β€ n β€ 105). The second line contains n positive integers a1, a2, ..., an (1 β€ ai β€ 109).
The numbers in the lines are separated by single spaces.
Output
In a single line print the answer to the problem.
Please, don't use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 4
Output
3
Input
3
5 3 1
Output
1
Note
In the first sample any pair (i, j) will do, so the answer is 3.
In the second sample only pair (1, 2) will do. | instruction | 0 | 60,056 | 20 | 120,112 |
Tags: implementation, math
Correct Solution:
```
input();res=[0]*(10**5);ans=0;a=list(map(int,input().split()))
for i in a:res[bin(i).count('1')]+=1
for i in range(10**5):ans+=res[i]*(res[i]-1)//2
print(ans)
``` | output | 1 | 60,056 | 20 | 120,113 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima got into number sequences. Now he's got sequence a1, a2, ..., an, consisting of n positive integers. Also, Dima has got a function f(x), which can be defined with the following recurrence:
* f(0) = 0;
* f(2Β·x) = f(x);
* f(2Β·x + 1) = f(x) + 1.
Dima wonders, how many pairs of indexes (i, j) (1 β€ i < j β€ n) are there, such that f(ai) = f(aj). Help him, count the number of such pairs.
Input
The first line contains integer n (1 β€ n β€ 105). The second line contains n positive integers a1, a2, ..., an (1 β€ ai β€ 109).
The numbers in the lines are separated by single spaces.
Output
In a single line print the answer to the problem.
Please, don't use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 4
Output
3
Input
3
5 3 1
Output
1
Note
In the first sample any pair (i, j) will do, so the answer is 3.
In the second sample only pair (1, 2) will do. | instruction | 0 | 60,057 | 20 | 120,114 |
Tags: implementation, math
Correct Solution:
```
def f(x):
return str(bin(x)).count('1')
n = int(input())
a = list(map(int, input().split()))
ans = [f(x) for x in a]
s = set(ans)
counts = {x:ans.count(x) for x in s}
ans = 0
for i in counts:
ans += (counts[i]*(counts[i]-1))//2
print(ans)
``` | output | 1 | 60,057 | 20 | 120,115 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima got into number sequences. Now he's got sequence a1, a2, ..., an, consisting of n positive integers. Also, Dima has got a function f(x), which can be defined with the following recurrence:
* f(0) = 0;
* f(2Β·x) = f(x);
* f(2Β·x + 1) = f(x) + 1.
Dima wonders, how many pairs of indexes (i, j) (1 β€ i < j β€ n) are there, such that f(ai) = f(aj). Help him, count the number of such pairs.
Input
The first line contains integer n (1 β€ n β€ 105). The second line contains n positive integers a1, a2, ..., an (1 β€ ai β€ 109).
The numbers in the lines are separated by single spaces.
Output
In a single line print the answer to the problem.
Please, don't use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 4
Output
3
Input
3
5 3 1
Output
1
Note
In the first sample any pair (i, j) will do, so the answer is 3.
In the second sample only pair (1, 2) will do. | instruction | 0 | 60,058 | 20 | 120,116 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
x=[bin(int(i)).count('1') for i in input().split()]
s=0
for i in range(max(x)+1):
s=s+x.count(i)*(x.count(i)-1)
print(int(s/2))
# Made By Mostafa_Khaled
``` | output | 1 | 60,058 | 20 | 120,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima got into number sequences. Now he's got sequence a1, a2, ..., an, consisting of n positive integers. Also, Dima has got a function f(x), which can be defined with the following recurrence:
* f(0) = 0;
* f(2Β·x) = f(x);
* f(2Β·x + 1) = f(x) + 1.
Dima wonders, how many pairs of indexes (i, j) (1 β€ i < j β€ n) are there, such that f(ai) = f(aj). Help him, count the number of such pairs.
Input
The first line contains integer n (1 β€ n β€ 105). The second line contains n positive integers a1, a2, ..., an (1 β€ ai β€ 109).
The numbers in the lines are separated by single spaces.
Output
In a single line print the answer to the problem.
Please, don't use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 4
Output
3
Input
3
5 3 1
Output
1
Note
In the first sample any pair (i, j) will do, so the answer is 3.
In the second sample only pair (1, 2) will do. | instruction | 0 | 60,059 | 20 | 120,118 |
Tags: implementation, math
Correct Solution:
```
n = int( input() )
a = list( map( int, input().split() ) )
def f( n ):
return ( sum( [ 1 for i in n if i == '1' ] ) )
cnt = {}
for i in range( n ):
tmp = f( bin( a[i] )[2:] )
if tmp not in cnt:
cnt[ tmp ] = 1
else:
cnt[ tmp ] += 1
#print( cnt )
ans = 0
for i in cnt:
ans += int( cnt[i] * ( cnt[i] - 1 ) / 2 )
print( ans )
``` | output | 1 | 60,059 | 20 | 120,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima got into number sequences. Now he's got sequence a1, a2, ..., an, consisting of n positive integers. Also, Dima has got a function f(x), which can be defined with the following recurrence:
* f(0) = 0;
* f(2Β·x) = f(x);
* f(2Β·x + 1) = f(x) + 1.
Dima wonders, how many pairs of indexes (i, j) (1 β€ i < j β€ n) are there, such that f(ai) = f(aj). Help him, count the number of such pairs.
Input
The first line contains integer n (1 β€ n β€ 105). The second line contains n positive integers a1, a2, ..., an (1 β€ ai β€ 109).
The numbers in the lines are separated by single spaces.
Output
In a single line print the answer to the problem.
Please, don't use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 4
Output
3
Input
3
5 3 1
Output
1
Note
In the first sample any pair (i, j) will do, so the answer is 3.
In the second sample only pair (1, 2) will do. | instruction | 0 | 60,060 | 20 | 120,120 |
Tags: implementation, math
Correct Solution:
```
import array
def helper(x):
ret = 0
while x > 0 :
if x % 2 == 0: x //= 2
else:
ret+=1
x //= 2
return ret
n = int(input())
a = list(map(int, input().split()))
d = [0]*10000
for element in a:
res = helper(element)
d[res]+=1
ans = 0
for element in d:
ans += element*(element-1)/2
print(int(ans))
``` | output | 1 | 60,060 | 20 | 120,121 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima got into number sequences. Now he's got sequence a1, a2, ..., an, consisting of n positive integers. Also, Dima has got a function f(x), which can be defined with the following recurrence:
* f(0) = 0;
* f(2Β·x) = f(x);
* f(2Β·x + 1) = f(x) + 1.
Dima wonders, how many pairs of indexes (i, j) (1 β€ i < j β€ n) are there, such that f(ai) = f(aj). Help him, count the number of such pairs.
Input
The first line contains integer n (1 β€ n β€ 105). The second line contains n positive integers a1, a2, ..., an (1 β€ ai β€ 109).
The numbers in the lines are separated by single spaces.
Output
In a single line print the answer to the problem.
Please, don't use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 4
Output
3
Input
3
5 3 1
Output
1
Note
In the first sample any pair (i, j) will do, so the answer is 3.
In the second sample only pair (1, 2) will do. | instruction | 0 | 60,061 | 20 | 120,122 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
p=[int(x) for x in input().split()]
for i in range (0,n):
p[i]=str(bin(p[i])).count('1')
s=set(p)
t=0
for j in s:
t+=p.count(j)*(p.count(j)-1)/2
print(int(t))
``` | output | 1 | 60,061 | 20 | 120,123 |
Provide a correct Python 3 solution for this coding contest problem.
The nth triangular number is defined as the sum of the first n positive integers. The nth tetrahedral number is defined as the sum of the first n triangular numbers. It is easy to show that the nth tetrahedral number is equal to n(n+1)(n+2) β 6. For example, the 5th tetrahedral number is 1+(1+2)+(1+2+3)+(1+2+3+4)+(1+2+3+4+5) = 5Γ6Γ7 β 6 = 35.
The first 5 triangular numbers 1, 3, 6, 10, 15
Tr\[1\] Tr\[2\] Tr\[3\] Tr\[4\] Tr\[5\]
The first 5 tetrahedral numbers 1, 4, 10, 20, 35
Tet\[1\] Tet\[2\] Tet\[3\] Tet\[4\] Tet\[5\]
In 1850, Sir Frederick Pollock, 1st Baronet, who was not a professional mathematician but a British lawyer and Tory (currently known as Conservative) politician, conjectured that every positive integer can be represented as the sum of at most five tetrahedral numbers. Here, a tetrahedral number may occur in the sum more than once and, in such a case, each occurrence is counted separately. The conjecture has been open for more than one and a half century.
Your mission is to write a program to verify Pollock's conjecture for individual integers. Your program should make a calculation of the least number of tetrahedral numbers to represent each input integer as their sum. In addition, for some unknown reason, your program should make a similar calculation with only odd tetrahedral numbers available.
For example, one can represent 40 as the sum of 2 tetrahedral numbers, 4Γ5Γ6 β 6 + 4Γ5Γ6 β 6, but 40 itself is not a tetrahedral number. One can represent 40 as the sum of 6 odd tetrahedral numbers, 5Γ6Γ7 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6, but cannot represent as the sum of fewer odd tetrahedral numbers. Thus, your program should report 2 and 6 if 40 is given.
Input
The input is a sequence of lines each of which contains a single positive integer less than 106. The end of the input is indicated by a line containing a single zero.
Output
For each input positive integer, output a line containing two integers separated by a space. The first integer should be the least number of tetrahedral numbers to represent the input integer as their sum. The second integer should be the least number of odd tetrahedral numbers to represent the input integer as their sum. No extra characters should appear in the output.
Sample Input
40
14
5
165
120
103
106
139
0
Output for the Sample Input
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37
Example
Input
40
14
5
165
120
103
106
139
0
Output
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37 | instruction | 0 | 60,584 | 20 | 121,168 |
"Correct Solution:
```
from collections import defaultdict, deque
sq = [i for i in range(200)]
for i in range(199):
sq[i + 1] += sq[i]
for i in range(199):
sq[i + 1] += sq[i]
ss = []
for s in sq:
if s % 2:
ss.append(s)
dp = defaultdict(lambda: False)
check = defaultdict(lambda: False)
for s in sq:
dp[s] = True
check[s] = True
dps = defaultdict(lambda: False)
checks = defaultdict(lambda: False)
for s in ss:
dps[s] = True
checks[s] = True
def main(n, ss, check, dp):
q = deque()
q.append((n, 1))
check[n] = True
if dp[n]:
return 1
while q:
a, i = q.pop()
for s in ss:
aa = a - s
if aa <= 0:
break
if not check[aa]:
check[aa] = True
q.appendleft((aa, i + 1))
else:
if dp[aa]:
return i + 1
while 1:
n = int(input())
if n == 0:
break
check = defaultdict(lambda: False)
for s in sq:
check[s] = True
checks = defaultdict(lambda: False)
for s in ss:
checks[s] = True
print(main(n, sq, check, dp), main(n, ss, checks,dps))
``` | output | 1 | 60,584 | 20 | 121,169 |
Provide a correct Python 3 solution for this coding contest problem.
The nth triangular number is defined as the sum of the first n positive integers. The nth tetrahedral number is defined as the sum of the first n triangular numbers. It is easy to show that the nth tetrahedral number is equal to n(n+1)(n+2) β 6. For example, the 5th tetrahedral number is 1+(1+2)+(1+2+3)+(1+2+3+4)+(1+2+3+4+5) = 5Γ6Γ7 β 6 = 35.
The first 5 triangular numbers 1, 3, 6, 10, 15
Tr\[1\] Tr\[2\] Tr\[3\] Tr\[4\] Tr\[5\]
The first 5 tetrahedral numbers 1, 4, 10, 20, 35
Tet\[1\] Tet\[2\] Tet\[3\] Tet\[4\] Tet\[5\]
In 1850, Sir Frederick Pollock, 1st Baronet, who was not a professional mathematician but a British lawyer and Tory (currently known as Conservative) politician, conjectured that every positive integer can be represented as the sum of at most five tetrahedral numbers. Here, a tetrahedral number may occur in the sum more than once and, in such a case, each occurrence is counted separately. The conjecture has been open for more than one and a half century.
Your mission is to write a program to verify Pollock's conjecture for individual integers. Your program should make a calculation of the least number of tetrahedral numbers to represent each input integer as their sum. In addition, for some unknown reason, your program should make a similar calculation with only odd tetrahedral numbers available.
For example, one can represent 40 as the sum of 2 tetrahedral numbers, 4Γ5Γ6 β 6 + 4Γ5Γ6 β 6, but 40 itself is not a tetrahedral number. One can represent 40 as the sum of 6 odd tetrahedral numbers, 5Γ6Γ7 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6, but cannot represent as the sum of fewer odd tetrahedral numbers. Thus, your program should report 2 and 6 if 40 is given.
Input
The input is a sequence of lines each of which contains a single positive integer less than 106. The end of the input is indicated by a line containing a single zero.
Output
For each input positive integer, output a line containing two integers separated by a space. The first integer should be the least number of tetrahedral numbers to represent the input integer as their sum. The second integer should be the least number of odd tetrahedral numbers to represent the input integer as their sum. No extra characters should appear in the output.
Sample Input
40
14
5
165
120
103
106
139
0
Output for the Sample Input
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37
Example
Input
40
14
5
165
120
103
106
139
0
Output
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37 | instruction | 0 | 60,585 | 20 | 121,170 |
"Correct Solution:
```
def main():
INIT = 100
query = []
ans = []
while True:
q = int(input())
if q == 0:
break
query.append(q)
MAX = max(query)
table = [INIT] * (MAX + 1)
table[0] = 0
all_item = [i * (i + 1) * (i + 2) // 6 for i in range(1, 181)]
odd_item = [i for i in all_item if i % 2]
eve_item = [i for i in all_item if not i % 2]
for v in odd_item:
for j in range(v, MAX + 1):
tjv = table[j - v]
if table[j] > tjv + 1:
table[j] = tjv + 1
for q in query:
ans.append(table[q])
for v in eve_item:
for j in range(v, MAX + 1):
tjv = table[j - v]
if table[j] > tjv + 1:
table[j] = tjv + 1
for i, q in enumerate(query):
print(table[q], ans[i])
main()
``` | output | 1 | 60,585 | 20 | 121,171 |
Provide a correct Python 3 solution for this coding contest problem.
The nth triangular number is defined as the sum of the first n positive integers. The nth tetrahedral number is defined as the sum of the first n triangular numbers. It is easy to show that the nth tetrahedral number is equal to n(n+1)(n+2) β 6. For example, the 5th tetrahedral number is 1+(1+2)+(1+2+3)+(1+2+3+4)+(1+2+3+4+5) = 5Γ6Γ7 β 6 = 35.
The first 5 triangular numbers 1, 3, 6, 10, 15
Tr\[1\] Tr\[2\] Tr\[3\] Tr\[4\] Tr\[5\]
The first 5 tetrahedral numbers 1, 4, 10, 20, 35
Tet\[1\] Tet\[2\] Tet\[3\] Tet\[4\] Tet\[5\]
In 1850, Sir Frederick Pollock, 1st Baronet, who was not a professional mathematician but a British lawyer and Tory (currently known as Conservative) politician, conjectured that every positive integer can be represented as the sum of at most five tetrahedral numbers. Here, a tetrahedral number may occur in the sum more than once and, in such a case, each occurrence is counted separately. The conjecture has been open for more than one and a half century.
Your mission is to write a program to verify Pollock's conjecture for individual integers. Your program should make a calculation of the least number of tetrahedral numbers to represent each input integer as their sum. In addition, for some unknown reason, your program should make a similar calculation with only odd tetrahedral numbers available.
For example, one can represent 40 as the sum of 2 tetrahedral numbers, 4Γ5Γ6 β 6 + 4Γ5Γ6 β 6, but 40 itself is not a tetrahedral number. One can represent 40 as the sum of 6 odd tetrahedral numbers, 5Γ6Γ7 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6, but cannot represent as the sum of fewer odd tetrahedral numbers. Thus, your program should report 2 and 6 if 40 is given.
Input
The input is a sequence of lines each of which contains a single positive integer less than 106. The end of the input is indicated by a line containing a single zero.
Output
For each input positive integer, output a line containing two integers separated by a space. The first integer should be the least number of tetrahedral numbers to represent the input integer as their sum. The second integer should be the least number of odd tetrahedral numbers to represent the input integer as their sum. No extra characters should appear in the output.
Sample Input
40
14
5
165
120
103
106
139
0
Output for the Sample Input
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37
Example
Input
40
14
5
165
120
103
106
139
0
Output
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37 | instruction | 0 | 60,586 | 20 | 121,172 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: print('Yes' if b else 'No')
YESNO=lambda b: print('YES' if b else 'NO')
def main():
Q=[]
while True:
N=int(input())
if N==0:
break
Q.append(N)
MAX_Q=max(Q)
A=tuple((i+1)*(i+2)*(i+3)//6 for i in range(182))
A_odd=tuple(i for i in A if i%2)
A_even=tuple(i for i in A if i%2==0)
dp=[INF]*(MAX_Q+1)
dp[0]=0
for x in A_odd:
for k in range(x,MAX_Q+1):
if dp[k]>dp[k-x]+1:
dp[k]=dp[k-x]+1
ans=[]
for q in Q:
ans.append(dp[q])
for x in A_even:
for k in range(x,MAX_Q+1):
dp[k]=min(dp[k],dp[k-x]+1)
for i,q in enumerate(Q):
print(dp[q],ans[i])
if __name__ == '__main__':
main()
``` | output | 1 | 60,586 | 20 | 121,173 |
Provide a correct Python 3 solution for this coding contest problem.
The nth triangular number is defined as the sum of the first n positive integers. The nth tetrahedral number is defined as the sum of the first n triangular numbers. It is easy to show that the nth tetrahedral number is equal to n(n+1)(n+2) β 6. For example, the 5th tetrahedral number is 1+(1+2)+(1+2+3)+(1+2+3+4)+(1+2+3+4+5) = 5Γ6Γ7 β 6 = 35.
The first 5 triangular numbers 1, 3, 6, 10, 15
Tr\[1\] Tr\[2\] Tr\[3\] Tr\[4\] Tr\[5\]
The first 5 tetrahedral numbers 1, 4, 10, 20, 35
Tet\[1\] Tet\[2\] Tet\[3\] Tet\[4\] Tet\[5\]
In 1850, Sir Frederick Pollock, 1st Baronet, who was not a professional mathematician but a British lawyer and Tory (currently known as Conservative) politician, conjectured that every positive integer can be represented as the sum of at most five tetrahedral numbers. Here, a tetrahedral number may occur in the sum more than once and, in such a case, each occurrence is counted separately. The conjecture has been open for more than one and a half century.
Your mission is to write a program to verify Pollock's conjecture for individual integers. Your program should make a calculation of the least number of tetrahedral numbers to represent each input integer as their sum. In addition, for some unknown reason, your program should make a similar calculation with only odd tetrahedral numbers available.
For example, one can represent 40 as the sum of 2 tetrahedral numbers, 4Γ5Γ6 β 6 + 4Γ5Γ6 β 6, but 40 itself is not a tetrahedral number. One can represent 40 as the sum of 6 odd tetrahedral numbers, 5Γ6Γ7 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6, but cannot represent as the sum of fewer odd tetrahedral numbers. Thus, your program should report 2 and 6 if 40 is given.
Input
The input is a sequence of lines each of which contains a single positive integer less than 106. The end of the input is indicated by a line containing a single zero.
Output
For each input positive integer, output a line containing two integers separated by a space. The first integer should be the least number of tetrahedral numbers to represent the input integer as their sum. The second integer should be the least number of odd tetrahedral numbers to represent the input integer as their sum. No extra characters should appear in the output.
Sample Input
40
14
5
165
120
103
106
139
0
Output for the Sample Input
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37
Example
Input
40
14
5
165
120
103
106
139
0
Output
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37 | instruction | 0 | 60,587 | 20 | 121,174 |
"Correct Solution:
```
def main():
INIT = 100
query = []
ans = []
while True:
q = int(input())
if q == 0:
break
query.append(q)
MAX = max(query)
table = [INIT] * (MAX + 1)
table[0] = 0
all_item = [i * (i + 1) * (i + 2) // 6 for i in range(1, 181)]
odd_item = [i for i in all_item if i % 2]
eve_item = [i for i in all_item if not i % 2]
for v in odd_item:
for j in range(v, MAX + 1):
tjv = table[j - v]
if table[j] > tjv + 1:
table[j] = tjv + 1
for q in query:
ans.append(table[q])
for v in eve_item:
for j in range(v, MAX + 1):
tjv = table[j - v]
if tjv < 5 and table[j] > tjv + 1:
table[j] = tjv + 1
for i, q in enumerate(query):
print(table[q], ans[i])
main()
``` | output | 1 | 60,587 | 20 | 121,175 |
Provide a correct Python 3 solution for this coding contest problem.
The nth triangular number is defined as the sum of the first n positive integers. The nth tetrahedral number is defined as the sum of the first n triangular numbers. It is easy to show that the nth tetrahedral number is equal to n(n+1)(n+2) β 6. For example, the 5th tetrahedral number is 1+(1+2)+(1+2+3)+(1+2+3+4)+(1+2+3+4+5) = 5Γ6Γ7 β 6 = 35.
The first 5 triangular numbers 1, 3, 6, 10, 15
Tr\[1\] Tr\[2\] Tr\[3\] Tr\[4\] Tr\[5\]
The first 5 tetrahedral numbers 1, 4, 10, 20, 35
Tet\[1\] Tet\[2\] Tet\[3\] Tet\[4\] Tet\[5\]
In 1850, Sir Frederick Pollock, 1st Baronet, who was not a professional mathematician but a British lawyer and Tory (currently known as Conservative) politician, conjectured that every positive integer can be represented as the sum of at most five tetrahedral numbers. Here, a tetrahedral number may occur in the sum more than once and, in such a case, each occurrence is counted separately. The conjecture has been open for more than one and a half century.
Your mission is to write a program to verify Pollock's conjecture for individual integers. Your program should make a calculation of the least number of tetrahedral numbers to represent each input integer as their sum. In addition, for some unknown reason, your program should make a similar calculation with only odd tetrahedral numbers available.
For example, one can represent 40 as the sum of 2 tetrahedral numbers, 4Γ5Γ6 β 6 + 4Γ5Γ6 β 6, but 40 itself is not a tetrahedral number. One can represent 40 as the sum of 6 odd tetrahedral numbers, 5Γ6Γ7 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6, but cannot represent as the sum of fewer odd tetrahedral numbers. Thus, your program should report 2 and 6 if 40 is given.
Input
The input is a sequence of lines each of which contains a single positive integer less than 106. The end of the input is indicated by a line containing a single zero.
Output
For each input positive integer, output a line containing two integers separated by a space. The first integer should be the least number of tetrahedral numbers to represent the input integer as their sum. The second integer should be the least number of odd tetrahedral numbers to represent the input integer as their sum. No extra characters should appear in the output.
Sample Input
40
14
5
165
120
103
106
139
0
Output for the Sample Input
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37
Example
Input
40
14
5
165
120
103
106
139
0
Output
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37 | instruction | 0 | 60,588 | 20 | 121,176 |
"Correct Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip()
def resolve():
tetrahedral_num = [i*(i+1)*(i+2)//6 for i in range(1, 201)]
tetrahedral_num_odd = [i for i in tetrahedral_num if i%2==1]
n = []
while True:
tmp = int(input())
if tmp==0:
break
else:
n.append(tmp)
max_n = max(n)
# dp[i]: ζ°iγζ§ζγγζε°εζ°
dp = [float('inf')]*(max_n+1)
dp[0] = 0
for i in range(1, max_n+1):
tmp = []
for j in tetrahedral_num:
if i-j>=0:
tmp.append(dp[i-j])
dp[i] = min(tmp) + 1
dp_odd = [float('inf')]*(max_n+1)
dp_odd[0] = 0
for i in range(1, max_n+1):
tmp = []
for j in tetrahedral_num_odd:
if i-j>=0:
tmp.append(dp_odd[i-j])
dp_odd[i] = min(tmp) + 1
for i in n:
print(dp[i], dp_odd[i])
if __name__ == '__main__':
resolve()
``` | output | 1 | 60,588 | 20 | 121,177 |
Provide a correct Python 3 solution for this coding contest problem.
The nth triangular number is defined as the sum of the first n positive integers. The nth tetrahedral number is defined as the sum of the first n triangular numbers. It is easy to show that the nth tetrahedral number is equal to n(n+1)(n+2) β 6. For example, the 5th tetrahedral number is 1+(1+2)+(1+2+3)+(1+2+3+4)+(1+2+3+4+5) = 5Γ6Γ7 β 6 = 35.
The first 5 triangular numbers 1, 3, 6, 10, 15
Tr\[1\] Tr\[2\] Tr\[3\] Tr\[4\] Tr\[5\]
The first 5 tetrahedral numbers 1, 4, 10, 20, 35
Tet\[1\] Tet\[2\] Tet\[3\] Tet\[4\] Tet\[5\]
In 1850, Sir Frederick Pollock, 1st Baronet, who was not a professional mathematician but a British lawyer and Tory (currently known as Conservative) politician, conjectured that every positive integer can be represented as the sum of at most five tetrahedral numbers. Here, a tetrahedral number may occur in the sum more than once and, in such a case, each occurrence is counted separately. The conjecture has been open for more than one and a half century.
Your mission is to write a program to verify Pollock's conjecture for individual integers. Your program should make a calculation of the least number of tetrahedral numbers to represent each input integer as their sum. In addition, for some unknown reason, your program should make a similar calculation with only odd tetrahedral numbers available.
For example, one can represent 40 as the sum of 2 tetrahedral numbers, 4Γ5Γ6 β 6 + 4Γ5Γ6 β 6, but 40 itself is not a tetrahedral number. One can represent 40 as the sum of 6 odd tetrahedral numbers, 5Γ6Γ7 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6, but cannot represent as the sum of fewer odd tetrahedral numbers. Thus, your program should report 2 and 6 if 40 is given.
Input
The input is a sequence of lines each of which contains a single positive integer less than 106. The end of the input is indicated by a line containing a single zero.
Output
For each input positive integer, output a line containing two integers separated by a space. The first integer should be the least number of tetrahedral numbers to represent the input integer as their sum. The second integer should be the least number of odd tetrahedral numbers to represent the input integer as their sum. No extra characters should appear in the output.
Sample Input
40
14
5
165
120
103
106
139
0
Output for the Sample Input
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37
Example
Input
40
14
5
165
120
103
106
139
0
Output
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37 | instruction | 0 | 60,589 | 20 | 121,178 |
"Correct Solution:
```
import copy
item = [i *(i +1) * (i+2) //6 for i in range(1,181)]
q = []
while True:
in_ = int(input())
if in_ == 0:
break
q.append(in_)
INIT = 1000
MAX = max(q) +10
ans = [INIT] *MAX
ans[0] = 0
odd_item = [i for i in item if i % 2 ==0 ]
even_item = [i for i in item if not(i % 2 == 0)]
for i in even_item:
for j in range(0,MAX-i):
if ans[j+i] > ans[j] + 1:
ans[j+i] = ans[j] + 1
ans_ = copy.deepcopy(ans)
for i in odd_item:
for j in range(0,MAX-i):
if ans[j+i] > ans[j] + 1:
ans[j+i] = ans[j]+1
for i in q:
print(ans[i],ans_[i])
``` | output | 1 | 60,589 | 20 | 121,179 |
Provide a correct Python 3 solution for this coding contest problem.
The nth triangular number is defined as the sum of the first n positive integers. The nth tetrahedral number is defined as the sum of the first n triangular numbers. It is easy to show that the nth tetrahedral number is equal to n(n+1)(n+2) β 6. For example, the 5th tetrahedral number is 1+(1+2)+(1+2+3)+(1+2+3+4)+(1+2+3+4+5) = 5Γ6Γ7 β 6 = 35.
The first 5 triangular numbers 1, 3, 6, 10, 15
Tr\[1\] Tr\[2\] Tr\[3\] Tr\[4\] Tr\[5\]
The first 5 tetrahedral numbers 1, 4, 10, 20, 35
Tet\[1\] Tet\[2\] Tet\[3\] Tet\[4\] Tet\[5\]
In 1850, Sir Frederick Pollock, 1st Baronet, who was not a professional mathematician but a British lawyer and Tory (currently known as Conservative) politician, conjectured that every positive integer can be represented as the sum of at most five tetrahedral numbers. Here, a tetrahedral number may occur in the sum more than once and, in such a case, each occurrence is counted separately. The conjecture has been open for more than one and a half century.
Your mission is to write a program to verify Pollock's conjecture for individual integers. Your program should make a calculation of the least number of tetrahedral numbers to represent each input integer as their sum. In addition, for some unknown reason, your program should make a similar calculation with only odd tetrahedral numbers available.
For example, one can represent 40 as the sum of 2 tetrahedral numbers, 4Γ5Γ6 β 6 + 4Γ5Γ6 β 6, but 40 itself is not a tetrahedral number. One can represent 40 as the sum of 6 odd tetrahedral numbers, 5Γ6Γ7 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6, but cannot represent as the sum of fewer odd tetrahedral numbers. Thus, your program should report 2 and 6 if 40 is given.
Input
The input is a sequence of lines each of which contains a single positive integer less than 106. The end of the input is indicated by a line containing a single zero.
Output
For each input positive integer, output a line containing two integers separated by a space. The first integer should be the least number of tetrahedral numbers to represent the input integer as their sum. The second integer should be the least number of odd tetrahedral numbers to represent the input integer as their sum. No extra characters should appear in the output.
Sample Input
40
14
5
165
120
103
106
139
0
Output for the Sample Input
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37
Example
Input
40
14
5
165
120
103
106
139
0
Output
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37 | instruction | 0 | 60,590 | 20 | 121,180 |
"Correct Solution:
```
# https://onlinejudge.u-aizu.ac.jp/problems/1167
def porok(n):
return n * (n+1) * (n+2) // 6
def dp_1(n):
for j in poroks_odd:
for i in range(j, n+1):
tmp = dp[i-j] + 1
if dp[i-j] + 1 < dp[i]:
dp[i] = dp[i-j] + 1
def dp_2(n):
for j in poroks_even:
for i in range(j, n+1):
tmp = dp[i-j] + 1
if dp[i-j] + 1 < dp[i]:
dp[i] = dp[i-j] + 1
if __name__ == "__main__":
query_list = []
ans_even = []
while(True):
n = int(input())
if n == 0:
break
query_list.append(n)
poroks = [i * (i + 1) * (i + 2) // 6 for i in range(1, 181)]
poroks_odd = [
porok_number for porok_number in poroks if porok_number % 2 == 1]
poroks_even = [
porok_number for porok_number in poroks if porok_number % 2 == 0]
dp = [100] * (max(query_list)+1)
dp[0] = 0
dp_1(max(query_list))
for q in query_list:
ans_even.append(dp[q])
dp_2(max(query_list))
for i, q in enumerate(query_list):
print('{} {}'.format(dp[q], ans_even[i]))
``` | output | 1 | 60,590 | 20 | 121,181 |
Provide a correct Python 3 solution for this coding contest problem.
The nth triangular number is defined as the sum of the first n positive integers. The nth tetrahedral number is defined as the sum of the first n triangular numbers. It is easy to show that the nth tetrahedral number is equal to n(n+1)(n+2) β 6. For example, the 5th tetrahedral number is 1+(1+2)+(1+2+3)+(1+2+3+4)+(1+2+3+4+5) = 5Γ6Γ7 β 6 = 35.
The first 5 triangular numbers 1, 3, 6, 10, 15
Tr\[1\] Tr\[2\] Tr\[3\] Tr\[4\] Tr\[5\]
The first 5 tetrahedral numbers 1, 4, 10, 20, 35
Tet\[1\] Tet\[2\] Tet\[3\] Tet\[4\] Tet\[5\]
In 1850, Sir Frederick Pollock, 1st Baronet, who was not a professional mathematician but a British lawyer and Tory (currently known as Conservative) politician, conjectured that every positive integer can be represented as the sum of at most five tetrahedral numbers. Here, a tetrahedral number may occur in the sum more than once and, in such a case, each occurrence is counted separately. The conjecture has been open for more than one and a half century.
Your mission is to write a program to verify Pollock's conjecture for individual integers. Your program should make a calculation of the least number of tetrahedral numbers to represent each input integer as their sum. In addition, for some unknown reason, your program should make a similar calculation with only odd tetrahedral numbers available.
For example, one can represent 40 as the sum of 2 tetrahedral numbers, 4Γ5Γ6 β 6 + 4Γ5Γ6 β 6, but 40 itself is not a tetrahedral number. One can represent 40 as the sum of 6 odd tetrahedral numbers, 5Γ6Γ7 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6, but cannot represent as the sum of fewer odd tetrahedral numbers. Thus, your program should report 2 and 6 if 40 is given.
Input
The input is a sequence of lines each of which contains a single positive integer less than 106. The end of the input is indicated by a line containing a single zero.
Output
For each input positive integer, output a line containing two integers separated by a space. The first integer should be the least number of tetrahedral numbers to represent the input integer as their sum. The second integer should be the least number of odd tetrahedral numbers to represent the input integer as their sum. No extra characters should appear in the output.
Sample Input
40
14
5
165
120
103
106
139
0
Output for the Sample Input
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37
Example
Input
40
14
5
165
120
103
106
139
0
Output
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37 | instruction | 0 | 60,591 | 20 | 121,182 |
"Correct Solution:
```
n=1000001
i=1
p=[]
po=[]
nn=1
while nn<n:
p.append(nn)
if nn%2==1:
po.append(nn)
i+=1
nn= i*(i+1)*(i+2)//6
np=len(p)
npo=len(po)
pp=[]
def dpf(nn,pp,nnp):
dpm=[i for i in range(nn+1)]
for ppi in pp[1:nnp]:
if ppi>nn:
break
for j in range(ppi,nn+1):
dpij=1+dpm[j-ppi]
if j>=ppi and dpm[j]>dpij:
dpm[j]=dpij
# print("i",i,"dpm:",dpm)
return dpm
nlist=[]
while True:
n=int(input())
if n==0:
break
else:
nlist.append(n)
nmax=max(nlist)
dpm1=dpf(nmax,p,np)
dpm2=dpf(nmax,po,npo)
for i in nlist:
print(dpm1[i],dpm2[i])
``` | output | 1 | 60,591 | 20 | 121,183 |
Provide a correct Python 3 solution for this coding contest problem.
D: Many Decimal Integers
problem
Given a string S consisting only of numbers (0-9) and a string T consisting only of numbers and `?`. S and T are the same length.
Consider changing each `?` That exists in T to one of the numbers from 0 to 9 to create the string T'consisting of only numbers. At this time, it must be f (T') \ leq f (S). Where f (t) is a function that returns an integer value when the string t is read as a decimal number. Also, the number in the most significant digit of T'may be 0.
For all possible strings T', find the remainder of the sum of the values ββof f (T') divided by 10 ^ 9 + 7. If there is no T'that meets the conditions, answer 0.
Input format
S
T
Constraint
* 1 \ leq | S | = | T | \ leq 2 \ times 10 ^ 5
* S is a string consisting only of numbers (0 to 9)
* T is a string consisting only of numbers and `?`
Output format
Divide the sum of T's that satisfy the condition by 10 ^ 9 + 7 and output the remainder on one line.
Input example 1
73
6?
Output example 1
645
There are 10 possible strings for T', from 60 to 69. The sum of these is 645.
Input example 2
42
? 1
Output example 2
105
The number in the most significant digit of T'can be 0, so 01 also satisfies the condition.
Input example 3
1730597319
16 ?? 35 ?? 8?
Output example 3
502295105
Find the remainder divided by 10 ^ 9 + 7.
Example
Input
73
6?
Output
645 | instruction | 0 | 60,603 | 20 | 121,206 |
"Correct Solution:
```
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
s = list(map(int, input()))
t = list(input())
n = len(t)
for i in range(n):
if t[i].isdecimal():
t[i] = int(t[i])
dp = [[[0]*2 for j in range(2)] for i in range(n+1)]
dp[0][0] = [1,0]
p = [pow(10,i,mod) for i in range(n)]
for i in range(n):
ni = i+1
for j in range(2):
if t[i] == "?":
x = 9 if j else s[i]
for d in range(x+1):
nj = j|(d < s[i])
dp[ni][nj][0] += dp[i][j][0]
dp[ni][nj][1] += dp[i][j][0]*d+10*dp[i][j][1]
dp[ni][nj][0] %= mod
dp[ni][nj][1] %= mod
else:
d = t[i]
nj = j|(d < s[i])
if d <= s[i]:
dp[ni][nj][0] += dp[i][j][0]
dp[ni][nj][1] += dp[i][j][0]*d+10*dp[i][j][1]
dp[ni][nj][0] %= mod
dp[ni][nj][1] %= mod
else:
if nj:
dp[ni][nj][0] += dp[i][j][0]
dp[ni][nj][1] += dp[i][j][0]*d+10*dp[i][j][1]
dp[ni][nj][0] %= mod
dp[ni][nj][1] %= mod
print((dp[-1][0][1]+dp[-1][1][1])%mod)
return
if __name__ == "__main__":
solve()
``` | output | 1 | 60,603 | 20 | 121,207 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-negative integer n, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes.
Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits.
If a solution exists, you should print it.
Input
The single line of the input contains a non-negative integer n. The representation of number n doesn't contain any leading zeroes and its length doesn't exceed 100 digits.
Output
Print "NO" (without quotes), if there is no such way to remove some digits from number n.
Otherwise, print "YES" in the first line and the resulting number after removing digits from number n in the second line. The printed number must be divisible by 8.
If there are multiple possible answers, you may print any of them.
Examples
Input
3454
Output
YES
344
Input
10
Output
YES
0
Input
111111
Output
NO | instruction | 0 | 61,091 | 20 | 122,182 |
Tags: brute force, dp, math
Correct Solution:
```
z,zz=input,lambda:list(map(int,z().split()))
zzz=lambda:[int(i) for i in stdin.readline().split()]
szz,graph,mod,szzz=lambda:sorted(zz()),{},10**9+7,lambda:sorted(zzz())
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac
def lcd(xnum1,xnum2):return (xnum1*xnum2//gcd(xnum1,xnum2))
def prime(x):
p=ceil(x**.5)+1
for i in range(2,p):
if (x%i==0 and x!=2) or x==0:return 0
return 1
def dfs(u,visit,graph):
visit[u]=True
for i in graph[u]:
if not visit[i]:
dfs(i,visit,graph)
###########################---Test-Case---#################################
"""
"""
###########################---START-CODING---##############################
n=list(z())
for i in range(0,1001,8):
t=list(str(i))
k=0
c=0
for j in n:
if t[k]==j:
k+=1
c+=1
k=min(len(t)-1,k)
if c>=len(t):
print('YES')
print(i)
exit()
print('NO')
``` | output | 1 | 61,091 | 20 | 122,183 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-negative integer n, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes.
Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits.
If a solution exists, you should print it.
Input
The single line of the input contains a non-negative integer n. The representation of number n doesn't contain any leading zeroes and its length doesn't exceed 100 digits.
Output
Print "NO" (without quotes), if there is no such way to remove some digits from number n.
Otherwise, print "YES" in the first line and the resulting number after removing digits from number n in the second line. The printed number must be divisible by 8.
If there are multiple possible answers, you may print any of them.
Examples
Input
3454
Output
YES
344
Input
10
Output
YES
0
Input
111111
Output
NO | instruction | 0 | 61,092 | 20 | 122,184 |
Tags: brute force, dp, math
Correct Solution:
```
s=input()
n=len(s)
if n>2:
for x in range(n):
if int(s[x])%8==0:
print("YES")
print(s[x])
break
else:
pass
if int(s[x])%8==0:
pass
else:
for x in range(n-1):
for y in range(x+1,n):
m=int(s[x]+s[y])
if m%8==0:
print("YES")
print(m)
break
else:
pass
if m%8==0:
break
else:
pass
if m%8==0:
pass
else:
for x in range(n-2):
for y in range(x+1,n-1):
for z in range(y+1,n):
m=int(s[x]+s[y]+s[z])
if m%8==0:
print("YES")
print(s[x]+s[y]+s[z])
break
elif m%8!=0 and x!=n-3:
pass
else:
print("NO")
if m%8==0:
break
else:
pass
if m%8==0:
break
else:
pass
elif n==2:
if int(s)%8==0:
print("YES")
print(s)
else:
if int(s[0])%8==0:
print("YES")
print(s[0])
else:
if int(s[1])%8==0:
print("YES")
print(s[1])
else:
print("NO")
else:
if int(s)%8==0:
print("YES")
print(s)
else:
print("NO")
``` | output | 1 | 61,092 | 20 | 122,185 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-negative integer n, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes.
Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits.
If a solution exists, you should print it.
Input
The single line of the input contains a non-negative integer n. The representation of number n doesn't contain any leading zeroes and its length doesn't exceed 100 digits.
Output
Print "NO" (without quotes), if there is no such way to remove some digits from number n.
Otherwise, print "YES" in the first line and the resulting number after removing digits from number n in the second line. The printed number must be divisible by 8.
If there are multiple possible answers, you may print any of them.
Examples
Input
3454
Output
YES
344
Input
10
Output
YES
0
Input
111111
Output
NO | instruction | 0 | 61,093 | 20 | 122,186 |
Tags: brute force, dp, math
Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
s = S()
l = len(s)
for i in range(l):
si = s[i]
if int(si) % 8 == 0:
return 'YES\n{}'.format(si)
for j in range(i+1,l):
sj = si + s[j]
if int(sj) % 8 == 0:
return 'YES\n{}'.format(sj)
for k in range(j+1,l):
sk = sj + s[k]
if int(sk) % 8 == 0:
return 'YES\n{}'.format(sk)
return 'NO'
print(main())
``` | output | 1 | 61,093 | 20 | 122,187 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-negative integer n, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes.
Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits.
If a solution exists, you should print it.
Input
The single line of the input contains a non-negative integer n. The representation of number n doesn't contain any leading zeroes and its length doesn't exceed 100 digits.
Output
Print "NO" (without quotes), if there is no such way to remove some digits from number n.
Otherwise, print "YES" in the first line and the resulting number after removing digits from number n in the second line. The printed number must be divisible by 8.
If there are multiple possible answers, you may print any of them.
Examples
Input
3454
Output
YES
344
Input
10
Output
YES
0
Input
111111
Output
NO | instruction | 0 | 61,094 | 20 | 122,188 |
Tags: brute force, dp, math
Correct Solution:
```
from itertools import combinations
# input 6 digit
def eight_divisibility(num, no_leading=False):
if no_leading:
comb = combinations(num, 1)
for c in comb:
cc = ''.join(i for i in c)
N = int(cc)
if N % 8 == 0:
return cc
comb = combinations(num, 2)
for c in comb:
cc = ''.join(i for i in c)
N = int(cc)
if N % 8 == 0:
return cc
comb = combinations(num, 3)
for c in comb:
cc = ''.join(i for i in c)
N = int(cc)
if N % 8 == 0:
return cc
return None
def answer(num=None):
if num:
print("YES")
print(num)
else:
print("NO")
if __name__ == '__main__':
n = input()
while len(n) > 6:
res = eight_divisibility(n[-5:])
if res:
n = n[:-5]
n = n + res
answer(n)
exit(0)
else:
n = n[:-1]
res = eight_divisibility(n, no_leading=True)
answer(res)
``` | output | 1 | 61,094 | 20 | 122,189 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-negative integer n, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes.
Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits.
If a solution exists, you should print it.
Input
The single line of the input contains a non-negative integer n. The representation of number n doesn't contain any leading zeroes and its length doesn't exceed 100 digits.
Output
Print "NO" (without quotes), if there is no such way to remove some digits from number n.
Otherwise, print "YES" in the first line and the resulting number after removing digits from number n in the second line. The printed number must be divisible by 8.
If there are multiple possible answers, you may print any of them.
Examples
Input
3454
Output
YES
344
Input
10
Output
YES
0
Input
111111
Output
NO | instruction | 0 | 61,095 | 20 | 122,190 |
Tags: brute force, dp, math
Correct Solution:
```
# # non 100**3 solution
# a=[]
# for i in range(1000):
# if(i%8==0):
# arr=[0]*10
# x=list(map(int,list(str(i))))
# for j in x:
# arr[j-1]+=1
# a.append(arr)
# # print(len(str(100)))
# print(a)
# print(len(a))
# n=list(map(int,list(input())))
# carr=[0]*10
# for i in n:
# carr[i-1]+=1
#normal solution
f=1
n=list(map(int,list(input())))
n=[0]+[0]+n
# print(n)
for i in range(len(n)):
for j in range(i+1,len(n)):
for k in range(j+1,len(n)):
# if(i==j or j==k or k==i):
# continue
# else:
# if()
# print(int(n[i]+n[j]+n[k]))
if((n[i]*100+n[j]*10+n[k])%8==0 and f):
print("YES")
f=0
print((n[i]*100+n[j]*10+n[k]))
break
if(f):
print("NO")
``` | output | 1 | 61,095 | 20 | 122,191 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-negative integer n, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes.
Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits.
If a solution exists, you should print it.
Input
The single line of the input contains a non-negative integer n. The representation of number n doesn't contain any leading zeroes and its length doesn't exceed 100 digits.
Output
Print "NO" (without quotes), if there is no such way to remove some digits from number n.
Otherwise, print "YES" in the first line and the resulting number after removing digits from number n in the second line. The printed number must be divisible by 8.
If there are multiple possible answers, you may print any of them.
Examples
Input
3454
Output
YES
344
Input
10
Output
YES
0
Input
111111
Output
NO | instruction | 0 | 61,096 | 20 | 122,192 |
Tags: brute force, dp, math
Correct Solution:
```
from itertools import combinations
n=input()
if '8' in n:
print('YES')
print(8)
elif '0' in n:
print('YES')
print(0)
else:
a=list(combinations(n,2))+list(combinations(n,3))
res=-1
for x in a:
num=int(''.join(x))
if num%8==0:
res=num
break
if res==-1:
print('NO')
else:
print('YES')
print(res)
``` | output | 1 | 61,096 | 20 | 122,193 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-negative integer n, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes.
Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits.
If a solution exists, you should print it.
Input
The single line of the input contains a non-negative integer n. The representation of number n doesn't contain any leading zeroes and its length doesn't exceed 100 digits.
Output
Print "NO" (without quotes), if there is no such way to remove some digits from number n.
Otherwise, print "YES" in the first line and the resulting number after removing digits from number n in the second line. The printed number must be divisible by 8.
If there are multiple possible answers, you may print any of them.
Examples
Input
3454
Output
YES
344
Input
10
Output
YES
0
Input
111111
Output
NO | instruction | 0 | 61,097 | 20 | 122,194 |
Tags: brute force, dp, math
Correct Solution:
```
n=[char for char in str(input())]
n.reverse()
p = len(n)
d_by_eight = []
for i in range(125):
d_by_eight.append(str(8*i))
for num in d_by_eight:
num_copy = num
num = [char for char in num]
num.reverse()
length = len(num) # num of digits
n_index = 0
int_index = 0
while True:
if int_index == length:
print("YES\n" + num_copy)
exit()
if n_index == p:
break
if n[n_index] == num[int_index]:
n_index += 1
int_index += 1
else:
n_index += 1
print("NO")
``` | output | 1 | 61,097 | 20 | 122,195 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-negative integer n, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes.
Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits.
If a solution exists, you should print it.
Input
The single line of the input contains a non-negative integer n. The representation of number n doesn't contain any leading zeroes and its length doesn't exceed 100 digits.
Output
Print "NO" (without quotes), if there is no such way to remove some digits from number n.
Otherwise, print "YES" in the first line and the resulting number after removing digits from number n in the second line. The printed number must be divisible by 8.
If there are multiple possible answers, you may print any of them.
Examples
Input
3454
Output
YES
344
Input
10
Output
YES
0
Input
111111
Output
NO | instruction | 0 | 61,098 | 20 | 122,196 |
Tags: brute force, dp, math
Correct Solution:
```
def solve(n):
l = len(n)
for i in range(l):
c = n[i]
if c % 8 == 0: return c
for j in range(i + 1, l):
c = n[i]*10 + n[j]
if c % 8 == 0: return c
for k in range(j + 1, l):
c = n[i]*100 + n[j]*10 + n[k]
if c % 8 == 0: return c
def main():
n = list(map(int, input()))
x = solve(n)
if isinstance(x, int):
print("YES", x, sep='\n')
else:
print("NO")
main()
``` | output | 1 | 61,098 | 20 | 122,197 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-negative integer n, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes.
Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits.
If a solution exists, you should print it.
Input
The single line of the input contains a non-negative integer n. The representation of number n doesn't contain any leading zeroes and its length doesn't exceed 100 digits.
Output
Print "NO" (without quotes), if there is no such way to remove some digits from number n.
Otherwise, print "YES" in the first line and the resulting number after removing digits from number n in the second line. The printed number must be divisible by 8.
If there are multiple possible answers, you may print any of them.
Examples
Input
3454
Output
YES
344
Input
10
Output
YES
0
Input
111111
Output
NO
Submitted Solution:
```
n = input()
n = n[::-1]
sol = 0
found = False
for i in range(len(n)-2):
for j in range(i+1, len(n)-1):
for k in range(j+1, len(n)):
if int(n[k] + n[j] + n[i])%8 == 0:
sol = str(int(n[k] + n[j] + n[i]))
found = True
break
if found:
break
if found:
break
if found:
print("YES\n" + sol)
else:
for i in range(len(n)-1):
for j in range(i+1, len(n)):
if int(n[j] + n[i])%8 == 0:
sol = str(int(n[j] + n[i]))
found = True
break
if found:
break
if found:
print("YES\n"+sol)
else:
for i in n:
if int(i) == 8 or int(i) == 0:
sol = i
found = True
break
if found:
print("YES\n" + sol)
else:
print("NO")
``` | instruction | 0 | 61,099 | 20 | 122,198 |
Yes | output | 1 | 61,099 | 20 | 122,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.