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.
You are given two integers l and r (l β€ r). Your task is to calculate the sum of numbers from l to r (including l and r) such that each number contains at most k different digits, and print this sum modulo 998244353.
For example, if k = 1 then you have to calculate all numbers from l to r such that each number is formed using only one digit. For l = 10, r = 50 the answer is 11 + 22 + 33 + 44 = 110.
Input
The only line of the input contains three integers l, r and k (1 β€ l β€ r < 10^{18}, 1 β€ k β€ 10) β the borders of the segment and the maximum number of different digits.
Output
Print one integer β the sum of numbers from l to r such that each number contains at most k different digits, modulo 998244353.
Examples
Input
10 50 2
Output
1230
Input
1 2345 10
Output
2750685
Input
101 154 2
Output
2189
Note
For the first example the answer is just the sum of numbers from l to r which equals to (50 β
51)/(2) - (9 β
10)/(2) = 1230. This example also explained in the problem statement but for k = 1.
For the second example the answer is just the sum of numbers from l to r which equals to (2345 β
2346)/(2) = 2750685.
For the third example the answer is 101 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 121 + 122 + 131 + 133 + 141 + 144 + 151 = 2189. | instruction | 0 | 37 | 20 | 74 |
Tags: bitmasks, combinatorics, dp, math
Correct Solution:
```
MOD = 998244353
def pop_count(x) :
ans = 0
while (x > 0) :
ans = ans + x % 2
x = x // 2
return ans
def check(x, k) :
mask = 0
nx = int(x)
while (nx > 0) :
mask = mask | (1 << (nx % 10))
nx = nx // 10
if (pop_count(mask) <= k) :
return x
return 0
pop = []
p10 = []
f = [[0 for j in range(1 << 10)] for i in range(20)]
w = [[0 for j in range(1 << 10)] for i in range(20)]
def prepare() :
p10.append(1)
for i in range(20) :
p10.append(p10[i] * 10 % MOD)
for i in range(1 << 10) :
pop.append(pop_count(i))
w[0][0] = 1
for i in range(1, 20) :
for j in range(1 << 10) :
for use in range(10) :
w[i][j | (1 << use)] = (w[i][j | (1 << use)] + w[i - 1][j]) % MOD
f[i][j | (1 << use)] = (f[i][j | (1 << use)] + w[i - 1][j] * use * p10[i - 1] + f[i - 1][j]) % MOD
def solve(x, k) :
sx = [int(d) for d in str(x)]
n = len(sx)
ans = 0
for i in range(1, n) :
for use in range(1, 10) :
for mask in range(1 << 10) :
if (pop[(1 << use) | mask] <= k) :
ans = (ans + f[i - 1][mask] + use * w[i - 1][mask] % MOD * p10[i - 1]) % MOD
cmask = 0
csum = 0
for i in range(n) :
cdig = sx[i]
for use in range(cdig) :
if (i == 0 and use == 0) :
continue
nmask = cmask | (1 << use)
for mask in range(1 << 10) :
if (pop[nmask | mask] <= k) :
ans = (ans + f[n - i - 1][mask] + (csum * 10 + use) * w[n - i - 1][mask] % MOD * p10[n - i - 1]) % MOD
cmask |= 1 << cdig
csum = (10 * csum + cdig) % MOD
return ans
prepare()
l, r, k = map(int, input().split())
ans = (check(r, k) + solve(r, k) - solve(l, k) + MOD) % MOD
print(ans)
``` | output | 1 | 37 | 20 | 75 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers l and r (l β€ r). Your task is to calculate the sum of numbers from l to r (including l and r) such that each number contains at most k different digits, and print this sum modulo 998244353.
For example, if k = 1 then you have to calculate all numbers from l to r such that each number is formed using only one digit. For l = 10, r = 50 the answer is 11 + 22 + 33 + 44 = 110.
Input
The only line of the input contains three integers l, r and k (1 β€ l β€ r < 10^{18}, 1 β€ k β€ 10) β the borders of the segment and the maximum number of different digits.
Output
Print one integer β the sum of numbers from l to r such that each number contains at most k different digits, modulo 998244353.
Examples
Input
10 50 2
Output
1230
Input
1 2345 10
Output
2750685
Input
101 154 2
Output
2189
Note
For the first example the answer is just the sum of numbers from l to r which equals to (50 β
51)/(2) - (9 β
10)/(2) = 1230. This example also explained in the problem statement but for k = 1.
For the second example the answer is just the sum of numbers from l to r which equals to (2345 β
2346)/(2) = 2750685.
For the third example the answer is 101 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 121 + 122 + 131 + 133 + 141 + 144 + 151 = 2189. | instruction | 0 | 38 | 20 | 76 |
Tags: bitmasks, combinatorics, dp, math
Correct Solution:
```
import sys
from array import array # noqa: F401
import typing as Tp # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def main():
l, r, k = map(int, input().split())
valid_bits, is_valid_bits = [], [0] * 1024
for bit in range(1024):
if bin(bit).count('1') <= k:
valid_bits.append(bit)
is_valid_bits[bit] = 1
mod = 998244353
def solve(ub):
dp = array('i', [0]) * 1024
dp_cnt = array('i', [0]) * 1024
next_dp = array('i', [0]) * 1024
next_dp_cnt = array('i', [0]) * 1024
boundary_dp, b_bit = 0, 0
for e, digit in zip(range(len(str(ub)) - 1, -1, -1), map(int, str(ub))):
base = pow(10, e, mod)
for bit in valid_bits:
for d in range(10):
nextbit = bit | (1 << d)
if is_valid_bits[nextbit]:
next_dp[nextbit] = (
next_dp[nextbit] + dp[bit]
+ base * d * dp_cnt[bit]
) % mod
next_dp_cnt[nextbit] += dp_cnt[bit]
if next_dp_cnt[nextbit] >= mod:
next_dp_cnt[nextbit] -= mod
for d in range(digit):
nextbit = b_bit | (1 << d)
if is_valid_bits[nextbit]:
next_dp[nextbit] = (
next_dp[nextbit] + boundary_dp + base * d
) % mod
next_dp_cnt[nextbit] += 1
b_bit |= (1 << digit)
boundary_dp = (boundary_dp + base * digit) % mod
for i in valid_bits:
dp[i] = next_dp[i]
dp_cnt[i] = next_dp_cnt[i]
next_dp[i] = next_dp_cnt[i] = 0
dp[0], dp_cnt[0] = 0, 1
dp[1] = dp_cnt[1] = 0
return (sum(dp) + (boundary_dp if is_valid_bits[b_bit] else 0)) % mod
# print(solve(r), solve(l - 1))
print((solve(r) - solve(l - 1)) % mod)
if __name__ == '__main__':
main()
``` | output | 1 | 38 | 20 | 77 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers l and r (l β€ r). Your task is to calculate the sum of numbers from l to r (including l and r) such that each number contains at most k different digits, and print this sum modulo 998244353.
For example, if k = 1 then you have to calculate all numbers from l to r such that each number is formed using only one digit. For l = 10, r = 50 the answer is 11 + 22 + 33 + 44 = 110.
Input
The only line of the input contains three integers l, r and k (1 β€ l β€ r < 10^{18}, 1 β€ k β€ 10) β the borders of the segment and the maximum number of different digits.
Output
Print one integer β the sum of numbers from l to r such that each number contains at most k different digits, modulo 998244353.
Examples
Input
10 50 2
Output
1230
Input
1 2345 10
Output
2750685
Input
101 154 2
Output
2189
Note
For the first example the answer is just the sum of numbers from l to r which equals to (50 β
51)/(2) - (9 β
10)/(2) = 1230. This example also explained in the problem statement but for k = 1.
For the second example the answer is just the sum of numbers from l to r which equals to (2345 β
2346)/(2) = 2750685.
For the third example the answer is 101 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 121 + 122 + 131 + 133 + 141 + 144 + 151 = 2189. | instruction | 0 | 39 | 20 | 78 |
Tags: bitmasks, combinatorics, dp, math
Correct Solution:
```
import sys
mod = 998244353
MAX_LENGTH = 20
bound = [0] * MAX_LENGTH
def mul(a, b): return (a * b) % mod
def add(a, b):
a += b
if a < 0: a += mod
if a >= mod: a -= mod
return a
def digitize(num):
for i in range(MAX_LENGTH):
bound[i] = num % 10
num //= 10
def rec(smaller, start, pos, mask):
global k
if bit_count[mask] > k:
return [0, 0]
if pos == -1:
return [0, 1]
# if the two following lines are removed, the code reutrns correct results
if dp[smaller][start][pos][mask][0] != -1:
return dp[smaller][start][pos][mask]
res_sum = res_ways = 0
for digit in range(0, 10):
if smaller == 0 and digit > bound[pos]:
continue
new_smaller = smaller | (digit < bound[pos])
new_start = start | (digit > 0) | (pos == 0)
new_mask = (mask | (1 << digit)) if new_start == 1 else 0
cur_sum, cur_ways = rec(new_smaller, new_start, pos - 1, new_mask)
res_sum = add(res_sum, add(mul(mul(digit, ten_pow[pos]), cur_ways), cur_sum))
res_ways = add(res_ways, cur_ways)
dp[smaller][start][pos][mask][0], dp[smaller][start][pos][mask][1] = res_sum, res_ways
return dp[smaller][start][pos][mask]
def solve(upper_bound):
global dp
dp = [[[[[-1, -1] for _ in range(1 << 10)] for _ in range(MAX_LENGTH)] for _ in range(2)] for _ in range(2)]
digitize(upper_bound)
ans = rec(0, 0, MAX_LENGTH - 1, 0)
return ans[0]
inp = [int(x) for x in sys.stdin.read().split()]
l, r, k = inp[0], inp[1], inp[2]
bit_count = [0] * (1 << 10)
for i in range(1, 1 << 10): bit_count[i] = bit_count[i & (i - 1)] + 1
ten_pow = [1]
for i in range(MAX_LENGTH): ten_pow.append(mul(ten_pow[-1], 10))
print(add(solve(r), -solve(l - 1)))
``` | output | 1 | 39 | 20 | 79 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers l and r (l β€ r). Your task is to calculate the sum of numbers from l to r (including l and r) such that each number contains at most k different digits, and print this sum modulo 998244353.
For example, if k = 1 then you have to calculate all numbers from l to r such that each number is formed using only one digit. For l = 10, r = 50 the answer is 11 + 22 + 33 + 44 = 110.
Input
The only line of the input contains three integers l, r and k (1 β€ l β€ r < 10^{18}, 1 β€ k β€ 10) β the borders of the segment and the maximum number of different digits.
Output
Print one integer β the sum of numbers from l to r such that each number contains at most k different digits, modulo 998244353.
Examples
Input
10 50 2
Output
1230
Input
1 2345 10
Output
2750685
Input
101 154 2
Output
2189
Note
For the first example the answer is just the sum of numbers from l to r which equals to (50 β
51)/(2) - (9 β
10)/(2) = 1230. This example also explained in the problem statement but for k = 1.
For the second example the answer is just the sum of numbers from l to r which equals to (2345 β
2346)/(2) = 2750685.
For the third example the answer is 101 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 121 + 122 + 131 + 133 + 141 + 144 + 151 = 2189. | instruction | 0 | 40 | 20 | 80 |
Tags: bitmasks, combinatorics, dp, math
Correct Solution:
```
l, r, k =map(int,input().split())
d = {i:2**i for i in range(10)}
cache = {}
def can(i, m):
return d[i] & m
def calc(m):
b = 1
c = 0
for i in range(10):
if b & m:
c += 1
b *= 2
return c
def sm(ln, k, m, s='', first=False):
if ln < 1:
return 0, 1
if (ln, k, m, s, first) in cache:
return cache[(ln, k, m, s, first)]
ans = 0
count = 0
base = 10 ** (ln-1)
use_new = calc(m) < k
if s:
finish = int(s[0])+1
else:
finish = 10
for i in range(finish):
if use_new or can(i, m):
ss = s[1:]
if i != finish-1:
ss = ''
nm = m | d[i]
nfirst = False
if i == 0 and first:
nm = m
nfirst = True
nexta, nextc = sm(ln-1, k, nm, ss, nfirst)
ans += base * i * nextc + nexta
count += nextc
# print(ln, k, m, s, first, ans, count)
cache[(ln, k, m, s, first)] = (ans, count)
return ans, count
def call(a, k):
s = str(a)
return sm(len(s), k, 0, s, True)[0]
#print((call(r, k) - call(l-1, k)))
print((call(r, k) - call(l-1, k)) % 998244353)
``` | output | 1 | 40 | 20 | 81 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two integers l and r (l β€ r). Your task is to calculate the sum of numbers from l to r (including l and r) such that each number contains at most k different digits, and print this sum modulo 998244353.
For example, if k = 1 then you have to calculate all numbers from l to r such that each number is formed using only one digit. For l = 10, r = 50 the answer is 11 + 22 + 33 + 44 = 110.
Input
The only line of the input contains three integers l, r and k (1 β€ l β€ r < 10^{18}, 1 β€ k β€ 10) β the borders of the segment and the maximum number of different digits.
Output
Print one integer β the sum of numbers from l to r such that each number contains at most k different digits, modulo 998244353.
Examples
Input
10 50 2
Output
1230
Input
1 2345 10
Output
2750685
Input
101 154 2
Output
2189
Note
For the first example the answer is just the sum of numbers from l to r which equals to (50 β
51)/(2) - (9 β
10)/(2) = 1230. This example also explained in the problem statement but for k = 1.
For the second example the answer is just the sum of numbers from l to r which equals to (2345 β
2346)/(2) = 2750685.
For the third example the answer is 101 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 121 + 122 + 131 + 133 + 141 + 144 + 151 = 2189.
Submitted Solution:
```
def occurence(x):
ch=str(x)
i=0
L=[]
for x in range(len(ch)):
if ch[i] in L:
i+=1
else:
L.append(ch[i])
return(i)
ch=input(" ")
q=ch.index(" ")
th=ch[q+1:]
m=th.index(" ")
x=int(ch[:q])
y=int(th[:m])
p=int(th[m+1:])
h=0
for i in range(x,y+1,1):
if (occurence(i)<=p):
h=h+i
y=y % 998244353
print(h)
``` | instruction | 0 | 41 | 20 | 82 |
No | output | 1 | 41 | 20 | 83 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489). | instruction | 0 | 65 | 20 | 130 |
Tags: brute force, math, number theory
Correct Solution:
```
#!/usr/bin/env python3
import os
import sys
from io import BytesIO, IOBase
sys.stdout, stream = IOBase(), BytesIO()
sys.stdout.flush = lambda: os.write(1, stream.getvalue()) and not stream.truncate(0) and stream.seek(0)
sys.stdout.write = lambda s: stream.write(s.encode())
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def main():
def solve(n):
if len(n) == 1:
return int(n)
return max(int(n[0]) * solve(n[1:]), max(int(n[0]) - 1, 1) * 9**int(len(n) - 1))
print(solve(input().decode().rstrip('\r\n')))
if __name__ == '__main__':
main()
``` | output | 1 | 65 | 20 | 131 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489). | instruction | 0 | 66 | 20 | 132 |
Tags: brute force, math, number theory
Correct Solution:
```
n = int(input())
i = 1
def pro(x):
if x==0: return 1
return x%10*pro(x//10)
ans = pro(n)
while(n!=0):
# print(n%pow(10,i))
n-=(n%pow(10,i))
if n==0: break
# print("n",n-1)
# print("pro",pro(n-1))
ans = max(ans,pro(n-1))
i+=1
print(ans)
``` | output | 1 | 66 | 20 | 133 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489). | instruction | 0 | 67 | 20 | 134 |
Tags: brute force, math, number theory
Correct Solution:
```
def pd(d):
d = str(d)
ans = 1
for c in d:
ans *= int(c)
return ans
S = input()
D = int(S)
ans = pd(D)
if str(D)[0] == '1':
ans = 9 ** (len(str(D)) - 1)
else:
cur = 0
while 10 ** cur < D:
ans = max(ans, pd(D - (D % 10 ** cur) - 1))
cur += 1
print(ans)
``` | output | 1 | 67 | 20 | 135 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489). | instruction | 0 | 68 | 20 | 136 |
Tags: brute force, math, number theory
Correct Solution:
```
def solve(n):
s = [int(i) for i in str(n)]
if n < 10:
return n
if s[0] == 0:
return 0
return max(max(1, (s[0] - 1)) * 9 ** (len(s) - 1),
s[0] * solve(n - s[0] * 10 ** (len(s) - 1)))
# else:
# ans = 9 ** (len(s) - s.index(0)) * max(1, (s[s.index(0) - 1] - 1))
# for i in range(s.index(0) - 1):
# ans *= s[i]
#
# return ans
def prod(s):
ans = 1
for x in s:
ans *= x
return ans
n = int(input())
print(solve(n))
``` | output | 1 | 68 | 20 | 137 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489). | instruction | 0 | 69 | 20 | 138 |
Tags: brute force, math, number theory
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Spyder Editor
This is a temporary script file.
"""
def dfs(le, ri, n_str):
tmp1 = 1
tmp2 = 1
tmp3 = 1
if le==ri:
return 1
for i in range(le,ri):
tmp1 *= int(n_str[i])
tmp2 *= 9
tmp3 *= 9
tmp2 /= 9
tmp3 /= 9
tmp2 = tmp2*(int(n_str[le])-1) if int(n_str[le])>2 else 0
ans = max(tmp1,max(tmp2,tmp3))
ans = max(ans,int(n_str[le])*dfs(le+1,ri,n_str))
return ans
n = input()
n_str = str(n)
ans = dfs(0,len(n_str),n_str)
print(int(ans))
``` | output | 1 | 69 | 20 | 139 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489). | instruction | 0 | 70 | 20 | 140 |
Tags: brute force, math, number theory
Correct Solution:
```
s=[int(n) for n in input()]
k=1
def f(s):
m=1
for n in s:
if n!=0:
m*=n
else:
m*=1
return m
m=f(s)
for n in s:
k*=n
n=len(s)-1
while n>0:
if s[n]!=9:
s[n]=9
s[n-1]-=1
n-=1
m=max(m,f(s))
print(m)
``` | output | 1 | 70 | 20 | 141 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489). | instruction | 0 | 71 | 20 | 142 |
Tags: brute force, math, number theory
Correct Solution:
```
def sucin(aa):
b = str(aa)
r = 1
for x in range(len(b)):
r = r * int(b[x])
return(r)
def take_num(aa):
i = 1
while aa > 0:
aa = aa // 10
i *= 10
if aa > 0:
b.append(aa * i - 1)
a = int(input())
b = [a]
take_num(a)
print(max([sucin(x) for x in b]))
``` | output | 1 | 71 | 20 | 143 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489). | instruction | 0 | 72 | 20 | 144 |
Tags: brute force, math, number theory
Correct Solution:
```
r=p=1
for d in map(int,input()[::-1]):r=max(d*r,d*p-p);p*=9
print(max(r,p//9))
``` | output | 1 | 72 | 20 | 145 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489).
Submitted Solution:
```
def product(z):
product2 = 1
for j in range(len(z)):
product2 = product2 * z[j]
return product2
d = [int(x) for x in input()]
n = len(d)
r = 0
m = product(d)
if m > r:
r = m
for i in range(n-1, 0, -1):
d[i] = 9
if d[i-1] - 1 > 0:
d[i-1] = d[i-1] - 1
m = product(d)
if m > r:
r = m
print(max(r, 9**(n-1)))
``` | instruction | 0 | 73 | 20 | 146 |
Yes | output | 1 | 73 | 20 | 147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489).
Submitted Solution:
```
"""
Satwik_Tiwari ;) .
4th july , 2020 - Saturday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
import bisect
from heapq import *
from math import *
from collections import deque
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
#If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
#If the element is already present in the list,
# the right most position where element has to be inserted is returned
#==============================================================================================
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
#some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(a,b):
ans = 1
while(b>0):
if(b%2==1):
ans*=a
a*=a
b//=2
return ans
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) : # Check Prime Number or not
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
def bs(a,l,h,x):
while(l<h):
# print(l,h)
mid = (l+h)//2
if(a[mid] == x):
return mid
if(a[mid] < x):
l = mid+1
else:
h = mid
return l
def bfs(g,st):
visited = [-1]*(len(g))
visited[st] = 0
queue = []
queue.append(st)
new = []
while(len(queue) != 0):
s = queue.pop()
new.append(s)
for i in g[s]:
if(visited[i] == -1):
visited[i] = visited[s]+1
queue.append(i)
return visited
def dfsusingstack(v,st):
d = deque([])
visited = [0]*(len(v))
d.append(st)
new = []
visited[st] = 1
while(len(d) != 0):
curr = d.pop()
new.append(curr)
for i in v[curr]:
if(visited[i] == 0):
visited[i] = 1
d.append(i)
return new
def sieve(a,n): #O(n loglogn) nearly linear
#all odd mark 1
for i in range(3,((n)+1),2):
a[i] = 1
#marking multiples of i form i*i 0. they are nt prime
for i in range(3,((n)+1),2):
for j in range(i*i,((n)+1),i):
a[j] = 0
a[2] = 1 #special left case
return (a)
def solve():
a = list(inp())
for i in range(0,len(a)):
a[i] = int(a[i])
n = len(a)
ans = 1
for i in range(1,n):
ans *= 9
temp = 1
for i in range(n):
temp *= a[i]
ans = max(ans,temp)
for i in range(n):
if(a[i] > 1):
temp = 1
for j in range(i):
temp *=a[j]
temp *=a[i]-1
for j in range(i+1,n):
temp*=9
ans = max(ans,temp)
print(ans)
testcase(1)
# testcase(int(inp()))
``` | instruction | 0 | 74 | 20 | 148 |
Yes | output | 1 | 74 | 20 | 149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489).
Submitted Solution:
```
def f(n):
if n < 10:
return n
else:
s = list(str(n))
s = list(map(int, s))
q = max(1, (s[0] - 1)) * 9 ** (len(s) - 1)
w = s[0] * f(n % (10 ** (len(s) - 1)))
return max(q, w)
print(f(int(input())))
``` | instruction | 0 | 75 | 20 | 150 |
Yes | output | 1 | 75 | 20 | 151 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489).
Submitted Solution:
```
n = int(input())
digits_r = []
def prod(l):
p = 1
for num in l:
p *= num
return p
# print(n)
while n!=0:
digits_r.append(n%10)
n = n//10
# print(digits_r)
digits = list(reversed(digits_r))
# print(digits)
p = prod(digits)
# print(p)
for i in range(len(digits)):
cand = digits[i]-1 or 1
# print(digits,i+1,cand)
# print(str(cand)+('9'*(len(digits)-1-i)))
cand *= prod(digits[:i])
cand *= 9**(len(digits)-1-i)
if cand > p:
p = cand
print(p)
``` | instruction | 0 | 76 | 20 | 152 |
Yes | output | 1 | 76 | 20 | 153 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489).
Submitted Solution:
```
n = int(input())
if n > 9:
while str(n)[-1] != "9":
n -= 1
otv = 1
for i in range(len(str(n))):
otv *= int(str(n)[i])
print(otv)
``` | instruction | 0 | 77 | 20 | 154 |
No | output | 1 | 77 | 20 | 155 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489).
Submitted Solution:
```
n = int(input())
a = str(n)
ans = 9**(len(a) - 1)
cur = 1
curL = len(a)
for i in a:
curL -= 1
if int(i) > 1:
ans = max(ans, cur * int(i) * (9**(curL - 1)))
cur *= int(i)
print(max(ans, cur))
``` | instruction | 0 | 78 | 20 | 156 |
No | output | 1 | 78 | 20 | 157 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489).
Submitted Solution:
```
import re, math, decimal, bisect
def read(): return input().strip()
def iread(): return int(input().strip())
def viread(): return [_ for _ in input().strip().split()]
nines = [9 ** (x + 1) for x in range(9)]
# code goes here
n = read()
size = len(n)
og_size = size
if (n.count('0') != 0):
n = str(int(n[:n.find('0')]) - 1)
size -= len(n)
if n[0] == '0':
n = n[1:]
for i in range(size):
n += '9'
ans = 1
for c in n:
ans *= int(c)
print(max(ans, max(nines[:og_size - 1] if len(nines[:og_size - 1]) > 0 else [0])))
``` | instruction | 0 | 79 | 20 | 158 |
No | output | 1 | 79 | 20 | 159 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 1 to n.
Input
The only input line contains the integer n (1 β€ n β€ 2β
10^9).
Output
Print the maximum product of digits among all integers from 1 to n.
Examples
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
Note
In the first example the maximum product is achieved for 389 (the product of digits is 3β
8β
9=216).
In the second example the maximum product is achieved for 7 (the product of digits is 7).
In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489).
Submitted Solution:
```
b = input()
a = b
while('0' in str(a)):
a = int(a)-1
result = 1
for i in str(a):
result*=int(i)
print(result)
if(int(b[0]) - 1 > 0):
print(max(result, (9**(len(b)-1))*(int(b[0])-1)) )
else:
print(max(result, 9**(len(b)-1)) )
``` | instruction | 0 | 80 | 20 | 160 |
No | output | 1 | 80 | 20 | 161 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andrey's favourite number is n. Andrey's friends gave him two identical numbers n as a New Year present. He hung them on a wall and watched them adoringly.
Then Andrey got bored from looking at the same number and he started to swap digits first in one, then in the other number, then again in the first number and so on (arbitrary number of changes could be made in each number). At some point it turned out that if we sum the resulting numbers, then the number of zeroes with which the sum will end would be maximum among the possible variants of digit permutations in those numbers.
Given number n, can you find the two digit permutations that have this property?
Input
The first line contains a positive integer n β the original number. The number of digits in this number does not exceed 105. The number is written without any leading zeroes.
Output
Print two permutations of digits of number n, such that the sum of these numbers ends with the maximum number of zeroes. The permutations can have leading zeroes (if they are present, they all should be printed). The permutations do not have to be different. If there are several answers, print any of them.
Examples
Input
198
Output
981
819
Input
500
Output
500
500 | instruction | 0 | 179 | 20 | 358 |
Tags: greedy
Correct Solution:
```
n = input()
digits = [0 for x in range(10)]
for x in n:
digits[int(x)] += 1
best = -1
b1 = ''
b2 = ''
types = [(1,9), (2,8), (3,7), (4,6), (5,5)]
best = -1
b1 = ''
b2 = ''
for a,b in types:
if digits[a] and digits[b]:
d1 = digits[:]
d2 = digits[:]
d1[a] -= 1
d2[b] -= 1
s1 = str(a)
s2 = str(b)
for i,x in enumerate(d1):
num = min(x,d2[9-i])
s1 += str(i)*num
s2 += str(9-i)*num
d1[i] -= num
d2[9-i] -= num
num = min(d1[0], d2[0])
s1 = '0'*num+s1
s2 = '0'*num+s2
d1[0] -= num
d2[0] -= num
if len(s1) > best:
best = len(s1)
for i,x in enumerate(d1):
s1 += str(i)*x
for i,x in enumerate(d2):
s2 += str(i)*x
b1 = s1
b2 = s2
if best == -1:
for x in range(10):
b1 += str(x)*digits[x]
b2 += str(x)*digits[x]
print(b1[::-1])
print(b2[::-1])
``` | output | 1 | 179 | 20 | 359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andrey's favourite number is n. Andrey's friends gave him two identical numbers n as a New Year present. He hung them on a wall and watched them adoringly.
Then Andrey got bored from looking at the same number and he started to swap digits first in one, then in the other number, then again in the first number and so on (arbitrary number of changes could be made in each number). At some point it turned out that if we sum the resulting numbers, then the number of zeroes with which the sum will end would be maximum among the possible variants of digit permutations in those numbers.
Given number n, can you find the two digit permutations that have this property?
Input
The first line contains a positive integer n β the original number. The number of digits in this number does not exceed 105. The number is written without any leading zeroes.
Output
Print two permutations of digits of number n, such that the sum of these numbers ends with the maximum number of zeroes. The permutations can have leading zeroes (if they are present, they all should be printed). The permutations do not have to be different. If there are several answers, print any of them.
Examples
Input
198
Output
981
819
Input
500
Output
500
500 | instruction | 0 | 180 | 20 | 360 |
Tags: greedy
Correct Solution:
```
import itertools
def countZeroes(s):
ret = 0
for i in s:
if i != '0':
break
ret += 1
return ret
def stupid(n):
ansMax = 0
bn1 = n
bn2 = n
for n1 in itertools.permutations(n):
for n2 in itertools.permutations(n):
val = str(int(''.join(n1)) + int(''.join(n2)))[::-1]
cnt = countZeroes(val)
if cnt > ansMax:
ansMax = cnt
bn1 = ''.join(n1)
bn2 = ''.join(n2)
return (bn1, bn2)
def solution(n):
ansMax = n.count('0')
bestN1 = n.replace('0', '') + ansMax * '0'
bestN2 = n.replace('0', '') + ansMax * '0'
for i in range(1, 10):
cnt1 = [n.count(str(j)) for j in range(10)]
cnt2 = [n.count(str(j)) for j in range(10)]
if cnt1[i] == 0 or cnt2[10 - i] == 0:
continue
cnt1[i] -= 1
cnt2[10 - i] -= 1
curN1 = str(i)
curN2 = str(10 - i)
ansCur = 1
for j in range(10):
addend = min(cnt1[j], cnt2[9 - j])
ansCur += addend
cnt1[j] -= addend
cnt2[9 - j] -= addend
curN1 += str(j) * addend
curN2 += str(9 - j) * addend
if cnt1[0] > 0 and cnt2[0] > 0:
addend = min(cnt1[0], cnt2[0])
ansCur += addend
cnt1[0] -= addend
cnt2[0] -= addend
curN1 = '0' * addend + curN1
curN2 = '0' * addend + curN2
if ansCur > ansMax:
ansMax = ansCur
f = lambda x: str(x[0]) * x[1]
bestN1 = ''.join(map(f, enumerate(cnt1))) + curN1[::-1]
bestN2 = ''.join(map(f, enumerate(cnt2))) + curN2[::-1]
return (bestN1, bestN2)
n = input()
print('\n'.join(solution(n)))
``` | output | 1 | 180 | 20 | 361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andrey's favourite number is n. Andrey's friends gave him two identical numbers n as a New Year present. He hung them on a wall and watched them adoringly.
Then Andrey got bored from looking at the same number and he started to swap digits first in one, then in the other number, then again in the first number and so on (arbitrary number of changes could be made in each number). At some point it turned out that if we sum the resulting numbers, then the number of zeroes with which the sum will end would be maximum among the possible variants of digit permutations in those numbers.
Given number n, can you find the two digit permutations that have this property?
Input
The first line contains a positive integer n β the original number. The number of digits in this number does not exceed 105. The number is written without any leading zeroes.
Output
Print two permutations of digits of number n, such that the sum of these numbers ends with the maximum number of zeroes. The permutations can have leading zeroes (if they are present, they all should be printed). The permutations do not have to be different. If there are several answers, print any of them.
Examples
Input
198
Output
981
819
Input
500
Output
500
500
Submitted Solution:
```
a = input()
lis = {}
for i in range(10):
lis[i] = 0
for i in range(len(a)):
lis[int(a[i])] = lis[int(a[i])] + 1
lis_1 = lis.copy()
lis_2 = lis.copy()
L_1 = []
L_2 = []
A = ""
B = ""
for i in range(1, 6):
if lis[i] < lis[10 - i]:
lis_1[i] = 0
lis_2[10 - i] = lis[10 - i] - lis[i]
for j in range(lis[i]):
L_1.append(i)
L_2.append(10 - i)
else:
lis_1[10 -i] = 0
lis_2[i] = lis[i] - lis[10 - i]
for j in range(lis[10 - i]):
L_1.append(10 - i)
L_2.append(i)
for i in range(lis[0]):
L_1.append(0)
L_2.append(0)
for i in range(10):
for j in range(lis_1[i]):
A = A + str(i)
for i in range(len(L_1)):
A = A + str(L_1[i])
for i in range(10):
for j in range(lis_2[i]):
B = B + str(i)
for i in range(len(L_2)):
B = B + str(L_2[i])
print(int(A))
print(int(B))
``` | instruction | 0 | 181 | 20 | 362 |
No | output | 1 | 181 | 20 | 363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andrey's favourite number is n. Andrey's friends gave him two identical numbers n as a New Year present. He hung them on a wall and watched them adoringly.
Then Andrey got bored from looking at the same number and he started to swap digits first in one, then in the other number, then again in the first number and so on (arbitrary number of changes could be made in each number). At some point it turned out that if we sum the resulting numbers, then the number of zeroes with which the sum will end would be maximum among the possible variants of digit permutations in those numbers.
Given number n, can you find the two digit permutations that have this property?
Input
The first line contains a positive integer n β the original number. The number of digits in this number does not exceed 105. The number is written without any leading zeroes.
Output
Print two permutations of digits of number n, such that the sum of these numbers ends with the maximum number of zeroes. The permutations can have leading zeroes (if they are present, they all should be printed). The permutations do not have to be different. If there are several answers, print any of them.
Examples
Input
198
Output
981
819
Input
500
Output
500
500
Submitted Solution:
```
n = input()
digits = [0 for x in range(10)]
for x in n:
digits[int(x)] += 1
best = -1
b1 = ''
b2 = ''
types = [(1,9), (2,8), (3,7), (4,6), (5,5)]
best = -1
b1 = ''
b2 = ''
for a,b in types:
if digits[a] and digits[b]:
d1 = digits[:]
d2 = digits[:]
d1[a] -= 1
d2[b] -= 1
s1 = str(a)
s2 = str(b)
for i,x in enumerate(d1):
num = min(x,d2[9-i])
s1 += str(i)*num
s2 += str(9-i)*num
d1[i] -= num
d2[9-i] -= num
num = min(d1[0], d2[0])
s1 = '0'*num+s1
s2 = '0'*num+s2
d1[0] -= num
d2[0] -= num
if len(s1) > best:
best = len(s1)
for i,x in enumerate(d1):
s1 += str(i)*x
for i,x in enumerate(d2):
s2 += str(i)*x
b1 = s1
b2 = s2
print(b1[::-1])
print(b2[::-1])
``` | instruction | 0 | 182 | 20 | 364 |
No | output | 1 | 182 | 20 | 365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andrey's favourite number is n. Andrey's friends gave him two identical numbers n as a New Year present. He hung them on a wall and watched them adoringly.
Then Andrey got bored from looking at the same number and he started to swap digits first in one, then in the other number, then again in the first number and so on (arbitrary number of changes could be made in each number). At some point it turned out that if we sum the resulting numbers, then the number of zeroes with which the sum will end would be maximum among the possible variants of digit permutations in those numbers.
Given number n, can you find the two digit permutations that have this property?
Input
The first line contains a positive integer n β the original number. The number of digits in this number does not exceed 105. The number is written without any leading zeroes.
Output
Print two permutations of digits of number n, such that the sum of these numbers ends with the maximum number of zeroes. The permutations can have leading zeroes (if they are present, they all should be printed). The permutations do not have to be different. If there are several answers, print any of them.
Examples
Input
198
Output
981
819
Input
500
Output
500
500
Submitted Solution:
```
n = input()
zeroes = n.count('0')
n = n.replace('0', '')
ansMax = 0
bestN1 = n
bestN2 = n
for i in range(1, 10):
cnt1 = [0] + [n.count(str(j)) for j in range(1, 10)]
cnt2 = [0] + [n.count(str(j)) for j in range(1, 10)]
if cnt1[i] == 0 or cnt2[10 - i] == 0:
continue
cnt1[i] -= 1
cnt2[10 - i] -= 1
curN1 = str(i)
curN2 = str(10 - i)
ansCur = 1
for j in range(10):
addend = min(cnt1[j], cnt2[9 - j])
ansCur += addend
cnt1[j] -= addend
cnt2[9 - j] -= addend
curN1 += str(j) * addend
curN2 += str(9 - j) * addend
if ansCur > ansMax:
ansMax = ansCur
f = lambda x: str(x[0]) * x[1]
bestN1 = ''.join(map(f, enumerate(cnt1))) + curN1[::-1]
bestN2 = ''.join(map(f, enumerate(cnt2))) + curN2[::-1]
print(bestN1 + '0' * zeroes)
print(bestN2 + '0' * zeroes)
``` | instruction | 0 | 183 | 20 | 366 |
No | output | 1 | 183 | 20 | 367 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The first line of the input contains a single integer N (1 β€ N β€ 24). The next N lines contain 5 space-separated integers each. The first three integers will be between 0 and 2, inclusive. The last two integers will be between 0 and 3, inclusive. The sum of the first three integers will be equal to the sum of the last two integers.
Output
Output the result β a string of lowercase English letters.
Examples
Input
1
1 0 0 1 0
Output
a
Input
10
2 0 0 1 1
1 1 1 2 1
2 1 0 1 2
1 1 0 1 1
2 1 0 2 1
1 1 1 2 1
1 2 1 3 1
2 0 0 1 1
1 1 0 1 1
1 1 2 2 2
Output
codeforcez | instruction | 0 | 205 | 20 | 410 |
Tags: *special, implementation
Correct Solution:
```
a = ['10010', '11020', '20011', '21012', '11011', '21021', '22022', '12021', '00000', '12012', '10120', '11130', '20121', '21122', '11121', '21131', '22132', '12131', '11111', '12122', '10221', '11231', '12113', '20222', '21223', '11222']
n = int(input())
for i in range(n) :
f = input().replace(' ','')
print (chr (97 + a.index(f)), end='')
``` | output | 1 | 205 | 20 | 411 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The first line of the input contains a single integer N (1 β€ N β€ 24). The next N lines contain 5 space-separated integers each. The first three integers will be between 0 and 2, inclusive. The last two integers will be between 0 and 3, inclusive. The sum of the first three integers will be equal to the sum of the last two integers.
Output
Output the result β a string of lowercase English letters.
Examples
Input
1
1 0 0 1 0
Output
a
Input
10
2 0 0 1 1
1 1 1 2 1
2 1 0 1 2
1 1 0 1 1
2 1 0 2 1
1 1 1 2 1
1 2 1 3 1
2 0 0 1 1
1 1 0 1 1
1 1 2 2 2
Output
codeforcez | instruction | 0 | 206 | 20 | 412 |
Tags: *special, implementation
Correct Solution:
```
table = {
(1, 0, 0, 1, 0): 'a',
(1, 1, 0, 2, 0): 'b',
(2, 0, 0, 1, 1): 'c',
(2, 1, 0, 1, 2): 'd',
(1, 1, 0, 1, 1): 'e',
(2, 1, 0, 2, 1): 'f',
(2, 2, 0, 2, 2): 'g',
(1, 2, 0, 2, 1): 'h',
# (1, 1, 0, 1, 1): 'i',
(1, 2, 0, 1, 2): 'j',
(1, 0, 1, 2, 0): 'k',
(1, 1, 1, 3, 0): 'l',
(2, 0, 1, 2, 1): 'm',
(2, 1, 1, 2, 2): 'n',
(1, 1, 1, 2, 1): 'o',
(2, 1, 1, 3, 1): 'p',
(2, 2, 1, 3, 2): 'q',
(1, 2, 1, 3, 1): 'r',
# (1, 1, 1, 2, 1): 's',
(1, 2, 1, 2, 2): 't',
(1, 0, 2, 2, 1): 'u',
(1, 1, 2, 3, 1): 'v',
(1, 2, 1, 1, 3): 'w',
(2, 0, 2, 2, 2): 'x',
(2, 1, 2, 2, 3): 'y',
(1, 1, 2, 2, 2): 'z',
}
for item in table:
if item[0] + item[1] + item[2] !=item[3] + item[4]:
print(table[item])
exit(1)
ans = []
for _ in range(int(input())):
a = tuple(map(int, input().split()))
ans.append(table[a])
print(''.join(ans))
``` | output | 1 | 206 | 20 | 413 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The first line of the input contains a single integer N (1 β€ N β€ 24). The next N lines contain 5 space-separated integers each. The first three integers will be between 0 and 2, inclusive. The last two integers will be between 0 and 3, inclusive. The sum of the first three integers will be equal to the sum of the last two integers.
Output
Output the result β a string of lowercase English letters.
Examples
Input
1
1 0 0 1 0
Output
a
Input
10
2 0 0 1 1
1 1 1 2 1
2 1 0 1 2
1 1 0 1 1
2 1 0 2 1
1 1 1 2 1
1 2 1 3 1
2 0 0 1 1
1 1 0 1 1
1 1 2 2 2
Output
codeforcez | instruction | 0 | 209 | 20 | 418 |
Tags: *special, implementation
Correct Solution:
```
dic = {}
dic['1 0 0 1 0'] = 'a'
dic['1 1 0 2 0'] = 'b'
dic['2 0 0 1 1'] = 'c'
dic['2 1 0 1 2'] = 'd'
dic['1 1 0 1 1'] = 'e'
dic['2 1 0 2 1'] = 'f'
dic['2 2 0 2 2'] = 'g'
dic['1 2 0 2 1'] = 'h'
# dic['1 1 0 1 1'] = 'i'
dic['1 2 0 1 2'] = 'j'
dic['1 0 1 2 0'] = 'k'
dic['1 1 1 3 0'] = 'l'
dic['2 0 1 2 1'] = 'm'
dic['2 1 1 2 2'] = 'n'
dic['1 1 1 2 1'] = 'o'
dic['2 1 1 3 1'] = 'p'
dic['2 2 1 3 2'] = 'q'
dic['1 2 1 3 1'] = 'r'
# dic['1 1 1 2 1'] = 's'
dic['1 2 1 2 2'] = 't'
dic['1 0 2 2 1'] = 'u'
dic['1 1 2 3 1'] = 'v'
dic['1 2 1 1 3'] = 'w'
dic['2 0 2 2 2'] = 'x'
dic['2 1 2 2 3'] = 'y'
dic['1 1 2 2 2'] = 'z'
ans = ''
for _ in range(int(input())):
s = input()
ans += dic[s]
print(ans)
``` | output | 1 | 209 | 20 | 419 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The first line of the input contains a single integer N (1 β€ N β€ 24). The next N lines contain 5 space-separated integers each. The first three integers will be between 0 and 2, inclusive. The last two integers will be between 0 and 3, inclusive. The sum of the first three integers will be equal to the sum of the last two integers.
Output
Output the result β a string of lowercase English letters.
Examples
Input
1
1 0 0 1 0
Output
a
Input
10
2 0 0 1 1
1 1 1 2 1
2 1 0 1 2
1 1 0 1 1
2 1 0 2 1
1 1 1 2 1
1 2 1 3 1
2 0 0 1 1
1 1 0 1 1
1 1 2 2 2
Output
codeforcez | instruction | 0 | 210 | 20 | 420 |
Tags: *special, implementation
Correct Solution:
```
n = int(input())
d = dict()
d[10010] = "a"
d[11020] = "b"
d[20011] = "c"
d[21012] = "d"
d[11011] = "e"
d[21021] = "f"
d[22022] = "g"
d[12021] = "h"
#d[11011] = "i"
d[12012] = "j"
d[10120] = "k"
d[11130] = "l"
d[20121] = "m"
d[21122] = "n"
d[11121] = "o"
d[21131] = "p"
d[22132] = "q"
d[12131] = "r"
#d[11121] = "s"
d[12122] = "t"
d[10221] = "u"
d[11231] = "v"
d[12113] = "w"
d[20222] = "x"
d[21223] = "y"
d[11222] = "z"
ans = ""
for _ in range(n):
ans += d[int("".join(list(input().split())))]
print(ans)
``` | output | 1 | 210 | 20 | 421 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The first line of the input contains a single integer N (1 β€ N β€ 24). The next N lines contain 5 space-separated integers each. The first three integers will be between 0 and 2, inclusive. The last two integers will be between 0 and 3, inclusive. The sum of the first three integers will be equal to the sum of the last two integers.
Output
Output the result β a string of lowercase English letters.
Examples
Input
1
1 0 0 1 0
Output
a
Input
10
2 0 0 1 1
1 1 1 2 1
2 1 0 1 2
1 1 0 1 1
2 1 0 2 1
1 1 1 2 1
1 2 1 3 1
2 0 0 1 1
1 1 0 1 1
1 1 2 2 2
Output
codeforcez | instruction | 0 | 211 | 20 | 422 |
Tags: *special, implementation
Correct Solution:
```
a = ['10010','11020','20011','21012','11011','21021','22022','12021','00000','12012','10120','11130','20121','21122','11121','21131','22132','12131','11111','12122','10221','11231','12113','20222','21223','11222']
from string import ascii_lowercase as l
n = int(input())
r = ''
for i in range(n):
*b, = map(int, input().split())
s = ''.join(map(str, b))
r += l[a.index(s)]
print(r)
``` | output | 1 | 211 | 20 | 423 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Input
The first line of the input contains a single integer N (1 β€ N β€ 24). The next N lines contain 5 space-separated integers each. The first three integers will be between 0 and 2, inclusive. The last two integers will be between 0 and 3, inclusive. The sum of the first three integers will be equal to the sum of the last two integers.
Output
Output the result β a string of lowercase English letters.
Examples
Input
1
1 0 0 1 0
Output
a
Input
10
2 0 0 1 1
1 1 1 2 1
2 1 0 1 2
1 1 0 1 1
2 1 0 2 1
1 1 1 2 1
1 2 1 3 1
2 0 0 1 1
1 1 0 1 1
1 1 2 2 2
Output
codeforcez | instruction | 0 | 212 | 20 | 424 |
Tags: *special, implementation
Correct Solution:
```
braille = [["a", "1"],
["b", "12"],
["c", "14"],
["d", "145"],
["e", "15"],
["f", "124"],
["g", "1245"],
["h", "125"],
["i", "24"],
["j", "245"],
["k", "13"],
["l", "123"],
["m", "134"],
["n", "1345"],
["o", "135"],
["p", "1234"],
["q", "12345"],
["r", "1235"],
["s", "234"],
["t", "2345"],
["u", "136"],
["v", "1236"],
["w", "2456"],
["x", "1346"],
["y", "13456"],
["z", "1356"]]
decoded = {}
for ch, enc in braille:
final = [0] * 5
for idx in enc:
idx = ord(idx) - ord('1')
r = idx % 3
c = idx //3
final[r] += 1
final[c+3] += 1
if tuple(final) not in decoded:
decoded[tuple(final)] = ch
n = int(input())
ans = ""
for i in range(n):
a, b, c, d, e = map(int, input().split())
ans += decoded[a,b,c,d,e]
print(ans)
``` | output | 1 | 212 | 20 | 425 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6 | instruction | 0 | 396 | 20 | 792 |
Tags: bitmasks, brute force, combinatorics, implementation
Correct Solution:
```
n=input()
l=len(n)
s=0
l-=1
while l>0:
s+=2**l
l-=1
f=list(n)
f.reverse()
j=0
for i in f:
if i=='7':
s+=2**j
j+=1
s+=1
print(s)
``` | output | 1 | 396 | 20 | 793 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6 | instruction | 0 | 397 | 20 | 794 |
Tags: bitmasks, brute force, combinatorics, implementation
Correct Solution:
```
n = input()
if n=='4' :
print(1)
else:
s='4'
for i in range(2,100000):
if s[len(s)-1]=='4':
s=list(s)
s[len(s)-1]='7'
s=''.join(s)
elif '4' not in s:
l=len(s)
s=''
for j in range(l+1):
s=s+'4'
elif s[len(s)-1]=='7' :
j=len(s)-1
while s[j]=='7':
s=list(s)
s[j]='4'
j-=1
s[j]='7'
s=''.join(s)
if s==n:
print(i)
break
``` | output | 1 | 397 | 20 | 795 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6 | instruction | 0 | 398 | 20 | 796 |
Tags: bitmasks, brute force, combinatorics, implementation
Correct Solution:
```
def getDecValue(n):
n = binConvert(n)
decValue = int(n, 2)
return decValue
def binConvert(n):
narray = list(str(n))
for i in range(len(narray)):
if(narray[i] == '4'):
narray[i] = '0'
else:
narray[i] = '1'
binValue = "".join(narray)
return binValue
def getBits(n):
bitarray = list(str(n))
bits = len(bitarray)
return bits
def getLeftPos(bits):
temp = 0
for i in range(1, bits+1):
temp = temp + pow(2, i)
return temp
def getPosition(n):
decValue = int(getDecValue(n)) + 1
bits = int(getBits(n))
leftpos = getLeftPos(bits-1)
res = leftpos + decValue
return res
n = int(input())
pos = getPosition(n)
print(pos, end="")
``` | output | 1 | 398 | 20 | 797 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6 | instruction | 0 | 399 | 20 | 798 |
Tags: bitmasks, brute force, combinatorics, implementation
Correct Solution:
```
s = input().replace('7', '1').replace('4', '0')
n = 0
for i in range(1, len(s)):
n += 2**i
print(n + int(s, 2) + 1)
``` | output | 1 | 399 | 20 | 799 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6 | instruction | 0 | 400 | 20 | 800 |
Tags: bitmasks, brute force, combinatorics, implementation
Correct Solution:
```
import sys
s = input()
ans = 0
for i in s:
if i == '4':
ans = ans * 2
else:
ans = ans * 2 + 1
ans += 1
ans += (1<<len(s))-2
print ("%d"%(ans))
``` | output | 1 | 400 | 20 | 801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6 | instruction | 0 | 401 | 20 | 802 |
Tags: bitmasks, brute force, combinatorics, implementation
Correct Solution:
```
s = input()
s = '7' + s
s = s.replace("4", "0")
s = s.replace("7", "1")
print(int(s,2)-1)
``` | output | 1 | 401 | 20 | 803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6 | instruction | 0 | 402 | 20 | 804 |
Tags: bitmasks, brute force, combinatorics, implementation
Correct Solution:
```
n = input()
x = 1
ans = 0
for i in range(len(n) - 1):
x <<= 1
ans += x
x = 0
for i in range(len(n)):
if n[len(n) - 1 - i] == '4':
continue
else:
x |= 1<<i
ans += x
print(ans+1)
``` | output | 1 | 402 | 20 | 805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6 | instruction | 0 | 403 | 20 | 806 |
Tags: bitmasks, brute force, combinatorics, implementation
Correct Solution:
```
s=input()
l=len(s)
n = (1<<l)
num = n-1
sum=0
for i in range(l):
n=n//2
if s[i]== '7':
num+=n
print(num)
``` | output | 1 | 403 | 20 | 807 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
Submitted Solution:
```
def DFS(number):
if (number > 1e9):
return []
return DFS(number * 10 + 4) + DFS(number * 10 + 7) + [number]
def main():
res = DFS(0)
res.sort()
n = int(input())
return res.index(n)
if __name__ == '__main__':
print(main())
``` | instruction | 0 | 404 | 20 | 808 |
Yes | output | 1 | 404 | 20 | 809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
Submitted Solution:
```
'''
for i in range(1,10000):
if str(i).count('4')+str(i).count('7')==len(str(i)):
print(i)
'''
n=int(input())
if n==4:
print(1)
elif n==7:
print(2)
else:
count=len(str(n))
sum=0
for i in range(1,count):
sum+=pow(2,i)
l=[]
for i in str(n):
if i=='7':
l.append('1')
else:
l.append('0')
n=''.join(l)
ans=0
for i in range(len(n)-1,-1,-1):
ans+=int(n[i])*pow(2,len(n)-i-1)
print(ans+sum+1)
``` | instruction | 0 | 405 | 20 | 810 |
Yes | output | 1 | 405 | 20 | 811 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
Submitted Solution:
```
from sys import stdin
#####################################################################
def iinput(): return int(stdin.readline())
def minput(): return map(int, stdin.readline().split())
def linput(): return list(map(int, stdin.readline().split()))
#####################################################################
n = input()
d = {'4':'0', '7':'1'}
x = 2**len(n) - 1
b = ''
for e in n:
b += d[e]
m = int(b, 2)
print(x+m)
``` | instruction | 0 | 406 | 20 | 812 |
Yes | output | 1 | 406 | 20 | 813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
Submitted Solution:
```
'''
Get the number n and turn it into a list l of its digits.
'''
n = int(input())
l = list(int(i) for i in str(n))
def index_of(l):
idx = 0
zero = [0 for i in range(len(l))]
# We turn a digit into 0 when we change to a lucky number with fewer
# digits.
while l != zero:
# We run through the digits starting from right to left turning 7's into
# 4's and 4's into 7's (and when we turn 4's into 7's it's a bit more
# complicated because you have to change the next digit to something)
for i in range(len(l) - 1, -1, -1):
if l[i] == 0:
break
# hard case
elif l[i] == 4:
# When the current digit is 4, we change it into 0 if:
# the digit 4 is the leftmost digit, for example if l is
# [4, 4], the next lucky number is [0, 7] and the series of
# changes we do is [4, 4] -> [4, 7] -> [0, 7].
#
# the digit to the left of 4 is 0, for example if l is
# [0, 4, 4], the next lucky number would be [0, 0, 7] and the
# series of changes we do is [0, 4, 4] -> [0, 4, 7] ->
# [0, 0, 7].
#
# Note that it is important that we put i == 0 as our first
# condition as otherwise it's possible that i - 1 < 0.
if i == 0 or l[i - 1] == 0:
l[i] = 0
else:
l[i] = 7
# easy case
elif l[i] == 7:
l[i] = 4
break
idx += 1
return idx
print(index_of(l))
``` | instruction | 0 | 407 | 20 | 814 |
Yes | output | 1 | 407 | 20 | 815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
Submitted Solution:
```
def lucky(n):
if(n==4):
print(1)
if(n==7):
print(2)
else:
x=len(str(n))
s=0
for i in range(1,x):
s+=2**i
for i in range(len(str(x))):
if str(n)[i]=="4":
pass
else:
s+=2**(x-1-i)
if str(n)[-1]=="7":
s+=1
print(s+1)
lucky(int(input()))
``` | instruction | 0 | 408 | 20 | 816 |
No | output | 1 | 408 | 20 | 817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
Submitted Solution:
```
import sys
lucky = str(input())
position = 0
multiplicador=1
for char in lucky:
if char == '4':
position+=multiplicador*1
else:
position+=multiplicador*2
multiplicador*=2
print (position)
``` | instruction | 0 | 409 | 20 | 818 |
No | output | 1 | 409 | 20 | 819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
Submitted Solution:
```
def main(n):
x = len(str(n))
res1 = (1<<x)-2
i = 0
res2 = 0
while i<x:
if str(n)[i] == 7:
res2 += (1<<(x-i))
i+=1
return res1 + res2 +1
``` | instruction | 0 | 410 | 20 | 820 |
No | output | 1 | 410 | 20 | 821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
Submitted Solution:
```
def calc(n):
x = len(str(n))
res1 = (1<<x)-2
i = 0
res2 = 0
while i<x:
if str(n)[i] == 7:
index = x - i
res2 += (1<<(x-i))
i+=1
return res1 + res2 +1
``` | instruction | 0 | 411 | 20 | 822 |
No | output | 1 | 411 | 20 | 823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasily has recently learned about the amazing properties of number Ο. In one of the articles it has been hypothesized that, whatever the sequence of numbers we have, in some position, this sequence is found among the digits of number Ο. Thus, if you take, for example, the epic novel "War and Peace" of famous Russian author Leo Tolstoy, and encode it with numbers, then we will find the novel among the characters of number Ο.
Vasily was absolutely delighted with this, because it means that all the books, songs and programs have already been written and encoded in the digits of Ο. Vasily is, of course, a bit wary that this is only a hypothesis and it hasn't been proved, so he decided to check it out.
To do this, Vasily downloaded from the Internet the archive with the sequence of digits of number Ο, starting with a certain position, and began to check the different strings of digits on the presence in the downloaded archive. Vasily quickly found short strings of digits, but each time he took a longer string, it turned out that it is not in the archive. Vasily came up with a definition that a string of length d is a half-occurrence if it contains a substring of length of at least <image>, which occurs in the archive.
To complete the investigation, Vasily took 2 large numbers x, y (x β€ y) with the same number of digits and now he wants to find the number of numbers in the interval from x to y, which are half-occurrences in the archive. Help Vasily calculate this value modulo 109 + 7.
Input
The first line contains string s consisting of decimal digits (1 β€ |s| β€ 1000) that Vasily will use to search substrings in. According to hypothesis, this sequence of digis indeed occurs in the decimal representation of Ο, although we can't guarantee that.
The second and third lines contain two positive integers x, y of the same length d (x β€ y, 2 β€ d β€ 50). Numbers x, y do not contain leading zeroes.
Output
Print how many numbers in the segment from x to y that are half-occurrences in s modulo 109 + 7.
Examples
Input
02
10
19
Output
2
Input
023456789
10
19
Output
9
Input
31415926535
10
29
Output
20
Submitted Solution:
```
a = [0] * 10 ** 4
ans = 0
for i in range(10 ** 2):
for i in range(10 ** 4):
ans += a[i]
print('2')
``` | instruction | 0 | 425 | 20 | 850 |
No | output | 1 | 425 | 20 | 851 |
Provide a correct Python 3 solution for this coding contest problem.
Do the following for a four-digit number N consisting of numbers 0-9.
1. Let L be the number obtained as a result of arranging the numerical values ββof each of the N digits in descending order.
2. Let S be the number obtained as a result of arranging the numerical values ββof each of the N digits in ascending order.
3. Let the difference L-S be the new N (end of one operation)
4. Repeat from 1. for the new N
At this time, it is known that any four-digit number will eventually become 6174, unless all digits are the same number (0000, 1111, etc.). For example, when N = 2012
First time (N = 2012): L = 2210, S = 0122, L-S = 2088
Second time (N = 2088): L = 8820, S = 0288, L-S = 8532
Third time (N = 8532): L = 8532, S = 2358, L-S = 6174
And reach 6174 in 3 operations.
Write a program that calculates how many operations will reach 6174 given a four-digit number consisting of the numbers 0-9.
input
The input consists of multiple datasets. The end of the input is indicated by 0000 on one line. Each dataset is given in the following format:
N
The dataset is one line and N (1 β€ N β€ 9999) indicates a four-digit number. If N <1000, the upper digit is padded with zeros.
The number of datasets does not exceed 10000.
output
The number of operations to reach 6174 for each data set is output on one line. However, if a number with all the same digits is given as input, NA is output.
Example
Input
6174
2012
3333
0000
Output
0
3
NA | instruction | 0 | 700 | 20 | 1,400 |
"Correct Solution:
```
# Aizu Problem 0259: All Numbers Lead to 6174
import sys, math, os, bisect
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def solve(digits):
steps = 0
while digits != ['6', '1', '7', '4']:
L = int(''.join(sorted(digits)))
S = int(''.join(sorted(digits, reverse=True)))
digits = [_ for _ in str(S - L)]
while len(digits) < 4:
digits = ['0'] + digits
steps += 1
return steps
while True:
digits = [_ for _ in input().strip()]
if digits == ['0'] * 4:
break
print("NA" if len(set(digits)) == 1 else solve(digits))
``` | output | 1 | 700 | 20 | 1,401 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.