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 = (R//d) - (L//d)
if L % 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 = (int(x) for x in input().split())
ans = r//d - (l-1)//d
print(ans)

Solution (Python):
a,b,c = map(int,input().split())
print(b//c-(a-1)//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())

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():
    import sys
    L,R,d=list(map(int,sys.stdin.readline().split()))
    print(R//d-(L-1)//d)

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().strip().split())
cnt=0
for n in range(L,R+1):
    if n%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 = 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):
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 += 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,open(0).read().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())
c = 0
for i in range(l, r+1):
    if i % d == 0:
        c += 1

print(c)

Solution (Python):
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))
def getArray(intn):
    return [int(input()) for i in range(intn)]
def input():
    return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
    return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
    return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
  ns = []
  while len(ns) < rantime:
    n = random.randint(ran1, ran2)
    if not n in ns:
      ns.append(n)
  return sorted(ns)

def rand_query(ran1, ran2, rantime):
  r_query = []
  while len(r_query) < rantime:
    n_q = rand_ints_nodup(ran1, ran2, 2)
    if not n_q in r_query:
      r_query.append(n_q)
  return sorted(r_query)

from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right

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





L, R, D = getNM()
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):
'''
    Auther: ghoshashis545 Ashis Ghosh
    College: jalpaiguri Govt Enggineering College

'''
from os import path
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,defaultdict as dd 
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
mod=1000000007

inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]

def bo(i):
    return ord(i)-ord('a')

file=0





def solve():


    
    
        

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








        
if __name__ =="__main__":

    if(file):

        if path.exists('input1.txt'):
            sys.stdin=open('input1.txt', 'r')
            sys.stdout=open('output1.txt','w')
        else:
            input=sys.stdin.readline
    solve()

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())
Rx=R//d
Lx=L//d
if L%d==0:
    Lx-=1
print(Rx-Lx)

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    L, R, d = LI()

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

if __name__ == '__main__':
    resolve()

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 += 1
print(count)

Solution (Python):
def resolve():
    '''
    code here
    '''
    L, R, d = [int(item) for item in input().split()]

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

    print(cnt)

if __name__ == "__main__":
    resolve()

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

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

print(ans)

Solution (Python):



def compute(le, ri, d):
    return sum(x % d == 0 for x in range(le, ri + 1))


def main():
    le, ri, d = (int(z) for z in input().split())
    res = compute(le, ri, d)
    print(res)


if __name__ == '__main__':
    main()

Solution (Python):
lower, upper, d_baisuu = map(int, input().split())

cnt = 0

for num in range(lower, upper + 1):
    if (num % d_baisuu == 0):
        cnt += 1

print(cnt)

Solution (Python):
def main():
    left, right, div = [int(x) for x in input().split()]
    ans = sum(x % div == 0 for x in range(left, right + 1))
    print(ans)


if __name__ == '__main__':
    main()

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

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 = [int(i) for i in 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())
print(r//d - (l - 1)//d)

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

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

X = list(map(int, input().split()))



count = 0

for i in range(X[0], X[1]+1):
    if (i % X[2] == 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())

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

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

Solution (Python):

l,r,d=[int(x) for x in input().split()]
c=0
for _ in  range(l,r+1):
    if _%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())


ll = int((L - 1) // d)
rr = int(R // d)
print(rr -ll)

Solution (Python):




def input_int():
    return int(input())



def int1(x):
    return int(x) - 1



def input_to_int_map():
    return map(int, input().split())



def input_to_int_tuple():
    return tuple(map(int, input().split()))



def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


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

    return cnt

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

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())
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
    else:
        pass

print(ans)

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

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

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

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

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    L, R, d = i2nn()
    print(R // d - (L - 1) // d)
    return

main()

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

Solution (Python):
import bisect
import copy
import heapq
import math
import sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
sys.setrecursionlimit(500000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]

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

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

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

def solve():
    L, R, d = map(int, readline().split())

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


solve()

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

Solution (Python):


'''
Author: andyli
Time: 2020-07-11 19:58:46
'''

import os
from io import BytesIO, IOBase
import sys
import math

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



BUFSIZE = 1048576


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)
def input(): return sys.stdin.readline().rstrip('\r\n')




if __name__ == '__main__':
    main()

Solution (Python):
L, R, d = [int(x) for x in 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())

cnt=0

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

print(cnt)

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

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

if __name__ == "__main__":
    main()

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):
import sys

def I(): 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 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=map(int,input().split())

