problem_id
stringlengths 6
6
| buggy_code
stringlengths 8
526k
| fixed_code
stringlengths 12
526k
| labels
listlengths 0
15
⌀ | buggy_submission_id
int64 1
1.54M
| fixed_submission_id
int64 2
1.54M
| user_id
stringlengths 10
10
| language
stringclasses 8
values |
|---|---|---|---|---|---|---|---|
p02780
|
n, k = map(int,input().split())
p = list(map(int, input().split()))
val = 0
for i in range(k):
val += p[i]
point = k-1
cnt = val
for i in range(k,n):
cnt += p[i] - p[i-k]
if cnt > val:
val = cnt
point = i-k+1
#print(point)
ans = 0
for i in range(k):
ans += (p[point] + 1) / 2
point += 1
print(ans)
|
n, k = map(int,input().split())
p = list(map(int, input().split()))
val = 0
for i in range(k):
val += p[i]
point = 0
cnt = val
for i in range(k,n):
cnt = cnt + p[i] - p[i-k]
if cnt > val:
val = cnt
point = i-k+1
#print(point)
ans = 0
for i in range(k):
ans += (p[point] + 1) / 2
point += 1
print(ans)
|
[
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 581,088
| 581,089
|
u361381049
|
python
|
p02780
|
import numpy as np
n,k = map(int(input().split()))
p = np.array(list(map(int, input().split())))
m = (p+1)/2
s = sum(m[:k])
r = s
for i in range(n-k):
s -= m[i]
s += m[i+k]
r = max(r,s)
print(r)
|
import numpy as np
n,k = map(int, input().split())
p = np.array(list(map(int, input().split())))
m = (p+1)/2
s = sum(m[:k])
r = s
for i in range(n-k):
s -= m[i]
s += m[i+k]
r = max(r,s)
print(r)
|
[
"assignment.value.change",
"call.arguments.change"
] | 581,103
| 581,104
|
u864989756
|
python
|
p02780
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
#q=[x-1 for x in p]
ans=0
s=sum(p[:k])
for i in range(n-k):
s=s+p[k+i]-p[i]
ans=max(ans,s)
print(ans/2+k/2)
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
s=sum(p[:k])
ans=s
for i in range(n-k):
s=s+p[k+i]-p[i]
ans=max(ans,s)
print(ans/2+k/2)
|
[
"assignment.remove",
"assignment.add"
] | 581,127
| 581,128
|
u762540523
|
python
|
p02780
|
N, K = map(int, input().split())
p = list(map(int, input().split()))
S = [0]*(N+1)
for i in range(N):
S[i+1] = S[i] + (1+p[i])/2
print(S)
ans = 0
for i in range(N-K+1):
diff = S[i+K] - S[i]
ans = max(ans, diff)
print(ans)
|
N, K = map(int, input().split())
p = list(map(int, input().split()))
S = [0]*(N+1)
for i in range(N):
S[i+1] = S[i] + (1+p[i])/2
ans = 0
for i in range(N-K+1):
diff = S[i+K] - S[i]
ans = max(ans, diff)
print(ans)
|
[
"call.remove"
] | 581,136
| 581,137
|
u273010357
|
python
|
p02780
|
n,k,*p=map(int,open(0).read().split())
s=m=k
for i in range(k,n):s+=p[i]-p[i-k]*(i>=k);m=max(m,s)
print(m/2)
|
n,k,*p=map(int,open(0).read().split())
s=m=k
for i in range(n):s+=p[i]-p[i-k]*(i>=k);m=max(m,s)
print(m/2)
|
[
"call.arguments.change"
] | 581,154
| 581,155
|
u729133443
|
python
|
p02780
|
n,k,*p=map(int,open(0).read().split())
s=m=sum(p[:k])
for i in range(k,n):s+=p[i]-p[i-k];m=max(m,s)
print((s+k)/2)
|
n,k,*p=map(int,open(0).read().split())
s=m=sum(p[:k])
for i in range(k,n):s+=p[i]-p[i-k];m=max(m,s)
print((m+k)/2)
|
[
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 581,157
| 581,158
|
u729133443
|
python
|
p02780
|
n,k,*p=map(int,open(0).read().split())
p+=0,
for i in range(n):p[i]-=~p[i-1]
print(max(p[i+k]-p[i-1]for i in range(n-k))/2)
|
n,k,*p=map(int,open(0).read().split())
p+=0,
for i in range(n):p[i]-=~p[i-1]
print(max(p[i+k]-p[i]for i in range(-1,n-k))/2)
|
[
"expression.operation.binary.remove",
"call.arguments.add"
] | 581,160
| 581,161
|
u729133443
|
python
|
p02780
|
N,K = map(int,input().split())
ps = list(map(int,input().split()))
dicesSum=[]
l1=ps[0:K]
dicesSum.append(sum(l1))
if K==N:
exp= (K+ dicesSum[0])/2
print(exp)
else:
for i in range(1,N-K+1):
dicesSum.append(dicesSum[i-1]-ps[i-1]+ps[i+K-1])
print(dicesSum)
max_value = max(dicesSum)
exp= (K+ max_value)/2
print(exp)
|
N,K = map(int,input().split())
ps = list(map(int,input().split()))
dicesSum=[]
l1=ps[0:K]
dicesSum.append(sum(l1))
if K==N:
exp= (K+ dicesSum[0])/2
print(exp)
else:
for i in range(1,N-K+1):
dicesSum.append(dicesSum[i-1]-ps[i-1]+ps[i+K-1])
max_value = max(dicesSum)
exp= (K+ max_value)/2
print(exp)
|
[
"call.remove"
] | 581,166
| 581,167
|
u971719367
|
python
|
p02780
|
N,K = map(int,input().split())
ps = list(map(int,input().split()))
dicesSum=[]
l1=ps[0:K]
dicesSum.append(sum(l1))
if K==1:
exp= (1+ dicesSum[0])/2
print(exp)
else:
for i in range(1,N-K):
dicesSum.append(dicesSum[i-1]-ps[i-1]+ps[i+K-1])
max_value = max(dicesSum)
exp= (K+ max_value)/2
print(exp)
|
N,K = map(int,input().split())
ps = list(map(int,input().split()))
dicesSum=[]
l1=ps[0:K]
dicesSum.append(sum(l1))
if K==N:
exp= (K+ dicesSum[0])/2
print(exp)
else:
for i in range(1,N-K+1):
dicesSum.append(dicesSum[i-1]-ps[i-1]+ps[i+K-1])
max_value = max(dicesSum)
exp= (K+ max_value)/2
print(exp)
|
[
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 581,168
| 581,167
|
u971719367
|
python
|
p02780
|
import numpy as np
N, K = map(int, input().split())
x = np.array(list(map(float, input().split())))
for i in range(N):
x[i] = (1 + x[i]) / 2
ans = 0
data = np.sum(x[:K])
for i in range(N-K):
data = data + x[i+K] - x[i]
if data > ans:
ans = data
print(ans)
|
import numpy as np
N, K = map(int, input().split())
x = np.array(list(map(float, input().split())))
for i in range(N):
x[i] = (1 + x[i]) / 2
data = np.sum(x[:K])
ans = data
for i in range(N-K):
data = data + x[i+K] - x[i]
if data > ans:
ans = data
print(ans)
|
[
"assignment.remove",
"assignment.add"
] | 581,183
| 581,184
|
u370217787
|
python
|
p02780
|
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from math import gcd
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
n, k = MAP()
p = LIST()
def kitai(a):
tmp = 0
# for a in A:
tmp = 1/a * (1/2 * a * (a+1))
return tmp
acc = [0] * n
# それぞれの期待値を先に求めて，それから和を求める
for i in range(n):
acc[i] = (p[i] + 1) / 2
ruiseki = [0] * n
ruiseki[0] = acc[i]
for i in range(n-1):
ruiseki[i+1] = ruiseki[i] + acc[i+1]
# print(acc)
# print(ruiseki)
# acc = list(accumulate([0]+acc))
ans = 0
ruiseki.insert(0, 0)
ans = 0
for i in range(n-k+1):
m = ruiseki[k+i] - ruiseki[i]
ans = max(ans, m)
print(ans)
# if i == 0:
# ruiseki[k]
# else:
# ruiseki[k+i] - ruiseki[i]
# ans = max(ans, acc[i+k]-acc[i])
|
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from math import gcd
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
n, k = MAP()
p = LIST()
def kitai(a):
tmp = 0
# for a in A:
tmp = 1/a * (1/2 * a * (a+1))
return tmp
acc = [0] * n
# それぞれの期待値を先に求めて，それから和を求める
for i in range(n):
acc[i] = (p[i] + 1) / 2
ruiseki = [0] * n
ruiseki[0] = acc[0]
for i in range(n-1):
ruiseki[i+1] = ruiseki[i] + acc[i+1]
ruiseki.insert(0, 0)
# print(ruiseki)
ans = 0
for i in range(n-k+1):
m = ruiseki[k+i] - ruiseki[i]
# print(m)
ans = max(ans, m)
print(ans)
# if i == 0:
# ruiseki[k]
# else:
# ruiseki[k+i] - ruiseki[i]
# ans = max(ans, acc[i+k]-acc[i])
|
[
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change"
] | 581,193
| 581,194
|
u083960235
|
python
|
p02780
|
def main():
from itertools import accumulate
import sys
read = sys.stdin.buffer.read
N, K, *p = map(int, read().split())
p = [0] + list(accumulate(p))
print((max(y - x for x, y in zip(p, p[K:])) + K) / 2)
if __name__ == '__main__':
print(main())
|
def main():
from itertools import accumulate
import sys
read = sys.stdin.buffer.read
N, K, *p = map(int, read().split())
p = [0] + list(accumulate(p))
print((max(y - x for x, y in zip(p, p[K:])) + K) / 2)
if __name__ == '__main__':
main()
|
[
"call.remove",
"call.arguments.change"
] | 581,203
| 581,204
|
u607729897
|
python
|
p02780
|
from itertools import accumulate
n,k = map(int,input().split())
P = list(map(int,input().split()))
# 期待値の前計算
expP = [(P[i]+1)/2 for i in range(n)]
# 累積和の計算
acc = [0]+ list(+accumulate(expP)) # 0を忘れずに
print(acc)
# 隣接する K 項の和の計算
ans = 0
for i in range(n-k+1):
ans = max(ans,acc[i+k]-acc[i])
print(ans)
|
from itertools import accumulate
n,k = map(int,input().split())
P = list(map(int,input().split()))
# 期待値の前計算
expP = [(P[i]+1)/2 for i in range(n)]
# 累積和の計算
acc = [0]+ list(accumulate(expP)) # 0を忘れずに
# 隣接する K 項の和の計算
ans = 0
for i in range(n-k+1):
ans = max(ans,acc[i+k]-acc[i])
print(ans)
|
[
"expression.operation.unary.arithmetic.remove",
"call.arguments.change",
"call.remove"
] | 581,205
| 581,206
|
u202727309
|
python
|
p02780
|
nk = list(map(int,input().split()))
p = list(map(int,input().split()))
ans = [0] * (nk[0] + nk[1])
zeros = [0] * nk[1]
seq4search = zeros + p
for i in range(nk[1], nk[0] + nk[1]):
seq4search[i] = (seq4search[i] + 1) / 2
ans[i] = ans[i-1] + seq4search[i] - seq4search[i - k]
print(max(ans))
|
nk = list(map(int,input().split()))
p = list(map(int,input().split()))
ans = [0] * (nk[0] + nk[1])
zeros = [0] * nk[1]
seq4search = zeros + p
for i in range(nk[1], nk[0] + nk[1]):
seq4search[i] = (seq4search[i] + 1) / 2
ans[i] = ans[i-1] + seq4search[i] - seq4search[i - nk[1]]
print(max(ans))
|
[
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 581,207
| 581,208
|
u882696550
|
python
|
p02780
|
nk = list(map(int,input().split()))
p = list(map(int,input().split()))
ans = [0] * (nk[0] + nk[1])
zeros = [0] * nk[1]
seq4search = zeros + p
for i in range(nk[1] + 1, nk[0] + nk[1]):
seq4search[i] = (seq4search[i] + 1) / 2
ans[i] = ans[i-1] + seq4search[i] - seq4search[i - k]
print(max(ans))
|
nk = list(map(int,input().split()))
p = list(map(int,input().split()))
ans = [0] * (nk[0] + nk[1])
zeros = [0] * nk[1]
seq4search = zeros + p
for i in range(nk[1], nk[0] + nk[1]):
seq4search[i] = (seq4search[i] + 1) / 2
ans[i] = ans[i-1] + seq4search[i] - seq4search[i - nk[1]]
print(max(ans))
|
[
"expression.operation.binary.remove",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 581,209
| 581,208
|
u882696550
|
python
|
p02780
|
n, k = map(int, input().split())
l = list(map(int, input().split()))
tmp = l[:k]
now = tmp
for i in range(n-k):
tmp -= l[i]
tmp += l[i+k]
now = max(tmp, now)
print((now + k) / 2)
|
n, k = map(int, input().split())
l = list(map(int, input().split()))
tmp = sum(l[:k])
now = tmp
for i in range(n-k):
tmp -= l[i]
tmp += l[i+k]
now = max(tmp, now)
print((now + k) / 2)
|
[
"call.add",
"call.arguments.change"
] | 581,222
| 581,223
|
u055875839
|
python
|
p02780
|
n, k = map(int, input().split())
l = list(map(int, input().split()))
tmp = l[:k]
now = tmp
for i in range(n-k+1):
tmp -= l[i]
tmp += l[i+k]
now = max(tmp, now)
print((now + k) / 2)
|
n, k = map(int, input().split())
l = list(map(int, input().split()))
tmp = sum(l[:k])
now = tmp
for i in range(n-k):
tmp -= l[i]
tmp += l[i+k]
now = max(tmp, now)
print((now + k) / 2)
|
[
"call.add",
"call.arguments.change",
"expression.operation.binary.remove"
] | 581,224
| 581,223
|
u055875839
|
python
|
p02780
|
N, K = map(int, input().split())
p = list(map(int, input().split()))
now = sum(p[:K])
saidai = now
for i in range(K, N):
now -= p[i-K]
now += p[i+K]
if now > saidai:
saidai = now
print('{:.12f}'.format((saidai + K)/2))
|
N, K = map(int, input().split())
p = list(map(int, input().split()))
now = sum(p[:K])
saidai = now
for i in range(K, N):
now -= p[i-K]
now += p[i]
if now > saidai:
saidai = now
print('{:.12f}'.format((saidai + K)/2))
|
[
"expression.operation.binary.remove"
] | 581,225
| 581,226
|
u096983897
|
python
|
p02780
|
a, b = map(int, input().split())
num_list = list(map(int, input().split()))
k_sum = sum(num_list[0:b])
max_sum = k_sum
for i, j in zip(num_list[0:], num_list[k:]):
k_sum -= i
k_sum += j
max_sum = max(max_sum, k_sum)
out = (max_sum + b) / 2
print(out)
|
a, b = map(int, input().split())
num_list = list(map(int, input().split()))
k_sum = sum(num_list[0:b])
max_sum = k_sum
for i, j in zip(num_list[0:], num_list[b:]):
k_sum -= i
k_sum += j
max_sum = max(max_sum, k_sum)
out = (max_sum + b) / 2
print(out)
|
[
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 581,240
| 581,241
|
u078982327
|
python
|
p02780
|
from itertools import accumulate
N, K = map(int, input().split())
A = list(map(int, input().split()))
expected = [(a+1)/2 for a in A]
accum_expected = list(accumulate(expected))
accum_expected.insert(0, 0)
ans = 0
for i in range(K, N-K+1):
ans = max(ans, accum_expected[i]-accum_expected[i-K])
print(ans)
|
from itertools import accumulate
N, K = map(int, input().split())
A = list(map(int, input().split()))
expected = [(a+1)/2 for a in A]
accum_expected = list(accumulate(expected))
accum_expected.insert(0, 0)
ans = 0
for i in range(K, N+1):
ans = max(ans, accum_expected[i]-accum_expected[i-K])
print(ans)
|
[
"expression.operation.binary.remove"
] | 581,242
| 581,243
|
u746849814
|
python
|
p02780
|
def main():
def CalExVal(x):
return (1/2*(x+1))
N, K = map(int, input().split())
A = list(map(int, input().split()))
Ex = list((map(CalExVal, A)))
#temp = len(A)-K + 1
#adjlist = [0]*(temp)
#adjlist = [sum(list(map(CalExVal, A))[i:(K+i)]) for i in range(temp)]
tem = sum(Ex[:K])
res = tem
for i in range(0,N-K):
adj = tem - Ex[i] + Ex[i+K]
if res < adj:
res = adj
print(res)
if __name__ == '__main__':
main()
|
def main():
def CalExVal(x):
return (1/2*(x+1))
N, K = map(int, input().split())
A = list(map(int, input().split()))
Ex = list((map(CalExVal, A)))
#temp = len(A)-K + 1
#adjlist = [0]*(temp)
#adjlist = [sum(list(map(CalExVal, A))[i:(K+i)]) for i in range(temp)]
tem = sum(Ex[:K])
res = tem
for i in range(0,N-K):
tem = tem - Ex[i] + Ex[i+K]
if res < tem:
res = tem
print(res)
if __name__ == '__main__':
main()
|
[
"assignment.variable.change",
"identifier.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 581,248
| 581,249
|
u841924362
|
python
|
p02780
|
raw = input()
N, K = raw.split(' ')
N = int(N)
K = int(K)
str_li = input().split(' ')
num_li = list(map(int, str_li))
sum_li = [0]
for i in num_li:
sum_li.append(sum_li[-1] + i + 1)
ans = 0
for index in range(K, N):
ans_tmp = sum_li[index] - sum_li[index - K]
if ans_tmp > ans:
ans = ans_tmp
print(ans/2)
|
raw = input()
N, K = raw.split(' ')
N = int(N)
K = int(K)
str_li = input().split(' ')
num_li = list(map(int, str_li))
sum_li = [0]
for i in num_li:
sum_li.append(sum_li[-1] + i + 1)
ans = 0
for index in range(K, N+1):
ans_tmp = sum_li[index] - sum_li[index - K]
if ans_tmp > ans:
ans = ans_tmp
print(ans/2)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 581,252
| 581,253
|
u064136529
|
python
|
p02780
|
# sys.stdin.readline()
import sys
input = sys.stdin.readline
def main():
n,k = map(int,input().split())
l=list(map(int,input().split()))
l2 = [(1+i)/2 for i in l]
kitai=sum(l2[0:k])
tmp = kitai
for idx in range(n)[:n - k + 1]:
tmp -= l2[idx]
tmp += l2[idx+k]
if (kitai < tmp):
kitai = tmp
print(kitai)
main()
|
# sys.stdin.readline()
import sys
input = sys.stdin.readline
def main():
n,k = map(int,input().split())
l=list(map(int,input().split()))
l2 = [(1+i)/2 for i in l]
kitai=sum(l2[0:k])
tmp = kitai
for idx in range(n)[:n - k]:
tmp -= l2[idx]
tmp += l2[idx+k]
if (kitai < tmp):
kitai = tmp
print(kitai)
main()
|
[
"expression.operation.binary.remove"
] | 581,267
| 581,268
|
u820284192
|
python
|
p02781
|
N = input()
K = int(input())
m = len(N)
dp = [[[0] * (K+1) for _ in range(2)] for _ in range(m+1)]
dp[0][0][0] = 1
for i in range(1,m+1):
l = int(N[i-1])
for k in range(K+1):
if k-1>0:
if l!=0:
dp[i][0][k]=dp[i-1][0][k-1]
dp[i][1][k] = dp[i-1][1][k] + 9 * dp[i-1][1][k-1]+dp[i-1][0][k] + (l-1) * dp[i-1][0][k-1]
else:
dp[i][0][k] = dp[i-1][0][k]
dp[i][1][k] = dp[i-1][1][k] + 9 * dp[i-1][1][k-1]
else:
dp[i][0][k] = 0
dp[i][1][k] = 1
print(dp[m][0][K] + dp[m][1][K])
|
N = input()
K = int(input())
m = len(N)
dp = [[[0] * (K+1) for _ in range(2)] for _ in range(m+1)]
dp[0][0][0] = 1
for i in range(1,m+1):
l = int(N[i-1])
for k in range(K+1):
if k-1>=0:
if l!=0:
dp[i][0][k]=dp[i-1][0][k-1]
dp[i][1][k] = dp[i-1][1][k] + 9 * dp[i-1][1][k-1]+dp[i-1][0][k] + (l-1) * dp[i-1][0][k-1]
else:
dp[i][0][k] = dp[i-1][0][k]
dp[i][1][k] = dp[i-1][1][k] + 9 * dp[i-1][1][k-1]
else:
dp[i][0][k] = 0
dp[i][1][k] = 1
print(dp[m][0][K] + dp[m][1][K])
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 581,314
| 581,315
|
u434872492
|
python
|
p02781
|
import sys
sys.setrecursionlimit(100)
n = input()
k = int(input())
m = {}
def doit(n, k):
if len(n) == 0:
return k == 0
d = int(n[0])
if (n, k) not in m:
ret = 0
for i in range(d + 1):
if i == d:
ret += doit(n[1:], k - 1 if i > 0 else k)
else:
ret += doit('9' * (len(n) - 1), k - 1 if i > 0 else k)
m[(n, k)] = ret
return m[(n, k)]
print(doit(n, k))
|
import sys
sys.setrecursionlimit(10000)
n = input()
k = int(input())
m = {}
def doit(n, k):
if len(n) == 0:
return k == 0
d = int(n[0])
if (n, k) not in m:
ret = 0
for i in range(d + 1):
if i == d:
ret += doit(n[1:], k - 1 if i > 0 else k)
else:
ret += doit('9' * (len(n) - 1), k - 1 if i > 0 else k)
m[(n, k)] = ret
return m[(n, k)]
print(doit(n, k))
|
[
"literal.number.integer.change",
"call.arguments.change"
] | 581,321
| 581,322
|
u971632623
|
python
|
p02781
|
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
# INF = float("inf")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353
N = input()
K = int(input())
dp = [[[0]*(K+2) for j in range(2)] for i in range(len(N) + 1)]
dp[0][1][0] = 1
for i in range(len(N)):
for k in range(K+1):
dp[i+1][0][k] += dp[i][0][k]
dp[i+1][0][k+1] += dp[i][0][k]*9
if N[i] != 0:
dp[i+1][0][k] += dp[i][1][k]
dp[i+1][0][k+1] += dp[i][1][k]*(int(N[i])-1)
dp[i+1][1][k+1] += dp[i][1][k]
else:
dp[i+1][1][k] += dp[i][1][k]
print(dp[-1][0][K] + dp[-1][1][K])
|
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
# INF = float("inf")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353
N = input()
K = int(input())
dp = [[[0]*(K+2) for j in range(2)] for i in range(len(N) + 1)]
dp[0][1][0] = 1
for i in range(len(N)):
for k in range(K+1):
dp[i+1][0][k] += dp[i][0][k]
dp[i+1][0][k+1] += dp[i][0][k]*9
if N[i] != "0":
dp[i+1][0][k] += dp[i][1][k]
dp[i+1][0][k+1] += dp[i][1][k]*(int(N[i])-1)
dp[i+1][1][k+1] += dp[i][1][k]
else:
dp[i+1][1][k] += dp[i][1][k]
print(dp[-1][0][K] + dp[-1][1][K])
|
[
"control_flow.branch.if.condition.change"
] | 581,327
| 581,328
|
u788260274
|
python
|
p02781
|
def resolve():
N = list(input())
lenN = len(N)
K = int(input())
dp = [[[None, None] for _ in range(K+1)] for __ in range(lenN)]
def rec(i, k, smaller):
if k==0:
return 1
if i>=lenN:
return 0
if dp[i][k][int(smaller)] is not None:
return dp[i][k][int(smaller)]
ret = 0
if smaller:
ret += rec(i+1, k, True)
ret += rec(i+1, k-1, True) * 9
else:
if N[i] == "0":
ret += rec(i+1, k, True)
else:
ret += rec(i+1, k, True) # 次も0を選ぶ
ret += rec(i+1, k-1, True) * (int(N[i]) - 1) # 0 < ?? < N[i]
ret += rec(i+1, k-1, False) # N[i]を選ぶ、真にsmallerとは限らないのでまだFalse
dp[i][k][int(smaller)] = ret
return ret
print(rec(0, K, False))
if __name__ == "__main__":
resolve()
|
def resolve():
N = list(input())
lenN = len(N)
K = int(input())
dp = [[[None, None] for _ in range(K+1)] for __ in range(lenN)]
def rec(i, k, smaller):
if k==0:
return 1
if i>=lenN:
return 0
if dp[i][k][int(smaller)] is not None:
return dp[i][k][int(smaller)]
ret = 0
if smaller:
ret += rec(i+1, k, True)
ret += rec(i+1, k-1, True) * 9
else:
if N[i] == "0":
ret += rec(i+1, k, False)
else:
ret += rec(i+1, k, True) # 次も0を選ぶ
ret += rec(i+1, k-1, True) * (int(N[i]) - 1) # 0 < ?? < N[i]
ret += rec(i+1, k-1, False) # N[i]を選ぶ、真にsmallerとは限らないのでまだFalse
dp[i][k][int(smaller)] = ret
return ret
print(rec(0, K, False))
if __name__ == "__main__":
resolve()
|
[
"misc.opposites",
"call.arguments.change"
] | 581,347
| 581,348
|
u106797249
|
python
|
p02781
|
N = input()
K = int(input())
dp = [[[0] * (K + 1) for _ in range(2)] for _ in range(len(N) + 1)]
dp[0][0][0] = 1
for i in range(len(N)):
n = int(N[i])
for j in range(2):
for k in range(K + 1):
for d in range((9 if j == 1 else n) + 1):
if k + int(d != 0) <= K:
dp[i + 1][j | (d < n)][k + int(d != 0)] += dp[i][j][k]
cnt = len(N) - N.count("0")
print(dp[-1][-1][-1] + int(cnt <= K))
|
N = input()
K = int(input())
dp = [[[0] * (K + 1) for _ in range(2)] for _ in range(len(N) + 1)]
dp[0][0][0] = 1
for i in range(len(N)):
n = int(N[i])
for j in range(2):
for k in range(K + 1):
for d in range((9 if j == 1 else n) + 1):
if k + int(d != 0) <= K:
dp[i + 1][j | (d < n)][k + int(d != 0)] += dp[i][j][k]
cnt = len(N) - N.count("0")
print(dp[-1][-1][-1] + int(cnt == K))
|
[
"expression.operator.compare.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 581,353
| 581,354
|
u057109575
|
python
|
p02781
|
N = input()
K = int(input())
if len(N) < K:
print(0)
exit()
ans = [1, int(N[-1]), 0, 0];
nine = [1, 9, 81, 729]
def combination(N,K):
if N < K:
return 0
elif K == 0:
return 0
elif K == 1:
return N
elif K == 2:
return N*(N-1)//2
else:
return N*(N-1)*(N-2)//6
for k in range(1, len(N)):
if int(N[-k-1]) > 0:
a = [1, 0, 0, 0]
for j in range(1, K+1):
a[j] += nine[j]*combination(k, j)
a[j] += (int(N[-k-1])-1)*combination(k, j-1)*nine[j-1] + ans[j-1]
ans = a
print(ans[K])
|
N = input()
K = int(input())
if len(N) < K:
print(0)
exit()
ans = [1, int(N[-1]), 0, 0];
nine = [1, 9, 81, 729]
def combination(N,K):
if N < K:
return 0
elif K == 0:
return 1
elif K == 1:
return N
elif K == 2:
return N*(N-1)//2
else:
return N*(N-1)*(N-2)//6
for k in range(1, len(N)):
if int(N[-k-1]) > 0:
a = [1, 0, 0, 0]
for j in range(1, K+1):
a[j] += nine[j]*combination(k, j)
a[j] += (int(N[-k-1])-1)*combination(k, j-1)*nine[j-1] + ans[j-1]
ans = a
print(ans[K])
|
[
"literal.number.integer.change",
"function.return_value.change"
] | 581,365
| 581,366
|
u627600101
|
python
|
p02781
|
N = input()
K = int(input())
if len(N) < K:
print(0)
exit()
ans = [1, int(N[-1]), 0, 0];
nine = [1, 9, 81, 729]
def combination(N,K):
if N < K:
return 0
elif K == 0:
return 0
elif K == 1:
return N
elif K == 2:
return N*(N-1)//2
else:
return N*(N-1)*(N-3)//6
for k in range(1, len(N)):
if int(N[-k-1]) > 0:
a = [1, 0, 0, 0]
for j in range(1, K+1):
a[j] += nine[j]*combination(k, j)
a[j] += (int(N[-k-1])-1)*combination(k, j-1)*nine[j-1] + ans[j-1]
ans = a
print(ans[K])
|
N = input()
K = int(input())
if len(N) < K:
print(0)
exit()
ans = [1, int(N[-1]), 0, 0];
nine = [1, 9, 81, 729]
def combination(N,K):
if N < K:
return 0
elif K == 0:
return 1
elif K == 1:
return N
elif K == 2:
return N*(N-1)//2
else:
return N*(N-1)*(N-2)//6
for k in range(1, len(N)):
if int(N[-k-1]) > 0:
a = [1, 0, 0, 0]
for j in range(1, K+1):
a[j] += nine[j]*combination(k, j)
a[j] += (int(N[-k-1])-1)*combination(k, j-1)*nine[j-1] + ans[j-1]
ans = a
print(ans[K])
|
[
"literal.number.integer.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 581,367
| 581,366
|
u627600101
|
python
|
p02781
|
N = input()
K = int(input())
if int(N) < K:
print(0)
exit()
keta = []
for k in range(len(N)):
keta.append(int(N[-k-1]))
ans = [1, keta[0], 0, 0];
def combination(N,K):
if N < K:
return 0
else:
p = 1
for k in range(K):
p *= N
N -= 1
for k in range(1, K+1):
p //= k
return p
for k in range(1, len(N)-1):
if keta[k] > 0:
a = [1, 0, 0, 0]
for j in range(1, 4):
a[j] += (9**(j))*combination(k, j)
a[j] += (keta[k]-1)*combination(k, j-1)*(9**(j-1)) + ans[j-1]
ans = [] + a
answer = (9**(K))*combination(len(N)-1, K)
answer += (keta[-1]-1)*(9**(K-1))*combination(len(N)-1, K-1)
answer += ans[K-1]
print(answer)
|
N = input()
K = int(input())
if len(N) < K:
print(0)
exit()
keta = []
for k in range(len(N)):
keta.append(int(N[-k-1]))
ans = [1, keta[0], 0, 0];
def combination(N,K):
if N < K:
return 0
else:
p = 1
for k in range(K):
p *= N
N -= 1
for k in range(1, K+1):
p //= k
return p
for k in range(1, len(N)-1):
if keta[k] > 0:
a = [1, 0, 0, 0]
for j in range(1, 4):
a[j] += (9**(j))*combination(k, j)
a[j] += (keta[k]-1)*combination(k, j-1)*(9**(j-1)) + ans[j-1]
ans = [] + a
answer = (9**(K))*combination(len(N)-1, K)
answer += (keta[-1]-1)*(9**(K-1))*combination(len(N)-1, K-1)
answer += ans[K-1]
print(answer)
|
[
"identifier.change",
"call.function.change",
"control_flow.branch.if.condition.change"
] | 581,368
| 581,369
|
u627600101
|
python
|
p02781
|
import sys
sys.setrecursionlimit(10**6)
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
MOD = 10**9+7
N = int(readline())
K = int(readline())
@lru_cache(None)
def f(N,K):
if K == -1:
return 0
if N < 10:
if K == 0:
return 1
elif K == 1:
return N
else:
return 0
ans = 0
q, mod = divmod(N, 10)
ans += f(q,K) + mod * f(q,K-1) + (9-mod) * f(q-1,K-1)
return ans
print(f(N,K))
|
import sys
from functools import lru_cache
sys.setrecursionlimit(10**6)
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
MOD = 10**9+7
N = int(readline())
K = int(readline())
@lru_cache(None)
def f(N,K):
if K == -1:
return 0
if N < 10:
if K == 0:
return 1
elif K == 1:
return N
else:
return 0
ans = 0
q, mod = divmod(N, 10)
ans += f(q,K) + mod * f(q,K-1) + (9-mod) * f(q-1,K-1)
return ans
print(f(N,K))
|
[] | 581,385
| 581,386
|
u515740713
|
python
|
p02781
|
n = int(input())
k = int(input())
ans = 0
def k1(n):
str1_n = str(n)
keta1 = len(str1_n)
cnt = 9 * (keta1 - 1) + int(str1_n[0])
return cnt
def k2(n):
str2_n = str(n)
keta2 = len(str2_n)
cnt = 81 * (keta2 - 1) * (keta2 - 2) // 2
cnt += (int(str2_n[0]) - 1) * k1(10 ** (keta2 - 1) - 1)
cnt += k1(n - (int(str2_n[0]) * 10 ** (keta2 - 1)))
return cnt
def k3(n): # なんか違う
str3_n = str(n)
keta3 = len(str3_n)
t = 0
for i in range(keta3-3):
t += (i+1)*i//2
cnt = 729 * t
cnt += (int(str3_n[0]) - 1) * k2(10 ** (keta3 - 1) - 1)
cnt += k2(n - (int(str3_n[0]) * 10 ** (keta3 - 1)))
return cnt
if k == 1:
ans = k1(n)
if k == 2:
ans = k2(n)
if k == 3:
ans = k3(n)
print(ans)
|
n = int(input())
k = int(input())
ans = 0
def k1(n):
str1_n = str(n)
keta1 = len(str1_n)
cnt = 9 * (keta1 - 1) + int(str1_n[0])
return cnt
def k2(n):
str2_n = str(n)
keta2 = len(str2_n)
cnt = 81 * (keta2 - 1) * (keta2 - 2) // 2
cnt += (int(str2_n[0]) - 1) * k1(10 ** (keta2 - 1) - 1)
cnt += k1(n - (int(str2_n[0]) * 10 ** (keta2 - 1)))
return cnt
def k3(n):
str3_n = str(n)
keta3 = len(str3_n)
t = 0
for i in range(keta3-2):
t += (i+1)*i//2
cnt = 729 * t
cnt += (int(str3_n[0]) - 1) * k2(10 ** (keta3 - 1) - 1)
cnt += k2(n - (int(str3_n[0]) * 10 ** (keta3 - 1)))
return cnt
if k == 1:
ans = k1(n)
if k == 2:
ans = k2(n)
if k == 3:
ans = k3(n)
print(ans)
|
[
"literal.number.integer.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.range.bounds.upper.change"
] | 581,394
| 581,395
|
u222668979
|
python
|
p02781
|
import functools
N = int(input())
K = int(input())
@functools.lru_cache(user_function)
def func(num,counter):
remain = num%10
quotient = num//10
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K))
|
import functools
N = int(input())
K = int(input())
@functools.lru_cache(None)
def func(num,counter):
remain = num%10
quotient = num//10
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K))
|
[
"call.arguments.change"
] | 581,421
| 581,422
|
u772029934
|
python
|
p02781
|
import functiontool
N = int(input())
K = int(input())
@functools.lru_cache(user_function)
def func(num,counter):
remain = num%10
quotient = num//10
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K))
|
import functools
N = int(input())
K = int(input())
@functools.lru_cache(None)
def func(num,counter):
remain = num%10
quotient = num//10
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K))
|
[
"identifier.change",
"call.arguments.change"
] | 581,423
| 581,422
|
u772029934
|
python
|
p02781
|
import functools
N = int(input())
K = int(input())
@functools.lru_cache(user_function)
def func(num,counter):
remain = num%10
quotient = num//10
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K))
|
import functools
N = int(input())
K = int(input())
@functools.lru_cache()
def func(num,counter):
remain = num%10
quotient = num//10
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K))
|
[
"call.arguments.change"
] | 581,421
| 581,425
|
u772029934
|
python
|
p02781
|
import functiontool
N = int(input())
K = int(input())
@functools.lru_cache(user_function)
def func(num,counter):
remain = num%10
quotient = num//10
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K))
|
import functools
N = int(input())
K = int(input())
@functools.lru_cache()
def func(num,counter):
remain = num%10
quotient = num//10
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K))
|
[
"identifier.change",
"call.arguments.change"
] | 581,423
| 581,425
|
u772029934
|
python
|
p02781
|
N = int(input())
K = int(input())
@lru_cache
def func(num,counter):
remain = num%10
quotient = num//10
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K))
|
import functools
N = int(input())
K = int(input())
@functools.lru_cache()
def func(num,counter):
remain = num%10
quotient = num//10
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K))
|
[
"call.add"
] | 581,426
| 581,425
|
u772029934
|
python
|
p02781
|
N = int(input())
K = int(input())
def func(num,counter):
remain = num%10
quotient = num//10
print(num,counter)
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K))
|
N = int(input())
K = int(input())
def func(num,counter):
remain = num%10
quotient = num//10
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K))
|
[
"call.remove"
] | 581,427
| 581,428
|
u772029934
|
python
|
p02781
|
def main():
import sys
input = sys.stdin.readline
N = list(map(int, list(input()[:-1])))
K = int(input())
L = len(N)
# dp[i][j][k]
# i 桁目まで決めて
# j 個の非0を使って
# k = 0 : そこまでの桁はNと一致
# k = 1 : そこまでの桁でN未満であることが確定
dp = [[[0] * 2 for _ in range(K + 2)] for _ in range(L + 1)]
dp[0][0][0] = 1
from pprint import pprint
for i, x in enumerate(N):
for k in range(K + 1):
# 桁ごと数え上げ
if x == 0:
# x == 0
dp[i + 1][k][0] += dp[i][k][0]
else:
# x == 0
dp[i + 1][k][1] = dp[i][k][0]
# 0 < n < x
dp[i + 1][k + 1][1] += dp[i][k][0] * (x - 1)
# n == x
dp[i + 1][k + 1][0] += dp[i][k][0]
# N未満で次の桁に1~9を入れる
dp[i + 1][k + 1][1] += dp[i][k][1] * 9
# N未満で次の桁に0を入れる
dp[i + 1][k][1] += dp[i][k][1]
print(sum(dp[L][K]))
if __name__ == '__main__':
main()
|
def main():
import sys
input = sys.stdin.readline
N = list(map(int, list(input()[:-1])))
K = int(input())
L = len(N)
# dp[i][j][k]
# i 桁目まで決めて
# j 個の非0を使って
# k = 0 : そこまでの桁はNと一致
# k = 1 : そこまでの桁でN未満であることが確定
dp = [[[0] * 2 for _ in range(K + 2)] for _ in range(L + 1)]
dp[0][0][0] = 1
for i, x in enumerate(N):
for k in range(K + 1):
# 桁ごと数え上げ
if x == 0:
# x == 0
dp[i + 1][k][0] += dp[i][k][0]
else:
# x == 0
dp[i + 1][k][1] += dp[i][k][0]
# 0 < n < x
dp[i + 1][k + 1][1] += dp[i][k][0] * (x - 1)
# n == x
dp[i + 1][k + 1][0] += dp[i][k][0]
# N未満で次の桁に1~9を入れる
dp[i + 1][k + 1][1] += dp[i][k][1] * 9
# N未満で次の桁に0を入れる
dp[i + 1][k][1] += dp[i][k][1]
print(sum(dp[L][K]))
if __name__ == '__main__':
main()
|
[
"assignment.value.change"
] | 581,436
| 581,437
|
u111473084
|
python
|
p02781
|
def main():
import sys
input = sys.stdin.readline
N = list(map(int, list(input()[:-1])))
K = int(input())
L = len(N)
# dp[i][j][k]
# i 桁目まで決めて
# j 個の非0を使って
# k = 0 : そこまでの桁はNと一致
# k = 1 : そこまでの桁でN未満であることが確定
dp = [[[0] * 2 for _ in range(K + 2)] for _ in range(L + 1)]
dp[0][0][0] = 1
from pprint import pprint
for i, x in enumerate(N):
for k in range(K + 1):
# 桁ごと数え上げ
if x == 0:
# x == 0
dp[i + 1][k][0] += dp[i][k][0]
else:
# x == 0
dp[i + 1][k][1] = dp[i][k][0]
# 0 < n < x
dp[i + 1][k + 1][1] += dp[i][k][0] * (x - 1)
# n == x
dp[i + 1][k + 1][0] += dp[i][k][0]
# N未満で次の桁に1~9を入れる
dp[i + 1][k + 1][1] += dp[i][k][1] * 9
# N未満で次の桁に0を入れる
dp[i + 1][k][1] += dp[i][k][1]
print(sum(dp[L][K]))
if __name__ == '__main__':
main()
|
def main():
import sys
input = sys.stdin.readline
N = list(map(int, list(input()[:-1])))
K = int(input())
L = len(N)
# dp[i][j][k]
# i 桁目まで決めて
# j 個の非0を使って
# k = 0 : そこまでの桁はNと一致
# k = 1 : そこまでの桁でN未満であることが確定
dp = [[[0] * 2 for _ in range(K + 2)] for _ in range(L + 1)]
dp[0][0][0] = 1
from pprint import pprint
for i, x in enumerate(N):
for k in range(K + 1):
# 桁ごと数え上げ
if x == 0:
# x == 0
dp[i + 1][k][0] += dp[i][k][0]
else:
# x == 0
dp[i + 1][k][1] += dp[i][k][0]
# 0 < n < x
dp[i + 1][k + 1][1] += dp[i][k][0] * (x - 1)
# n == x
dp[i + 1][k + 1][0] += dp[i][k][0]
# N未満で次の桁に1~9を入れる
dp[i + 1][k + 1][1] += dp[i][k][1] * 9
# N未満で次の桁に0を入れる
dp[i + 1][k][1] += dp[i][k][1]
print(sum(dp[L][K]))
if __name__ == '__main__':
main()
|
[
"assignment.value.change"
] | 581,436
| 581,438
|
u111473084
|
python
|
p02781
|
def main():
NOT_DET = 0
SMALLER = 1
s = input()
n = len(s) # 桁数
k = int(input())
dp = [[[0] * 2 for _ in range(k + 1)] for _ in range(n + 1)]
# dp[上から何桁決めたか][0でない数字の個数][smaller=1]
dp[0][0][0] = 1
for i, ci in enumerate(s):
for j in range(k + 1):
dp[i + 1][j][SMALLER] = (
dp[i][j][SMALLER]
+ dp[i][j][NOT_DET] * (1 if ci != '0' else 0)
+ (dp[i][j - 1][SMALLER] if j > 0 else 0) * 9
+ (dp[i][j - 1][NOT_DET] if j > 0 else 0) * (int(ci) - 1)
)
dp[i + 1][j][NOT_DET] = dp[i][j][NOT_DET] if ci == '0' else (
dp[i][j - 1][NOT_DET] if j > 0 else 0)
print(sum(dp[n][k]))
if __name__ == '__main__':
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
|
def main():
NOT_DET = 0
SMALLER = 1
s = input()
n = len(s) # 桁数
k = int(input())
dp = [[[0] * 2 for _ in range(k + 1)] for _ in range(n + 1)]
# dp[上から何桁決めたか][0でない数字の個数][smaller=1]
dp[0][0][0] = 1
for i, ci in enumerate(s):
for j in range(k + 1):
dp[i + 1][j][SMALLER] = (
dp[i][j][SMALLER]
+ dp[i][j][NOT_DET] * (1 if ci != '0' else 0)
+ (dp[i][j - 1][SMALLER] if j > 0 else 0) * 9
+ (dp[i][j - 1][NOT_DET] if j > 0 else 0) * max(0, int(ci) - 1)
)
dp[i + 1][j][NOT_DET] = dp[i][j][NOT_DET] if ci == '0' else (
dp[i][j - 1][NOT_DET] if j > 0 else 0)
print(sum(dp[n][k]))
if __name__ == '__main__':
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
|
[
"call.add",
"call.arguments.add"
] | 581,444
| 581,445
|
u562935282
|
python
|
p02781
|
n = str(input())
k = int(input())
dp = [[[0] * (k+1) for i in range(2)] for j in range(len(n)+1)]
dp[0][0][0] = 1
for i in range(len(n)):
for j in range(k+1):
if n[i] == "0":
dp[i+1][0][j] = dp[i][0][j]
dp[i+1][1][j] = dp[i][1][j]
if j > 0:
dp[i+1][1][j] += dp[i][1][j-1]*9
else:
dp[i+1][1][j] = dp[i][0][j] + dp[i][1][j]
if j > 0:
dp[i+1][0][j] = dp[i][0][j-1]
dp[i+1][1][j] += dp[i][1][j-1] * (int(n[i])-1) + dp[i][1][j-1] * 9
# print(dp)
print(dp[-1][0][k] + dp[-1][1][k])
|
n = str(input())
k = int(input())
dp = [[[0] * (k+1) for i in range(2)] for j in range(len(n)+1)]
dp[0][0][0] = 1
for i in range(len(n)):
for j in range(k+1):
if n[i] == "0":
dp[i+1][0][j] = dp[i][0][j]
dp[i+1][1][j] = dp[i][1][j]
if j > 0:
dp[i+1][1][j] += dp[i][1][j-1]*9
else:
dp[i+1][1][j] = dp[i][0][j] + dp[i][1][j]
if j > 0:
dp[i+1][0][j] = dp[i][0][j-1]
dp[i+1][1][j] += dp[i][0][j-1] * (int(n[i])-1) + dp[i][1][j-1] * 9
# print(dp)
print(dp[-1][0][k] + dp[-1][1][k])
|
[
"expression.operation.binary.change"
] | 581,446
| 581,447
|
u667024514
|
python
|
p02781
|
from functools import lru_cache
N = input()
K = int(input())
@lru_cache(maxsize=None)
def search(d, cnt, isEq):
if d == len(N):
return 1 if cnt == K else 0
n = int(N[d])
if isEq and n == '0':
return search(d + 1, cnt, isEq)
if isEq:
ret = 0
ret += search(d + 1, cnt, False)
for _ in range(1, n):
ret += search(d + 1, cnt + 1, False)
ret += search(d + 1, cnt + 1, True)
return ret
return search(d + 1, cnt, False) + search(d + 1, cnt + 1, False) * 9
print(search(0, 0, True))
|
from functools import lru_cache
N = input()
K = int(input())
@lru_cache(maxsize=None)
def search(d, cnt, isEq):
if d == len(N):
return 1 if cnt == K else 0
n = int(N[d])
if isEq and n == 0:
return search(d + 1, cnt, isEq)
if isEq:
ret = 0
ret += search(d + 1, cnt, False)
for _ in range(1, n):
ret += search(d + 1, cnt + 1, False)
ret += search(d + 1, cnt + 1, True)
return ret
return search(d + 1, cnt, False) + search(d + 1, cnt + 1, False) * 9
print(search(0, 0, True))
|
[
"control_flow.branch.if.condition.change"
] | 581,462
| 581,463
|
u392319141
|
python
|
p02781
|
import math
import numpy as np
import queue
from collections import deque
import heapq
def cmb(n,r):
c = 1
for i in range(r):
c *= (n-i)
for i in range(r):
c //= (i+1)
return c
n = input()
k = int(input())
ln = len(n)
ans = 1
nn0 = 0
for i in range(ln):
if int(n[i]) > 0:
ans += cmb(ln-i-1,k-nn0)*(9**(k-nn0))
nn0 += 1
ans += (int(n[i])-1)*cmb(ln-i-1,k-nn0)*(9**(k-nn0))
if nn0 == k:
break
print(ans)
|
import math
import numpy as np
import queue
from collections import deque
import heapq
def cmb(n,r):
c = 1
for i in range(r):
c *= (n-i)
for i in range(r):
c //= (i+1)
return c
n = input()
k = int(input())
ln = len(n)
ans = 0
nn0 = 0
for i in range(ln):
if int(n[i]) > 0:
ans += cmb(ln-i-1,k-nn0)*(9**(k-nn0))
nn0 += 1
ans += (int(n[i])-1)*cmb(ln-i-1,k-nn0)*(9**(k-nn0))
if nn0 == k:
ans += 1
break
print(ans)
|
[
"literal.number.integer.change",
"assignment.value.change"
] | 581,466
| 581,467
|
u169350228
|
python
|
p02781
|
n_str = input() # 3***
k = int(input())
dp1 = [[0] * (k + 2) for _ in range(len(n_str) + 1)]
dp2 = [[0] * (k + 2) for _ in range(len(n_str) + 1)]
# dp1[i][j] : 上から i 桁はnと一致していて、0でない数が j 個現れているような数
# dp2[i][j] : 上から i 桁が既にnより小さく、0でない数が j 個現れているような数
dp1[0][0] = 1
# dp2[0][1] = int(n_str[0]) - 1
# dp2[0][0] = 1
for i in range(len(n_str)):
for j in range(k + 1):
if n_str[i] != '0':
dp1[i + 1][j + 1] += dp1[i][j]
dp2[i + 1][j + 1] += dp1[i][j] * (int(n_str[i]) - 1)
dp2[i + 1][j + 1] += dp2[i][j] * 9
dp2[i + 1][j] += dp1[i][j]
dp2[i + 1][j] += dp2[i][j]
else:
print(i, j)
dp1[i + 1][j] += dp1[i][j]
dp2[i + 1][j + 1] += dp2[i][j] * 9
dp2[i + 1][j] += dp2[i][j]
# print(*dp1, sep='\n')
# print(*dp2, sep='\n')
ans = dp1[len(n_str)][k] + dp2[len(n_str)][k]
print(ans)
|
n_str = input() # 3***
k = int(input())
dp1 = [[0] * (k + 2) for _ in range(len(n_str) + 1)]
dp2 = [[0] * (k + 2) for _ in range(len(n_str) + 1)]
# dp1[i][j] : 上から i 桁はnと一致していて、0でない数が j 個現れているような数
# dp2[i][j] : 上から i 桁が既にnより小さく、0でない数が j 個現れているような数
dp1[0][0] = 1
# dp2[0][1] = int(n_str[0]) - 1
# dp2[0][0] = 1
for i in range(len(n_str)):
for j in range(k + 1):
if n_str[i] != '0':
dp1[i + 1][j + 1] += dp1[i][j]
dp2[i + 1][j + 1] += dp1[i][j] * (int(n_str[i]) - 1)
dp2[i + 1][j + 1] += dp2[i][j] * 9
dp2[i + 1][j] += dp1[i][j]
dp2[i + 1][j] += dp2[i][j]
else:
dp1[i + 1][j] += dp1[i][j]
dp2[i + 1][j + 1] += dp2[i][j] * 9
dp2[i + 1][j] += dp2[i][j]
# print(*dp1, sep='\n')
# print(*dp2, sep='\n')
ans = dp1[len(n_str)][k] + dp2[len(n_str)][k]
print(ans)
|
[
"call.remove"
] | 581,492
| 581,493
|
u533039576
|
python
|
p02781
|
def solve(n,k) :
if n <= 9 and k == 1 :
return n
elif n <= 9 and k >= 2 :
return 0
elif k == 0:
return 0
else :
m = n //10
r = n % 10
return r * solve(m,k-1) + (9 - r) * solve(m-1,k-1) + solve(m,k)
n = int(input())
k = int(input())
print(solve(n,k))
|
def solve(n,k) :
if n <= 9 and k == 1 :
return n
elif n <= 9 and k >= 2 :
return 0
elif k == 0:
return 1
else :
m = n //10
r = n % 10
return r * solve(m,k-1) + (9 - r) * solve(m-1,k-1) + solve(m,k)
n = int(input())
k = int(input())
print(solve(n,k))
|
[
"literal.number.integer.change",
"function.return_value.change"
] | 581,496
| 581,497
|
u645487439
|
python
|
p02781
|
n = input()
k = input()
nl = len(n)
dp = [[[0]*(k+1) for _ in range(2)]for _ in range(nl+1)]
#dp[i][j][k] i:上からの桁数、j:smaller flag、k:0以外の数字の個数
dp[0][0][0] = 1
for i in range(nl):
for j in range(2):
for l in range(k+1):
c = int(n[i])
if j == 1:
dp[i+1][j][l] += dp[i][j][l]
if l < k:
dp[i+1][j][l+1] += dp[i][j][l]*9
else:
if c == 0:#0しか選べない上にsmallを確定できない
dp[i+1][0][l] += dp[i][j][l]
else:
dp[i+1][1][l] += dp[i][j][l]#cより確実に小さい0を使う。small確定
if l < k:
dp[i+1][1][l+1] += dp[i][j][l]*(c-1) #c以下の数字を使えばsmall確定
dp[i+1][0][l+1] += dp[i][j][l] #cを使ったらsmall確定できない
print(dp[nl][0][k]+dp[nl][1][k])
|
n = input()
k = int(input())
nl = len(n)
dp = [[[0]*(k+1) for _ in range(2)]for _ in range(nl+1)]
#dp[i][j][k] i:上からの桁数、j:smaller flag、k:0以外の数字の個数
dp[0][0][0] = 1
for i in range(nl):
for j in range(2):
for l in range(k+1):
c = int(n[i])
if j == 1:
dp[i+1][j][l] += dp[i][j][l]
if l < k:
dp[i+1][j][l+1] += dp[i][j][l]*9
else:
if c == 0:#0しか選べない上にsmallを確定できない
dp[i+1][0][l] += dp[i][j][l]
else:
dp[i+1][1][l] += dp[i][j][l]#cより確実に小さい0を使う。small確定
if l < k:
dp[i+1][1][l+1] += dp[i][j][l]*(c-1) #c以下の数字を使えばsmall確定
dp[i+1][0][l+1] += dp[i][j][l] #cを使ったらsmall確定できない
print(dp[nl][0][k]+dp[nl][1][k])
|
[
"call.add",
"call.arguments.change"
] | 581,531
| 581,532
|
u977141657
|
python
|
p02781
|
# coding: utf-8
import re
import math
import itertools
from copy import deepcopy
import fractions
import random
from functools import lru_cache
from heapq import heappop,heappush
import time
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(2000)
#import numpy as np
alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
if b:
print("yes")
else:
print("no")
def Yn(b):
if b:
print("Yes")
else:
print("No")
def YN(b):
if b:
print("YES")
else:
print("NO")
class union_find():
def __init__(self,n):
self.n=n
self.P=[a for a in range(N)]
self.rank=[0]*n
def find(self,x):
if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
return self.P[x]
def same(self,x,y):
return self.find(x)==self.find(y)
def link(self,x,y):
if self.rank[x]<self.rank[y]:
self.P[x]=y
elif self.rank[y]<self.rank[x]:
self.P[y]=x
else:
self.P[x]=y
self.rank[y]+=1
def unite(self,x,y):
self.link(self.find(x),self.find(y))
def size(self):
S=set()
for a in range(self.n):
S.add(self.find(a))
return len(S)
def bin_(num,size):
A=[0]*size
for a in range(size):
if (num>>(size-a-1))&1==1:
A[a]=1
else:
A[a]=0
return A
def fac_list(n,mod_=0):
A=[1]*(n+1)
for a in range(2,len(A)):
A[a]=A[a-1]*a
if(mod>0):A[a]%=mod_
return A
def comb(n,r,mod,fac):
if(n-r<0):return 0
return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
x=num&(-num)
y=num+x
z=num&(~y)
z//=x
z=z>>1
num=(y|z)
if(num>=(1<<size)):return False
else:
return num
def get_primes(n,type="int"):
A=[True]*(n+1)
A[0]=False
A[1]=False
for a in range(2,n+1):
if A[a]:
for b in range(a*2,n+1,a):
A[b]=False
if(type=="bool"):return A
B=[]
for a in range(n+1):
if(A[a]):B.append(a)
return B
def is_prime(num):
if(num<=2):return False
i=2
while i*i<=num:
if(num%i==0):return False
i+=1
return True
def join(A,c=" "):
n=len(A)
A=list(map(str,A))
s=""
for a in range(n):
s+=A[a]
if(a<n-1):s+=c
return s
#main
@lru_cache(maxsize=None)#メモ化デコレータ
def f(num,k):
if(num==0 and k==0):return 1
elif(num<=0 or k<=0):return 0
else:
r=num-(num//10)*10
m=num//10
return f(m,k-1)*r+f(m-1,k-1)*(10-r)+f(m,k)
s=int(input())
k=int(input())
print(f(s,k))
|
# coding: utf-8
import re
import math
import itertools
from copy import deepcopy
import fractions
import random
from functools import lru_cache
from heapq import heappop,heappush
import time
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(2000)
#import numpy as np
alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
if b:
print("yes")
else:
print("no")
def Yn(b):
if b:
print("Yes")
else:
print("No")
def YN(b):
if b:
print("YES")
else:
print("NO")
class union_find():
def __init__(self,n):
self.n=n
self.P=[a for a in range(N)]
self.rank=[0]*n
def find(self,x):
if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
return self.P[x]
def same(self,x,y):
return self.find(x)==self.find(y)
def link(self,x,y):
if self.rank[x]<self.rank[y]:
self.P[x]=y
elif self.rank[y]<self.rank[x]:
self.P[y]=x
else:
self.P[x]=y
self.rank[y]+=1
def unite(self,x,y):
self.link(self.find(x),self.find(y))
def size(self):
S=set()
for a in range(self.n):
S.add(self.find(a))
return len(S)
def bin_(num,size):
A=[0]*size
for a in range(size):
if (num>>(size-a-1))&1==1:
A[a]=1
else:
A[a]=0
return A
def fac_list(n,mod_=0):
A=[1]*(n+1)
for a in range(2,len(A)):
A[a]=A[a-1]*a
if(mod>0):A[a]%=mod_
return A
def comb(n,r,mod,fac):
if(n-r<0):return 0
return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
x=num&(-num)
y=num+x
z=num&(~y)
z//=x
z=z>>1
num=(y|z)
if(num>=(1<<size)):return False
else:
return num
def get_primes(n,type="int"):
A=[True]*(n+1)
A[0]=False
A[1]=False
for a in range(2,n+1):
if A[a]:
for b in range(a*2,n+1,a):
A[b]=False
if(type=="bool"):return A
B=[]
for a in range(n+1):
if(A[a]):B.append(a)
return B
def is_prime(num):
if(num<=2):return False
i=2
while i*i<=num:
if(num%i==0):return False
i+=1
return True
def join(A,c=" "):
n=len(A)
A=list(map(str,A))
s=""
for a in range(n):
s+=A[a]
if(a<n-1):s+=c
return s
#main
@lru_cache(maxsize=None)#メモ化デコレータ
def f(num,k):
if(num==0 and k==0):return 1
elif(num<=0 or k<0):return 0
else:
r=num-(num//10)*10
m=num//10
return f(m,k-1)*r+f(m-1,k-1)*(9-r)+f(m,k)
s=int(input())
k=int(input())
print(f(s,k))
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.number.integer.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 581,545
| 581,546
|
u902151549
|
python
|
p02781
|
N = [0] + list(map(int, input()))
K = int(input())
n = len(N)
DP = [
[[0] * (K+1) for _ in range(2)] for _ in range(n)
]
# 0桁目(0)で最大値を取っていてk=0の要素は1個。
DP[0][0][0] = 1
for i in range(1, n):
for k in range(K):
if N[i] != 0:
DP[i][0][k+1] += DP[i-1][0][k]
DP[i][1][k] += DP[i-1][0][k]
DP[i][1][k+1] += DP[i-1][0][k] * (N[i] - 1)
else:
DP[i][0][k] += DP[i-1][0][k]
DP[i][1][k] += DP[i-1][1][k]
DP[i][1][k+1] += DP[i-1][1][k] * 9
print(DP[n-1][1][K] + DP[n-1][0][K])
|
N = [0] + list(map(int, input()))
K = int(input())
n = len(N)
DP = [
[[0] * (K+2) for _ in range(2)] for _ in range(n)
]
# 0桁目(0)で最大値を取っていてk=0の要素は1個。
DP[0][0][0] = 1
for i in range(1, n):
for k in range(K+1):
if N[i] != 0:
DP[i][0][k+1] += DP[i-1][0][k]
DP[i][1][k] += DP[i-1][0][k]
DP[i][1][k+1] += DP[i-1][0][k] * (N[i] - 1)
else:
DP[i][0][k] += DP[i-1][0][k]
DP[i][1][k] += DP[i-1][1][k]
DP[i][1][k+1] += DP[i-1][1][k] * 9
print(DP[n-1][1][K] + DP[n-1][0][K])
|
[
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 581,563
| 581,564
|
u875541136
|
python
|
p02781
|
import sys
from math import factorial
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
K = ir()
length = 0
for i in range(1, 100):
if 10 ** i > N:
length = i
break
answer = 0
def F(length, K, N):
ret = 0
if length == 1:
if K == 1:
return N
elif K == 0:
return 1
else:
return 0
if length < K:
return 0
top = int(str(N)[0])
if length-K >= 1:
ret += factorial(length-1) // factorial(K) // factorial(length-K-1) * 9 ** K # 一個前まで
ret += factorial(length-1) // factorial(K-1) // factorial(length-K) * (top-1) * 9 ** (K-1) # 一桁目がtopより小さい数
if K > 1: # 一桁目がtopと同じ数
N = int(str(N)[1:])
length = 0
for i in range(1, 100):
if 10 ** i > N:
length = i
break
ret += F(length, K-1, N)
else:
ret += 1 # 2000のような数
return ret
answer = F(length, K, N)
print(answer)
|
import sys
from math import factorial
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
K = ir()
length = 0
for i in range(1, 102):
if 10 ** i > N:
length = i
break
answer = 0
def F(length, K, N):
ret = 0
if length == 1:
if K == 1:
return N
elif K == 0:
return 1
else:
return 0
if length < K:
return 0
top = int(str(N)[0])
if length-K >= 1:
ret += factorial(length-1) // factorial(K) // factorial(length-K-1) * 9 ** K # 一個前まで
ret += factorial(length-1) // factorial(K-1) // factorial(length-K) * (top-1) * 9 ** (K-1) # 一桁目がtopより小さい数
if K > 1: # 一桁目がtopと同じ数
N = int(str(N)[1:])
length = 0
for i in range(1, 100):
if 10 ** i > N:
length = i
break
ret += F(length, K-1, N)
else:
ret += 1 # 2000のような数
return ret
answer = F(length, K, N)
print(answer)
|
[
"literal.number.integer.change",
"call.arguments.change",
"control_flow.loop.range.bounds.upper.change"
] | 581,576
| 581,577
|
u600402037
|
python
|
p02781
|
N = int(input())
K = int(input())
#桁DP
string = str(N)
digits = len(string)
#dp[i][j][k]=と同じ桁数の整数で上からi桁目までで0でない数字がj個あるものの個数
#k=0: i桁目まで見てN未満が確定, k=1: 未確定
dp = [[[0]*2 for _ in range(K+1)] for __ in range(digits+1)]
#初期状態
dp1[0][0][1] = 1
for i in range(digits):
d = int(string[i])
ni = i+1
for j in range(K+1):
for k in range(2):
for nd in range(10):
nk = 1 if k == 1 and nd == d else 0
if k == 1 and nd > d: break
nj = j + (1 if nd != 0 else 0)
if nj > K: continue
dp[ni][nj][nk] += dp[i][j][k]
print(dp[digits][K][0] + dp[digits][K][1])
|
N=int(input())
K=int(input())
string = str(N)
digits = len(string)
#dp[i][j][k]=と同じ桁数の整数で上からi桁目までで0でない数字がj個あるものの個数
#k=0: i桁目まで見てN未満が確定, k=1: 未確定
dp = [[[0]*2 for _ in range(K+1)] for __ in range(digits+1)]
#初期状態
dp[0][0][1] = 1
for i in range(digits):
d = int(string[i])
ni = i+1
for j in range(K+1):
for k in range(2):
for nd in range(10):
nk = 1 if k == 1 and nd == d else 0
if k == 1 and nd > d: break
nj = j + (1 if nd != 0 else 0)
if nj > K: continue
dp[ni][nj][nk] += dp[i][j][k]
print(dp[digits][K][0] + dp[digits][K][1])
|
[
"assignment.variable.change",
"identifier.change"
] | 581,590
| 581,591
|
u852690916
|
python
|
p02781
|
N = int(input())
K = int(input())
#桁DP
string = str(N)
digits = len(string)
#dp[i][j][k]=と同じ桁数の整数で上からi桁目までで0でない数字がj個あるものの個数
#k=0: i桁目まで見てN未満が確定, k=1: 未確定
dp = [[[0]*2 for _ in range(K+1)] for __ in range(digits+1)]
#初期状態
dp1[0][0][1] = 1
for i in range(digits):
d = int(string[i])
ni = i+1
for j in range(K+1):
for k in range(2):
for nd in range(10):
nk = 1 if k == 1 and nd == d else 0
if k == 1 and nd > d: break
nj = j + (1 if nd != 0 else 0)
if nj > K: continue
dp[ni][nj][nk] += dp[i][j][k]
print(dp[digits][K][0] + dp[digits][K][1])
|
N = int(input())
K = int(input())
#桁DP
string = str(N)
digits = len(string)
#dp[i][j][k]=と同じ桁数の整数で上からi桁目までで0でない数字がj個あるものの個数
#k=0: i桁目まで見てN未満が確定, k=1: 未確定
dp = [[[0]*2 for _ in range(K+1)] for __ in range(digits+1)]
#初期状態
dp[0][0][1] = 1
for i in range(digits):
d = int(string[i])
ni = i+1
for j in range(K+1):
for k in range(2):
for nd in range(10):
nk = 1 if k == 1 and nd == d else 0
if k == 1 and nd > d: break
nj = j + (1 if nd != 0 else 0)
if nj > K: continue
dp[ni][nj][nk] += dp[i][j][k]
print(dp[digits][K][0] + dp[digits][K][1])
|
[
"assignment.variable.change",
"identifier.change"
] | 581,590
| 581,592
|
u852690916
|
python
|
p02781
|
import sys
def solve():
input = sys.stdin.readline
N = int(input())
K = int(input())
if N <= 1000:
count = 0
for i in range(1, N + 1):
d = 0
ci = i
while ci > 0:
d += (1 if ci % 10 > 0 else 0)
ci //= 10
if d == K: count += 1
else:
strN = str(N)
dig = len(strN)
DPsmall = [[0 for j in range(K + 1)] for i in range(dig)]
DPsmall[0][0] = 1
DPsmall[0][1] = int(strN[0]) - 1
for i in range(1, dig):
DPsmall[i][0] = 1
for j in range(1, K + 1):
DPsmall[i][j] += DPsmall[i-1][j-1] * 9 + DPsmall[i-1][j]
DPlarge = [[0 for j in range(K + 1)] for i in range(dig)] #最初の桁がNの最初と一致
DPlarge[0][0] = 1
for i in range(1, dig):
if strN[i] == "0": DPlarge[i][0] = DPlarge[i-1][0]
else: DPlarge[i][0] = DPlarge[i-1][0] + 1
for j in range(1, K + 1):
if DPlarge[i-1][0] == j - 1: DPlarge[i][j] += (int(strN[i]) - 1 if strN[i] != "0" else 0)
if DPlarge[i-1][0] == j: DPlarge[i][j] += (1 if strN[i] != "0" else 0)
DPlarge[i][j] += DPlarge[i-1][j] #i桁目が0
if j > 1: DPlarge[i][j] += DPlarge[i-1][j-1] * 9 #i桁目は0以上
ans = DPsmall[dig-1][K] + DPlarge[dig-1][K]
if DPlarge[dig-1][0] == K: ans += 1
print(ans)
#print(DPsmall)
#print(DPlarge)
return 0
if __name__ == "__main__":
solve()
|
import sys
def solve():
input = sys.stdin.readline
N = int(input())
K = int(input())
if N <= 1000:
count = 0
for i in range(1, N + 1):
d = 0
ci = i
while ci > 0:
d += (1 if ci % 10 > 0 else 0)
ci //= 10
if d == K: count += 1
print(count)
else:
strN = str(N)
dig = len(strN)
DPsmall = [[0 for j in range(K + 1)] for i in range(dig)]
DPsmall[0][0] = 1
DPsmall[0][1] = int(strN[0]) - 1
for i in range(1, dig):
DPsmall[i][0] = 1
for j in range(1, K + 1):
DPsmall[i][j] += DPsmall[i-1][j-1] * 9 + DPsmall[i-1][j]
DPlarge = [[0 for j in range(K + 1)] for i in range(dig)] #最初の桁がNの最初と一致
DPlarge[0][0] = 1
for i in range(1, dig):
if strN[i] == "0": DPlarge[i][0] = DPlarge[i-1][0]
else: DPlarge[i][0] = DPlarge[i-1][0] + 1
for j in range(1, K + 1):
if DPlarge[i-1][0] == j - 1: DPlarge[i][j] += (int(strN[i]) - 1 if strN[i] != "0" else 0)
if DPlarge[i-1][0] == j: DPlarge[i][j] += (1 if strN[i] != "0" else 0)
DPlarge[i][j] += DPlarge[i-1][j] #i桁目が0
if j > 1: DPlarge[i][j] += DPlarge[i-1][j-1] * 9 #i桁目は0以上
ans = DPsmall[dig-1][K] + DPlarge[dig-1][K]
if DPlarge[dig-1][0] == K: ans += 1
print(ans)
#print(DPsmall)
#print(DPlarge)
return 0
if __name__ == "__main__":
solve()
|
[
"call.add"
] | 581,595
| 581,596
|
u608088992
|
python
|
p02781
|
n = input()
k = int(input())
if len(n) <= k:
cnt = 0
for i in range(1,int(n)+1):
if len(str(i)) - str(i).count('0') == k:
cnt += 1
print(cnt)
exit()
cnt = 0
l = len(n)
def combi(n,k):
ans = 1
if k == 0:
return ans
for i in range(k):
ans = ans * (n-i) // (i+1)
return ans
flag = 0
for i in range(l):
if flag > k:
break
if n[i] == '0':
if i == l-1:
cnt += 1
continue
flag += 1
cnt += int(((int(n[i])-1)*9**(k-flag))*combi(l-i-1,k-flag) + 9**(k-flag+1)*combi(l-i-1,k-flag+1))
print(cnt)
|
n = input()
k = int(input())
if len(n) <= k:
cnt = 0
for i in range(1,int(n)+1):
if len(str(i)) - str(i).count('0') == k:
cnt += 1
print(cnt)
exit()
cnt = 0
l = len(n)
def combi(n,k):
ans = 1
if k == 0:
return ans
for i in range(k):
ans = ans * (n-i) // (i+1)
return ans
flag = 0
for i in range(l):
if flag > k:
break
if n[i] == '0':
if i == l-1 and k == flag:
cnt += 1
continue
flag += 1
cnt += int(((int(n[i])-1)*9**(k-flag))*combi(l-i-1,k-flag) + 9**(k-flag+1)*combi(l-i-1,k-flag+1))
print(cnt)
|
[
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 581,613
| 581,614
|
u145600939
|
python
|
p02781
|
def main():
s = [int(char) for char in input()]
l = len(s)
k = int(input())
tmp = 0
nonzero = []
for number in s:
if number > 0:
tmp += 1
nonzero.append(tmp)
nonzero.append(0) # let nonzero[-1] be 0
def binomial(n, k):
if n < k or n < 0 or k < 0:
raise ValueError
if k == 0:
return 1
if k == 1:
return n
if k == 2:
return n * (n-1) // 2
if k == 3:
return n * (n-1) * (n-2) // 6
raise ValueError
def dp(i, _cache={-1: 0}):
if i in _cache:
return _cache[i]
if nonzero[i-1] > k or s[i] == 0:
result = dp(i-1)
_cache[i] = result
return result
if nonzero[i-1] == k:
result = dp(i-1) + 1
_cache[i] = result
return result
result = (
dp(i-1) +
(s[i] - 1) * binomial(l - 1 - i, k - nonzero[i-1] - 1) *
9 ** (k - nonzero[i-1] - 1) +
binomial(l - 1 - i, k - nonzero[i-1]) *
9 ** (k - nonzero[i-1])
)
_cache[i] = result
return result
print(dp(l-1) + (nonzero[l-1] == k))
main()
|
def main():
s = [int(char) for char in input()]
l = len(s)
k = int(input())
tmp = 0
nonzero = []
for number in s:
if number > 0:
tmp += 1
nonzero.append(tmp)
nonzero.append(0) # let nonzero[-1] be 0
def binomial(n, k):
if n < k or n < 0 or k < 0:
return 0
if k == 0:
return 1
if k == 1:
return n
if k == 2:
return n * (n-1) // 2
if k == 3:
return n * (n-1) * (n-2) // 6
raise ValueError
def dp(i, _cache={-1: 0}):
if i in _cache:
return _cache[i]
if nonzero[i-1] > k or s[i] == 0:
result = dp(i-1)
_cache[i] = result
return result
if nonzero[i-1] == k:
result = dp(i-1) + 1
_cache[i] = result
return result
result = (
dp(i-1) +
(s[i] - 1) * binomial(l - 1 - i, k - nonzero[i-1] - 1) *
9 ** (k - nonzero[i-1] - 1) +
binomial(l - 1 - i, k - nonzero[i-1]) *
9 ** (k - nonzero[i-1])
)
_cache[i] = result
return result
print(dp(l-1) + (nonzero[l-1] == k))
main()
|
[] | 581,635
| 581,636
|
u595856802
|
python
|
p02781
|
import math
def combi(n,r):
if r > n:return 0
return math.factorial(n) // (math.factorial(n - r)*(math.factorial(r)))
def solve(i,k,smaller):
#一番最後の桁まで調べたら終了
if i == N:
if k == 0:return 1
else: 0
#途中であっても0以外の数字を使い切ったら終了
if k == 0:return 1
#Nより小さいことが確定すれば残りの桁数（N-i）のうち
#k個所に0以外の数字（9**k通り）を使い，それ以外の桁の数字は0なので
#C(n-i,n-i-k)=C(n-i,k)個所に0をはめる
if smaller: return combi(N-i, k)*(9**k)
else:
#i桁目が0なら，smallerであるといえない
if S[i] == '0':return solve(i+1,k,False)
else:
zero = solve(i+1, k, True)
aida = solve(i+1, k-1, True) * (int(S[i])-1)
icchi = solve(i+1, k-1, False)
return zero + aida + icchi
#0出ない数字がちょうどＫ個であるようなN以下の整数を探索
S = input()
N = len(S)
K = int(input())
print((solve(0,K,False)))
|
import math
def combi(n,r):
if r > n:return 0
return math.factorial(n) // (math.factorial(n - r)*(math.factorial(r)))
def solve(i,k,smaller):
#一番最後の桁まで調べたら終了
if i == N:
if k == 0:return 1
else: return 0
#途中であっても0以外の数字を使い切ったら終了
if k == 0:return 1
#Nより小さいことが確定すれば残りの桁数（N-i）のうち
#k個所に0以外の数字（9**k通り）を使い，それ以外の桁の数字は0なので
#C(n-i,n-i-k)=C(n-i,k)個所に0をはめる
if smaller: return combi(N-i, k)*(9**k)
else:
#i桁目が0なら，smallerであるといえない
if S[i] == '0':return solve(i+1,k,False)
else:
zero = solve(i+1, k, True)
aida = solve(i+1, k-1, True) * (int(S[i])-1)
icchi = solve(i+1, k-1, False)
return zero + aida + icchi
#0出ない数字がちょうどＫ個であるようなN以下の整数を探索
S = input()
N = len(S)
K = int(input())
print((solve(0,K,False)))
|
[
"control_flow.return.add"
] | 581,691
| 581,692
|
u215315599
|
python
|
p02781
|
ar = input()
k = int(input())
l = len(ar)
DP = [[[-1] * 2 for j in range(5)] for i in range(102)]
def dp(i, j, fl):
if i == l:
if j == k:
return 1
else:
return 0
if DP[i][j][fl] != -1:
return DP[i][j][fl]
res = 0
# print(i,j,fl)
if fl:
for p in range(10):
res += dp(i+1, j + (p != 0) , fl == 1)
else:
ko = ord(ar[i]) - ord('0')
for p in range(ko + 1):
res += dp(i + 1, j + (p != 0), p < ko)
DP[i][j][fl] = res
return res
print(dp(0, 0, 0))
|
ar = input()
k = int(input())
l = len(ar)
DP = [[[-1] * 2 for j in range(103)] for i in range(102)]
def dp(i, j, fl):
if i == l:
if j == k:
return 1
else:
return 0
if DP[i][j][fl] != -1:
return DP[i][j][fl]
res = 0
# print(i,j,fl)
if fl:
for p in range(10):
res += dp(i+1, j + (p != 0) , fl == 1)
else:
ko = ord(ar[i]) - ord('0')
for p in range(ko + 1):
res += dp(i + 1, j + (p != 0), p < ko)
DP[i][j][fl] = res
return res
print(dp(0, 0, 0))
|
[
"literal.number.integer.change",
"assignment.value.change",
"call.arguments.change",
"control_flow.loop.range.bounds.upper.change"
] | 581,717
| 581,718
|
u449403739
|
python
|
p02781
|
S = input()
N = len(S)
K = int(input())
MOD = 10 ** 9 + 7
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
# 必要なだけforを回す
for i in range(2, 6):
fact.append((fact[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
factinv.append((factinv[-1] * inv[-1]) % MOD)
# nCr n個から重複を許さずr個の組み合わせを選ぶ
def cmb(n, r):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % MOD
def rec(i, k, isSmaller):
if i == N:
if k == 0:
return 1
else:
return 0
if k == 0:
return 1
if isSmaller:
return cmb(N-i, k) * pow(9, k)
else:
if S[i] == '0':
return rec(i+1, k, False)
else:
zero = rec(i+1, k, True)
between = rec(i+1, k-1, True) * (int(S[i]) - 1)
same = rec(i+1, k-1, False)
return zero + between + same
print(rec(0, K, False))
|
S = input()
N = len(S)
K = int(input())
MOD = 10 ** 9 + 7
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
# 必要なだけforを回す
for i in range(2, 10 ** 6):
fact.append((fact[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
factinv.append((factinv[-1] * inv[-1]) % MOD)
# nCr n個から重複を許さずr個の組み合わせを選ぶ
def cmb(n, r):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % MOD
def rec(i, k, isSmaller):
if i == N:
if k == 0:
return 1
else:
return 0
if k == 0:
return 1
if isSmaller:
return cmb(N-i, k) * pow(9, k)
else:
if S[i] == '0':
return rec(i+1, k, False)
else:
zero = rec(i+1, k, True)
between = rec(i+1, k-1, True) * (int(S[i]) - 1)
same = rec(i+1, k-1, False)
return zero + between + same
print(rec(0, K, False))
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 581,727
| 581,728
|
u112317104
|
python
|
p02781
|
import sys
sys.setrecursionlimit(10 ** 6)
from math import factorial
def comb(n, r):
if r < 0 or r > n:
return 0
else:
return factorial(n) // (factorial(n - r) * factorial(r))
# 左から i 桁目以降について、0 以外の値を残り K 個使用可能
# smaller: i 桁目までが 一致している時=False, 小さい時=True
def solve(i, k, smaller):
if i == n:
if k == 0:
return 1
else:
return 0
if k == 0:
return 1
if smaller:
return comb(n - i, k) * 9 ** k
else:
if S[i] == "0":
return solve(i + 1, k, Flase)
else:
zero = solve(i + 1, k, True)
aida = solve(i + 1, k - 1, True) * (int(S[i]) - 1)
icchi = solve(i + 1, k - 1, False)
return zero + aida + icchi
S = input()
n = len(S)
k = int(input())
print(solve(0, k, False))
|
import sys
sys.setrecursionlimit(10 ** 6)
from math import factorial
def comb(n, r):
if r < 0 or r > n:
return 0
else:
return factorial(n) // (factorial(n - r) * factorial(r))
# 左から i 桁目以降について、0 以外の値を残り K 個使用可能
# smaller: i 桁目までが 一致している時=False, 小さい時=True
def solve(i, k, smaller):
if i == n:
if k == 0:
return 1
else:
return 0
if k == 0:
return 1
if smaller:
return comb(n - i, k) * 9 ** k
else:
if S[i] == "0":
return solve(i + 1, k, False)
else:
zero = solve(i + 1, k, True)
aida = solve(i + 1, k - 1, True) * (int(S[i]) - 1)
icchi = solve(i + 1, k - 1, False)
return zero + aida + icchi
S = input()
n = len(S)
k = int(input())
print(solve(0, k, False))
|
[
"call.arguments.change",
"function.return_value.change"
] | 581,739
| 581,740
|
u802963389
|
python
|
p02781
|
n = int(input())
k = int(input())
keta = len(str(n))
dp = [[[0 for j in range(keta+2)] for _ in range(2)] for i in range(keta)]
s = str(n)
#dp[何桁目か][未満フラグ 0 = 未満][ゼロ以外のの個数]
x = int(s[0])
if x == 1:
dp[0][1][0] = 1
else:
dp[0][1][0] += 1
dp[0][0][0] += x - 1
for index, c in enumerate(s[1:]):
i = index + 1
x = int(c)
dp[i][0][0] += 9
for j in range(keta+1):
dp[i][0][j] += dp[i-1][0][j]
if x == 0:
dp[i][1][j] += dp[i - 1][1][j]
dp[i][0][j + 1] += dp[i - 1][0][j] * 9
elif x:
dp[i][0][j + 1] += dp[i - 1][1][j]
dp[i][0][j] += dp[i - 1][1][j]
dp[i][0][j + 1] += dp[i - 1][0][j] * 9
dp[i][0][j + 1] += dp[i - 1][1][j] * (x - 1)
# print(sum(dp[i][0]) + sum(dp[i][1]))
print(dp[-1][0][k-1] + dp[-1][1][k-1])
|
n = int(input())
k = int(input())
keta = len(str(n))
dp = [[[0 for j in range(k+2)] for _ in range(2)] for i in range(keta)]
s = str(n)
#dp[何桁目か][未満フラグ 0 = 未満][ゼロ以外のの個数]
x = int(s[0])
if x == 1:
dp[0][1][0] = 1
else:
dp[0][1][0] += 1
dp[0][0][0] += x - 1
for index, c in enumerate(s[1:]):
i = index + 1
x = int(c)
dp[i][0][0] += 9
for j in range(k+1):
dp[i][0][j] += dp[i - 1][0][j]
if x == 0:
dp[i][1][j] += dp[i - 1][1][j]
dp[i][0][j + 1] += dp[i - 1][0][j] * 9
elif x:
dp[i][1][j + 1] += dp[i - 1][1][j]
dp[i][0][j] += dp[i - 1][1][j]
dp[i][0][j + 1] += dp[i - 1][0][j] * 9
dp[i][0][j + 1] += dp[i - 1][1][j] * (x - 1)
# print(sum(dp[i][0]) + sum(dp[i][1]))
# print(s[:index + 2])
# print(dp)
print(dp[-1][0][k-1] + dp[-1][1][k-1])
|
[
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.range.bounds.upper.change",
"literal.number.integer.change",
"variable_access.subscript.index.change"
] | 581,745
| 581,746
|
u301984327
|
python
|
p02781
|
import sys
import math
input = sys.stdin.readline
n = int(input())
k = int(input())
t = n
m = 0
while t:
m += 1
t //= 10
def comb(n, r):
if r > n:
return 0
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
ans = 9 ** k * comb(m-1, k)
tk = k
def dfs(i, mt, kt):
a = i // 10 ** mt
b = n // 10 ** mt
if kt < 0:
return 0
if mt < kt:
return 0
if a < b:
if mt > 0:
return 9 ** kt * comb(mt, kt)
else:
return 1
elif a > b:
return 0
if i == n:
return 1
elif i > n:
return 0
ret = 0
for j in range(10):
f = 0
if j != 0:
f = 1
ret += dfs(i+j*10**(mt-1), mt-1, kt-f)
return ret
t_ans = 0
for i in range(1, n // (10 ** (m-1) )+1):
ti = i * 10 ** (m-1)
t_ans += dfs(ti, m-1, k-1)
print(int(ans+t_ans))
|
import sys
import math
input = sys.stdin.readline
n = int(input())
k = int(input())
t = n
m = 0
while t:
m += 1
t //= 10
def comb(n, r):
if r > n:
return 0
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
ans = 9 ** k * comb(m-1, k)
tk = k
def dfs(i, mt, kt):
a = i // 10 ** mt
b = n // 10 ** mt
if kt < 0:
return 0
if mt < kt:
return 0
if a < b:
if mt > 0:
return 9 ** kt * comb(mt, kt)
else:
return 1
elif a > b:
return 0
if i == n and kt == 0:
return 1
elif i > n:
return 0
ret = 0
for j in range(10):
f = 0
if j != 0:
f = 1
ret += dfs(i+j*10**(mt-1), mt-1, kt-f)
return ret
t_ans = 0
for i in range(1, n // (10 ** (m-1) )+1):
ti = i * 10 ** (m-1)
t_ans += dfs(ti, m-1, k-1)
print(int(ans+t_ans))
|
[
"control_flow.branch.if.condition.change"
] | 581,774
| 581,775
|
u408620326
|
python
|
p02781
|
N=input()
K=int(input())
dp_0 = [[0]*(len(N)) for i in range(K+1)]
dp_1 = [[0]*(len(N)) for i in range(K+1)]
dp_0[0][0]=1
dp_0[1][0]=int(N[0])-1
dp_1[1][0]=1
for i in range(len(N)-1):
for j in range(K+1):
if j==K:
dp_0[j][i+1] += dp_0[j][i]
elif j==0:
dp_0[j][i+1] =dp_0[j][i]
dp_0[j+1][i+1] += dp_0[j][i]*9
else:
dp_0[j][i+1] += dp_0[j][i]
dp_0[j+1][i+1] += dp_0[j][i]*9
if j != K and N[i] != '0':
dp_0[j+1][i+1] += (int(N[i+1])-1)*dp_1[j][i]
dp_0[j][i+1] += dp_1[j][i]
dp_1[j+1][i+1] = dp_1[j][i]
elif N[i] =='0':
dp_1[j][i+1] = dp_1[j][i]
else:
dp_0[j][i+1] += dp_1[j][i]
print(dp_0[K][len(N)-1]+dp_1[K][len(N)-1])
|
N=input()
K=int(input())
dp_0 = [[0]*(len(N)) for i in range(K+1)]
dp_1 = [[0]*(len(N)) for i in range(K+1)]
dp_0[0][0]=1
dp_0[1][0]=int(N[0])-1
dp_1[1][0]=1
for i in range(len(N)-1):
for j in range(K+1):
if j==K:
dp_0[j][i+1] += dp_0[j][i]
elif j==0:
dp_0[j][i+1] =dp_0[j][i]
dp_0[j+1][i+1] += dp_0[j][i]*9
else:
dp_0[j][i+1] += dp_0[j][i]
dp_0[j+1][i+1] += dp_0[j][i]*9
if j != K and N[i+1] != '0':
dp_0[j+1][i+1] += (int(N[i+1])-1)*dp_1[j][i]
dp_0[j][i+1] += dp_1[j][i]
dp_1[j+1][i+1] = dp_1[j][i]
elif N[i+1] =='0':
dp_1[j][i+1] = dp_1[j][i]
else:
dp_0[j][i+1] += dp_1[j][i]
print(dp_0[K][len(N)-1]+dp_1[K][len(N)-1])
|
[
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 581,798
| 581,799
|
u474423089
|
python
|
p02781
|
N = input()
K = int(input())
DP = [[[0 for i in range(K+1)] for i in range(2)] for i in range(len(N))]
for d in range(int(N[0])+1):
DP[0][d<int(N[0])][d!=0] += 1
for i in range(len(N)-1):
for j in range(2):
for k in range(K+1):
for d in range(10 if j else int(N[i+1])+1):
if k+(d!=0) <= K:
DP[i+1][j|(d<int(N[i]))][k+(d!=0)] += DP[i][j][k]
print(DP[len(N)-1][0][K]+DP[len(N)-1][1][K])
|
N = input()
K = int(input())
DP = [[[0 for i in range(K+1)] for i in range(2)] for i in range(len(N))]
for d in range(int(N[0])+1):
DP[0][d<int(N[0])][d!=0] += 1
for i in range(len(N)-1):
for j in range(2):
for k in range(K+1):
for d in range(10 if j else int(N[i+1])+1):
if k+(d!=0) <= K:
DP[i+1][j|(d<int(N[i+1]))][k+(d!=0)] += DP[i][j][k]
print(DP[len(N)-1][0][K]+DP[len(N)-1][1][K])
|
[
"expression.operation.binary.add"
] | 581,805
| 581,806
|
u441575327
|
python
|
p02781
|
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
n,k = get_all_int()
# m桁の数値でf(n)=kとなる数の個数
# dp[k][m]
dp = [ [None]*101 for _ in range(4)]
for i in range(101):
dp[0][i] = 1
dp[0][0] = 0
dp[1][0] = 0
dp[2][0] = 0
dp[3][0] = 0
dp[1][1] = 9
dp[2][1] = 0
dp[3][1] = 0
dp[1][2] = 1 * dp[1][1] + 9 * dp[0][1]
for i in range(2,101):
dp[1][i] = 1 * dp[1][i-1] + 9 * dp[0][i-1]
dp[2][i] = 1 * dp[2][i-1] + 9 * dp[1][i-1]
dp[3][i] = 1 * dp[3][i-1] + 9 * dp[2][i-1]
# log(dp[1])
# log(dp[2])
ans = 0
keta = 0
x = n
while x > 0:
keta += 1
x //= 10
def sol(n, keta, k):
if k == 0:
return 1
if k < 0:
return 0
if keta < k:
return 0
if keta == 0:
return 1
top = n//10**(keta-1)%10
if keta==1:
return top
ans = 0
# 0のとき
if top == 0:
ans += sol(n, keta-1, k)
else:
ans += 1 * (0 if keta==1 else dp[k][keta-1])
# ans += sol(n, keta-1, k)
log(keta,top,k,ans)
# 1～top-1のとき
if top != 0:
if top == 1:
ans += sol(n, keta-1, k-1)
else:
ans += (top-1) * (1 if keta==1 else dp[k-1][keta-1])
# ans += (top-1) * sol(n, keta-1, k-1)
log(keta,top,k,ans)
# topのとき
if top != 0:
ans += sol(n, keta-1, k-1)
log(keta,top,k,ans)
return ans
if keta < k:
print(0)
exit()
ans += sol(n, keta, k)
print(ans)
|
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
n,k = get_all_int()
# m桁の数値でf(n)=kとなる数の個数
# dp[k][m]
dp = [ [None]*101 for _ in range(4)]
for i in range(101):
dp[0][i] = 1
dp[0][0] = 0
dp[1][0] = 0
dp[2][0] = 0
dp[3][0] = 0
dp[1][1] = 9
dp[2][1] = 0
dp[3][1] = 0
dp[1][2] = 1 * dp[1][1] + 9 * dp[0][1]
for i in range(2,101):
dp[1][i] = 1 * dp[1][i-1] + 9 * dp[0][i-1]
dp[2][i] = 1 * dp[2][i-1] + 9 * dp[1][i-1]
dp[3][i] = 1 * dp[3][i-1] + 9 * dp[2][i-1]
# log(dp[1])
# log(dp[2])
ans = 0
keta = 0
x = n
while x > 0:
keta += 1
x //= 10
def sol(n, keta, k):
if k == 0:
return 1
if k < 0:
return 0
if keta < k:
return 0
if keta == 0:
return 1
top = n//10**(keta-1)%10
if keta==1:
return top
ans = 0
# 0のとき
if top == 0:
ans += sol(n, keta-1, k)
else:
ans += 1 * (0 if keta==1 else dp[k][keta-1])
# ans += sol(n, keta-1, k)
log(keta,top,k,ans)
# 1～top-1のとき
if top != 0:
if top == 1:
ans += sol(n, keta-1, k-1)
else:
ans += (top-1) * (1 if keta==1 else dp[k-1][keta-1])
# ans += (top-1) * sol(n, keta-1, k-1)
log(keta,top,k,ans)
# topのとき
if top > 1:
ans += sol(n, keta-1, k-1)
log(keta,top,k,ans)
return ans
if keta < k:
print(0)
exit()
ans += sol(n, keta, k)
print(ans)
|
[] | 581,820
| 581,821
|
u407160848
|
python
|
p02781
|
n = input()
k = int(input())
n_list = []
for a in n:
n_list.append(int(a))
n_num = len(n_list)
if n_num < k:
print('0')
return
dp = [[[0] * (n_num + 1) for _ in range(2)]for _ in range(n_num + 1)]
dp[0][0][0] = 1
for i in range(n_num):
for smaller in range(2):
for j in range(n_num):
lim = 9 if smaller else n_list[i]
for x in range(lim + 1):
if x != 0:
ns = j + 1
else:
ns = j
nlt = smaller | (x < n_list[i])
dp[i + 1][nlt][ns] += dp[i][smaller][j]
ans = dp[n_num][0][k] + dp[n_num][1][k]
print(ans)
|
n = input()
k = int(input())
n_list = []
for a in n:
n_list.append(int(a))
n_num = len(n_list)
if n_num < k:
print('0')
else:
dp = [[[0] * (n_num + 1) for _ in range(2)]for _ in range(n_num + 1)]
dp[0][0][0] = 1
for i in range(n_num):
for smaller in range(2):
for j in range(n_num):
lim = 9 if smaller else n_list[i]
for x in range(lim + 1):
if x != 0:
ns = j + 1
else:
ns = j
nlt = smaller | (x < n_list[i])
dp[i + 1][nlt][ns] += dp[i][smaller][j]
ans = dp[n_num][0][k] + dp[n_num][1][k]
print(ans)
|
[
"function.return_value.change"
] | 581,827
| 581,828
|
u255382385
|
python
|
p02781
|
def count(keta,kazu):
if(keta<kazu):
return 0
result=1
wari=1
for i in range(kazu):
wari*=i+1
result*=keta-i
result//=wari
#print(result)
for i in range(kazu):
result*=9
return result
def Ans(moji,kazu):
#print(moji,kazu)
naga=len(moji)
if(naga<kazu):
return 0
if(kazu==0):
return 1
sento=int(moji[0])
if(naga==1):
return sento
#return Ans(moji[1:],kazu)+Ans(moji[1:],kazu-1)+count()
if(sento==0):
plus=Ans(moji[1:],kazu)
else:
plus=Ans(moji[1:],kazu-1)
#print(count(naga-1,kazu),count(naga-1,kazu-1),plus)
return count(naga-1,kazu)+count(naga-1,kazu-1)*(sento-1)+plus
n=input()
l=len(n)
k=int(input())
print(Ans(n,k))
|
def count(keta,kazu):
if(keta<kazu):
return 0
result=1
wari=1
for i in range(kazu):
wari*=i+1
result*=keta-i
result//=wari
#print(result)
for i in range(kazu):
result*=9
return result
def Ans(moji,kazu):
#print(moji,kazu)
naga=len(moji)
if(naga<kazu):
return 0
if(kazu==0):
return 1
sento=int(moji[0])
if(naga==1):
return sento
#return Ans(moji[1:],kazu)+Ans(moji[1:],kazu-1)+count()
if(sento==0):
plus=Ans(moji[1:],kazu)
return plus
else:
plus=Ans(moji[1:],kazu-1)
#print(count(naga-1,kazu),count(naga-1,kazu-1),plus)
return count(naga-1,kazu)+count(naga-1,kazu-1)*(sento-1)+plus
n=input()
l=len(n)
k=int(input())
print(Ans(n,k))
#ans=count(l-1,k)
#print(ans)
#batu=0
#for i in range(l):
# suji=int(n[i])
# if(suji!=0):
# batu+=1
# if(k<batu):
# break
# nok=count(l-i-1,k-batu)
# print(suji,nok)
# ans+=nok*(suji-1)
#print(ans)
|
[
"control_flow.return.add"
] | 581,835
| 581,836
|
u965840662
|
python
|
p02781
|
N_str = str(input())
K = int(input())
digit_length = len(N_str)
topmost_digit = int(N_str[0])
C_table = [[0, 0, 0] for _ in range(digit_length)]
def C(all, pick):
if C_table[all][pick] == 0:
count_child = 1
count_parent = 1
for i in range(pick):
count_child *= all - i
count_parent *= i + 1
C_table[all][pick] = count_child // count_parent
return C_table[all][pick]
def get_count(top_digit, digit_count, needed_nonzero):
if needed_nonzero <= 0 or needed_nonzero > digit_count:
return 0
if digit_count == 1:
if needed_nonzero == 1:
return top_digit
else:
return 0
if top_digit == 0:
return get_count(int(N_str[digit_length - digit_count + 1]) ,digit_count - 1, needed_nonzero)
if top_digit >= 1:
count = C(digit_count - 1, needed_nonzero) * (9 ** needed_nonzero)
if needed_nonzero == 1:
count += 1
if top_digit > 1:
count += C(digit_count - 1, needed_nonzero - 1) * (9 ** (needed_nonzero - 1)) * (top_digit - 1)
return count + get_count(int(N_str[digit_length - digit_count + 1]) ,digit_count - 1, needed_nonzero - 1)
print(get_count(topmost_digit, digit_length, K))
|
N_str = str(input())
K = int(input())
digit_length = len(N_str)
topmost_digit = int(N_str[0])
C_table = [[0, 0, 0, 0] for _ in range(digit_length+10)]
def C(all, pick):
if C_table[all][pick] == 0:
count_child = 1
count_parent = 1
for i in range(pick):
count_child *= all - i
count_parent *= i + 1
C_table[all][pick] = count_child // count_parent
return C_table[all][pick]
def get_count(top_digit, digit_count, needed_nonzero):
if needed_nonzero <= 0 or needed_nonzero > digit_count:
return 0
if digit_count == 1:
if needed_nonzero == 1:
return top_digit
else:
return 0
if top_digit == 0:
return get_count(int(N_str[digit_length - digit_count + 1]) ,digit_count - 1, needed_nonzero)
if top_digit >= 1:
count = C(digit_count - 1, needed_nonzero) * (9 ** needed_nonzero)
if needed_nonzero == 1:
count += 1
if top_digit > 1:
count += C(digit_count - 1, needed_nonzero - 1) * (9 ** (needed_nonzero - 1)) * (top_digit - 1)
return count + get_count(int(N_str[digit_length - digit_count + 1]) ,digit_count - 1, needed_nonzero - 1)
print(get_count(topmost_digit, digit_length, K))
|
[
"control_flow.loop.range.bounds.upper.change",
"assignment.change"
] | 581,841
| 581,842
|
u736524428
|
python
|
p02781
|
def nCk(n, k):
return factorial(n)/factorial(n-k)/factorial(k)
from math import factorial
N = input()
K = int(input())
order = len(N)
diff = order - K
if order < K:
print(0)
s = int(N[0])
#lower = factorial(order-1)/factorial(diff-1)/ factorial(K) * (9**K)
if order - 1 >= K:
lower = nCk(order - 1, K) * (9**K)
else:
lower = 0
total = lower
for i in range(1, s):
# total += factorial(order-1)/factorial(diff)/ factorial(K-1) * (9**(K-1))
total += nCk(order - 1, K - 1) * (9**(K-1))
if K == 1:
total += 1
elif K == 2:
under = int(N[1:])
num = "0"*(order -1)
for k in range(order - 1):
for kk in range(1, 10):
tmp = num[:k] + str(kk) + num[k+1:]
if int(tmp) <= under:
total += 1
elif K == 3:
under = int(N[1:])
num = "0"*(order -1)
for k in range(1, order - 1):
for j in range(k):
for kk in range(1, 10):
for jj in range(1, 10):
tmp = num[:j] + str(jj) + num[j+1:k] +str(kk) + num[k+1:]
if int(tmp) <= under:
total += 1
print(int(total))
#pattern = factorial(order)/factorial(diff)/ factorial(K) * (9**K)
|
def nCk(n, k):
return factorial(n)/factorial(n-k)/factorial(k)
from math import factorial
N = input()
K = int(input())
order = len(N)
diff = order - K
if order < K:
print(0)
else:
s = int(N[0])
#lower = factorial(order-1)/factorial(diff-1)/ factorial(K) * (9**K)
if order - 1 >= K:
lower = nCk(order - 1, K) * (9**K)
else:
lower = 0
total = lower
for i in range(1, s):
# total += factorial(order-1)/factorial(diff)/ factorial(K-1) * (9**(K-1))
total += nCk(order - 1, K - 1) * (9**(K-1))
if K == 1:
total += 1
elif K == 2:
under = int(N[1:])
num = "0"*(order -1)
for k in range(order - 1):
for kk in range(1, 10):
tmp = num[:k] + str(kk) + num[k+1:]
if int(tmp) <= under:
total += 1
elif K == 3:
under = int(N[1:])
num = "0"*(order -1)
for k in range(1, order - 1):
for j in range(k):
for kk in range(1, 10):
for jj in range(1, 10):
tmp = num[:j] + str(jj) + num[j+1:k] +str(kk) + num[k+1:]
if int(tmp) <= under:
total += 1
print(int(total))
#pattern = factorial(order)/factorial(diff)/ factorial(K) * (9**K)
|
[] | 581,843
| 581,844
|
u770199020
|
python
|
p02781
|
''' بِسْمِ اللَّهِ الرَّحْمَٰنِ الرَّحِيمِ '''
#codeforces
gi = lambda : list(map(int,input().split()))
s = input()
n, = gi()
ans = 0
mag = len(s) - 1
#corner cases:
if len(s) <= 3:
s = int(s)
for k in range(s + 1):
if len(str(k)) - str(k).count("0") == n:
ans += 1
print(ans)
exit()
while mag - n >= 0:
a = 9
b = 1
c = 1
if n > 2:
c = 81 * ((mag - 1) * (mag - 2) // 2)
elif n > 1:
b = 9 * (mag - 1)
ans += a * b * c
#print(mag, a, b, c, ans)
mag -= 1
mag = len(s)
a = int(s[0]) - 1
b, c = 1, 1
if n > 2:
c = 81 * ((mag - 1) * (mag - 2) // 2)
elif n > 1:
b = 9 * (mag - 1)
ans += a * b * c
a = b = c = 1
if n == 1:
print(ans + 1)
exit()
if n > 1:
i = -1
for k in range(1, len(s)):
if s[k] != "0":
i = k
break;
if i != -1:
a = int(s[i]) - 1
if n > 2:
b = len(s) - i - 1
b *= 9
ans += a * b
a = b = 1
if n > 2:
x = len(s) - i - 1
a = 81 * (x * (x - 1)) // 2
else:
a = 9 * (len(s) - i - 1)
ans += a
if n > 2:
a = b = c = 1
j = -1
for k in range(i + 1, len(s)):
if s[k] != "0":
j = k
break;
if j != -1:
ans += 9 * (len(s) - j - 1) + int(s[j])
else:
ans += 1
print(ans)
|
''' بِسْمِ اللَّهِ الرَّحْمَٰنِ الرَّحِيمِ '''
#codeforces
gi = lambda : list(map(int,input().split()))
s = input()
n, = gi()
ans = 0
mag = len(s) - 1
#corner cases:
if len(s) <= 7:
s = int(s)
for k in range(s + 1):
if len(str(k)) - str(k).count("0") == n:
ans += 1
print(ans)
exit()
while mag - n >= 0:
a = 9
b = 1
c = 1
if n > 2:
c = 81 * ((mag - 1) * (mag - 2) // 2)
elif n > 1:
b = 9 * (mag - 1)
ans += a * b * c
#print(mag, a, b, c, ans)
mag -= 1
mag = len(s)
a = int(s[0]) - 1
b, c = 1, 1
if n > 2:
c = 81 * ((mag - 1) * (mag - 2) // 2)
elif n > 1:
b = 9 * (mag - 1)
ans += a * b * c
a = b = c = 1
if n == 1:
print(ans + 1)
exit()
if n > 1:
i = -1
for k in range(1, len(s)):
if s[k] != "0":
i = k
break;
if i != -1:
a = int(s[i]) - 1
if n > 2:
b = len(s) - i - 1
b *= 9
ans += a * b
a = b = 1
if n > 2:
x = len(s) - i - 1
a = 81 * (x * (x - 1)) // 2
else:
a = 9 * (len(s) - i - 1)
ans += a
if n > 2:
a = b = c = 1
j = -1
for k in range(i + 1, len(s)):
if s[k] != "0":
j = k
break;
if j != -1:
ans += 9 * (len(s) - j - 1) + int(s[j])
else:
ans += 1
print(ans)
|
[
"literal.number.integer.change",
"control_flow.branch.if.condition.change"
] | 581,847
| 581,848
|
u909815117
|
python
|
p02781
|
# does not contain more than K non
# zero digits
# This function returns the count of
# required numbers from 0 to num
def countInRangeUtil(pos, cnt, tight, num):
# Last position
if pos == len(num):
# If count of non zero digits
# is less than or equal to K
if cnt <= K:
return 1
return 0
# If this result is already computed
# simply return it
if dp[pos][cnt][tight] != -1:
return dp[pos][cnt][tight]
ans = 0
# Maximum limit upto which we can place
# digit. If tight is 1, means number has
# already become smaller so we can place
# any digit, otherwise num[pos]
limit = 9 if tight else num[pos]
for dig in range(limit + 1):
currCnt = cnt
# If the current digit is nonzero
# increment currCnt
if dig != 0:
currCnt += 1
currTight = tight
# At this position, number becomes
# smaller
if dig < num[pos]:
currTight = 1
# Next recursive call
ans += countInRangeUtil(pos + 1, currCnt, currTight, num)
dp[pos][cnt][tight] = ans
return dp[pos][cnt][tight]
# This function converts a number into its
# digit vector and uses above function to compute
# the answer
def countInRange(x):
global dp, K, M
num = []
while x:
num.append(x % 10)
x //= 10
num.reverse()
# Initialize dp
dp = [[[-1, -1] for i in range(M)] for j in range(M)]
return countInRangeUtil(0, 0, 0, num)
# Driver Code
if __name__ == "__main__":
# states - position, count, tight
dp = []
M = 20
# K is the number of non zero digits
K = 0
L = 1
R = int(input())
K = int(input())
a=countInRange(R)
K=K-1
b=countInRange(R)
print(a-b)
|
# does not contain more than K non
# zero digits
# This function returns the count of
# required numbers from 0 to num
def countInRangeUtil(pos, cnt, tight, num):
# Last position
if pos == len(num):
# If count of non zero digits
# is less than or equal to K
if cnt <= K:
return 1
return 0
# If this result is already computed
# simply return it
if dp[pos][cnt][tight] != -1:
return dp[pos][cnt][tight]
ans = 0
# Maximum limit upto which we can place
# digit. If tight is 1, means number has
# already become smaller so we can place
# any digit, otherwise num[pos]
limit = 9 if tight else num[pos]
for dig in range(limit + 1):
currCnt = cnt
# If the current digit is nonzero
# increment currCnt
if dig != 0:
currCnt += 1
currTight = tight
# At this position, number becomes
# smaller
if dig < num[pos]:
currTight = 1
# Next recursive call
ans += countInRangeUtil(pos + 1, currCnt, currTight, num)
dp[pos][cnt][tight] = ans
return dp[pos][cnt][tight]
# This function converts a number into its
# digit vector and uses above function to compute
# the answer
def countInRange(x):
global dp, K, M
num = []
while x:
num.append(x % 10)
x //= 10
num.reverse()
# Initialize dp
dp = [[[-1, -1] for i in range(M)] for j in range(M)]
return countInRangeUtil(0, 0, 0, num)
# Driver Code
if __name__ == "__main__":
# states - position, count, tight
dp = []
M = 100
# K is the number of non zero digits
K = 0
L = 1
R = int(input())
K = int(input())
a=countInRange(R)
K=K-1
b=countInRange(R)
print(a-b)
|
[
"literal.number.integer.change",
"assignment.value.change"
] | 581,849
| 581,850
|
u237380963
|
python
|
p02781
|
def factorial(n):
a = 1
for i in range(1, n + 1):
a *= i
return a
def nCr(n,r):
if r > n:
return 0
return factorial(n) // factorial(r) // factorial(n - r)
def normal(d, k):
#print("normal d,k ", d, k)
return nCr(d, k) * (9**k)
def main():
tmp = input()
N = [int(c) for c in tmp]
D = len(N)
K = int(input())
#print(D, K)
x = 0
ans1, ans2, ans3, ans4, ans5, ans6 = 0, 0, 0, 0, 0, 0
if K == 1:
ans1 = normal(D-1, K)
ans2 = N[0]
elif K == 2:
ans1 = normal(D-1, K)
ans2 = (N[0] - 1) * normal(D-1, K-1)
x = 1
found = False
for i in range(x, D):
if N[i] != 0:
x = i
found = True
break
if found:
if x == D - 1:
ans4 = N[x]
else:
ans3 = normal(D-(x+1), K-1)
ans4 = N[x]
elif K == 3:
ans1 = normal(D-1, K)
ans2 = (N[0] - 1) * normal(D-1, K-1)
x = 1
found = False
for i in range(x, D):
if N[i] != 0:
x = i
found = True
break
if found:
if x == D - 1:
pass
else:
ans3 = normal(D-(x+1), K-1)
ans4 = (N[x] - 1) * normal(D-(x+1), K-2)
found = False
for i in range(x, D):
if N[i] != 0:
x = i
found = True
break
if found:
if x == D - 1:
ans6 = N[x]
else:
ans5 = normal(D-(x+1), K-2)
ans6 = N[x]
#print("ans1", ans1)
#print("ans2", ans2)
#print("ans3", ans3)
#print("ans4", ans4)
#print("ans5", ans5)
#print("ans6", ans6)
ans = ans1+ans2+ans3+ans4+ans5+ans6
#print("ans", ans)
print(ans)
main()
|
def factorial(n):
a = 1
for i in range(1, n + 1):
a *= i
return a
def nCr(n,r):
if r > n:
return 0
return factorial(n) // factorial(r) // factorial(n - r)
def normal(d, k):
#print("normal d,k ", d, k)
return nCr(d, k) * (9**k)
def main():
tmp = input()
N = [int(c) for c in tmp]
D = len(N)
K = int(input())
#print(D, K)
x = 0
ans1, ans2, ans3, ans4, ans5, ans6 = 0, 0, 0, 0, 0, 0
if K == 1:
ans1 = normal(D-1, K)
ans2 = N[0]
elif K == 2:
ans1 = normal(D-1, K)
ans2 = (N[0] - 1) * normal(D-1, K-1)
x = 1
found = False
for i in range(x, D):
if N[i] != 0:
x = i
found = True
break
if found:
if x == D - 1:
ans4 = N[x]
else:
ans3 = normal(D-(x+1), K-1)
ans4 = N[x]
elif K == 3:
ans1 = normal(D-1, K)
ans2 = (N[0] - 1) * normal(D-1, K-1)
x = 1
found = False
for i in range(x, D):
if N[i] != 0:
x = i
found = True
break
if found:
if x == D - 1:
pass
else:
ans3 = normal(D-(x+1), K-1)
ans4 = (N[x] - 1) * normal(D-(x+1), K-2)
x = x + 1
found = False
for i in range(x, D):
if N[i] != 0:
x = i
found = True
break
if found:
if x == D - 1:
ans6 = N[x]
else:
ans5 = normal(D-(x+1), K-2)
ans6 = N[x]
#print("ans1", ans1)
#print("ans2", ans2)
#print("ans3", ans3)
#print("ans4", ans4)
#print("ans5", ans5)
#print("ans6", ans6)
ans = ans1+ans2+ans3+ans4+ans5+ans6
#print("ans", ans)
print(ans)
main()
|
[
"assignment.add"
] | 581,881
| 581,882
|
u162773977
|
python
|
p02782
|
from sys import stdout
printn = lambda x: stdout.write(str(x))
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 999999999
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
def modinv2(x,r):
return pow(x,r-2,r)
def f(r,c):
d = c
prod = 1
div = 1
divacc = 1
for i in range(r-1):
prod = (prod*d)%R
divacc = (divacc*div)%R
d += 1
div += 1
ret = (prod*modinv2(divacc,R))%R
#ddprint("f r {} c {} ret {}".format(r,c,ret))
return ret
r1,c1,r2,c2 = inm()
r1 += 1
c1 += 1
r2 += 1
c2 += 1
print(f(r2+1,c2+1)-f(r2+1,c1)-f(r1,c2+1)+f(r1,c1))
|
from sys import stdout
printn = lambda x: stdout.write(str(x))
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 999999999
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
def modinv2(x,r):
return pow(x,r-2,r)
def f(r,c):
d = c
prod = 1
div = 1
divacc = 1
for i in range(r-1):
prod = (prod*d)%R
divacc = (divacc*div)%R
d += 1
div += 1
ret = (prod*modinv2(divacc,R))%R
#ddprint("f r {} c {} ret {}".format(r,c,ret))
return ret
r1,c1,r2,c2 = inm()
r1 += 1
c1 += 1
r2 += 1
c2 += 1
print((f(r2+1,c2+1)-f(r2+1,c1)-f(r1,c2+1)+f(r1,c1))%R)
|
[
"call.arguments.change",
"call.arguments.add"
] | 581,965
| 581,966
|
u102445737
|
python
|
p02782
|
r1,c1,r2,c2 = map(int,input().split())
# 二項係数 mod P
mod = 10**9+7
m = r2+c2 +10
fac = [1]*m
ninv = [1]*m
finv = [1]*m
for i in range(2,m):
fac[i] = fac[i-1]*i%mod
ninv[i] = (-(mod//i)*ninv[mod%i])%mod
finv[i] = finv[i-1]*ninv[i]%mod
def comb(n,k):
return (fac[n]*finv[k]%mod)*finv[n-k]%mod
def g(r,c):
ret = 0
for i in range(0,r+1):
ret += comb(i+c+1,i+1)
ret %= mod
return ret
ans = g(r2,c2) - g(r1-1,c2) - g(r2,c1-1) + g(r1-1,c1-1)
print(ans)
|
r1,c1,r2,c2 = map(int,input().split())
# 二項係数 mod P
mod = 10**9+7
m = r2+c2 +10
fac = [1]*m
ninv = [1]*m
finv = [1]*m
for i in range(2,m):
fac[i] = fac[i-1]*i%mod
ninv[i] = (-(mod//i)*ninv[mod%i])%mod
finv[i] = finv[i-1]*ninv[i]%mod
def comb(n,k):
return (fac[n]*finv[k]%mod)*finv[n-k]%mod
def g(r,c):
ret = 0
for i in range(0,r+1):
ret += comb(i+c+1,i+1)
ret %= mod
return ret
ans = (g(r2,c2) - g(r1-1,c2) - g(r2,c1-1) + g(r1-1,c1-1))%mod
print(ans)
|
[
"assignment.change"
] | 582,042
| 582,043
|
u391731808
|
python
|
p02782
|
bikkuri = [1]
mod = 10**9+7
for i in range(1,2*10**6+1000):
bikkuri.append((bikkuri[-1]*i)%mod)
r1,c1,r2,c2 = map(int,input().split())
def F(r,c):
tmp = (bikkuri[r+c+2]*pow(bikkuri[c+1],mod-2,mod)*pow(bikkuri[r+1],mod-2,mod) - 1)%mod
return tmp
ans = F(r2,c2)-F(r1-1,c2)-F(r2,c1-1)+F(r1-1,c1-1)
print(ans)
|
bikkuri = [1]
mod = 10**9+7
for i in range(1,2*10**6+1000):
bikkuri.append((bikkuri[-1]*i)%mod)
r1,c1,r2,c2 = map(int,input().split())
def F(r,c):
tmp = (bikkuri[r+c+2]*pow(bikkuri[c+1],mod-2,mod)*pow(bikkuri[r+1],mod-2,mod) - 1)%mod
return tmp
ans = (F(r2,c2)-F(r1-1,c2)-F(r2,c1-1)+F(r1-1,c1-1))%mod
print(ans)
|
[
"assignment.change"
] | 582,059
| 582,060
|
u980322611
|
python
|
p02782
|
MOD = 10 ** 9 + 7
FACT_MAX = 2 * 10 ** 6 + 3
fact = [1] * FACT_MAX
for i in range(1, FACT_MAX):
fact[i] = fact[i - 1] * i % MOD
def comb(n, r):
return fact[n] * pow(fact[n - r], MOD - 2, MOD) * pow(fact[r], MOD - 2, MOD)
def g(r, c):
return (comb(r + c + 2, c + 1) - 1) % MOD
r1, c1, r2, c2 = map(int, input().split())
print(g(r2, c2) - g(r2, c1 - 1) - g(r1 - 1, c2) + g(r1 - 1, c1 - 1))
|
MOD = 10 ** 9 + 7
FACT_MAX = 2 * 10 ** 6 + 3
fact = [1] * FACT_MAX
for i in range(1, FACT_MAX):
fact[i] = fact[i - 1] * i % MOD
def comb(n, r):
return fact[n] * pow(fact[n - r], MOD - 2, MOD) * pow(fact[r], MOD - 2, MOD)
def g(r, c):
return (comb(r + c + 2, c + 1) - 1) % MOD
r1, c1, r2, c2 = map(int, input().split())
print((g(r2, c2) - g(r2, c1 - 1) - g(r1 - 1, c2) + g(r1 - 1, c1 - 1)) % MOD)
|
[
"call.arguments.change",
"call.arguments.add"
] | 582,214
| 582,215
|
u638282348
|
python
|
p02782
|
import sys
input = sys.stdin.buffer.readline
def main():
a,b,c,d = map(int,input().split())
MOD = 10**9+7
N = c+d+5
fac = [0 for _ in range(N+1)]
fac[0],fac[1] = 1,1
for i in range(2,N+1):
fac[i] = (fac[i-1]*i)%MOD
def comb(x,y):
return (fac[x+y]*pow(fac[x],MOD-2,MOD)*pow(fac[y],MOD-2,MOD))%MOD
print((comb(c+1,d+1)-comb(c+1,b)-comb(d+1,a)+comb(a,b))%MOD)
if _name_ == "_main_":
main()
|
import sys
import math
input = sys.stdin.buffer.readline
def main():
a,b,c,d = map(int,input().split())
MOD = 10**9+7
N = c+d+5
fac = [0 for _ in range(N+1)]
fac[0],fac[1] = 1,1
for i in range(2,N+1):
fac[i] = (fac[i-1]*i)%MOD
def comb(x,y):
return (fac[x+y]*pow(fac[x],MOD-2,MOD)*pow(fac[y],MOD-2,MOD))%MOD
print((comb(c+1,d+1)-comb(c+1,b)-comb(d+1,a)+comb(a,b))%MOD)
if __name__ == "__main__":
main()
|
[
"identifier.change",
"control_flow.branch.if.condition.change",
"literal.string.change"
] | 582,247
| 582,248
|
u816631826
|
python
|
p02782
|
import sys
input = sys.stdin.buffer.readline
def main():
a,b,c,d = map(int,input().split())
MOD = 10**9+7
N = c+d+5
fac = [0 for _ in range(N+1)]
fac[0],fac[1] = 1,1
for i in range(2,N+1):
fac[i] = (fac[i-1]*i)%MOD
def comb(x,y):
return (fac[x+y]*pow(fac[x],MOD-2,MOD)*pow(fac[y],MOD-2,MOD))%MOD
print(comb(c+1,d+1)-comb(c+1,b)-comb(d+1,a)+comb(a,b))
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.buffer.readline
def main():
a,b,c,d = map(int,input().split())
MOD = 10**9+7
N = c+d+5
fac = [0 for _ in range(N+1)]
fac[0],fac[1] = 1,1
for i in range(2,N+1):
fac[i] = (fac[i-1]*i)%MOD
def comb(x,y):
return (fac[x+y]*pow(fac[x],MOD-2,MOD)*pow(fac[y],MOD-2,MOD))%MOD
print((comb(c+1,d+1)-comb(c+1,b)-comb(d+1,a)+comb(a,b))%MOD)
if __name__ == "__main__":
main()
|
[
"call.arguments.change",
"call.arguments.add"
] | 582,276
| 582,277
|
u648212584
|
python
|
p02782
|
r1,c1,r2,c2=map(int,input().split())
r2+=1
c2+=1
N=2*(10**6)
mod=10**9+7
fac=[1]*(N+2)
inv=[1]*(N+2)
t=1
for i in range(1,N+2):
t*=i
t%=mod
fac[i]=t
t=pow(fac[N+1],mod-2,mod)
for i in range(N+1,0,-1):
inv[i]=t
t*=i
t%=mod
def comb(n,r):
return fac[n]*inv[n-r]*inv[r]%mod
print(comb(r2+c2,c2)-comb(r2+c1,c1)-comb(r1+c2,c2)+comb(r1+c1,c1))
|
r1,c1,r2,c2=map(int,input().split())
r2+=1
c2+=1
N=2*(10**6)+2
mod=10**9+7
fac=[1]*(N+2)
inv=[1]*(N+2)
t=1
for i in range(1,N+2):
t*=i
t%=mod
fac[i]=t
t=pow(fac[N+1],mod-2,mod)
for i in range(N+1,0,-1):
inv[i]=t
t*=i
t%=mod
def comb(n,r):
return fac[n]*inv[n-r]*inv[r]%mod
print((comb(r2+c2,c2)-comb(r2+c1,c1)-comb(r1+c2,c2)+comb(r1+c1,c1))%mod)
|
[
"call.arguments.change",
"call.arguments.add"
] | 582,289
| 582,290
|
u065446124
|
python
|
p02782
|
import sys
readline = sys.stdin.buffer.readline
r1,c1,r2,c2 = map(int,readline().split())
mod = 10**9+7
def pow(n,p,mod=10**9+7): #繰り返し二乗法(nのp乗)
res = 1
while p > 0:
if p % 2 == 0:
n = n ** 2 % mod
p //= 2
else:
res = res * n % mod
p -= 1
return res % mod
def factrial_memo(n=20**6+1,mod=10**9+7):
fact = [1, 1]
for i in range(2, n + 1):
fact.append((fact[-1] * i) % mod)
return fact
def fermat_cmb(n, r, mod=10**9+7): #needs pow,factrial_memo(only fact). return nCk
return fact[n] * pow(fact[r],mod-2) * pow(fact[n-r],mod-2) %mod
fact = factrial_memo()
r1,c1,r2,c2 = r1+1,c1+1,r2+1,c2+1
al = fermat_cmb(r2+c2,r2)
sub_r = fermat_cmb(r1-1+c2,r1-1)
sub_c = fermat_cmb(r2+c1-1,c1-1)
add_rc = fermat_cmb(r1-1+c1-1,r1-1)
al -= sub_r+sub_c
al += add_rc
print(al%mod)
|
import sys
readline = sys.stdin.buffer.readline
r1,c1,r2,c2 = map(int,readline().split())
mod = 10**9+7
def pow(n,p,mod=10**9+7): #繰り返し二乗法(nのp乗)
res = 1
while p > 0:
if p % 2 == 0:
n = n ** 2 % mod
p //= 2
else:
res = res * n % mod
p -= 1
return res % mod
def factrial_memo(n=3*10**6+1,mod=10**9+7):
fact = [1, 1]
for i in range(2, n + 1):
fact.append((fact[-1] * i) % mod)
return fact
def fermat_cmb(n, r, mod=10**9+7): #needs pow,factrial_memo(only fact). return nCk
return fact[n] * pow(fact[r],mod-2) * pow(fact[n-r],mod-2) %mod
fact = factrial_memo()
r1,c1,r2,c2 = r1+1,c1+1,r2+1,c2+1
al = fermat_cmb(r2+c2,r2)
sub_r = fermat_cmb(r1-1+c2,r1-1)
sub_c = fermat_cmb(r2+c1-1,c1-1)
add_rc = fermat_cmb(r1-1+c1-1,r1-1)
al -= sub_r+sub_c
al += add_rc
print(al%mod)
|
[
"literal.number.integer.change",
"expression.operation.binary.change"
] | 582,346
| 582,345
|
u372144784
|
python
|
p02782
|
r1,c1,r2,c2=map(int,input().split())
MOD=10**9+7
idx=r2+c2+2
perm=[1]*(idx+1)
perm_inv=[1]*(idx+1)
for i in range(1,idx+1):
perm[i]=perm[i-1]*i
perm[i]%=MOD
def inv_mod(a):
return pow(a,MOD-2,MOD)
perm_inv[-1]=inv_mod(perm[-1])
for i in range(idx-1,-1,-1):
perm_inv[i]=perm_inv[i+1]*(i+1)
perm_inv[i]%=MOD
def comb(i,j):
buf=perm[i+j+2]
buf*=perm_inv[i+1]
buf%=MOD
buf*=perm_inv[j+1]
buf%=MOD
return buf
res=comb(r2,c2)
res-=comb(r2,c1-1)
res-=comb(r1-1,c2)
res+=comb(r1-1,c1-1)
print(res)
|
r1,c1,r2,c2=map(int,input().split())
MOD=10**9+7
idx=r2+c2+2
perm=[1]*(idx+1)
perm_inv=[1]*(idx+1)
for i in range(1,idx+1):
perm[i]=perm[i-1]*i
perm[i]%=MOD
def inv_mod(a):
return pow(a,MOD-2,MOD)
perm_inv[-1]=inv_mod(perm[-1])
for i in range(idx-1,-1,-1):
perm_inv[i]=perm_inv[i+1]*(i+1)
perm_inv[i]%=MOD
def comb(i,j):
buf=perm[i+j+2]
buf*=perm_inv[i+1]
buf%=MOD
buf*=perm_inv[j+1]
buf%=MOD
return buf
res=comb(r2,c2)
res-=comb(r2,c1-1)
res-=comb(r1-1,c2)
res+=comb(r1-1,c1-1)
print(res%MOD)
|
[
"expression.operation.binary.add"
] | 582,462
| 582,463
|
u492026192
|
python
|
p02782
|
r1,c1,r2,c2=map(int,input().split())
MOD=10**9+7
idx=r2+c2+3
perm=[1]*(idx+1)
for i in range(1,idx+1):
perm[i]=perm[i-1]*i
perm[i]%=MOD
def inv_mod(a):
return pow(a,MOD-2,MOD)
def comb(n,m,p=10**9+7):
if n < m : return 0
if n < 0 or m < 0:return 0
m = min(m, n-m)
top = bot = 1
for i in range(m):
top = top*(n-i) % p
bot = bot*(i+1) % p
bot = pow(bot, p-2, p)
return top*bot % p
def g(i,j):
return comb(i+j+2,i+1,MOD)
def s(n,m):
return comb(n+m+2, m+1, MOD)
res=g(r2,c2)-g(r2,c1-1)-g(r1-1,c2)+g(r1-1,c1-1)
ans = s(r2,c2) - s(r2, c1-1) - s(r1-1, c2) + s(r1-1, c1-1)
ans %= MOD
print(res)
|
r1,c1,r2,c2=map(int,input().split())
MOD=10**9+7
idx=r2+c2+3
perm=[1]*(idx+1)
for i in range(1,idx+1):
perm[i]=perm[i-1]*i
perm[i]%=MOD
def inv_mod(a):
return pow(a,MOD-2,MOD)
def comb(n,m,p=10**9+7):
if n < m : return 0
if n < 0 or m < 0:return 0
m = min(m, n-m)
top = bot = 1
for i in range(m):
top = top*(n-i) % p
bot = bot*(i+1) % p
bot = pow(bot, p-2, p)
return top*bot % p
def g(i,j):
return comb(i+j+2,i+1,MOD)
def s(n,m):
return comb(n+m+2, m+1, MOD)
res=g(r2,c2)-g(r2,c1-1)-g(r1-1,c2)+g(r1-1,c1-1)
res%=MOD
ans = s(r2,c2) - s(r2, c1-1) - s(r1-1, c2) + s(r1-1, c1-1)
ans %= MOD
print(res)
|
[] | 582,464
| 582,465
|
u492026192
|
python
|
p02782
|
m = 1000000007
r1, c1, r2, c2 = map(int, input().split())
nf = 10 ** 6 * 2 + 100
fact = [0] * (nf + 1)
fact[0] = 1
for i in range(nf):
fact[i + 1] = fact[i] * (i + 1) % m
def F(r, c):
path = (fact[r + c + 2] % m) * pow(fact[r + 1] * fact[c + 1], m - 2, m) % m
return path - 1
r1 -= 1
c1 -= 1
ans = F(r2, c2)
ans -= F(r1, c2)
ans -= F(r2, c1)
ans += F(r1, c1)
print(ans)
|
m = 1000000007
r1, c1, r2, c2 = map(int, input().split())
nf = 10 ** 6 * 2 + 100
fact = [0] * (nf + 1)
fact[0] = 1
for i in range(nf):
fact[i + 1] = fact[i] * (i + 1) % m
def F(r, c):
path = (fact[r + c + 2] % m) * pow(fact[r + 1] * fact[c + 1], m - 2, m) % m
return path - 1
r1 -= 1
c1 -= 1
ans = F(r2, c2)
ans -= F(r1, c2)
ans -= F(r2, c1)
ans += F(r1, c1)
ans = ans % m
print(ans)
|
[
"assignment.add"
] | 582,466
| 582,467
|
u325956328
|
python
|
p02782
|
#input
r_1, c_1, r_2, c_2 = map(int, input().split())
#output
mod = 10**9 + 7
n_ = 10**7 + 3
fun = [1]*(n_+1)
for i in range(1,n_+1):
fun[i] = fun[i-1]*i%mod
rev = [1]*(n_+1)
rev[n_] = pow(fun[n_],mod-2,mod)
for i in range(n_-1,0,-1):
rev[i] = rev[i+1]*(i+1)%mod
def cmb(n,r):
if n <= 0 or r < 0 or r > n: return 0
return fun[n]*rev[r]%mod*rev[n-r]%mod
answer = 0
for j in range(c_1, c_2+1):
answer += cmb(r_2+j+1, j+1) % mod - cmb(r_1+j, j+1) % mod
print(answer % mod)
|
#input
r_1, c_1, r_2, c_2 = map(int, input().split())
#output
mod = 10**9 + 7
n_ = 2*10**6 + 1
fun = [1]*(n_+1)
for i in range(1,n_+1):
fun[i] = fun[i-1]*i%mod
rev = [1]*(n_+1)
rev[n_] = pow(fun[n_],mod-2,mod)
for i in range(n_-1,0,-1):
rev[i] = rev[i+1]*(i+1)%mod
def cmb(n,r):
if n <= 0 or r < 0 or r > n: return 0
return fun[n]*rev[r]%mod*rev[n-r]%mod
answer = 0
for j in range(c_1, c_2+1):
answer += cmb(r_2+j+1, j+1) % mod - cmb(r_1+j, j+1) % mod
print(answer % mod)
|
[
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 582,512
| 582,513
|
u461454424
|
python
|
p02782
|
#input
r_1, c_1, r_2, c_2 = map(int, input().split())
#output
mod = 10**9 + 7
n_ = 10**10 + 3
fun = [1]*(n_+1)
for i in range(1,n_+1):
fun[i] = fun[i-1]*i%mod
rev = [1]*(n_+1)
rev[n_] = pow(fun[n_],mod-2,mod)
for i in range(n_-1,0,-1):
rev[i] = rev[i+1]*(i+1)%mod
def cmb(n,r):
if n <= 0 or r < 0 or r > n: return 0
return fun[n]*rev[r]%mod*rev[n-r]%mod
answer = 0
for j in range(c_1, c_2+1):
answer += cmb(r_2+j+1, j+1) % mod - cmb(r_1+j, j+1) % mod
print(answer % mod)
|
#input
r_1, c_1, r_2, c_2 = map(int, input().split())
#output
mod = 10**9 + 7
n_ = 2*10**6 + 1
fun = [1]*(n_+1)
for i in range(1,n_+1):
fun[i] = fun[i-1]*i%mod
rev = [1]*(n_+1)
rev[n_] = pow(fun[n_],mod-2,mod)
for i in range(n_-1,0,-1):
rev[i] = rev[i+1]*(i+1)%mod
def cmb(n,r):
if n <= 0 or r < 0 or r > n: return 0
return fun[n]*rev[r]%mod*rev[n-r]%mod
answer = 0
for j in range(c_1, c_2+1):
answer += cmb(r_2+j+1, j+1) % mod - cmb(r_1+j, j+1) % mod
print(answer % mod)
|
[
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 582,514
| 582,513
|
u461454424
|
python
|
p02782
|
import sys
import numpy as np
sys.setrecursionlimit(10 ** 7)
r1, c1, r2, c2 = map(int, input().split())
# 階乗、Combinationコンビネーション(numpyを使う)
def cumprod(arr, MOD):
L = len(arr)
Lsq = int(L**.5+1)
arr = np.resize(arr, Lsq**2).reshape(Lsq, Lsq)
for n in range(1, Lsq):
arr[:, n] *= arr[:, n-1]
arr[:, n] %= MOD
for n in range(1, Lsq):
arr[n] *= arr[n-1, -1]
arr[n] %= MOD
return arr.ravel()[:L]
def make_fact(U, MOD):
x = np.arange(U, dtype=np.int64)
x[0] = 1
fact = cumprod(x, MOD)
x = np.arange(U, 0, -1, dtype=np.int64)
x[0] = pow(int(fact[-1]), MOD-2, MOD)
fact_inv = cumprod(x, MOD)[::-1]
return fact, fact_inv
MOD = 10 ** 9 + 7
U = 10**6 * 2 + 1
fact, fact_inv = make_fact(U, MOD)
def mod_comb_k(n, k, mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n - k] % mod
def calc_rc(r, c):
a = mod_comb_k(r + c + 2, r + 1, MOD)
b = 1
return a-b
ans = calc_rc(r2, c2) + calc_rc(r1-1, c1-1) - \
calc_rc(r1-1, c2) - calc_rc(r2, c1-1)
print(ans)
|
import sys
import numpy as np
sys.setrecursionlimit(10 ** 7)
r1, c1, r2, c2 = map(int, input().split())
# 階乗、Combinationコンビネーション(numpyを使う)
def cumprod(arr, MOD):
L = len(arr)
Lsq = int(L**.5+1)
arr = np.resize(arr, Lsq**2).reshape(Lsq, Lsq)
for n in range(1, Lsq):
arr[:, n] *= arr[:, n-1]
arr[:, n] %= MOD
for n in range(1, Lsq):
arr[n] *= arr[n-1, -1]
arr[n] %= MOD
return arr.ravel()[:L]
def make_fact(U, MOD):
x = np.arange(U, dtype=np.int64)
x[0] = 1
fact = cumprod(x, MOD)
x = np.arange(U, 0, -1, dtype=np.int64)
x[0] = pow(int(fact[-1]), MOD-2, MOD)
fact_inv = cumprod(x, MOD)[::-1]
return fact, fact_inv
MOD = 10 ** 9 + 7
U = 10**6 * 2 + 10
fact, fact_inv = make_fact(U, MOD)
def mod_comb_k(n, k, mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n - k] % mod
def calc_rc(r, c):
a = mod_comb_k(r + c + 2, r + 1, MOD)
b = 1
return a-b
ans = calc_rc(r2, c2) + calc_rc(r1-1, c1-1) - \
calc_rc(r1-1, c2) - calc_rc(r2, c1-1)
ans %= MOD
print(ans)
|
[
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 582,523
| 582,522
|
u593567568
|
python
|
p02783
|
h,a=map(int,input.split())
cnt=0
while True:
h-=a
cnt+=1
if h<=0:
break
print(cnt)
|
h,a=map(int,input().split())
cnt=0
while True:
h-=a
cnt+=1
if h<=0:
break
print(cnt)
|
[
"call.add"
] | 582,566
| 582,567
|
u243159381
|
python
|
p02783
|
H,A = map(int(),input().split)
print(H//A if H%A == 0 else H//A+1)
|
H,A = map(int,input().split())
print(H//A if H%A == 0 else H//A+1)
|
[
"call.arguments.change",
"call.add"
] | 582,572
| 582,573
|
u288980918
|
python
|
p02783
|
a,b=list(map(int,input().split()))
count=0
while (a<0):
count+=1
a-=b
print(count)
|
a,b=list(map(int,input().split()))
count=0
while (a>0):
count+=1
a-=b
print(count)
|
[
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 582,584
| 582,585
|
u754511616
|
python
|
p02783
|
a,b=list(map(int,input()))
count=0
while (a<0):
count+=1
a-=b
print(count)
|
a,b=list(map(int,input().split()))
count=0
while (a>0):
count+=1
a-=b
print(count)
|
[
"call.add",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 582,586
| 582,585
|
u754511616
|
python
|
p02783
|
tmp = input().split(" ")
HP = int(tmp[0])
attack = int(tmp[1])
print(math.ceil(HP/attack))
|
import math
tmp = input().split(" ")
HP = int(tmp[0])
attack = int(tmp[1])
print(math.ceil(HP/attack))
|
[] | 582,587
| 582,588
|
u739843002
|
python
|
p02783
|
H,A = map(int,input().split())
answer = H // A
if answer == 0:
answer += 1
print(answer)
|
H,A = map(int,input().split())
answer = H // A + 1
if H % A == 0:
answer -= 1
print(answer)
|
[
"control_flow.branch.if.condition.change",
"expression.operator.change"
] | 582,595
| 582,596
|
u732061897
|
python
|
p02783
|
import math
#h = int(input())
#a = int(input())
h,a = map(int,input().split())
print(math.ceil((h+a)/a))
|
import math
#h = int(input())
#a = int(input())
h,a = map(int,input().split())
print(math.ceil((h)/a))
|
[
"expression.operation.binary.remove"
] | 582,597
| 582,598
|
u704411633
|
python
|
p02783
|
INPUT = list(input().split())
H = INT(INPUT[0])
A = INT(INPUT[1])
if H%A == 0:
print(H//A)
else:
print(H//A + 1)
|
INPUT = list(input().split())
H = int(INPUT[0])
A = int(INPUT[1])
if H%A == 0:
print(H//A)
else:
print(H//A + 1)
|
[
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 582,599
| 582,600
|
u893418950
|
python
|
p02783
|
H,A=map(int, input().split())
print(math.ceil(H/A))
|
import math
H,A=map(int, input().split())
print(math.ceil(H/A))
|
[] | 582,603
| 582,604
|
u799428010
|
python
|
p02783
|
H, A =map(int,input().split())
T = 0
while H <= 0:
H -= A
T += 1
print(T)
|
H, A =map(int,input().split())
T = 0
while H > 0:
H -= A
T += 1
print(T)
|
[
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 582,607
| 582,608
|
u272457181
|
python
|
p02783
|
h,a = map(int,input().split())
counter = 0
while h >= 0:
h -= a
counter +=1
print(counter)
|
h,a = map(int,input().split())
counter = 0
while h > 0:
h -= a
counter += 1
print(counter)
|
[
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 582,609
| 582,610
|
u598684283
|
python
|
p02783
|
H, A = map(int, input().split())
i = 0
while H>=0:
H = H-A
i += 1
print(i)
|
H, A = map(int, input().split())
i = 0
while H >= 1:
H = H-A
i += 1
print(i)
|
[
"literal.number.integer.change",
"control_flow.loop.condition.change"
] | 582,617
| 582,618
|
u710398282
|
python
|
p02783
|
h, a = map(int, input().split())
count = 0
while h >= 0:
h -= a
count += 1
print(count)
|
h, a = map(int, input().split())
count = 0
while h > 0:
h -= a
count += 1
print(count)
|
[
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 582,625
| 582,626
|
u125269142
|
python
|
p02783
|
h,a=map(int,input().split())
ans=0
while h>=0:
h-=a
ans+=1
print(ans)
|
h,a=map(int,input().split())
ans=0
while h>0:
h-=a
ans+=1
print(ans)
|
[
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 582,631
| 582,632
|
u486773779
|
python
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.