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 |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let f(x) be the sum of digits of a decimal number x.
Find the smallest non-negative integer x such that f(x) + f(x + 1) + ... + f(x + k) = n.
Input
The first line contains one integer t (1 ≤ t ≤ 150) — the number of test cases.
Each test case consists of one line containing two integers n and k (1 ≤ n ≤ 150, 0 ≤ k ≤ 9).
Output
For each test case, print one integer without leading zeroes. If there is no such x that f(x) + f(x + 1) + ... + f(x + k) = n, print -1; otherwise, print the minimum x meeting that constraint.
Example
Input
7
1 0
1 1
42 7
13 7
99 1
99 0
99 2
Output
1
0
4
-1
599998
99999999999
7997
Submitted Solution:
```
"""sm=dict()
def numsum(x):
return sum([int(e) for e in str(x)])
ar=[]
for i in range(10**5):
a,b,c,d,e,f,g,h,I,j=i,i+1,i+2,i+3,i+4,i+5,i+6,i+7,i+8,i+9
v=numsum(a)+numsum(b)+numsum(c)+numsum(d)+numsum(e)+numsum(f)+numsum(g)+numsum(h)+numsum(I)+numsum
if(v>150):
continue
if(v not in sm.keys()):
sm[v]=a
#print(a,b,v)
ar.append([v,a])
ar=sorted(ar)
print(*ar)"""
def get(n,k):
if(k==0):
ans=[]
while(n):
ans.append(min(9,n))
n-=min(9,n)
ans=sorted(ans)
return ''.join([str(x) for x in ans])
elif(k==1):
if(n<30):
ar=[[1, 0], [3, 1], [5, 2], [7, 3], [9, 4], [10, 9], [11, 5], [12, 19], [13, 6], [14, 29], [15, 7], [16, 39], [17, 8], [18, 49], [19, 18], [20, 59], [21, 28], [22, 69], [23, 38], [24, 79], [25, 48], [26, 89], [27, 58], [28, 189], [29, 68]]
for e in ar:
if(e[0]==n):
return e[1]
return -1
if(n%2==0):
res=30
cur=289
add=100
while(res<n):
res+=2
if(len(str(cur+add))>len(str(cur))):
add*=10
cur+=add
return cur
else:
res=31
cur=78
add=10
while(res<n):
res+=2
if(len(str(cur+add))>len(str(cur))):
add*=10
cur+=add
return cur
elif(k==2):
ar=[3, 0], [6, 1], [9, 2], [12, 3], [15, 4], [18, 5], [21, 6], [24, 7], [27, 17], [30, 27], [33, 37], [36, 47], [39, 57], [42, 67], [45, 77], [48, 87], [51, 97], [54, 197], [57, 297], [60, 397], [63, 497], [66, 597], [69, 697], [72, 797], [75, 897], [78, 997], [81, 1997], [84, 2997], [87, 3997], [90, 4997], [93, 5997], [96, 6997], [99, 7997], [102, 8997], [105, 9997], [108, 19997], [111, 29997], [114, 39997], [117, 49997], [120, 59997], [123, 69997], [126, 79997], [129, 89997], [132, 99997], [135, 199997], [138, 299997], [141, 399997], [144, 499997], [147, 599997], [150, 699997]
for e in ar:
if(e[0]==n):
return e[1]
return -1
elif(k==3):
ar=[6, 0], [10, 1], [14, 2], [15, 9], [18, 3], [19, 19], [20, 8], [22, 4], [23, 29], [24, 18], [25, 7], [26, 5], [27, 39], [28, 28], [29, 17], [30, 6], [31, 49], [32, 38], [33, 27], [34, 16], [35, 59], [36, 48], [37, 37], [38, 26], [39, 69], [40, 58], [41, 47], [42, 36], [43, 79], [44, 68], [45, 57], [46, 46], [47, 89], [48, 78], [49, 67], [50, 56], [51, 189], [52, 88], [53, 77], [54, 66], [55, 289], [56, 188], [57, 87], [58, 76], [59, 389], [60, 288], [61, 187], [62, 86], [63, 489], [64, 388], [65, 287], [66, 96], [67, 589], [68, 488], [69, 387], [70, 196], [71, 689], [72, 588], [73, 487], [74, 296], [75, 789], [76, 688], [77, 587], [78, 396], [79, 889], [80, 788], [81, 687], [82, 496], [83, 989], [84, 888], [85, 787], [86, 596], [87, 1989], [88, 988], [89, 887], [90, 696], [91, 2989], [92, 1988], [93, 987], [94, 796], [95, 3989], [96, 2988], [97, 1987], [98, 896], [99, 4989], [100, 3988], [101, 2987], [102, 996], [103, 5989], [104, 4988], [105, 3987], [106, 1996], [107, 6989], [108, 5988], [109, 4987], [110, 2996], [111, 7989], [112, 6988], [113, 5987], [114, 3996], [115, 8989], [116, 7988], [117, 6987], [118, 4996], [119, 9989], [120, 8988], [121, 7987], [122, 5996], [123, 19989], [124, 9988], [125, 8987], [126, 6996], [127, 29989], [128, 19988], [129, 9987], [130, 7996], [131, 39989], [132, 29988], [133, 19987], [134, 8996], [135, 49989], [136, 39988], [137, 29987], [138, 9996], [139, 59989], [140, 49988], [141, 39987], [142, 19996], [143, 69989], [144, 59988], [145, 49987], [146, 29996], [147, 79989], [148, 69988], [149, 59987], [150, 39996]
for e in ar:
if(e[0]==n):
return e[1]
return -1
elif(k==4):
ar=[[10, 0], [15, 1], [19, 9], [20, 2], [23, 8], [24, 19], [25, 3], [27, 7], [28, 18], [29, 29], [30, 4], [31, 6], [32, 17], [33, 28], [34, 39], [35, 5], [36, 16], [37, 27], [38, 38], [39, 49], [40, 15], [41, 26], [42, 37], [43, 48], [44, 59], [45, 25], [46, 36], [47, 47], [48, 58], [49, 69], [50, 35], [51, 46], [52, 57], [53, 68], [54, 79], [55, 45], [56, 56], [57, 67], [58, 78], [59, 89], [60, 55], [61, 66], [62, 77], [63, 88], [64, 189], [65, 65], [66, 76], [67, 87], [68, 188], [69, 289], [70, 75], [71, 86], [72, 187], [73, 288], [74, 389], [75, 85], [76, 186], [77, 287], [78, 388], [79, 489], [80, 95], [81, 286], [82, 387], [83, 488], [84, 589], [85, 195], [86, 386], [87, 487], [88, 588], [89, 689], [90, 295], [91, 486], [92, 587], [93, 688], [94, 789], [95, 395], [96, 586], [97, 687], [98, 788], [99, 889], [100, 495], [101, 686], [102, 787], [103, 888], [104, 989], [105, 595], [106, 786], [107, 887], [108, 988], [109, 1989], [110, 695], [111, 886], [112, 987], [113, 1988], [114, 2989], [115, 795], [116, 986], [117, 1987], [118, 2988], [119, 3989], [120, 895], [121, 1986], [122, 2987], [123, 3988], [124, 4989], [125, 995], [126, 2986], [127, 3987], [128, 4988], [129, 5989], [130, 1995], [131, 3986], [132, 4987], [133, 5988], [134, 6989], [135, 2995], [136, 4986], [137, 5987], [138, 6988], [139, 7989], [140, 3995], [141, 5986], [142, 6987], [143, 7988], [144, 8989], [145, 4995], [146, 6986], [147, 7987], [148, 8988], [149, 9989], [150, 5995]]
for e in ar:
if(e[0]==n):
return e[1]
return -1
elif(k==5):
ar=[[15, 0], [21, 1], [24, 9], [27, 2], [30, 7], [33, 3], [36, 5], [39, 4], [42, 15], [45, 14], [48, 25], [51, 24], [54, 35], [57, 34], [60, 45], [63, 44], [66, 55], [69, 54], [72, 65], [75, 64], [78, 75], [81, 74], [84, 85], [87, 84], [90, 185], [93, 94], [96, 285], [99, 194], [102, 385], [105, 294], [108, 485], [111, 394], [114, 585], [117, 494], [120, 685], [123, 594], [126, 785], [129, 694], [132, 885], [135, 794], [138, 985], [141, 894], [144, 1985], [147, 994], [150, 2985]]
for e in ar:
if(e[0]==n):
return e[1]
return -1
elif(k==6):
ar=[[21, 0], [28, 1], [30, 9], [32, 8], [34, 7], [35, 2], [36, 6], [37, 19], [38, 5], [39, 18], [40, 4], [41, 17], [42, 3], [43, 16], [44, 29], [45, 15], [46, 28], [47, 14], [48, 27], [49, 13], [50, 26], [51, 39], [52, 25], [53, 38], [54, 24], [55, 37], [56, 23], [57, 36], [58, 49], [59, 35], [60, 48], [61, 34], [62, 47], [63, 33], [64, 46], [65, 59], [66, 45], [67, 58], [68, 44], [69, 57], [70, 43], [71, 56], [72, 69], [73, 55], [74, 68], [75, 54], [76, 67], [77, 53], [78, 66], [79, 79], [80, 65], [81, 78], [82, 64], [83, 77], [84, 63], [85, 76], [86, 89], [87, 75], [88, 88], [89, 74], [90, 87], [91, 73], [92, 86], [93, 189], [94, 85], [95, 188], [96, 84], [97, 187], [98, 83], [99, 186], [100, 289], [101, 185], [102, 288], [103, 184], [104, 287], [105, 93], [106, 286], [107, 389], [108, 285], [109, 388], [110, 284], [111, 387], [112, 193], [113, 386], [114, 489], [115, 385], [116, 488], [117, 384], [118, 487], [119, 293], [120, 486], [121, 589], [122, 485], [123, 588], [124, 484], [125, 587], [126, 393], [127, 586], [128, 689], [129, 585], [130, 688], [131, 584], [132, 687], [133, 493], [134, 686], [135, 789], [136, 685], [137, 788], [138, 684], [139, 787], [140, 593], [141, 786], [142, 889], [143, 785], [144, 888], [145, 784], [146, 887], [147, 693], [148, 886], [149, 989], [150, 885]]
for e in ar:
if(e[0]==n):
return e[1]
return -1
elif(k==7):
ar=[[28, 0], [36, 1], [37, 9], [38, 8], [39, 7], [40, 6], [41, 5], [42, 4], [43, 3], [44, 2], [45, 19], [46, 18], [47, 17], [48, 16], [49, 15], [50, 14], [51, 13], [52, 12], [53, 29], [54, 28], [55, 27], [56, 26], [57, 25], [58, 24], [59, 23], [60, 22], [61, 39], [62, 38], [63, 37], [64, 36], [65, 35], [66, 34], [67, 33], [68, 32], [69, 49], [70, 48], [71, 47], [72, 46], [73, 45], [74, 44], [75, 43], [76, 42], [77, 59], [78, 58], [79, 57], [80, 56], [81, 55], [82, 54], [83, 53], [84, 52], [85, 69], [86, 68], [87, 67], [88, 66], [89, 65], [90, 64], [91, 63], [92, 62], [93, 79], [94, 78], [95, 77], [96, 76], [97, 75], [98, 74], [99, 73], [100, 72], [101, 89], [102, 88], [103, 87], [104, 86], [105, 85], [106, 84], [107, 83], [108, 82], [109, 189], [110, 188], [111, 187], [112, 186], [113, 185], [114, 184], [115, 183], [116, 92], [117, 289], [118, 288], [119, 287], [120, 286], [121, 285], [122, 284], [123, 283], [124, 192], [125, 389], [126, 388], [127, 387], [128, 386], [129, 385], [130, 384], [131, 383], [132, 292], [133, 489], [134, 488], [135, 487], [136, 486], [137, 485], [138, 484], [139, 483], [140, 392], [141, 589], [142, 588], [143, 587], [144, 586], [145, 585], [146, 584], [147, 583], [148, 492], [149, 689], [150, 688]]
for e in ar:
if(e[0]==n):
return e[1]
return -1
elif(k==8):
ar=[[36, 0], [45, 1], [54, 11], [63, 21], [72, 31], [81, 41], [90, 51], [99, 61], [108, 71], [117, 81], [126, 91], [135, 191], [144, 291]]
for e in ar:
if(e[0]==n):
return e[1]
return -1
elif(k==9):
ar=[[45, 0], [46, 1], [47, 2], [48, 3], [49, 4], [50, 5], [51, 6], [52, 7], [53, 8], [54, 9], [55, 10], [56, 11], [57, 12], [58, 13], [59, 14], [60, 15], [61, 16], [62, 17], [63, 18], [64, 19], [65, 20], [66, 21], [67, 22], [68, 23], [69, 24], [70, 25], [71, 26], [72, 27], [73, 28], [74, 29], [75, 30], [76, 31], [77, 32], [78, 33], [79, 34], [80, 35], [81, 36], [82, 37], [83, 38], [84, 39], [85, 40], [86, 41], [87, 42], [88, 43], [89, 44], [90, 45], [91, 46], [92, 47], [93, 48], [94, 49], [95, 50], [96, 51], [97, 52], [98, 53], [99, 54], [100, 55], [101, 56], [102, 57], [103, 58], [104, 59], [105, 60], [106, 61], [107, 62], [108, 63], [109, 64], [110, 65], [111, 66], [112, 67], [113, 68], [114, 69], [115, 70], [116, 71], [117, 72], [118, 73], [119, 74], [120, 75], [121, 76], [122, 77], [123, 78], [124, 79], [125, 80], [126, 81], [127, 82], [128, 83], [129, 84], [130, 85], [131, 86], [132, 87], [133, 88], [134, 89], [135, 90], [136, 181], [137, 182], [138, 183], [139, 184], [140, 185], [141, 186], [142, 187], [143, 188], [144, 189], [145, 190], [146, 281], [147, 282], [148, 283], [149, 284], [150, 285]]
for e in ar:
if(e[0]==n):
return e[1]
return -1
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
print(get(n,k))
``` | instruction | 0 | 1,825 | 20 | 3,650 |
Yes | output | 1 | 1,825 | 20 | 3,651 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let f(x) be the sum of digits of a decimal number x.
Find the smallest non-negative integer x such that f(x) + f(x + 1) + ... + f(x + k) = n.
Input
The first line contains one integer t (1 ≤ t ≤ 150) — the number of test cases.
Each test case consists of one line containing two integers n and k (1 ≤ n ≤ 150, 0 ≤ k ≤ 9).
Output
For each test case, print one integer without leading zeroes. If there is no such x that f(x) + f(x + 1) + ... + f(x + k) = n, print -1; otherwise, print the minimum x meeting that constraint.
Example
Input
7
1 0
1 1
42 7
13 7
99 1
99 0
99 2
Output
1
0
4
-1
599998
99999999999
7997
Submitted Solution:
```
# 1.Iterate over the last (rightmost) digit
# 2. Iterate over the number of 9s before it.
# 3. Calculate the needed sum of left digits, check it to be non-negative and integer.
# 4. Construct left part greedy to fit that sum.
# And find the minimum value among them. No special cases.
def get(s):
return str(s % 9) + '9' * (s // 9)
for tc in range(int(input())):
n, k = map(int, input().split())
k += 1
bst = 10**100
for d in range(10):
ends = 0
for i in range(k):
ends += (d + i) % 10
if ends > n:
continue
if d + k > 10:
for cnt in range(12):
s = 9 * cnt * (10 - d)
if s > n - ends:
break
for nd in range(9):
ns = s + (10 - d) * nd + (k - (10 - d)) * (nd + 1)
if ns > n - ends:
break
if (n - ends - ns) % k == 0:
bst = min(bst, int(get((n - ends - ns) // k) + str(nd) + '9' * cnt + str(d)))
elif (n - ends) % k == 0:
bst = min(bst, int(get((n - ends) // k) + str(d)))
print(-1 if bst == 10**100 else bst)
``` | instruction | 0 | 1,826 | 20 | 3,652 |
Yes | output | 1 | 1,826 | 20 | 3,653 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let f(x) be the sum of digits of a decimal number x.
Find the smallest non-negative integer x such that f(x) + f(x + 1) + ... + f(x + k) = n.
Input
The first line contains one integer t (1 ≤ t ≤ 150) — the number of test cases.
Each test case consists of one line containing two integers n and k (1 ≤ n ≤ 150, 0 ≤ k ≤ 9).
Output
For each test case, print one integer without leading zeroes. If there is no such x that f(x) + f(x + 1) + ... + f(x + k) = n, print -1; otherwise, print the minimum x meeting that constraint.
Example
Input
7
1 0
1 1
42 7
13 7
99 1
99 0
99 2
Output
1
0
4
-1
599998
99999999999
7997
Submitted Solution:
```
def get(s):
return str(s % 9) + '9' * (s // 9)
for tc in range(int(input())):
n, k = map(int, input().split())
k += 1
bst = 10**100
for d in range(10):
ends = 0
for i in range(k):
ends += (d + i) % 10
if ends > n:
continue
if d + k > 10:
for cnt in range(12):
s = 9 * cnt * (10 - d)
if s > n - ends:
break
for nd in range(9):
ns = s + (10 - d) * nd + (k - (10 - d)) * (nd + 1)
if ns > n - ends:
break
if (n - ends - ns) % k == 0:
bst = min(bst, int(get((n - ends - ns) // k) + str(nd) + '9' * cnt + str(d)))
elif (n - ends) % k == 0:
bst = min(bst, int(get((n - ends) // k) + str(d)))
print(-1 if bst == 10**100 else bst)
``` | instruction | 0 | 1,827 | 20 | 3,654 |
Yes | output | 1 | 1,827 | 20 | 3,655 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let f(x) be the sum of digits of a decimal number x.
Find the smallest non-negative integer x such that f(x) + f(x + 1) + ... + f(x + k) = n.
Input
The first line contains one integer t (1 ≤ t ≤ 150) — the number of test cases.
Each test case consists of one line containing two integers n and k (1 ≤ n ≤ 150, 0 ≤ k ≤ 9).
Output
For each test case, print one integer without leading zeroes. If there is no such x that f(x) + f(x + 1) + ... + f(x + k) = n, print -1; otherwise, print the minimum x meeting that constraint.
Example
Input
7
1 0
1 1
42 7
13 7
99 1
99 0
99 2
Output
1
0
4
-1
599998
99999999999
7997
Submitted Solution:
```
from sys import stdin, stdout
def cont(n):
res = 0
if n < 8:
return n
n -= 8
res += n % 9
n -= n % 9
while (n):
res *= 10
res += min(n, 9)
n -= min(n, 9)
res = (res * 10) + 8
return res
t = 1
t = int(stdin.readline())
for _ in range(t):
n, k = list(map(int, stdin.readline().split()))
ans = 10**17 +1
po = 1
for n9 in range(0,17,1):
po *= 10
for d in range(0,10,1):
a = min(10 - d, k + 1)
s = n - n9*9*a - (k + 1 - a)
for i in range(k + 1):
s -= (i + d) % 10
if s >= 0 and (s % (k + 1)) == 0:
ans = min(ans, po * cont(s // (k + 1)) + (po - 10 + d))
if ans == 10**17 +1:
print(-1)
else:
print(ans)
``` | instruction | 0 | 1,828 | 20 | 3,656 |
Yes | output | 1 | 1,828 | 20 | 3,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let f(x) be the sum of digits of a decimal number x.
Find the smallest non-negative integer x such that f(x) + f(x + 1) + ... + f(x + k) = n.
Input
The first line contains one integer t (1 ≤ t ≤ 150) — the number of test cases.
Each test case consists of one line containing two integers n and k (1 ≤ n ≤ 150, 0 ≤ k ≤ 9).
Output
For each test case, print one integer without leading zeroes. If there is no such x that f(x) + f(x + 1) + ... + f(x + k) = n, print -1; otherwise, print the minimum x meeting that constraint.
Example
Input
7
1 0
1 1
42 7
13 7
99 1
99 0
99 2
Output
1
0
4
-1
599998
99999999999
7997
Submitted Solution:
```
from sys import stdin, stdout
# 42 7
# 4 5 6 7 8 9 10 11 = 42
# 99 2
# 7997 7998 7999
# 32 33 34
# 99 => 9**11
# 0 1 2 3 4 5 6 7 8 9
# x x+1 x+2 x+3.....x+9 = n
# 1 2 3 4 5 6 7 8 9 | 0
#
# x+1 x+2 x+3..
# 109(x) => 110 => x-9y+1
# 1999(x) => 2000 => x-9y+1
# 111 => 120
# 191 => 200 (-9)
#
# k = 6
# x-4 + x-3 + x-2 + x-1 + x + x-9y+1 + x-9y+2 = n
# (k+1)x - 18y -3 -4 = n
# x = (n + 18y + 3 + 4)/(k+1)
# 99 2
# x-2 x-1 x
# 3x - 3 = 99 => x = 34 => 7999 => x-2 = 7997
# x-1 x x-9y+1
# 3x - 9y = 99 => x = 36 => 19989 => x-1 = 19988
# x x-9y+1 x-9y+2
# 3x - 18y + 3 = 99 => 19899
# 150 => 9*20
# Kx - 9*Ny = B
# x = (B + 9*Ny) / K
# (B + 9Ny) % K
# ex:
# 79297 79298 79299 79300 79301
# 7929[7] 7929[8] 7929[9] 7930[0] 7930[1] => end
# [79]297 [79]298 [79]299 [79]300 [79]301 => head
# 792[9]7 792[9]8 792[9]9 79300 79301 => cnt, s
# 79[2]97 79[2]98 79299 79[3]00 79[3]01 => nd, nd+1
if __name__ == '__main__':
def get(s):
return str(s%9) + '9'*(s//9)
def sum_of_digits(n, k):
k += 1
res = 10**100
for d in range(10):
end = 0
for i in range(k):
end += (d+i) % 10
if end > n:
continue
if d + k > 10:
#case XX8, XX9, XX0
for cnt in range(12):
s = 9 * cnt * (10 - d)
if s > n - end:
break
for nd in range(9):
ns = s + (10 - d)*nd + (k - (10 - d))*(nd + 1)
if ns > n - end:
break
if (n - end - ns) % k == 0:
res = min(res, int(get((n - end - ns) // k) + str(nd) + '9' * cnt + str(d)))
else:
#case XX0, XX1, XX2
if (n - end) % k == 0:
res = min(res, int(get((n - end)//k) + str(d)))
if res == 2**31-1:
return -1
else:
return res
t = int(stdin.readline())
for i in range(t):
n, k = map(int, stdin.readline().split())
stdout.write(str(sum_of_digits(n, k)) + '\n')
``` | instruction | 0 | 1,829 | 20 | 3,658 |
No | output | 1 | 1,829 | 20 | 3,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let f(x) be the sum of digits of a decimal number x.
Find the smallest non-negative integer x such that f(x) + f(x + 1) + ... + f(x + k) = n.
Input
The first line contains one integer t (1 ≤ t ≤ 150) — the number of test cases.
Each test case consists of one line containing two integers n and k (1 ≤ n ≤ 150, 0 ≤ k ≤ 9).
Output
For each test case, print one integer without leading zeroes. If there is no such x that f(x) + f(x + 1) + ... + f(x + k) = n, print -1; otherwise, print the minimum x meeting that constraint.
Example
Input
7
1 0
1 1
42 7
13 7
99 1
99 0
99 2
Output
1
0
4
-1
599998
99999999999
7997
Submitted Solution:
```
t=int(input())
grid=[]
for i in range(10):
grid.append([])
for j in range(151):
grid[-1].append(-1)
for i in range(100000):
ans=0
for j in range(10):
s=str(i+j)
for k in range(len(s)):
ans+=int(s[k])
if ans>150:
break
if ans>150:
break
if ans<=150 and grid[j][ans]==-1:
grid[j][ans]=i
for _ in range(t):
n,k=map(int,input().split())
if k>2:
print(grid[k][n])
continue
if k==0:
counter=0
while (counter+1)*9<n:
counter+=1
ans=[]
for i in range(counter):
ans.append('9')
ans.append(str(n-counter*9))
ans.reverse()
print(''.join(ans))
continue
if k==1:
if n<50:
print(grid[k][n])
else:
if n%2==0:
ans=['9','8']
n-=26
counter=0
while (counter+1)*18<n:
counter+=1
for i in range(counter):
ans.append('9')
ans.append(str((n-counter*18)//2))
ans.reverse()
print(''.join(ans))
else:
ans=['8','9']
n-=35
counter=0
while (counter+1)*18<n:
counter+=1
for i in range(counter):
ans.append('9')
ans.append(str((n-counter*18)//2))
ans.reverse()
print(''.join(ans))
continue
if k==2:
if n<100:
print(grid[k][n])
else:
ans=['7']
n-=24
counter=0
while (counter+1)*27<n:
counter+=1
for i in range(counter):
ans.append('9')
ans.append(str((n-counter*27)//3))
ans.reverse()
print(''.join(ans))
``` | instruction | 0 | 1,830 | 20 | 3,660 |
No | output | 1 | 1,830 | 20 | 3,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let f(x) be the sum of digits of a decimal number x.
Find the smallest non-negative integer x such that f(x) + f(x + 1) + ... + f(x + k) = n.
Input
The first line contains one integer t (1 ≤ t ≤ 150) — the number of test cases.
Each test case consists of one line containing two integers n and k (1 ≤ n ≤ 150, 0 ≤ k ≤ 9).
Output
For each test case, print one integer without leading zeroes. If there is no such x that f(x) + f(x + 1) + ... + f(x + k) = n, print -1; otherwise, print the minimum x meeting that constraint.
Example
Input
7
1 0
1 1
42 7
13 7
99 1
99 0
99 2
Output
1
0
4
-1
599998
99999999999
7997
Submitted Solution:
```
#!/usr/bin/env python3
def f(x):
ans = 0
while x > 0:
ans += x % 10
x //= 10
return ans
def calc(x, k):
ans = 0
for i in range(k + 1):
ans += f(x + i)
return ans
m = []
for i in range(151):
m.append([-1] * 10)
for x in range(100):
for k in range(10):
n = calc(x, k)
if n >= len(m):
continue
if m[n][k] == -1 or m[n][k] > x:
m[n][k] = x
def calc2(x):
global m
for i in range(11):
for k in range(10):
n = calc(x - i, k)
if n >= len(m):
continue
if m[n][k] == -1 or m[n][k] > x:
m[n][k] = x - i
for i in range(1, 15):
for j in range(1, 10):
# i: amount of 9
# j: first digit
mul = 1
x = 0
for k in range(i):
x += mul * 9
mul *= 10
x += mul * j
calc2(x)
for _ in range(int(input())):
n, k = map(int, input().split())
print(m[n][k])
``` | instruction | 0 | 1,831 | 20 | 3,662 |
No | output | 1 | 1,831 | 20 | 3,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let f(x) be the sum of digits of a decimal number x.
Find the smallest non-negative integer x such that f(x) + f(x + 1) + ... + f(x + k) = n.
Input
The first line contains one integer t (1 ≤ t ≤ 150) — the number of test cases.
Each test case consists of one line containing two integers n and k (1 ≤ n ≤ 150, 0 ≤ k ≤ 9).
Output
For each test case, print one integer without leading zeroes. If there is no such x that f(x) + f(x + 1) + ... + f(x + k) = n, print -1; otherwise, print the minimum x meeting that constraint.
Example
Input
7
1 0
1 1
42 7
13 7
99 1
99 0
99 2
Output
1
0
4
-1
599998
99999999999
7997
Submitted Solution:
```
for ss in range(int(input())):
n, k = input().strip().split()
n = int(n)
k = int(k)
list = []
ilist = []
klaar = True
for i in range(10):
m = 0
for t in range(k + 1):
s = i + t
if s >= 10:
s = s - 9
m = m + s
if ((i == 0) and m > n):
print(-1)
klaar = False
break
if (((n - m) % (k + 1)) == 0) and (n > m):
list.append(m)
ilist.append(i)
if n == m:
print(i)
klaar = False
break
if not(klaar):
break
# print("output: "+str(i))
# print("m: "+str(m))
# get max m waarde van list [m1, m2, m3, ... , mn]
if klaar:
if not(list):
print(-1)
continue
else:
i = ilist[list.index(max(list))]
if (i + k < 10) or (int((n - max(list))/(k + 1)) < 10):
lom = int((n - max(list))/(k + 1))
print(int(str(lom % 9) + ((lom // 9) * "9") + str(i)))
else:
lom = int(((n - max(list))/(k + 1)) - 8)
print(int(str(lom % 9) + ((lom // 9) * "9") + "8" + str(i)))
``` | instruction | 0 | 1,832 | 20 | 3,664 |
No | output | 1 | 1,832 | 20 | 3,665 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera has array a, consisting of n integers a0, a1, ..., an - 1, and function f(x), taking an integer from 0 to 2n - 1 as its single argument. Value f(x) is calculated by formula <image>, where value bit(i) equals one if the binary representation of number x contains a 1 on the i-th position, and zero otherwise.
For example, if n = 4 and x = 11 (11 = 20 + 21 + 23), then f(x) = a0 + a1 + a3.
Help Valera find the maximum of function f(x) among all x, for which an inequality holds: 0 ≤ x ≤ m.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of array elements. The next line contains n space-separated integers a0, a1, ..., an - 1 (0 ≤ ai ≤ 104) — elements of array a.
The third line contains a sequence of digits zero and one without spaces s0s1... sn - 1 — the binary representation of number m. Number m equals <image>.
Output
Print a single integer — the maximum value of function f(x) for all <image>.
Examples
Input
2
3 8
10
Output
3
Input
5
17 0 10 2 1
11010
Output
27
Note
In the first test case m = 20 = 1, f(0) = 0, f(1) = a0 = 3.
In the second sample m = 20 + 21 + 23 = 11, the maximum value of function equals f(5) = a0 + a2 = 17 + 10 = 27. | instruction | 0 | 1,945 | 20 | 3,890 |
Tags: implementation, math, number theory
Correct Solution:
```
import sys
class DFSHelper:
mxNum = 0
d = DFSHelper()
def backTrack(maxval, curval, binPos, maxBinPos, arr, total):
if binPos > maxBinPos:
if maxval >= curval:
d.mxNum = max(d.mxNum, total)
return
# Try 1
nxtVal = (1 << binPos) + curval
backTrack(maxval, nxtVal, binPos + 1, maxBinPos, arr, total + arr[binPos])
# Try 0
nxtVal = curval
backTrack(maxval, nxtVal, binPos + 1, maxBinPos, arr, total)
def constructM(m):
mult = 0
total = 0
for char in m:
if char == "1":
total += 2 ** mult
mult += 1
return total
def solve(arr, m):
maxval = constructM(m)
curval = 0
binPos = 0
maxBinPos = len(m) - 1
backTrack(maxval, curval, binPos, maxBinPos, arr, 0)
return d.mxNum
def solve2(arr, m):
DPTable = [[0 for _ in range(3)] for _ in range(len(arr) + 1)]
for i in range(len(arr)):
if m[i] == "0":
DPTable[i + 1][2] = DPTable[i][2] # max between ones and zeroes
DPTable[i + 1][1] = max(
DPTable[i][1], DPTable[i][1] + arr[i]
) # max of both ones and zeroes
if m[i] == "1":
DPTable[i + 1][2] = max(
DPTable[i][2] + arr[i], DPTable[i][1]
) # best of '01' chains leading up to here and either the 1 or max of 0000 for this chain
DPTable[i + 1][1] = max(
DPTable[i][1], DPTable[i][1] + arr[i]
) # max of both ones and zeroes
return DPTable[-1][2]
def readinput():
n = int(sys.stdin.readline().rstrip())
arr = list(map(int, (sys.stdin.readline().rstrip().split(" "))))
m = str(sys.stdin.readline().rstrip())
print(solve2(arr, m))
readinput()
``` | output | 1 | 1,945 | 20 | 3,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
C*++ language is quite similar to C++. The similarity manifests itself in the fact that the programs written in C*++ sometimes behave unpredictably and lead to absolutely unexpected effects. For example, let's imagine an arithmetic expression in C*++ that looks like this (expression is the main term):
* expression ::= summand | expression + summand | expression - summand
* summand ::= increment | coefficient*increment
* increment ::= a++ | ++a
* coefficient ::= 0|1|2|...|1000
For example, "5*a++-3*++a+a++" is a valid expression in C*++.
Thus, we have a sum consisting of several summands divided by signs "+" or "-". Every summand is an expression "a++" or "++a" multiplied by some integer coefficient. If the coefficient is omitted, it is suggested being equal to 1.
The calculation of such sum in C*++ goes the following way. First all the summands are calculated one after another, then they are summed by the usual arithmetic rules. If the summand contains "a++", then during the calculation first the value of the "a" variable is multiplied by the coefficient, then value of "a" is increased by 1. If the summand contains "++a", then the actions on it are performed in the reverse order: first "a" is increased by 1, then — multiplied by the coefficient.
The summands may be calculated in any order, that's why sometimes the result of the calculation is completely unpredictable! Your task is to find its largest possible value.
Input
The first input line contains an integer a ( - 1000 ≤ a ≤ 1000) — the initial value of the variable "a". The next line contains an expression in C*++ language of the described type. The number of the summands in the expression does not exceed 1000. It is guaranteed that the line describing the expression contains no spaces and tabulation.
Output
Output a single number — the maximal possible value of the expression.
Examples
Input
1
5*a++-3*++a+a++
Output
11
Input
3
a+++++a
Output
8
Note
Consider the second example. Initially a = 3. Suppose that at first the first summand is calculated, and then the second one is. The first summand gets equal to 3, and the value of a is increased by 1. At the calculation of the second summand a is increased once more (gets equal to 5). The value of the second summand is 5, and together they give 8. If we calculate the second summand first and the first summand later, then the both summands equals to 4, and the result is 8, too. | instruction | 0 | 1,959 | 20 | 3,918 |
Tags: expression parsing, greedy
Correct Solution:
```
import re
class Term:
def __init__(self, factor, type):
self.factor = factor
self.type = type
def __str__(self):
return '(%d * %s)' % (self.factor, self.type)
a = int(input())
s = '+' + input().strip()
terms = []
pos = 0
while pos != len(s):
sign = 1
if s[pos] == '-':
sign = -1
factor = 1
if re.match('\d', s[pos + 1]):
start = pos + 1
pos = start + 1
while s[pos] != '*':
pos += 1
factor = int(s[start:pos])
pos += 4
term_type = 'pre'
if s[pos - 3: pos] == 'a++':
term_type = 'post'
terms.append(Term(sign * factor, term_type))
terms.sort(key = lambda term: term.factor)
#print(', '.join(map(str, terms)))
result = 0
for term in terms:
if term.type == 'pre':
a += 1
result += term.factor * a
if term.type == 'post':
a += 1
print(result)
``` | output | 1 | 1,959 | 20 | 3,919 |
Provide tags and a correct Python 3 solution for this coding contest problem.
C*++ language is quite similar to C++. The similarity manifests itself in the fact that the programs written in C*++ sometimes behave unpredictably and lead to absolutely unexpected effects. For example, let's imagine an arithmetic expression in C*++ that looks like this (expression is the main term):
* expression ::= summand | expression + summand | expression - summand
* summand ::= increment | coefficient*increment
* increment ::= a++ | ++a
* coefficient ::= 0|1|2|...|1000
For example, "5*a++-3*++a+a++" is a valid expression in C*++.
Thus, we have a sum consisting of several summands divided by signs "+" or "-". Every summand is an expression "a++" or "++a" multiplied by some integer coefficient. If the coefficient is omitted, it is suggested being equal to 1.
The calculation of such sum in C*++ goes the following way. First all the summands are calculated one after another, then they are summed by the usual arithmetic rules. If the summand contains "a++", then during the calculation first the value of the "a" variable is multiplied by the coefficient, then value of "a" is increased by 1. If the summand contains "++a", then the actions on it are performed in the reverse order: first "a" is increased by 1, then — multiplied by the coefficient.
The summands may be calculated in any order, that's why sometimes the result of the calculation is completely unpredictable! Your task is to find its largest possible value.
Input
The first input line contains an integer a ( - 1000 ≤ a ≤ 1000) — the initial value of the variable "a". The next line contains an expression in C*++ language of the described type. The number of the summands in the expression does not exceed 1000. It is guaranteed that the line describing the expression contains no spaces and tabulation.
Output
Output a single number — the maximal possible value of the expression.
Examples
Input
1
5*a++-3*++a+a++
Output
11
Input
3
a+++++a
Output
8
Note
Consider the second example. Initially a = 3. Suppose that at first the first summand is calculated, and then the second one is. The first summand gets equal to 3, and the value of a is increased by 1. At the calculation of the second summand a is increased once more (gets equal to 5). The value of the second summand is 5, and together they give 8. If we calculate the second summand first and the first summand later, then the both summands equals to 4, and the result is 8, too. | instruction | 0 | 1,960 | 20 | 3,920 |
Tags: expression parsing, greedy
Correct Solution:
```
import re
u = int
G = input
X = sorted
y = print
A = re.findall
a = u(G())
b = X([[u((i[0]or '+')+(i[1]or '1')), i[3]]
for i in A('(\+|-)?(\d{0,4})(\*)?(a\+\+|\+\+a)', G())])
z = 0
for i in b:
if i[1] == 'a++':
z += i[0]*a
else:
z += i[0]*(a+1)
a += 1
y(z)
``` | output | 1 | 1,960 | 20 | 3,921 |
Provide tags and a correct Python 3 solution for this coding contest problem.
C*++ language is quite similar to C++. The similarity manifests itself in the fact that the programs written in C*++ sometimes behave unpredictably and lead to absolutely unexpected effects. For example, let's imagine an arithmetic expression in C*++ that looks like this (expression is the main term):
* expression ::= summand | expression + summand | expression - summand
* summand ::= increment | coefficient*increment
* increment ::= a++ | ++a
* coefficient ::= 0|1|2|...|1000
For example, "5*a++-3*++a+a++" is a valid expression in C*++.
Thus, we have a sum consisting of several summands divided by signs "+" or "-". Every summand is an expression "a++" or "++a" multiplied by some integer coefficient. If the coefficient is omitted, it is suggested being equal to 1.
The calculation of such sum in C*++ goes the following way. First all the summands are calculated one after another, then they are summed by the usual arithmetic rules. If the summand contains "a++", then during the calculation first the value of the "a" variable is multiplied by the coefficient, then value of "a" is increased by 1. If the summand contains "++a", then the actions on it are performed in the reverse order: first "a" is increased by 1, then — multiplied by the coefficient.
The summands may be calculated in any order, that's why sometimes the result of the calculation is completely unpredictable! Your task is to find its largest possible value.
Input
The first input line contains an integer a ( - 1000 ≤ a ≤ 1000) — the initial value of the variable "a". The next line contains an expression in C*++ language of the described type. The number of the summands in the expression does not exceed 1000. It is guaranteed that the line describing the expression contains no spaces and tabulation.
Output
Output a single number — the maximal possible value of the expression.
Examples
Input
1
5*a++-3*++a+a++
Output
11
Input
3
a+++++a
Output
8
Note
Consider the second example. Initially a = 3. Suppose that at first the first summand is calculated, and then the second one is. The first summand gets equal to 3, and the value of a is increased by 1. At the calculation of the second summand a is increased once more (gets equal to 5). The value of the second summand is 5, and together they give 8. If we calculate the second summand first and the first summand later, then the both summands equals to 4, and the result is 8, too. | instruction | 0 | 1,961 | 20 | 3,922 |
Tags: expression parsing, greedy
Correct Solution:
```
import re
n = int(input())
v = input()
f1, f2 = v.count('a++'), v.count('++a')
s = []
i = 0
while i < len(v) - 2:
if v[i] + v[i + 1] + v[i + 2] == '++a':
s.append('b')
i += 3
elif v[i] + v[i + 1] + v[i + 2] == 'a++':
s.append('a')
i += 3
else:
if i == len(v) - 2:
s.extend(v[i:])
i = len(v)
else:
s.append(v[i])
i += 1
a, m = [], []
z = 1
t = ''
for i in s:
if i in ['-', '+']:
if z:
a.append(t)
else:
m.append(t)
t = ''
z = 0 if i == '-' else 1
else:
t += i
if t != '':
if z:
a.append(t)
else:
m.append(t)
for i in range(len(a)):
t = a[i].split('*')
r = 1
k1 = k2 = 0
for j in t:
if not j.isalpha():
r *= int(j)
elif j == 'a':
k1 += 1
else:
k2 += 1
a[i] = (r, k1, k2)
for i in range(len(m)):
t = m[i].split('*')
r = 1
k1 = k2 = 0
for j in t:
if j.isnumeric():
r *= int(j)
elif j == 'a':
k1 += 1
else:
k2 += 1
m[i] = (r, k1, k2)
a.sort(key=lambda x: x[0])
m.sort(key=lambda x: -x[0])
ans = 0
t = n
for i in m:
if i[1] + i[2] == 0:
ans += i[0]
continue
z = i[0]
for j in range(i[1]):
z *= t
t += 1
for j in range(i[2]):
t += 1
z *= t
ans += z
res = 0
for i in a:
if i[1] + i[2] == 0:
res += i[0]
continue
z = i[0]
for j in range(i[1]):
z *= t
t += 1
for j in range(i[2]):
t += 1
z *= t
res += z
print(res - ans)
``` | output | 1 | 1,961 | 20 | 3,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all. | instruction | 0 | 2,507 | 20 | 5,014 |
Tags: games, greedy, implementation
Correct Solution:
```
n = int(input())
l = list(map(int,list(input())))
diff = n-11
if(l[0:diff+1].count(8)>diff//2):
print("YES")
else:
print("NO")
``` | output | 1 | 2,507 | 20 | 5,015 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all. | instruction | 0 | 2,508 | 20 | 5,016 |
Tags: games, greedy, implementation
Correct Solution:
```
n = int(input().strip())
s = input().strip()
n = len(s)
eights = s[:-10].count('8')
if eights == 0:
print('NO')
else:
extras = n-10-eights
if extras > eights:
print('NO')
else:
print('YES')
``` | output | 1 | 2,508 | 20 | 5,017 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all. | instruction | 0 | 2,509 | 20 | 5,018 |
Tags: games, greedy, implementation
Correct Solution:
```
n = int(input())
s = input()
r = n - 11
if s[:r+1].count('8') > (r+1)//2:
print('YES')
else:
print('NO')
``` | output | 1 | 2,509 | 20 | 5,019 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all. | instruction | 0 | 2,510 | 20 | 5,020 |
Tags: games, greedy, implementation
Correct Solution:
```
n = int(input())
s = input()
x = (n-11)//2
a = s.count('8')
if a<=x:
print('NO')
else:
res=[]
for i,y in enumerate(s):
if y=='8':
res.append(i)
e=0
for i in range(x+1):
if res[i]-e>x:
print('NO')
from sys import exit
exit()
e+=1
print('YES')
``` | output | 1 | 2,510 | 20 | 5,021 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all. | instruction | 0 | 2,511 | 20 | 5,022 |
Tags: games, greedy, implementation
Correct Solution:
```
n=int(input())
num=input()
if num[0:-10].count('8')<=(n-11)//2:
print('NO')
else:
print('YES')
``` | output | 1 | 2,511 | 20 | 5,023 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all. | instruction | 0 | 2,512 | 20 | 5,024 |
Tags: games, greedy, implementation
Correct Solution:
```
n = int(input())
string = str(input())
count = 0
first = 0
for i in range(n-10):
if string[i] == '8':
count += 1
if count > (n-11)/2:
print("YES")
else:
print("NO")
``` | output | 1 | 2,512 | 20 | 5,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all. | instruction | 0 | 2,513 | 20 | 5,026 |
Tags: games, greedy, implementation
Correct Solution:
```
n=int(input())
s=input()
a=0
for i in range(len(s)-10) :
if s[i]=="8" :
a+=1
if a>(n-10-a) :
print("YES")
else :
print("NO")
``` | output | 1 | 2,513 | 20 | 5,027 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all. | instruction | 0 | 2,514 | 20 | 5,028 |
Tags: games, greedy, implementation
Correct Solution:
```
import sys
from math import ceil
input = sys.stdin.readline
n = int(input())
s = list(input().strip())
deleteEights = (n-11)//2
deleteOthers = (n-11)//2
for i in range(n):
if deleteEights > 0:
if s[i] == '8':
s[i] = -1
deleteEights -= 1
continue
if deleteOthers > 0:
if s[i] != '8':
s[i] = -1
deleteOthers -= 1
continue
for i in range(n):
if s[i] != -1:
if s[i] == '8':
print("YES")
else:
print("NO")
break
``` | output | 1 | 2,514 | 20 | 5,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
n = int(input())
s = input()
t = n - 11
f = t // 2
ss = 0
for i in s:
if i == '8':
ss += 1
if ss <= f:
print('NO')
else:
for i in range(n):
if s[i] == '8':
f = f - 1
if f == -1:
p = i
break
if i <= t:
print('YES')
else:
print('NO')
``` | instruction | 0 | 2,515 | 20 | 5,030 |
Yes | output | 1 | 2,515 | 20 | 5,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
n = int(input())
s = input()
cnt = 0
for i in range(n - 10):
if s[i] == '8':
cnt += 1
if cnt >= ((n - 9) // 2):
print('YES')
else:
print('NO')
``` | instruction | 0 | 2,516 | 20 | 5,032 |
Yes | output | 1 | 2,516 | 20 | 5,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
n=int(input())
s=input()
# for i in range(n-10) :
# if s['i']!='8'
# if s[:n-10].count('8')%2==0:
# print(s[:n-10])
# print("YES")
# else: print("NO")
c=n-10-(s[:n-10].count('8'))
if c<s[:n-10].count('8'):
print("YES")
else: print("NO")
``` | instruction | 0 | 2,517 | 20 | 5,034 |
Yes | output | 1 | 2,517 | 20 | 5,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
N = int(input())
S = input()
turns = (N - 11) // 2
cnt = 0
for i in range(N - 10):
if S[i] == '8':
cnt += 1
if cnt >= turns + 1:
print("YES")
else:
print("NO")
``` | instruction | 0 | 2,518 | 20 | 5,036 |
Yes | output | 1 | 2,518 | 20 | 5,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
import sys, collections
n = int(sys.stdin.readline())
arr = list(map(int, sys.stdin.readline().rstrip()))
v = 0
p = 0
for i in range(n):
if v == (n - 11) // 2:
break
if arr[i] != 8:
arr[i] = -1
v += 1
for i in range(n):
if p == (n - 11) // 2:
break
if arr[i] == 8:
arr[i] = -1
p += 1
print('YES' if arr[n - 11] == 8 else 'NO')
``` | instruction | 0 | 2,520 | 20 | 5,040 |
No | output | 1 | 2,520 | 20 | 5,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
def mp():
return map(int, input().split())
n = int(input())
s = [int(i) for i in input()]
if s.count(8) >= n - 11:
print('YES')
else:
print('NO')
``` | instruction | 0 | 2,521 | 20 | 5,042 |
No | output | 1 | 2,521 | 20 | 5,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
n = int(input())
s = input()
if s[0] != '8':
if s[1] != '8': print('NO'); exit()
else: s = s[1:]
while(s[0] == '8'):
if s[1] == '8': s = s[1:]
else: s = s[0] + s[2:]
if len(s) == 11: print('YES'); exit()
s = s[1:]
if len(s) == 11: print('YES'); exit()
print('NO')
``` | instruction | 0 | 2,522 | 20 | 5,044 |
No | output | 1 | 2,522 | 20 | 5,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5 | instruction | 0 | 2,523 | 20 | 5,046 |
Tags: implementation
Correct Solution:
```
st=''
for i in range(1,10000):
st+=str(i)
n=int(input())
print(st[n-1])
``` | output | 1 | 2,523 | 20 | 5,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5 | instruction | 0 | 2,524 | 20 | 5,048 |
Tags: implementation
Correct Solution:
```
import sys,math
def read_int():
return int(sys.stdin.readline().strip())
def read_int_list():
return list(map(int,sys.stdin.readline().strip().split()))
def read_string():
return sys.stdin.readline().strip()
def read_string_list(delim=" "):
return sys.stdin.readline().strip().split(delim)
###### Author : Samir Vyas #######
###### Write Code Below #######
k = read_int()
base_digit_number = 1; expo = 0
while k >= base_digit_number:
base_digit_number += 9*(expo+1)*(10**expo)
expo += 1
base_digit_number -= 9*(expo)*(10**(expo-1))
ans_number = (k - base_digit_number)//expo + 10**(expo-1)
ans_digit = str(ans_number)[(k - base_digit_number)%expo]
print(ans_digit)
``` | output | 1 | 2,524 | 20 | 5,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5 | instruction | 0 | 2,525 | 20 | 5,050 |
Tags: implementation
Correct Solution:
```
st="0"
n=int(input(''))
i=0
j=1
while i<n :
st += str(j)
i+=1
j+=1
print(st[n]);
#print(st)
``` | output | 1 | 2,525 | 20 | 5,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5 | instruction | 0 | 2,526 | 20 | 5,052 |
Tags: implementation
Correct Solution:
```
l=int(input())
k=''
for i in range(1,10001):
k=k+str(i)
m=str(k)
print(m[l-1])
``` | output | 1 | 2,526 | 20 | 5,053 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5 | instruction | 0 | 2,527 | 20 | 5,054 |
Tags: implementation
Correct Solution:
```
st=""
for i in range(1,pow(10,4)+1):
st=st+str(i)
#print(st)
k=int(input())
print(st[k-1])
``` | output | 1 | 2,527 | 20 | 5,055 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5 | instruction | 0 | 2,528 | 20 | 5,056 |
Tags: implementation
Correct Solution:
```
n = ''
for i in range(1, 100001, 1):
n += str(i)
k = int(input())
print(n[k-1])
``` | output | 1 | 2,528 | 20 | 5,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5 | instruction | 0 | 2,529 | 20 | 5,058 |
Tags: implementation
Correct Solution:
```
def main():
k = int(input())
digit = 1; low=1; high=9; totalDigit=9; lastTotalDigit=0
while (totalDigit < k) :
low *= 10
high = 10*low-1
digit += 1
lastTotalDigit = totalDigit
totalDigit += (high+1-low)*digit
k -= lastTotalDigit
cur = str(low+(k-1) // digit)
print(cur[(k-1)%digit])
main()
``` | output | 1 | 2,529 | 20 | 5,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5 | instruction | 0 | 2,530 | 20 | 5,060 |
Tags: implementation
Correct Solution:
```
n=int(input())
ar=map(str,range(1,10001))
s=''
d=s.join(ar)
print(d[n-1])
``` | output | 1 | 2,530 | 20 | 5,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
k = int(input())
a=""
i=0
while(True):
a = a + str(i)
i += 1
if len(a) > k:
break
print(a[k])
``` | instruction | 0 | 2,531 | 20 | 5,062 |
Yes | output | 1 | 2,531 | 20 | 5,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
num = input()
num = int(num)
lst = []
i = 1
count = 0
index = -1
while (count<num):
strI = str(i)
strI = list(strI)
for n in range(0,len(strI)):
lst.append(strI[n])
if(i>=1000):
count+=4
elif(i>=100):
count+=3
elif(i>=10):
count+=2
else:
count+=1
i+=1
if count != num:
diff = count - num
index -= diff
ans = (lst[index])
finalAns = ''.join(ans)
print(finalAns)
``` | instruction | 0 | 2,532 | 20 | 5,064 |
Yes | output | 1 | 2,532 | 20 | 5,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
k = int(input())
number = 1
main_number = ''
while len(main_number) + len(str(number)) < k:
main_number += str(number)
number += 1
print(str(number)[k - len(main_number) - 1])
``` | instruction | 0 | 2,533 | 20 | 5,066 |
Yes | output | 1 | 2,533 | 20 | 5,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
n = int(input())
s = ''
k = 1
while len(s)<n:
s+=str(k)
k+=1
print(s[n-1])
``` | instruction | 0 | 2,534 | 20 | 5,068 |
Yes | output | 1 | 2,534 | 20 | 5,069 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
n=int(input())
x=1
while n>(10**len(str(x))*9):
n-=10**len(str(x))*9
x*=10
while n>len(str(x)):
n-=len(str(x))
x+=1
for i in range(len(str(x))):
if n!=0:
s=str(x)[i]
n-=1
print(s)
``` | instruction | 0 | 2,535 | 20 | 5,070 |
No | output | 1 | 2,535 | 20 | 5,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
import os
k = int(input())
string = ""
i=0
while len(string)<k:
i=i+1
string=string+str(i)
print(string[-1])
``` | instruction | 0 | 2,536 | 20 | 5,072 |
No | output | 1 | 2,536 | 20 | 5,073 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
import math
k = int(input())
x = 1
s=0
while s < k:
s = s + int(math.log10(x)) + 1
x += 1
print(str(x-1)[s-k-1])
``` | instruction | 0 | 2,537 | 20 | 5,074 |
No | output | 1 | 2,537 | 20 | 5,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number — the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes. | instruction | 0 | 2,702 | 20 | 5,404 |
Tags: brute force, implementation
Correct Solution:
```
def main():
mode="filee"
if mode=="file":f=open("test.txt","r")
get = lambda :[str(x) for x in (f.readline() if mode=="file" else input()).split()]
[g]=get()
#print(g)
n = len(g)
maxx = -1
for i in range( 1, n-1 ):
for j in range(i+1, n):
x = g[:i]
y = g[i:j]
z = g[j:]
#print(x, y, z)
if int(x) > 10**6 or int(y) > 10**6 or int(z) > 10**6 or len(x) > 1 and x[0] == '0' or len(y) > 1 and y[0] == '0' or len(z) > 1 and z[0] == '0':
continue
maxx = max( maxx, int(x) + int(y) + int(z) )
print(maxx)
if mode=="file":f.close()
if __name__=="__main__":
main()
``` | output | 1 | 2,702 | 20 | 5,405 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number — the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes. | instruction | 0 | 2,706 | 20 | 5,412 |
Tags: brute force, implementation
Correct Solution:
```
s = input()
n = len(s)
ans = -1
def f(x):
if x[0] == '0' and len(x) > 1:
return -1000000000000000000000000000000000000000000000000
ret = int(x)
if ret > 1000000:
return -1000000000000000000000000000000000000000000000000
return ret
for i in range(1, n):
for j in range(i + 1, n):
ans = max(ans, f(s[0:i]) + f(s[i:j]) + f(s[j:]))
print(ans)
``` | output | 1 | 2,706 | 20 | 5,413 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number — the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes. | instruction | 0 | 2,707 | 20 | 5,414 |
Tags: brute force, implementation
Correct Solution:
```
import sys
[s] = sys.stdin.read().split()
def isvalid (s):
if s == "0" or s=="1000000":
return True
if s[0] == '0' or len(s)>6:
return False
return True
mx = -1
for i in range(1, len(s)):
for j in range(i+1, len(s)):
s1 = s[0:i]
s2 = s[i:j]
s3 = s[j:]
if isvalid(s1) and isvalid(s2) and isvalid(s3):
a = int(s1)
b = int(s2)
c = int(s3)
mx = max(mx, a+b+c)
print(mx)
``` | output | 1 | 2,707 | 20 | 5,415 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number — the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes. | instruction | 0 | 2,708 | 20 | 5,416 |
Tags: brute force, implementation
Correct Solution:
```
s=input()
n=len(s)
maxi=-1
for i in range(n-2):
for j in range(i+1,n-1):
a,b,c= s[:i+1],s[i+1:j+1],s[j+1:]
if len(a)==len(str(int(a))) and len(b)==len(str(int(b))) and len(c)==len(str(int(c))):
if int(a)<=1e6 and int(b)<=1e6 and int(c)<=1e6:
maxi=max(maxi,int(a)+int(b)+int(c))
print(maxi)
``` | output | 1 | 2,708 | 20 | 5,417 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number — the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes. | instruction | 0 | 2,709 | 20 | 5,418 |
Tags: brute force, implementation
Correct Solution:
```
def isint(strx):
if strx == '0':
return True
if strx[0] == '0':
return False
return int(strx) <= 1000000
maxx = -1
x = input()
for i in range(1, len(x)):
for j in range(i+1, len(x)):
a, b, c = x[:i], x[i:j], x[j:]
if isint(a) and isint(b) and isint(c):
maxx = max(maxx, int(a)+int(b)+int(c))
print(maxx)
``` | output | 1 | 2,709 | 20 | 5,419 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6. | instruction | 0 | 2,920 | 20 | 5,840 |
Tags: dp, matrices
Correct Solution:
```
f = lambda: map(int, input().split())
m = 1000000007
n, b, k, x = f()
s = [0] * x
for q in f(): s[q % x] += 1
def g(t, d):
if not t: return s
p = [0] * x
for i, a in enumerate(t):
for j, b in enumerate(s):
p[(i + d * j) % x] += a * b
return [q % m for q in p]
t = []
u, v = 1, 10
while b:
if b & 1:
t = g(t, u)
u = v * u % x
s = g(s, v)
v = v * v % x
b >>= 1
print(t[k])
``` | output | 1 | 2,920 | 20 | 5,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6. | instruction | 0 | 2,921 | 20 | 5,842 |
Tags: dp, matrices
Correct Solution:
```
f = lambda: map(int, input().split())
m = 1000000007
n, b, k, x = f()
s = [0] * x
for q in f(): s[q % x] += 1
def g(t, d):
p = [0] * x
for i, a in enumerate(t):
for j, b in enumerate(s):
p[(i + d * j) % x] += a * b
return [q % m for q in p]
t = []
u, v = 1, 10
while b:
if b & 1:
t = g(t, u) if t else s
u = v * u % x
s = g(s, v)
v = v * v % x
b >>= 1
print(t[k])
``` | output | 1 | 2,921 | 20 | 5,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6. | instruction | 0 | 2,922 | 20 | 5,844 |
Tags: dp, matrices
Correct Solution:
```
n,b,k,x=map(int,input().split())
arr=list(map(int,input().split()))
flg=[0]*x
mod = 10**9+7
for i in arr:
flg[i%x]+=1
def mul(dp,flg,rank):
global x
res=[0]*x
for i in range(x):
for j in range(x):
res[ ( (i*rank)%x+j)%x ] += dp[i]*flg[j]%mod
res[ ( (i*rank)%x+j)%x ] %= mod
# print(i,j,dp[i],dp[j],res[ ( (i*rank)%x+j)%x ])
return res
def pow(n):
global x
res=1
base=10
while n:
if n&1:
res=(res*base)%x
base=(base*base)%x
n>>=1
return res
dp=[0]*x
dp[0]=1
# print(mul(dp,flg,1))
rank=1
while b:
if b&1:
dp=mul(dp,flg,pow(rank))
flg=mul(flg,flg,pow(rank))
rank<<=1
b>>=1
print(dp[k])
``` | output | 1 | 2,922 | 20 | 5,845 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.