a=r//d
b=(l-1)//d

print(a-b)

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

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

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

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

def input():
    return sys.stdin.readline()[:-1]

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

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

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

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())
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())
res = 0

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

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

Solution (Python):
import bisect
import sys
import math
from collections import deque
from heapq import heappush, heappop

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


def ssRaw():
    return input().split()


def isRaw():
    return list(map(int, ssRaw()))


INF = 1 << 29

DIV = (10**9) + 7


def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)


def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def CONV_TBL(max, mod=DIV):
    fac, finv, inv = [0]*max, [0]*max, [0]*max
    fac[0] = fac[1] = 1
    finv[0] = finv[1] = 1
    inv[1] = 1
    for i in range(2, max):
        fac[i] = fac[i-1]*i % mod
        inv[i] = mod - inv[mod % i] * (mod//i) % mod
        finv[i] = finv[i-1]*inv[i] % mod

    class CONV:
        def __init__(self):
            self.fac = fac
            self.finv = finv
            pass

        def ncr(self, n, k):
            if(n < k):
                return 0
            if(n < 0 or k < 0):
                return 0
            return fac[n]*(finv[k]*finv[n-k] % DIV) % DIV

    return CONV()


def cumsum(As):
    s = 0
    for a in As:
        s += a
        yield s


sys.setrecursionlimit(200005)


def dijkstra(G,start=0):
    heap = []
    cost = [INF]*len(G)
    heappush(heap,(0,start))
    while len(heap)!=0:
        c,n = heappop(heap)
        if cost[n] !=INF:
            continue
        cost[n]=c
        for e in G[n]:
            ec,v = e
            if cost[v]!=INF:
                continue
            heappush(heap,(ec+c,v))
    return cost


def main():
    L,R,d = isRaw()

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


main()

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

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

Solution (Python):
from math import gcd

from math import factorial as f

from math import ceil, floor, sqrt
import math

import bisect
import re
import heapq

from copy import deepcopy
import itertools
from itertools import permutations

from sys import exit

ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(map(int, input().split()))

yes = "Yes"
no = "No"


def main():
    l, r, d = mi()
    cnt = 0
    tmp = d
    while tmp <= r:
        if tmp <= r and tmp >= l:
            cnt += 1
        tmp += d
    print(cnt)


main()

Solution (Python):





import math
import fractions
import sys
import bisect
import heapq  
import collections
from collections import Counter
from collections import deque
import pprint
import itertools

sr = lambda: input()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""


def factorization(n):
    arr = []
    temp = n
    if n == 1:
        return arr

    for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
        if temp % i == 0:
            cnt = 0
            while temp % i == 0:
                cnt += 1
                temp //= i
            arr.append([i, cnt])

    if temp != 1:
        arr.append([temp, 1])

    if arr == []:
        arr.append([n, 1])

    return arr



def power(a, n, mod):
    x = 1
    while n:
        if n & 1:
            x *= a % mod
        n >>= 1
        a *= a % mod
    return x % mod



def kaijo(n, l, mod):
    if n == 0:
        return 1
    a = n
    tmp = n - 1
    while (tmp >= l):
        a = a * tmp % mod
        tmp -= 1
    return a


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors


inf = 10 ** 18
mod = 10 ** 9 + 7

l,r,d = lr()
mind = l//d
if l%d == 0:
    mind-=1
maxd = r//d
print(maxd-mind)

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
    return ans 

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

Solution (Python):
a,b,c=map(int,input().split())
cnt=0
for x in range(a,b+1):
        if x%c==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 = 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())
count=0
for i in range(l,r+1):
    if i%d==0:
        count+=1
print(count)

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

count = 0

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

print(count)

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

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

print(out)

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


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




main()

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

    return c

print(main())

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



L, R, d = (int(i) for i in 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())
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 = tuple(map(int, input().split()))

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

print(ans)

Solution (Python):


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

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

    print(cnt)


submit()

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 9)

def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')







def solve():
    L, R, D = MI()

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

if __name__ == '__main__':
    solve()

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

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,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())
print(r // d - (l - 1) // d)

Solution (Python):
L,R,D = map(int,input().split())
r = 0
for i in range(L,R+1):
  if 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):
import sys
sys.setrecursionlimit(10**9)

def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))

INF=10**20
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):
a,b,n=map(int,input().split())
print(b//n-a//n+(a%n==0))

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):
def resolve():
    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)

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):
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 n in range(l, r + 1):
    if n % 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)