Problem:
 Score : 200 points    Problem Statement Find the sum of the integers between 1 and N (inclusive), whose sum of digits written in base 10 is between A and B (inclusive).      Constraints  1 \leq N \leq 10^4  1 \leq A \leq B \leq 36  All input values are integers.         Input Input is given from Standard Input in the following format:  N  A  B       Output Print the sum of the integers between 1 and N (inclusive), whose sum of digits written in base 10 is between A and B (inclusive).        Sample Input 1 20 2 5      Sample Output 1 84  Among the integers not greater than 20 , the ones whose sums of digits are between 2 and 5 , are: 2,3,4,5,11,12,13,14 and 20 . We should print the sum of these, 84 .       Sample Input 2 10 1 2      Sample Output 2 13       Sample Input 3 100 4 16      Sample Output 3 4554

Solution (Python):
import subprocess
import gzip, base64, os
import stat

gz = b'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'
bin = gzip.decompress(base64.b64decode(gz))
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
with open(pymain, "wb") as f:
    f.write(bin)
os.chmod(pymain, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
if p == "":
    pymain = "./" + pymain
subprocess.call(pymain)



'''


def sum_digit(a):
    res = 0
    while a > 0:
        res += a % 10
        a //= 10
    return res

def main2():
    stdin = open('/dev/stdin')
    N, A, B = map(int, stdin.readline().split())
    ans = 0
    for i in range(1, N + 1):
        if A <= sum_digit(i) <= B:
            ans += i
    print(ans)
'''

Solution (Python):
N, A, B = map(int, input().split())
ans = 0 

for n in range(N + 1): 
    if A <= sum(list(map(int, str(n)))) <= B:
        ans += n
print(ans)

Solution (Python):
n, a, b = map(int, input().split())
ans = 0
for i in range(a, n+1):
    x = sum(list(map(int, list(str(i)))))
    if x >= a and x <= b:
        ans += i
print(ans)

Solution (Python):
n,a,b=map(int,input().split())
print(sum(i for i in range(n+1) if a<=sum(map(int,str(i)))<=b))

Solution (Python):
n, a, b = map(int, input().split())
ans = 0
for i in range(1, n+1):
    if a <= sum(map(int, str(i))) <= b:
        ans += i
print(ans)

Solution (Python):
n,a,b = map(int,input().split())
ans = 0

for i in range(n+1):
  if a <= sum(list(map(int,str(i)))) <= b:
    ans += i
    
print(ans)

Solution (Python):
N,A,B = map(int,input().split())
ans = 0
for i in range(1,N+1):
    s = str(i)
    S = sum(map(int,list(s)))
    if A <= S <= B:
        ans += i
print(ans)

Solution (Python):
n, a, b =map(int, input().split())

sum=0
for i in range(1, n+1):
    z=i%10
    y=(i//10)%10
    x=(i//100)%10
    w=(i//1000)%10
    v=(i//10000)
    if a<=v+w+x+y+z<=b:
        sum+=i
print(sum)

Solution (Python):
n,a,b=map(int,input().split())
def digitsum(k):
    s=str(k)
    array=list(map(int,s))
    return sum(array)
c=1
ans=0
while n>=c:
    if digitsum(c)>=a and digitsum(c) <=b:
        ans+=c
    c+=1
print(ans)

Solution (Python):
X,A,B = map(int,input().split())
list = []
for i in range(X + 1):
    tmp = 0
    for j in range(len(str(i))):
        tmp += int(str(i)[j])
    if A <= tmp <= B:
        list.append(i)

print(sum(list))

Solution (Python):

def findsum(n):
    sum = 0 
    while True:
        q, mod = divmod(n, 10)
        sum += mod
        n = q
        if n == 0:
            break

    return sum

N, A, B = map(int, input().split())

arr = range(1,N+1)

sum = 0 
for i in range(N):
    a = findsum(arr[i])

    if A <= a <= B:
        sum += arr[i]

print(sum)

Solution (Python):


N, A, B = map(int, input().split())


res = sum([n for n, y in zip(range(1, N+1), [sum([int(e) for e in str(x)]) for x in range(1, N+1)]) if y >= A and y <= B])


print(res)

Solution (Python):
inputs = list(map(lambda i: int(i), input().split()))
N, A, B = inputs[0], inputs[1], inputs[2]
total_sum = 0

for n in range(N+1):
    n_sum = sum(list(map(lambda m: int(m), list(str(n)))))
    if n_sum in range(A, B+1):
        total_sum += n

print(total_sum)

Solution (Python):
n, a, b = map(int, input().split())
ans = 0

for i in range(1, n+1):
    if a <= sum(map(int, list(str(i)))) <= b:
        ans += i
    else:
        continue

print(ans)

Solution (Python):
def Findsumofdigits(i):
    c = 0
    while i > 0:
        c = c + i % 10
        i = (i - i % 10)/10
    return c
L = input().split()
N = int(L[0])
A = int(L[1])
B = int(L[2])
count = 0
for value in range(N + 1):
    if Findsumofdigits(value) >= A and Findsumofdigits(value) <= B:
        count = count + value
    else:
        pass
print(count)

Solution (Python):
N, A, B = [int(i) for i in input().split()]

def sum_n(n):
    sum = 0
    while n > 0:
        sum += n % 10
        n //= 10
    return sum

ans = 0
for i in range(1, N+1):
    sum = sum_n(i)
    if sum >= A and sum <= B:
        ans += i

print(ans)

Solution (Python):
n,a,b = map(int,input().split())
count=0

for i in range(1,n+1):
  sum=0
  t=i
  while t>0:
    sum += t%10
    t = (t-t%10)/10
  
  if a <= sum <= b:
    count += i
  
print(count)

Solution (Python):
N, A, B = map(int, input().split())
result = 0

for i in range(N + 1):
    if A <= sum(list(map(int, str(i)))) <= B:
        result = result + i
        
print(result)

Solution (Python):
n, a, b = [int(x) for x in input().split()]

sum = 0
for x in range(1, n + 1):
    gyo_sum = 0
    x_str = str(x)
    for y in range(len(x_str)):
        gyo_sum += int(x_str[y])
    if gyo_sum >= a and gyo_sum <= b:
        sum += x

print(sum)

Solution (Python):
n, a, b = map(int, input().split())
ans = 0
for i in range(1, n + 1):
    s = 0
    init = i
    while i > 0:
        i, r = divmod(i, 10)
        s += r
    if s >= a and s <= b:
        ans += init
print(ans)

Solution (Python):
N,A,B = map(int,input().split())

count = 0

box = []

for x in range(N+1):
    result = sum(list(map(int, str(x))))
    if A<=result & result<=B:
        box.append(x)

print(sum(box))

Solution (Python):


def main():

    N,A,B = map(int,input().split())
    ans = 0

    for outer in map(str,range(1,N+1)):
        inner = sum([int(inner) for inner in outer])
        if A<=inner and inner <= B:
            ans += int(outer)

    print(ans)



if __name__== "__main__":
    main()

Solution (Python):
N,A,B = map(int,input().split())
count = 0

for i in range(N+1):
    s = sum(map(int,list(str(i))))
    if A <= s and s <= B:
        count += i

print(count)

Solution (Python):
N, a, b =map (int, input().split(' '))

res =0
for i in range(1,N+1):
    total =0
    for d in list(str(i)):
        total += int(d)
    
    
    if total >= a and total <= b:
        res += i
            
print(res)

Solution (Python):
N,a,b = map(int,input().split())
ans = 0
for i in range(N+1):
    if a <= sum(list(map(int,list(str(i))))) <= b:
        ans += i
print(ans)

Solution (Python):
N,A,B = map(int,input().split())
goal = 0

for i in range(1,N+1):
    tmpstr = str(i)
    tmplist = list(tmpstr)
    tmpsum = 0
    for j in tmplist:
        tmpsum += int(j)
    
    if tmpsum >= A and tmpsum <= B:
        goal += i

print(goal)

Solution (Python):
a,b,c = map(int,input().split())
y = 0
for num in range(a + 1):
  s = 0
  x = num
  while x > 0:
    s += int(x % 10)
    x = int(x / 10)
  if s >= b and s <= c:
    y += num
print(y)

Solution (Python):
n,a,b=map(int,input().split())
print(sum(i for i in range(n+1) if a<=sum(map(int,str(i)))<=b))

Solution (Python):
N, A, B = map(int, input().split())
s = 0
for i in range(1,N+1):
  a = i%10
  b = (i//10)%10
  c = (i//100)%10
  d = (i//1000)%10
  e = (i//10000)%10
  f = (a+b+c+d+e)
  if A <= f <= B:
    s += i
print(s)

Solution (Python):
def sums(n):
    ans = 0
    while n > 0:
        a = n%10
        n = n//10
        ans += a
    return(ans)

N, A, B = map(int, input().split())
ans = 0
for i in range(1, N+1):
    sum = sums(i)
    if A <= sum <= B:
        ans += i
print(ans)

Solution (Python):
from collections import defaultdict, Counter
from heapq import heapify, heappop, heappush
from sys import stdin

def main():
    n, a, b = map(int, input().split())
    ans = 0
    for i in range(1, n+1):
        tmp = i%10 + i//10%10 + i//(10**2)%10 + i//(10**3)%10 + i//(10**4)%10
        if a <= tmp and tmp <= b:
            ans += i
    print(ans)

input = lambda: stdin.readline().rstrip()
main()

Solution (Python):
N, A, B = map(int, input().split())
cnt = 0
for i in range(1,N+1):
    s = sum(map(int,list(str(i))))
    if A <= s <= B:
        cnt += i
print(cnt)

Solution (Python):
n,a,b=map(int,input().split())
print(sum([i for i in range(1,n+1) if a<=sum(map(int,str(i)))<=b]))

Solution (Python):
n, a, b = map(int, input().split())

res = 0
for num in range(1, n + 1):
    s = sum(map(int, list(str(num))))
    if a <= s <= b:
        res += num
print(res)

Solution (Python):
n,a,b = map(int,input().split())
L = []
for i in range(1,n+1):
  wa = 0
  for j in range(len(str(i))):
    wa += int(str(i)[j])
  if a<=wa<=b:
    L.append(i)
print(sum(L))

Solution (Python):
n,a,b=map(int,input().split())
ans=0
for i in range(n+1):
  ans+=[0,i][a<=sum([int(j) for j in list(str(i))])<=b]
print(ans)

Solution (Python):
import math
import numpy as np










n, a, b = map(int,input().split())

ans = 0
for i in range(n+1):
    sum = 0
    k = i
    while k > 0:
        sum += k % 10
        k = k // 10
    if a <= sum <= b:
        ans += i
print(ans)

Solution (Python):
n, a, b = map(int, input().split())
total = 0
for i in range(n+1):
    _i = sum(map(int, list(str(i))))
    if a <= _i <= b:
        total += i
print(total)

Solution (Python):
n, a, b = map(int, input().split())
l = 0
for j in range(n):
    m = list(str(n-j))
    keta = 0
    for i in m:
        keta += int(i)
    if a <= keta <= b:
        l += n-j
print(l)

Solution (Python):
n,a,b = map(int,input().split())

ans=0
for i in range(n+1):

    sum=0
    for i_str in list(str(i)):
        sum+=int(i_str)

    if a<= sum <= b:
        ans += i

print(ans)

Solution (Python):
N,A,B = map(int, input().split())
x = 0
for i in range(1,N+1):
  n = sum(list(map(int, str(i))))
  if A <= n <= B:
    x += i

print(x)

Solution (Python):
n, a, b = map(int, input().split())
ans = 0
for x in range(n+1):
    tmp = 0
    val = x
    while(x > 0):
        tmp += x % 10
        x //= 10
    if a <= tmp <= b:
        ans += val
print(ans)

Solution (Python):
n, a, b = list(map(int, input().split()))
total = 0
for i in range(n+1):
    s = str(i)
    wa = 0
    for j in range(len(s)):
        wa += int(s[j])
    if wa >= a and wa <= b:
        total += i
print(total)

Solution (Python):
N,A,B = map(int,input().split())

TRUE_LIST = []

list_1 = list(range(0,N+1))

for i in range(len(list_1)):
  s = str(list_1[i])
  arr = list(map(int,s))
  t=sum(arr)
  if A <= t and t <= B:
    TRUE_LIST.append(list_1[i])

print(sum(TRUE_LIST))

Solution (Python):
n, a, b = map(int, input().split())

ans = []
for i in range(n):
    add = sum([int(j) for j in str(i+1)])
    if a <= add <= b:
        ans.append(i+1)
print(sum(ans))

Solution (Python):
N, A, B = [int(n) for n in input().split()]

def dismantle(n):
  ans = 0
  while n > 0:
    ans += n % 10
    n //= 10
  return ans

ans = 0
for i in range(N+1):
  comp = dismantle(i)
  if i > 0 and A <= comp and comp <= B:
    ans += i

print(ans)

Solution (Python):
N,A,B=map(int,input().split())

ans=0

for i in range(N):
    tmp=0
    number=str(i+1)
    for j in range(len(number)):
        tmp+=int(number[j])
    if A<=tmp<=B:
        ans+=(i+1)

print(str(ans))

Solution (Python):
N,A,B = map(int,input().split())
count=0
for n in range(1,N+1):
    sumn=0
    strn = str(n)
    for lenn in range(len(strn)):
        if lenn == 0:
            sumn += n%10
        else:

            sumn += int(n/(10**lenn))%10

    if sumn >= A:
        if sumn <= B:
            count+=n
print(count)

Solution (Python):
n,a,b = map(int,input().split())
number = 0
ans = 0
for i in range(1,n+1):
  number = 0
  for j in range(len(str(i))):
    number += int(str(i)[j])
  if number >= a and number <= b:
    ans += i
print(ans)

Solution (Python):
def main():
    N, A, B = map(int, input().split())
    ans = 0
    for i in range(1, N+1):
        v = sum([int(c) for c in str(i)])
        if A <= v <= B:
            ans += i
    return ans

if __name__ == '__main__':
    print(main())

Solution (Python):
N,a,b = map(int,input().split())

temp = 0   
sum1 = 0
sum2 = 0
for i in range(N):
  temp = i+1
  sum1 = 0          
  while temp != 0:
    sum1 += temp%10
    temp = int(temp/10)
  if sum1 >= a and sum1 <= b:
    sum2 += i+1
    

print(sum2)

Solution (Python):
N, A, B = [int(x) for x in input().split(' ')]

rtn = 0
for i in range(1,N+1):
  sm = sum([int(x) for x in str(i)])
  if A <= sm and sm <= B:
    rtn += i
print(rtn)

Solution (Python):
n,a,b = map(int,input().split())
s = 0
for i in range(n):
    x = sum(list(map(int,str(i+1))))
    if a <= x and x <= b:
        s += i+1
print(s)

Solution (Python):
cou = 0
N, A, B = map(int, input().split())
for i in range(1, N + 1):
    tmp = list(str(i))
    if A <= sum(map(int, tmp)) <= B:
        cou += i
print(cou)

Solution (Python):
n, a, b = map(int, input().split())

def divide(num):
  sum = 0
  while num > 0:
    sum += num % 10
    num //= 10
  return sum

ans = 0
for i in range(n):
  temp = divide(i+1)
  if temp>= a and temp <= b:
    ans += (i+1)
print(ans)

Solution (Python):
N,A,B=map(int,input().split())
s=0

for n in range(0,N+1):
    m=0
    k=n
    while k > 0:
        m += k%10
        k = k//10

    if A<= m <=B:
        s += n

print(s)

Solution (Python):
n, a, b = (int(i) for i in input().split())
ans = 0
for i in range(1,n+1):
    cur = i
    cur_sum = 0
    while cur > 0:
        cur_sum += cur%10
        cur //= 10
    if a <= cur_sum <= b:
        ans += i
print(ans)

Solution (Python):
n, a, b = map(int, input().split())

sum = 0
for i in range(n + 1):
    sum2 = 0
    j = i
    while j != 0:
        sum2 += j % 10
        j = j // 10
    if sum2 >= a and sum2 <= b:
        sum += i

print(sum)

Solution (Python):
n, a, b = map(int, input().split())
ans = 0
for i in range(n+1):
    if a <= sum(list(map(int, list(str(i))))) <= b:
        ans += i
print(ans)

Solution (Python):
n, a, b = map(int, input().split())

sum = 0
for i in range(n + 1):
    sum2 = 0
    j = i
    while True:
        if j == 0:
            break
        sum2 += j % 10
        j = j // 10
    if sum2 >= a and sum2 <= b:
        sum += i

print(sum)

Solution (Python):
n, a, b = map(int, input().split())

sum = 0
for i in range(n + 1):
    sum2 = 0
    j = i
    while True:
        if j == 0:
            break
        sum2 += j % 10
        j = j // 10
    if sum2 >= a and sum2 <= b:
        sum += i

print(sum)

Solution (Python):
n, a, b = map(int, input().split())

sum = 0
for i in range(n + 1):
    sum2 = 0
    j = i
    while True:
        if j == 0:
            break
        sum2 += j % 10
        j = j // 10
    if sum2 >= a and sum2 <= b:
        sum += i

print(sum)

Solution (Python):
n, a, b = map(int, input().split())

sum = 0
for i in range(n + 1):
    sum2 = 0
    j = i
    while True:
        if j == 0:
            break
        sum2 += j % 10
        j = j // 10
    if sum2 >= a and sum2 <= b:
        sum += i

print(sum)

Solution (Python):


N,A,B=map(int,input().split())

count=0

for h in range(2):
    for i in range(10):
        for j in range(10):
            for k in range(10):
                for l in range(10):
                
                    if h+i+j+k+l>B:
                        break
                    elif ((h+i+j+k+l)>=A and (10000*h+1000*i+100*j+10*k+l)<=N):
                        count+=10000*h+1000*i+100*j+10*k+l
                        

                    
print(count)

Solution (Python):
N, A, B = map(int, input().split())

total = 0
for n in range(1, N + 1):
    tmp = n
    n_sum = 0

    while tmp != 0:
        n_sum += tmp % 10
        tmp //= 10

    if A <= n_sum <= B:
        total += n

print(total)

Solution (Python):
n,a,b = map(int,input().split())

ans = 0
n = str(n)
num = 1
while num <= int(n):
    sum1 = 0
    for s in str(num):
        sum1 += int(s)
        
    if a <= sum1 <= b:
        ans += num
        
    num += 1
    
print(ans)

Solution (Python):
n, a, b = map(int, input().split())
"""
n = 100
a = 4
b = 16
"""
ans = 0
for i in range(n+1):
    s = sum(list(map(int, str(i))))
    if a <= s and s <= b:
        ans += i
print(ans)

Solution (Python):
n,a,b = map(int, input().split())
i = 1
sum = 0
while ( i <= n ):
    l = list(str(i))
    s = 0
    for x in l:
        s = s + int(x)
    if a <= s and s <= b:
        sum = sum + i
    i = i + 1
print(sum)

Solution (Python):
n,a,b = map(int, input().split())
value = cnt = 0
for i in range(1, n+1):
    lst = []
    lst = list(str(i))
    for num in lst:
        value += int(num)
    if a <= value <= b:
    	cnt += i
    value = 0
print(cnt)