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 sys

l, r, d = map(int, sys.stdin.readline().split())

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

Solution (Python):
def main():
    import sys
    def input(): return sys.stdin.readline().rstrip()
    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 = list(map(int,input().split()))
x = l // d
y = r // d
if l%d == 0:
    print(y-x+1)
else:
    print(y-x)

Solution (Python):
def getInts():
    return [ int(x) for x in input().split() ]

[L,R,d] = getInts()

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

Solution (Python):
inp = list(map(int,input().split()))
l=inp[0]
r=inp[1]
d=inp[2]
if l%d!=0:
    l=l-(l%d)+d
r-=(r%d)
if l<=r:
    print (((r-l)//d)+1)
else:
    print (0)

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().strip().split(" ")]

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

Solution (Python):
A = input().split()
L = int(A[0])
R = int(A[1])
d = int(A[2])
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())

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

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

Solution (Python):


import sys
import math
import time

import collections
from collections import deque
from collections import Counter
import queue
import copy
import bisect
import heapq
import itertools



sys.setrecursionlimit(10**7)






L, R, d= map(int,input().split())
ans = 0
s = d
while True:
    if(L <= s <= R):
        ans+=1
    s += d
    if(R<s):
        break


print(ans)

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









import os
import sys




def main():
    L, R, d = map(int, input().split())
    left = L//d
    cnt = 0
    while (left+1)*d <= R:
        cnt += 1
        left += 1
    if L%d==0:
        cnt += 1
    print(cnt)




if __name__ == "__main__":
    main()

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

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

print(answer)

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

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

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

print(ans)

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

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

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

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

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

def main(l,r,d):
    ql=(l-1)//d
    qr=r//d
    ans=qr-ql
    return ans

if __name__=='__main__':
    l,r,d=readinput()
    ans=main(l,r,d)
    print(ans)

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

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

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

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


def main():
    L, R, d = map(int,input().split())
    m = (L + d- 1) // d
    M = R // d
    print(M - m + 1) 


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

L,R,d=(int(x) for x in input().rstrip('\n').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())
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())
cnt = 0
for i in range(l, r+1):
    if i%d == 0:
        cnt += 1
print(cnt)

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

l_d = math.floor((L-1)/d)
r_d = math.floor((R)/d)

ans = r_d - 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(1, 150):
    if L <= i * d <= R:
        cnt += 1
print(cnt)

Solution (Python):
import sys
import numpy as np

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

l, r, d = map(int, readline().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())
n =0
for i in range(l,r+1):
  if i%d == 0:
    n +=1
  else:
    pass
print(n)

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect

def LI(): return [int(x) for x in sys.stdin.readline().split()]


def I(): return int(sys.stdin.readline())


def LS(): return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


def IR(n):
    return [I() for i in range(n)]


def LIR(n):
    return [LI() for i in range(n)]


def SR(n):
    return [S() for i in range(n)]


def LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)
mod = 1000000007


def solve():
    l, r, d = LI()
    count = 0
    for i in range(l, r+1):
        if i % d == 0:
            count += 1
        else:
            pass
    print(count)
    return


if __name__ == "__main__":
    solve()

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

Solution (Python):
import sys


def resolve(in_):
    l, r, d = map(int, in_.readline().split())
    return sum(1 for i in range(l, r + 1) if i % d == 0)


def main():
    answer = resolve(sys.stdin.buffer)
    print(answer)


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

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

Solution (Python):
min_num, max_num, mul = map(int, input().split())

numbers = set(range(min_num, max_num+1))
multiples = set([mul*i for i in range(1, 100+1)])

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

print(cnt)

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

if d != 1:
  hoge = 0
  if l %d == 0:
    hoge += 1
  print(int(r//d -l //d + hoge))
else:
  print(r-l+1)

Solution (Python):
from collections import defaultdict,deque
from sys import stdin,setrecursionlimit
import heapq,bisect,math,itertools,string,queue,copy
setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, stdin.readline().split()))

L,R,d = inpl()

count = 0
if L % d == 0:
    k = int(L/d)
else:
    k = int(L/d)+1

k = k* d
while k <= R:
    count += 1
    k += d
print(count)

Solution (Python):
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

l,r,d=nm()

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

a = L // d
b = R // d
ans = b - a

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

Solution (Python):

a = 0
p ,q, r = map(int, input().split())
for i in range(p, q+1):
    if (i%r == 0):
        a += 1
print(a)

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
    else:
        ans += 0

print(ans)

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

if l%d==0:
  shita=l//d
else:
  shita=l//d + 1

ans=r//d-shita + 1

print(ans)

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

print(ii)

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

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

print(f)

Solution (Python):
x,y,num = map(int,input().split())
count = 0
for i in range(x,y + 1):
  if i%num == 0:
    count += 1
print(count)

Solution (Python):
import sys
import copy
from collections import deque
import collections
stdin = sys.stdin

mod = 10**9+7

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

a, b, c = na()

if a%c==0:
    p = a//c - 1
else:
    p = a//c

res = b//c - p
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())
a = r//d
b = l//d
c = l%d
if(c == 0):
    print(a-b+1)
else:
    print(a-b)

Solution (Python):
l, r, d = map(int, input().split())
cnt = 0
a = l
while True:
    if a % d == 0:
        break
    else:
        a += 1
while True:
    if a > r:
        break
    cnt += 1
    a += d
