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):
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
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(sum(1 for i in range(L,R+1) if i%d == 0))

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
for i in range(l,r+1):
   if i%d==0:
      ans+=1
print(ans)

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 sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction



mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def L(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]

try:
    sys.stdin = open("input.txt", "r")
except:
    pass



l,r,d=L()
ans=(r//d)-(l//d)+(l%d==0)
print(ans)

Solution (Python):
a, b, c = map(int, input().split(' '))
i = a
cnt = 0
while i <= b:
    if i % c == 0:
        cnt += 1
    i += 1

print(cnt)

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

def count(x):
    return x // d

print(count(r) - count(l-1))

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 i in range(L,R+1,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())

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(L,(R+1)):
  if i%d==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())
if l%d==0 and r%d==0:
    print(r//d-l//d+1)
else:
    print(r//d-l//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):
L, R, d = map(int, input().split())
Lmod = (L-1) // d
Rmod = R // d
print(Rmod - Lmod)

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):
import sys
input = sys.stdin.readline


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())
rr=r//d
ll=l//d
lll=l%d
if lll==0:
    print(rr-ll+1)
else:
    print(rr-ll)

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

for i in range(b[0], b[1] + 1):
    if i % b[2] == 0:
        ans += 1
                
print(str(ans))

Solution (Python):
L, R, d = list(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())
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())
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 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):
def resolve():
    L, R, d = map(int, input().split())
    c = 0
    for i in range(L, R+1):
        if i % d == 0:
            c += 1
    print(c)

if __name__ == "__main__":
    resolve()

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):
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 = map(int, input().split())
print(r // d - (l - 1) // 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):
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import reduce
import math
import itertools
import heapq

import bisect
import sys

sys.setrecursionlimit(10**6)


def bfs(s, n, node):
    
    check = [False for _ in range(n)]
    check[s] = True
    
    queue = deque([s])
    visited_num = 1

    
    
    color = [-1 for _ in range(n)]
    color[s] = 0

    while visited_num < n:
        
        if len(queue) == 0:
            
            
            return color

        now_vertex = queue.popleft()
        
        for next_vertex in node[now_vertex]:

            if check[next_vertex] == True:
                continue

            queue.append(next_vertex)
            check[next_vertex] = True

            
            color[next_vertex] = color[now_vertex]+1
            visited_num += 1

    return color


mod = 10**9+7



def ceil(x, y): return (x+y-1)//y
def input_list(): return list(map(int, input().split()))


l, r, d = list(map(int, input().split()))
ans = r//d-(l-1)//d
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,k=map(int,input().split())
ans=0
for i in range(l,r+1):
 if i%k==0:
  ans+=1
 else:
  pass
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())

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):
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())
ct = 0
for i in range(L,R+1):
    if i%d == 0:
        ct += 1
print(ct)

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

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
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):
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 = R // d  - (L - 1) // d
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())

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

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

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

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=list(map(int,input().split()))
count = 0
for i in range(L,R+1):
  if i%d==0:
    count+=1
print(count)

Solution (Python):
x,y,z=map(int,input().split())
print((y//z)-(x-1)//z)

Solution (Python):
import sys
input = sys.stdin.readline



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


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

Solution (Python):
L,R,D=map(int,input().split())
ans=0
i=L
while i<=R:
    ans+=i%D==0
    i+=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(r//d-(l-1)//d)

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

Solution (Python):

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

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

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 = 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__':
    l,r,d = map(int, input().split())
    a = r //d
    b = (l-1)//d
    print(a-b)

Solution (Python):
import sys

L, R, d = map(int, sys.stdin.readline().strip().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):
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())
ref = [i for i in range(L, R+1)]
cnt = 0
for i in ref:
  if i % d == 0:
    cnt += 1
print(cnt)

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):
A,B,C = list(map(int,input().split()))


ans = 0
for i in range(A,B+1):
    if i % C == 0:
        ans += 1
        
print(ans)

Solution (Python):


import sys

input = iter(sys.stdin.read().splitlines()).__next__

sys.setrecursionlimit(10000)

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

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

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

Solution (Python):
ans=0
l,r,d=map(int,input().split())
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(L,R+1):
    if i%d==0:
        count+=1
        
print(count)

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

cnt = 0

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

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, 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())

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())
res = 0
for i in range(l, r+1):
  if i%d == 0:
    res += 1
print(res)

Solution (Python):
def resolve():
    import sys
    input = sys.stdin.readline
    
    
    
    l, r, d = map(int, input().split())
    
    
    
    
    
    

    cnt = 0

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

    print(cnt)
resolve()

Solution (Python):
import sys

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

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

cnt = 0

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

print(cnt)

Solution (Python):


import sys
import numpy as np
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

L, R, d = map(int, readline().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):
def main():
    l, r, d = [int(e) for e in 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())
up = R // d
down = L // d
if L % d == 0:
  print (up-down+1)
else:
  print(up-down)

Solution (Python):
def resolve():
    L, R, d = [int(i) for i in input().split()]
    print(R // d - (L - 1) // d)


resolve()

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
read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7

def main():
    L, R, d = map(int, readline().split())
    ans = R//d - L//d
    if L%d==0:
        ans += 1
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
import sys


def resolve():
    readline = sys.stdin.readline

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

resolve()

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

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
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):
L, R, d = map(lambda x: int(x), 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())

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

