Problem:
 Score : 100 points    Problem Statement How many multiples of d are there among the integers between L and R (inclusive)?      Constraints  All values in input are integers.  1 \leq L \leq R \leq 100  1 \leq d \leq 100         Input Input is given from Standard Input in the following format:  L  R  d       Output Print the number of multiples of d among the integers between L and R (inclusive).        Sample Input 1 5 10 2      Sample Output 1 3   Among the integers between 5 and 10 , there are three multiples of 2 : 6 , 8 , and 10 .        Sample Input 2 6 20 7      Sample Output 2 2   Among the integers between 6 and 20 , there are two multiples of 7 : 7 and 14 .        Sample Input 3 1 100 1      Sample Output 3 100

Solution (Python):
import math
from collections import defaultdict

l,r,d = map(int,input().split())
c = 0
for i in range(l,r+1):
  if i%d == 0:
    c += 1
print(c)

Solution (Python):
L,R,d=map(int,input().split())
ans=0
for i in range(L,R+1):
    if(i%d==0):
        ans+=1
    
print(ans)

Solution (Python):
L, R, d = map(int,input().split())
if(L%d != 0):
  print(R//d-L//d)
else:
  print(R//d-L//d + 1)

Solution (Python):
L, R, d = map(int,input().split())
count=0
for i in range(L,R+1):
    if(i%d==0):
        count+=1
print(count)

Solution (Python):
li = list(map(int, input().split())) 
L = li[0]
R = li[1]
d = li[2]





count = 0

for X in range (L,R+1):
 if X % d == 0:
  count = count + 1
 else:
  pass

print(count)

Solution (Python):
lrd = input('')
l = int(lrd.split()[0])
r = int(lrd.split()[1])
d = int(lrd.split()[2])

cnt=0
for i in range(l,r+1):
    if i%d==0:
        cnt+=1

print(cnt)

Solution (Python):
s = input().split()

l = int(s[0])
r = int(s[1])
d = int(s[2])

count = 0
i = 0

for i in range(l, r+1):
    mod = i % d
    if mod == 0:
        count += 1

print(count)

Solution (Python):


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


x_1 = b // c
x_2 = (a-1)// c

res = x_1 - x_2

print("{}".format(res))

Solution (Python):
L,R,d = map(int,input().split())

if(R%d == 0):
  if(L%d == 0):
    print(int(R/d)-int(L/d)+1)
  else:
    print(int(R/d)-int(L/d))
else:
    print(int(R/d)-int(L/d))

Solution (Python):
L,R,d=map(int,input().split())
n=0
for i in range(L,R+1):
  if i%d==0:
     n+=1
print(n)

Solution (Python):
L, R, d = map(int, input().split())
ans = (R // d) - (L // d)
if L % d == 0: ans += 1
print(ans)

Solution (Python):
L, R, d = map(int, input().split())

cnt = 0
for n in range(L, R+1):
    if n % d == 0:
        cnt += 1
print(cnt)

Solution (Python):
l,d,r = map(int,input().split())
count = 0
for i in range(l,d+1):
  if i%r==0: count += 1
print(count)

Solution (Python):
L,R,d=(int(x) for x in input().split())

te=R-L+1
num=0

for i in range(te):
    if L%d==0:
        num+=1
        L+=1
    else:
        L+=1

print(num)

Solution (Python):
c = 0
L, R, d = map(int, input().split())
for i in range(L, R+1):
    if i % d == 0:
        c += 1
print(c)

Solution (Python):
d = input("")
list = d.split()

i = int(list[0])
count = 0
while i <= int(list[1]):
    if i % int(list[2]) == 0:
        count = count + 1
    i = i + 1

print(count)

Solution (Python):
import math 
a,b,n = map(int,input().split())
ans = b//n - (a-1)//n
print(ans)

Solution (Python):
L, R, d = map(int, input().split())

result = 0
for i in range(L,R+1):
  if i % d == 0 :
    result += 1
print (result)

Solution (Python):
a,b,c = input().split()
 
count = 0
num = int(a)

while num <= int(b):
  if num % int(c) == 0:
    count+=1
  num += 1
 
print(count)

Solution (Python):
l,r,d=map(int,input().split())
cnt=0
for i in range(l,r+1):
  if i%d==0:
    cnt+=1
print(cnt)

Solution (Python):
L, R, d = map(int, input().split())

print( R//d - (L-1)//d)

Solution (Python):
import sys

def L(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI():return list(map(int,sys.stdin.readline().rstrip().split()))
def LS():return list(sys.stdin.readline().rstrip().split())

def anser(prod):
    print(prod%(10**9+7))
    exit()

def solver(L,R,d):
    ans = 0

    for i in range(L,R+1):
        if i % d ==0:
            ans += 1

    print(ans)

def main():

    L,R,d = LI()

    solver(L,R,d)

if __name__ == '__main__':
    main()

Solution (Python):


l,r,d = map(int, input().split())
if l % d == 0:
    print(r//d - l//d + 1)
else:
    print(r//d - l//d)

Solution (Python):
l, r, d = input().split(" ")

L = int(l)
R = int(r)
D = int(d)

result=[]

for i in range(R - L + 1):
    if ((i + L) % D == 0):
        result.append(i)

print(len(result))

Solution (Python):
import math

L, R, d = map(int, input().split())
print(math.floor(R/d) - math.ceil(L/d) + 1)

Solution (Python):
l, r, d = list(map(int, input().split(" ")))

now = l
count = 0
while now <= r:
    if now % d == 0:
        count += 1
    now += 1
print(count)

Solution (Python):
l, r, d = map(int, input().split())

s1 = (l-1) // d
s2 = r // d

print(s2-s1)

Solution (Python):
l, r, d = map(int, input().split())


ans = 0
for i in range(l, r + 1):
    
    if i % d == 0:
        ans += 1
print(ans)

Solution (Python):
L,R,d=list(map(int,input().split()))
print(R//d-(L-1)//d)

Solution (Python):
L, R, d = map(int, input().split())

cnt = 0
for i in range(L, R+1):
    if i % d == 0:
        cnt += 1
print(cnt)

Solution (Python):
L, R, d = map(int, input().split())
count = 0
for i in range(L, R + 1):
    if i % d == 0:
        count += 1
print(count)

Solution (Python):
def multiples(l,r,d):
  
    c = 0
    if d == 0:
      return 0
    if d==1:
        return r-l+1
    i = l
    while i<=r:
        
        if i%d==0:
            c += 1
            i += d
            continue

        i += 1
        
    return c


if __name__ == '__main__':

    lrd = input().split()
    
    l = int(lrd[0])
    r = int(lrd[1])
    d = int(lrd[2])

    result = multiples(l,r,d)
    print(result)

Solution (Python):
l,r,d = map(int,input().split())
list = [i for i in range(l, r+1) if i % d == 0]
print(len(list))

Solution (Python):




import sys

iimr = lambda: map(int, sys.stdin.readline().rstrip().split())
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
MOD = (10 ** 9) + 7  


def 関数(l,r,d):
    res = 0
    for i in range(l, r+1):
        res += i % d == 0
    return res

def çözmek():
    L, R, d = iimr()
    res = []
    res.append(関数(L, R, d))
    print(*res, sep="\n")

if __name__ == "__main__":
    çözmek()

Solution (Python):
L, R, d = map(int, input().split())
count = 0

for i in range(L, R+1):
    if i%d == 0:
        count += 1

print(count)

Solution (Python):
L, R, d = list(map(int, input().split()))
n = 0
for i in range(L, R+1):
    if i % d == 0:
        n += 1
print(n)

Solution (Python):
L, R, d = map(int, input().split())

a = 0
for i in range(R)[L-1::]:
  if i%d == d-1:
    a += 1

print(a)

Solution (Python):
L, R, d = [int(_) for _ in input().split()]

ans = 0
for i in range(L, R+1):
    if i % d == 0:
        ans += 1
print(ans)

Solution (Python):
l, r, d = map(int, input().split())
ans = 0
for i in range(l, r+1):
    if i%d == 0:
        ans += 1

print(ans)

Solution (Python):




import sys

iimr = lambda: map(int, sys.stdin.readline().rstrip().split())
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
MOD = (10 ** 9) + 7  


def 関数(l,r,d):
    res = 0
    for i in range(l, r+1):
        if i % d == 0:
            res += 1
    return res

def çözmek():
    L, R, d = iimr()
    res = []
    res.append(関数(L, R, d))
    print(*res, sep="\n")

if __name__ == "__main__":
    çözmek()

Solution (Python):
l,r,d =map(int,input().split())
su =0
for i in range(l,r+1):
    if i % d == 0:
        su = su + 1
print(su)

Solution (Python):


l,r,d = map(int,input().split())

x = l%d
if l%d != 0:
    first = l + (d - l%d)
else:
    first = l

last = r - r%d

print((last - first)//d + 1)

Solution (Python):
l,r,d=map(int,input().split())
print(r//d-(l-1)//d)

Solution (Python):
L,R,d=list(map(int,(input().split())))
if (L==d):
  print(R//d-L//d+1)
elif L==R and L!=d:
  print(1)
else:
  print(R//d-L//d)

Solution (Python):
[L, R, d] = list(map(int, input().split()))
max_d = R // d
min_d = L // d
sho_R = R % d
sho_L = L % d
if sho_R == 0 and sho_L == 0:
  ans = max_d - min_d + 1
else:
  ans = max_d - min_d
print(ans)

Solution (Python):
L, R, d = map(int, input().split())

num_lower = int((L - 1) / d)
num_upper = int(R / d)
ans = num_upper - num_lower

print(ans)

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy



from collections import Counter,defaultdict,deque
from itertools import permutations, combinations, combinations_with_replacement
from heapq import heappop, heappush, heapify
from fractions import gcd

sys.setrecursionlimit(10**8)
mod = 10**9+7

def main():
    l,r,d = map(int,input().split())
    ans = r//d - l//d
    if l%d == 0:
        ans += 1
    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):

l,r,d=map(int,input().split())
i=1
j=0
result=0
while result<=r:
  if result>=l:
    j +=1
  result=d*i
  i+=1
print(j)

Solution (Python):
l,r,d=map(int,input().split())
c=0
for i in range(l,r+1):
  if(i%d == 0):
    c+=1
print(c)

Solution (Python):
import math 

L,R,d=list(map(int,input().split(" ")))

print(math.floor(R/d)-math.ceil(L/d)+1)

Solution (Python):
l,r,d=map(int,input().split())
count=0
for i in range(r+1):
    if i*d>=l and i*d<=r:
        count=count+1

print(count)

Solution (Python):
L,R,D = map(int,input().split())
ans = 0
for i in range(L,R+1):
  if i % D == 0:
    ans += 1
print(ans)

Solution (Python):
L, R, d = map(int, input().split())

count = 0
for i in range(R + 1):
    if i >= L and i % d == 0:
        count += 1

print(count)

Solution (Python):
L, R, d = map(int, input().split())

count = 0
for i in range(L, R+1):
    if i % d == 0:
        count += 1

print(count)

Solution (Python):
L,R,d = map(int,input().split())
ans = 0
for i in range(L,R+1):
    if i % d == 0:
        ans += 1
print(ans)

Solution (Python):
input=input()


L,R,d=input.split()
ans=[]
for i in range(int(L),int(R)+1):
  if i%int(d)==0:
    ans.append(i)

print(len(ans))

Solution (Python):
li = list(map(int,input().split()))
count = 0
for num in range(li[0],li[1]+1):
  if num % li[2] == 0:
    count += 1
print(count)

Solution (Python):
L, R, d = map(int, input().split())
count = 0

for i in range(L,R+1):
    if i%d == 0:
        count+=1

print(count)

Solution (Python):

L,R,d=map(int,input().split())
count=0
for i in range(L,R+1):
    if(i%d==0):
        count=count+1
print(count)

Solution (Python):
l, r, d = input().split()
l = int(l)
r = int(r)
d = int(d)

cnt = 0
for n in range(l, r+1):
  if n%d == 0:
    cnt += 1

print(cnt)

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

L = A[0]
R = A[1]
d = A[2]
result = 0
tmp = L

for i in range(R):
    if i+1 < L:
        continue
    if i+1 > R:
        break
    
    if (i+1) % d == 0:
        result += 1
    

print(result)

Solution (Python):
a, b, c = map(int, input().split())
count = 0
for i in range(a,b+1):
  if i%c == 0:
    count+=1
print(count)

Solution (Python):
l,r,d=map(int,input().split())
rdiv=r//d
ldiv=l//d
if l%d==0:
  print(rdiv-ldiv+1)
else:
  print(rdiv-ldiv)

Solution (Python):
L,R,d = map(int,input().split())
count = 0
tmp = 0
while(True):
    if tmp < L:
        tmp = tmp + d
    elif L <= tmp and tmp<= R:
        count += 1
        tmp = tmp + d
    else:
        break
if d == 1:
    print(R- L + 1)
else:
    print(count)

Solution (Python):
L,R,d =map(int,input().split())
if L%d == 0:
  print(R//d - L//d + 1)
else:
  print(R//d - L//d)

Solution (Python):
l,r,d=map(int,input().split())
if l%d == 0:
  print((r//d)-(l//d)+1)
else:
  print((r//d)-(l//d))

Solution (Python):
input_line = input().split(" ")
min_fig = int(input_line[0])
max_fig = int(input_line[1])
sample = int(input_line[2])
if min_fig % sample == 0:
    minus_num = int(min_fig / sample) -1
else:
    minus_num = int(min_fig / sample)
plus_num = int(max_fig / sample)
print(plus_num-minus_num)

Solution (Python):
l, r, d = map(int, input().split())
print(r // d - (l - 1) // d)

Solution (Python):
l, r, d = map(int, input().split())
diff_list = range(l, r+1)
cnt = 0

for i in diff_list:
    if i%d == 0:
        cnt += 1

print(cnt)

Solution (Python):
l,r,d=map(int,input().split())
k=r//d-(l-1)//d
print(k)

Solution (Python):
import math


l,r,d=map(int,input().split())



ll = math.ceil(l / d)
rr = r // d
print(rr - ll + 1)

Solution (Python):
L, R, d = map(int, input().split())
ans = 0
for i in range(L, R+1):
    if i % d == 0:
        ans += 1

print(ans)

Solution (Python):
L, R, D = map(int, input().split())
ANS = 0
if L % D == 0:
  ANS = 1
elif R % D == 0:
  ANS += 1
 
ANS += (R-L)//D
print(ANS)

Solution (Python):
l,r,d = map(int,input().split())
print(r//d-(l-1)//d)

Solution (Python):
l,r,d = map(int,input().split())

cnt = 0
for i in range(l,r+1):
  if i % d == 0:
    cnt += 1
    
print(cnt)

Solution (Python):
L,R,d=map(int, input().split())
r=R//d - L//d
if L%d == 0: r=r+1
print(r)

Solution (Python):
li=input().split()
l=int(li[0])
r=int(li[1])
d=int(li[2])
L=int(l/d)
R=int(r/d)
A=R-L
if l%d==0:
    if r%d==0:
        A+=1
print(A)

Solution (Python):
l, r, d=map(int, input().split())
cnt=0
for i in range(l, r+1):
  if i%d==0:
    cnt+=1
print(cnt)

Solution (Python):
L, R, d = map(int, input().split())
ans = 0

for n in range(L, R+1):
    if n%d == 0:
        ans += 1
        
print(ans)

Solution (Python):
input = input().split()
L = int(input[0])
M = int(input[1])
d = int(input[2])

num = 0
for i in range(L,M+1):
  if i % d == 0:
    num += 1

print(num)

Solution (Python):
para_line = list(map(int, input().split(' ')))
ans = para_line[1]//para_line[2] + (-para_line[0]//para_line[2]) + 1
print(ans)

Solution (Python):
l, r, d = map(int, input().split())
ans = 0
for i in range(l, r + 1):
    if i % d == 0:
        ans += 1
print(ans)

Solution (Python):
L,R,d = map(int,input().split())
n = L//d
m = R//d
if L%d == 0:
  ans = m-n+1
else:
  ans = m-n
print(ans)

Solution (Python):
L, R, d = list(map(int, input().split()))

if L%d:
    Ans = R//d - L//d
else :
    Ans = R//d - L//d +1

print(Ans)

Solution (Python):
l,r,d = map(int, input().split())

ans = 0
for i in range(l,r+1):
  if i%d == 0:
    ans += 1

print(ans)

Solution (Python):
l, r, d = map(int, input().split())
print(r//d - (l-1)//d)

Solution (Python):
L, R, d = map(int, input().split()) 
print(len([i for i in range(L, R+1) if i % d == 0]))

Solution (Python):
from itertools import product
L, R, d=map(int,input().split())





count = 0
for i in range(R+1):
    if i>=L and i%d==0:
        count+=1


print(count)

Solution (Python):
L,R,d = map(int, input().split())
count = 0
for i in range(1, 101):
    if L <= i <= R and i % d == 0:
        count += 1
print(count)

Solution (Python):
import math

a = list(map(int,input().split()))
l = a[0]
r = a[1]
d = a[2]

f = math.floor(l/d)
e = math.floor(r/d)

an = e-f
if l%d==0:
  an=an+1
print(an)

Solution (Python):
import math

count = 0
L,R,d = list(map(int,input().split()))
c = math.ceil(L/d)
p = math.floor(R/d)
print(p-c+1)

Solution (Python):
L, R, d = (int(i) for i in input().split())
count = 0
for n in range(L, R + 1):
    if n % d == 0:
        count += 1

print(count)

Solution (Python):

import math


L, R, d = map(int, input().split())
start_d = int(math.ceil(L / d))
end_d = int(math.floor(R / d))
print(end_d - start_d +1)

Solution (Python):
l,r,d=map(int,input().split())
ans=0

for x in range(l,r+1):
  if x%d==0:
    ans+=1

print(ans)

Solution (Python):
L, R, d = map(int, input().split())
x = list(range(L, R+1))
y = [i for i in x if i % d == 0]
print(len(y))

Solution (Python):
l, r, d = map(int, input().split())
c = 0
for i in range(l, r + 1):
    if i % d == 0:
        c = c + 1
print(c)

Solution (Python):



def main():
    l, r, d = map(int, input().split())

    cnt = 0
    for i in range(l, r + 1):
        if i % d == 0:
            cnt += 1
    print(cnt)



if __name__ == "__main__":
    main()

Solution (Python):

L,R,d = map(int, input().split())
N = L
count = 0

while N <= R:
    if N % d ==0:
        count += 1
        N += 1
    else:
        N += 1

print(count)

Solution (Python):
L, R, d = map(int, input().split())

unchi = 0
for i in range(L,R+1):
    if (i % d == 0):
        unchi += 1
print(unchi)

Solution (Python):
from heapq import *
from collections import *
import os
import sys
sys.setrecursionlimit(1<<30)
from io import BytesIO, IOBase
import math
import bisect
from math import inf

 
ins = lambda: [int(x) for x in input()]
inp = lambda: int(input())
inps = lambda: [int(x) for x in input().split()]
 
from fractions import Fraction as F
def main():
    
    l,r,a=inps()
    b=(l+a-1)//a
    e=(r)//a
    
    print(e-b+1)




  
 
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
 

 
if __name__ == "__main__":
    main()

Solution (Python):
l,r,k = map(int,input().split())    
L = l//k
R = r//k
ans = R-L
if l%k==0:
    print(ans+1)
else:
    print(ans)

Solution (Python):
l, r, d = map(int, input().split())

count = 0

for num in range(l, r+1):
    if num % d == 0:
        count += 1

print(count)

Solution (Python):
import math

L,R,d = list(map(int,input().split()))

a = math.floor(R/d)-math.ceil(L/d) + 1


print(a)

Solution (Python):
L, R, d = (int(x) for x in input().split())

print(R // d - (L-1) // d)

Solution (Python):
L, R, d = map(int, input().split())

numlist = [n for n in range(L, R+1)]
count = 0
i = 0
while i <= 100:
    if i * d in numlist:
        count += 1
    i += 1

print(count)

Solution (Python):
import math

def a():
    l,r,d = map(int,input().split())
    count = 0
    for i in range(l,r+1):
        if i % d == 0:
            count += 1
    print(count)


def b():
    print('')



def c():
    print('')



def d():
    print('')


a()

Solution (Python):
L, R, d = input().split()
d = int(d)
count = 0
for n in range(int(L), int(R)+1):
    if n % d == 0:
        count += 1
print(count)

Solution (Python):


L,R,d = map(int, input().split())

cnt = d
Ans = 0

while cnt <= R:
  if cnt >= L and cnt <= R:
    Ans += 1

  cnt += d

print(Ans)

Solution (Python):
l, r, d = map(int, input().split())

print(r // d - (l - 1) // d)

Solution (Python):
import math

L, R, d = map(int, input().split())

Ld = math.floor(L / d)
Rd = math.floor(R / d)

if L % d == 0:
    ans = Rd - Ld + 1
else:
    ans = Rd - Ld

print(ans)

Solution (Python):
l,r,d = map(int,input().split())
ans = 0
for i in range(l,r+1):
         if i % d == 0:
                  ans += 1
print(ans)

Solution (Python):
import math
import collections
import bisect
from collections import deque
from copy import copy, deepcopy


def main():
    L, R, d = map(int, input().split())

    ans = 0
    for i in range(L, R + 1):
        if i % d == 0:
            ans += 1

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
L, R, d = map(int, input().split())
res = 0
for i in range(L, R+1):
    if i % d == 0:
        res += 1
print(res)

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

print(
  	(1 if a % c == 0 else 0) +
  	(b // c - a // c)
)

Solution (Python):

L, R ,d= map(int,input().split())
counter=0
for i in range(R+1-L):
  num = i+L
  if num%d == 0:
    counter+=1
print(counter)

Solution (Python):
l,r,d = map(int,input().split())

ans = [i for i in range(l, r+1) if i % d == 0]

print(len(ans))

Solution (Python):






def main():
    L,R,d = map(int, input().split())
    
    count = 0
    for i in range(L, R+1):
        if i%d == 0:
            count += 1
            
    print(count)

main()

Solution (Python):
l, r, d = map(int, input().split())
if l % d == 0 and r % d == 0:
  print(r//d-l//d+1)
elif l % d != 0 and r % d == 0:
  print(r//d-l//d)
elif l % d == 0 and r % d != 0:
  print(r//d-l//d+1)
else:
  print(r//d-l//d)

Solution (Python):
a,b,c=map(int,input().split())
f=0
for i in range(a,b+1):
    if not i%c:
        f+=1
print(f)

Solution (Python):
import sys
import bisect
from functools import lru_cache
from collections import defaultdict
inf = float('inf')
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**6)
def input(): return sys.stdin.readline().rstrip()
def read():
  return int(readline())
def reads():
  return map(int, readline().split())
L,T,D=reads()
count=0
for i in range(L,T+1):
  if i%D==0:
    count+=1
print(count)

Solution (Python):
L, R, d = map(int, input().split())
count = 0
i = 1
while i * d <= R:
    j = i * d
    if j >= L and j <= R:
        count +=1
    i += 1
print(count)

Solution (Python):
L, R, d = map(int, input().split())
print(R//d - (L-1)//d)

Solution (Python):
L,R,d = map(int,input().split())
l= L
if not L % d == 0:
  l = L + L%d
if L < d:
  l = d
r = R // d * d 
print((r-l)//d + 1)

Solution (Python):
l,r,d = map(int,input().split())
A = []
for i in range(l,r+1):
    A.append(i)
cnt = 0
for i in A:
    if i % d == 0:
        cnt += 1
print(cnt)

Solution (Python):
L,R,d = map(int,input().split())
cnt = 0

for i in range(L,R + 1):
  if i % d == 0:
    cnt += 1
    
print(cnt)

Solution (Python):
L,R,d=(int(x) for x in input().split())
i=L
ans=0
while(i<=R):
  if(i % d == 0):
    ans+=1
  i+=1
print(ans)

Solution (Python):
l,r,d = map(int,input().split())

print(int(r/d) - int((l-1)/d))

Solution (Python):
l,r,d = map(int,input().split())
ans = 0
for i in range(l,r+1):
    if i % d == 0:
        ans += 1
print(ans)

Solution (Python):
import math

L, R, d = map(int,input().split())

ans = 0

for i in range(L,R+1):
    if i % d == 0:
        ans += 1

print(ans)

Solution (Python):
import sys
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

L,R,d=nm()
if(L%d==0):
    ans=R//d-L//d+1
else:
    ans=R//d-L//d

print(ans)

Solution (Python):
l,r,d=map(int,input().split())
cnt=0
for i in range(l,r+1):
  for j in range(1,101):
    if d*j==i:
      cnt+=1
      break
print(cnt)

Solution (Python):
L, R, d = map(int, input().split())

n = R-L+1
print(sum(1 if i%d == 0 else 0 for i in range(L, L+n)))

Solution (Python):

import collections
from functools import lru_cache
from math import floor, ceil


def read():
    return input().strip()


def readInt():
    return int(input().strip())


def readList():
    return list(map(int, input().strip().split()))


def solve(l, r, d):
    return floor(r/d) - ceil(l/d) + 1


[L, R, d] = readList()
print(solve(L, R, d))

Solution (Python):
from sys import stdin
input_line = stdin.readline()
L, R, d = input_line.split(' ')
L = int(L)
R = int(R)
d = int(d)

counter = 0
for i in range(L,R+1):
    if i%d == 0:
        counter +=1
        
print(counter)

Solution (Python):
L, R, d = list(map(int, input().split()))

n = L
i = 0
while n <= R:
    if n % d == 0:
        i = i + 1
        n = n + d
    else:
        n = n + 1

print(i)

Solution (Python):
a,b,c = map(int,input().split())
list1 = []
count = 0
for i in range(a,b+1):
    list1.append(i)
for x in list1:
    if x%c==0:
        count = count+1
print(count)

Solution (Python):
L,R,d=map(int,input().split())
c=0
for i in range(L,R+1):
	if i%d==0:c+=1
print(c)

Solution (Python):
L,R,d = map(int,input().split())

count = 0
for i in range(L,R+1):
    if i % d == 0:
        count += 1
print(count)

Solution (Python):
l, r, d = map(int,input().split())

gap = (d-l%d)%d

if gap > r-l:
    print(0)
else:
    print(1 + (r-l-gap)//d)

Solution (Python):
l,r,d=map(int,input().split())
count=0
for i in range(l,r+1):
    if i%d==0:
        count+=1
print(count)

Solution (Python):


numbers = input().split(" ")
l = int(numbers[0])
r = int(numbers[1])
d = int(numbers[2])

result = 0

for i in range(l, r + 1):
    if i % d == 0:
        result += 1

print(result)

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

top = b // c
if a%c == 0:
  bottom = a//c - 1
else:
  bottom = a//c

print(top-bottom)

Solution (Python):
L, R, d = map(int, input().split())

i = 0
cnt=0

while d*i <= R:
    if L <= d*i <= R:
        cnt += 1
    i += 1

print(cnt)

Solution (Python):
l,r,d=map(int,input().split())
cnt=0
for i in range(l,r+1):
  if i % d == 0:
    cnt+=1
print(cnt)

Solution (Python):
l,r,d=map(int,input().split())
count=0
for i in range(l,r+1):
  if i%d==0:
    count+=1
    
print(count)

Solution (Python):
l = [int(x) for x in input().split()]
ans = 0
for i in range(l[0],l[1]+1):
    if i % l[2] == 0:
        ans += 1
print(ans)

Solution (Python):
L, R, d = [int(x) for x in input().split()]
ans = 0
for i in range(L, R+1):
  if i % d == 0:
    ans += 1
print(ans)

Solution (Python):
l,r,d = map(int,input().split())
if l%d==0:
    print((r//d)-(l//d)+1)
else:
    print((r//d)-(l//d))

Solution (Python):
L,R,d = map(int, input().split())

count=int(0)

for x in range(L,R+1):
    if x%d==0:
        count=count+1
    else:
        count=count
print(count)

Solution (Python):
a,b,c=map(int,input().split())
total=0
for i in range(a,b+1):
    if i%c==0:
        total+=1
print(total)

Solution (Python):
L, R, d = [int(x) for x in input().split()]

lst = list(range(d, 101, d))

ret = list(filter(lambda x: L <= x <= R, lst))


print(len(ret))

Solution (Python):
n=input().split()
L=int(n[0])
R=int(n[1])
d=int(n[2])


list = [i for i in range(L, R+1) if i % d== 0]
print(len(list))

Solution (Python):
l,r,d=map(int,input().split())
count=0
for i in range(l,r+1):
  if i%d==0:
    count+=1
print(count)

Solution (Python):
a,b,c = map(int, input().split())
tmp = a//c
tmp2 = b//c
tmp3 = a % c
if tmp3 == 0:
  print(int(tmp2 - tmp) + 1)
else:
  print(int(tmp2 - tmp))

Solution (Python):
L,R,d=list(map(int,input().split()))
q=[]
for i in range(L,R+1):
    s=i%d
    if s == 0:
        q.append(i)
print(len(q))

Solution (Python):
def main():
    L,R,d = map(int,input().split())
    maxnum = R // d
    lownum = L // d
    add = 0
    if L % d == 0:
        add = 1
    print(maxnum - lownum + add)


if __name__ == '__main__':
    main()

Solution (Python):
l,r,d = map(int,input().split())
x = 1
ans = 0
for i in range(l,r+1):
    if i%d == 0:
        ans = ans + 1
        x = x + 1
        
print(ans)

Solution (Python):
L, R, d = map(int, input().split())
result = [i for i in range(L, R+1) if i % d == 0]
print(len(result))

Solution (Python):
l,r,d = map(int, input().split())
la,ra,p = l//d,r//d,0
if l % d == 0:
    p = 1
print(ra-la+p)

Solution (Python):
l,r,d = map(int,input().split())
cnt=0
for num in range(l,r+1):
  if num%d==0:
    cnt+=1
print(cnt)

Solution (Python):
L,R,d=map(int,input().split())
start = int(L/d)*d
x = 0
while True:
    if start < L:
        start += d
    if start  > R:
        break
    if start>=L and start <=R:
        x+=1
        start +=d
print(x)

Solution (Python):
L,R,d=map(int,input().split())
a=R//d
b=(L-1)//d
print(a-b)

Solution (Python):
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt
from copy import deepcopy


def main():
    l,r,d = map(int, input().split())
    ans = 0


    for i in range(l,r+1,1):
        if i%d == 0:
            ans += 1

    print(ans)

if __name__ == '__main__':
	main()

Solution (Python):
L, R, d = map(int,input().split())
result = 0
for i in range(L,R+1):
    if i%d == 0:
        result +=1
print(result)

Solution (Python):
l, r, d = map(int, input().split())
w = 1
count = 0
if l % d == 0:
    start = l // d
else:
    start = (l // d) + 1
while w < r:
    w = d * start
    if w <= r:
        start += 1
        count += 1

print(count)

Solution (Python):
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

L, R, D = map(int, read().split())

print(sum(x % D == 0 for x in range(L, R + 1)))

Solution (Python):
L, R, d = map(int, input().split())
ans = 0
for i in range(L, R+1):
    if i % d == 0:
        ans += 1
print(ans)

Solution (Python):
if __name__ == '__main__':
    s = list(map(int,input().split()))
    count = 0
    for i in range(s[0], s[1]+1):
        if i%s[2] == 0:
            count += 1

    print(count)

Solution (Python):
l, r, d = map(int, input().split())
mul = 0
ans = 0
while mul <= r:
    mul += d
    if mul >= l and mul <= r:
        ans += 1
print(ans)

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]





L, R, d = mi()

cnt = 0

for i in range(L, R+1):
    if i % d == 0:
        cnt += 1

print(cnt)

Solution (Python):
a, b, c = map(int, input().split())
cnt = 0
for i in range(a, b+1):
  if i%c == 0:
    cnt += 1
print(cnt)

Solution (Python):
L, R, d = map(int, input().split())
c = 0
for i in range(R-L+1):
    i = i+L
    if i%d == 0:
        c += 1
print(c)

Solution (Python):
l, r, d = map(int, input().split())
a = l // d
b = r // d
if l == 1:
  print(b)
elif l == r and a != 0:
  print(1)
elif l == r and a == 0:
  print(0)
else:
  print(b-a)

Solution (Python):
L, R, N = map(int, input().split())
cnt = 0
for i in range(L,R+1):
    cnt += i%N == 0
print(cnt)

Solution (Python):

import sys
input = sys.stdin.readline
L,R,d = (int(i) for i in input().split())
count_L =0
count_R =0
for i in range(1,101):
    if i*d <L:
        count_L +=1
    
    if i*d <=R:
        count_R +=1
ans =count_R -count_L
print(ans)

Solution (Python):
from math import *
l,r,d=map(int,input().split())

c=(l-1)//d
k=r//d
ans=k-c
print(ans)

Solution (Python):
L, R, d = list(map(int, input().split()))

if L % d == 0:
    a = (L // d) -1
else:
    a = L // d

b = R // d

print(b-a)

Solution (Python):
s, e, b = [int(i) for i in input().split()]

c = 0
for i in range(s,e+1):
  if i%b == 0:
    c +=1
print(c)