print(cnt)

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

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

for x in range(1, 101):
    if x >= l and x <= r and x % 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):
import math

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

Solution (Python):
import numpy as np


def main(L, R, d):
    num = L
    ans = 0
    while True:
        if num % d == 0:
            ans += 1
        if num >= R:
            break
        num += 1
    return ans


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

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

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

Solution (Python):
left,right,mul = map(int,input().split())

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

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

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

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

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

print(hoge)

Solution (Python):
def function(numbers):
    L = int(numbers[0])
    R = int(numbers[1])
    d = int(numbers[2])
    number = 0
    i = L
    while(i <= R):
        if i % d == 0:
            number += 1
        i += 1
    return number


if __name__ == '__main__':
    numbers = input().split()
    print(function(numbers))

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

Solution (Python):


import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())

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

    a, b = divmod(L, d)
    if b == 0:
        a -= 1
    print(R//d - a)


if __name__ == "__main__":
    resolve()

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, 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=map(int,input().split())
if(a%c==0 or b%c==0):
    print(((b-a)//c)+1)
else:
    print((b-a)//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(0,r+1,d):
  if l<=i<=r:
    ans+=1
print(ans)

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

Solution (Python):
A=list(map(int,input().split()))
L=A[0]
R=A[1]
d=A[2]
p=R//d
q=L//d
if L%d==0:
    print(p-q+1)
else:
    print(p-q)

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

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())
n = L
a = 0
while n<=R:
    if n%d==0:
        a = a+1
        n = n+1
    else:
        n = n+1
print(a)

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

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

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


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


def readint():
    return int(input())


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


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


def main():
    L, R, d = readnums()
    ans = (R - L) // d
    if not L % d:
        ans += 1
    elif not R % d:
        ans += 1
    print(ans)


if __name__ == "__main__":
    main()

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

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

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

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

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

lis =[]

for i in range(l,r+1):
    if i % d ==0:
        lis.append(i)
print(len(lis))

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

ln = l // d
rd = r // d

if l % d == 0:
    rd += 1

print(rd - ln)

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())
i=L
r=0

while(i<R+1):
  if(i%d==0):
    r+=1
  i+=1

print(r)

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

Solution (Python):

"""
@author: H_Hoshigi
"""
def main():
    L, R, d = map(int, input().split())
    
    N_R = R//d
    N_L = (L-1)//d
    print(N_R - N_L)

if __name__ == "__main__":
    main()

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

ls = L // d
rs = R // d + (L % d == 0)

print(rs - ls)

Solution (Python):
l, r, d = map(int, input().split())
mul = 1
count = 0
while True:
    if l <= mul * d <= r:
        count += 1
    mul += 1
    if mul * d > r:
        break
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):


import math

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

small = math.ceil(L / d)
big = R // d

print(big - small + 1)

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

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

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

Solution (Python):
n,m,k = map(int,input().split())
count = 0
for i in range(n,m+1):
  if i%k==0:
    count+=1
print(count)

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

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

def main():
    L, R, d = map(int, read().split())
    ans = R // d - (L-1) // d
    print(ans)
    return

if __name__ == '__main__':
    main()

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

a = []
for i in range(l, r + 1):
    if i % d == 0:
        a.append(i)

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

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

Solution (Python):
def cin():
    return input().split()

x = cin()
l = int(x[0])
r = int(x[1])
d = int(x[2])
sum = 0;
for i in range(l,r+1):
    if i % d == 0:
        sum += 1
print(sum)

Solution (Python):
input =raw_input

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

Solution (Python):
import sys

input = sys.stdin.readline

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

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

print(ans)

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

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

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)

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

Solution (Python):
import numpy as np
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())
ans=chk=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())

p = d
i=1
c=0
while(p<=r):
    p=d*i
    if(l<=p<=r):
        c+=1

    i+=1
print(c)

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

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())
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):
A,B,C = map(int , input().split())
S = []
for i in range(B-A + 1):
    S.append(A+i)
M= 0
for j in range (len(S)):
    if (S[j] % C) == 0:
        M += 1
print(M)

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):
l, r, d = map(int, input().split())
l_ = l // d
r_ = r // d
if l % d == 0:
    print(r_-l_+1)
else:
    print(r_-l_)

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()]
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):
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 = input().split(" ")

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

print(num)

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

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 = 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 = 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())
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):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue


Mod = 1000000007
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1] 
for i in range(2, 10**5 + 1):
    fact.append((fact[-1] * i) % Mod)
    inv.append((-inv[Mod % i] * (Mod // i)) % Mod)
    factinv.append((factinv[-1] * inv[-1]) % Mod)
    
def cmb(n, r, p):
    if (r < 0) or (n < r):
        return 0
    r = min(r, n - r)
    return fact[n] * factinv[r] * factinv[n - r] % p
    
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[y] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)
import string
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 = 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())
if L % d != 0:
    L += d - (L % d)
if R % 2 == 1:
    R -= L % d
if L > R:
    print(0)
else:
    print((R - L)//d + 1)

Solution (Python):
import math
LI = lambda: list(map(int,input().split()) )
MI = lambda: map(int,input().split())
SI = lambda: input()
II = lambda: int(input())
a,b,d = MI()
x = b//d
if int(a/d) == a/d:
    x -=a//d-1
else:
    x-=a//d
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())

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

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

print(cnt)

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

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