Solution (Python):
l,r,d=[int(x) for x in 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 i in range(L, R+1):
    if i % d  == 0:
        ans += 1

print(ans)

Solution (Python):
l, r, d = list(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
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
import numpy as np
import math  
from collections import deque
from collections import defaultdict
from copy import deepcopy
from itertools import accumulate 
def input(): return sys.stdin.readline().rstrip()
from functools import lru_cache 

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

if __name__ == "__main__":
    main()

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())

ans = r//d - l//d
if l%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):
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):
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()))
a=0
for i in range(l,r+1):
    if i%d==0:
        a=a+1
print(a)

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
for i in range(l,r+1):
    if i%d==0:
        ans+=1
print(ans)

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

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):
def main():
  l,r,d = map(int, input().split())

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

  print(sum)

if __name__ == '__main__':
  main()

Solution (Python):


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


sum =0
for i in range(l,r+1):
    if i % d ==  0:
        sum += 1
print(sum)
'''
a = []
for i in range(n):
    a.append(list(map(int,input().split())))
print(a)
'''

Solution (Python):
import sys

def II(): return int(input())
def MI(): return map(int,input().split())
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))
def RN(N): return [input().strip() for i in range(N)]


def main():
    L, R, d = MI()
    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 = [int(i) for i in input().split()]
def go(x):
    return x//d

print(go(r) - go(l-1))

Solution (Python):
L,R,d = list(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())
i = 1
ans = 0
while True:
    if d*i<l:
        i += 1
    elif l<=d*i<=r:
        i += 1
        ans += 1
    else:
        break
print(ans)

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

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

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

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

Solution (Python):


import sys

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)

if __name__ == "__main__":
    main()

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

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain, product
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp



class UnionFindEx:
    def __init__(self, size):
        
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


def main():
    L,R,d=mis()
    print(sum(i%d==0 for i in range(L,R+1)))









main()

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())

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

print(cnt)

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

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())

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):
L,R,d=map(int, input().split())
a=(L-1)//d
b=R//d
print(b-a)

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

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

print(num)

Solution (Python):
x, y, z = map(int, input().split())

num=0

for i in range(x,y+1):
    if i % z==0:
        num+=1
print(num)

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
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:
  geta = 1
else:
  geta = 0

print(R//d - L//d + geta)

Solution (Python):
def main():
  L, R, d = list(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):
"""
// Author : snape_here - Susanta Mukherjee
     
 """
 
from __future__ import division, print_function
 
import os,sys
from io import BytesIO, IOBase
 
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
 
def ii(): return int(input())
def fi(): return float(input())
def si(): return input()
def msi(): return map(str,input().split())
def mi(): return map(int,input().split())
def li(): return list(mi())
 
 
def read():
    sys.stdin = open('input.txt', 'r')  
    sys.stdout = open('output.txt', 'w') 
 
def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

mod=1000000007

from math import log,sqrt,factorial,cos,tan,sin,radians,ceil,floor

import bisect

from decimal import *

getcontext().prec = 25

abc="abcdefghijklmnopqrstuvwxyz"

pi=3.141592653589793238


def main():

    l,r,d=mi()

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



 
BUFSIZE = 8192
 
 
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
 
 
if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
 
input = lambda: sys.stdin.readline().rstrip("\r\n")
 

 
 
if __name__ == "__main__":
    
    main()

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

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())

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

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())
ans = 0
ans += r//d
ans -= (l-1)//d
print(ans)

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 i in range(l, r+1):
  if i%d==0:
    ans+=1
    

print(ans)

Solution (Python):
import sys 

a, b, d = map(int, input().split())
while a % d != 0: 
	a += 1

while b % d != 0:
	b -= 1

if a > b: 
	print(0)
else:
	print((b - a) // d + 1)

Solution (Python):
import sys 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
L, R, d = map(int, readline().split())
L -= 1
ans1 = L // d
ans2 = R // d
print(ans2-ans1)

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

Solution (Python):

printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 10**18
R = 10**9 + 7


def ddprint(x):
  if DBG:
    print(x)

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

Solution (Python):
a, b, d = [int(x) for x in input().split()]
multiples = 0
for i in range(a, b + 1):
  multiples += i % d == 0
print(multiples)

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())
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())
res = 0
for i in range(a, b+1):
    if i % c == 0:
        res += 1
print(res)

Solution (Python):
[L,R,d]=list(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
input = sys.stdin.readline




'''
a=[]
b=[]
for i in range():
    A, B = map(int, input().split())
    a.append(A)   
    b.append(B)'''

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

if a%c==0:
    print(b//c-a//c+1)
else:
    print(b//c-a//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):
import sys 
input = lambda:sys.stdin.readline().strip()
l,r,d = map(int,input().split())
print(max((r//d)-(l-1)//d,0))

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

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

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
readline = sys.stdin.buffer.readline
read = sys.stdin.buffer.read


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

print(r // d - (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):
l, r, d = [int(i) for i in 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())
ans = 0
for i in range(L, R + 1):
    if i % D == 0:
        ans += 1
print(ans)

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

Solution (Python):
import queue
from math import floor
from decimal import Decimal

L, R, d = list(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())
if L%d!=0:
    print(R//d-L//d)
else:
    print(R//d-L//d+1)

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

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

if __name__ == "__main__":
  resolve()