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

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

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

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

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

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())
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 = (int(X) for X in input().split())
Count = 0
for T in range(L,R+1):
    if T%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 = 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())
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())
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 = cnt+1
print(cnt)

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())
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())
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 = list(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
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return map(int, sys.stdin.readline().split())
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())


def FLIST(n):
    res = [1]
    for i in range(1, n+1):
        res.append(res[i-1]*i % DVSR)
    return res


L, R, d = LI()

res = 0
for i in range(100000):
    v = (L + i)
    if v <= R and v % d == 0:
        res += 1

print(res)

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

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

Solution (Python):
L, R, d = list(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())
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):
L, R, d = list(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):
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):
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)

main()

Solution (Python):
import sys
import itertools

import time
import math
import heapq
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
 
INF = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines



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

Solution (Python):

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

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

Solution (Python):
import sys

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

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

Solution (Python):

import sys

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

L, R, d = LI()

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

print(total)

Solution (Python):


import math
import re
import numpy as np
import copy


S = input().split(" ")
L = int(S[0])
R = int(S[1])
d = int(S[2])

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


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


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    L = int(next(tokens))  
    R = int(next(tokens))  
    d = int(next(tokens))  
    print(solve(L, R, d))

def test():
    import doctest
    doctest.testmod()

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

for a in range(L,R+1):
  if a%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 itertools
import decimal
import math
import collections
import sys

import copy







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


def main():

    L, R, d = map(int, sys.stdin.readline().rstrip().split())

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

    print(ans)
    return


main()

Solution (Python):
l , r, d = [int(x) for x in input().strip().split()]
res = 0

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

print(res)

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

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

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())
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())
Ans = 0
for i in range(A,B+1):
    if i % C == 0:
        Ans += 1
        
print(Ans)

Solution (Python):
import sys


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

    print(count)



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    L = int(next(tokens))  
    R = int(next(tokens))  
    d = int(next(tokens))  
    solve(L, R, d)

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

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

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

cnt=0

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

print(cnt)

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

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

Solution (Python):
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):
import sys,bisect,string,math,time,functools,random,fractions
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
rep=range
def Golf():n,*t=map(int,open(0).read().split())
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def MI():return map(int,input().split())
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def RA():return map(int,open(0).read().split())
def GI(V,E,ls=None,Directed=False,index=1):
    org_inp=[];g=[[] for i in R(V)]
    FromStdin=True if ls==None else False
    for i in R(E):
        if FromStdin:
            inp=LI()
            org_inp.append(inp)
        else:
            inp=ls[i]
        if len(inp)==2:
            a,b=inp;c=1
        else:
            a,b,c=inp
        if index==1:a-=1;b-=1
        aa=(a,c);bb=(b,c);g[a].append(bb)
        if not Directed:g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'
    
    mp=[boundary]*(w+2);found={}
    for i in R(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
    mp+=[boundary]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def accum(ls):
    rt=[0]
    for i in ls:rt+=[rt[-1]+i]
    return rt
def bit_combination(n,base=2):
    rt=[]
    for tb in R(base**n):s=[tb//(base**bt)%base for bt in R(n)];rt+=[s]
    return rt
def gcd(x,y):
    if y==0:return x
    if x%y==0:return y
    while x%y!=0:x,y=y,x%y
    return y
def YN(x):print(['NO','YES'][x])
def Yn(x):print(['No','Yes'][x])
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)

mo=10**9+7
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
l_alp=string.ascii_lowercase

read=sys.stdin.buffer.read;readline=sys.stdin.buffer.readline;input=lambda:sys.stdin.readline().rstrip()

show_flg=False
show_flg=True

ans=0

l,r,d=LI()

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

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    L,R,d=MI()
    
    cnt=0
    for i in range(L,R+1):
        if i%d==0:
            cnt+=1
            
    print(cnt)

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

print(count)

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

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


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

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

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

s = [i for i in range(L,R+1)]

ans = 0

for i in s:
    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 numpy as np

def int_mtx(N):
    x = []
    for _ in range(N):
        x.append(list(map(int,input().split())))
    return np.array(x)

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

ans = 0

for i in range(0,1000):
    if d*i >= L and d*i <= R:
        ans += 1

print(ans)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))

L, R, d = inm()


def solve():
    r = R // d
    l = (L - 1) // d
    return r - l


print(solve())

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

Solution (Python):
from sys import stdin, stdout

int_in = lambda: int(stdin.readline())
arr_in = lambda: [int(x) for x in stdin.readline().split()]
mat_in = lambda rows: [arr_in() for _ in range(rows)]
str_in = lambda: stdin.readline().strip()
out = lambda o: stdout.write("{}\n".format(o))
arr_out = lambda o: out(" ".join(map(str, o)))
bool_out = lambda o: out("YES" if o else "NO")
tests = lambda: range(1, int_in() + 1)
case_out = lambda i, o: out("Case 


if __name__ == "__main__":
    l, r, d = arr_in()
    result = 0
    for i in range(l, r+1):
        if i % d == 0:
            result += 1
    out(result)

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

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

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


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

    print(ans)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    L = int(next(tokens))  
    R = int(next(tokens))  
    d = int(next(tokens))  
    solve(L, R, d)

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,n = list(map(int,input().split()))
x = l//n
y = r//n
ans = y-x
if l%n==0:
    ans+=1
print(ans)

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

Solution (Python):
import sys
read = sys.stdin.read
from itertools import accumulate
def main():
    l, r, d = map(int, input().split())
    res = 0
    for i1 in range(l, r + 1):
        res += i1 % d == 0

    print(res)


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

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)
    return
if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys

def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))

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

if __name__ == '__main__':
    main()

Solution (Python):
from sys import exit
import math
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

l,r,d = mi()

cnt=0
while 1:
    if l%d==0:
        cnt+=1
    if l==r:
        print(cnt)
        exit()
    l+=1

Solution (Python):


import math

import itertools
from collections import deque
from collections import Counter



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

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())
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):
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):
import numpy as np
import math
import scipy as sp
import queue
import collections

MOD = 10 ** 9 + 7
INF = 10 ** 9

def main(kwargs):
    l = kwargs["l"]
    r = kwargs["r"]
    d = kwargs["d"]
    res = 0

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

    return res

if __name__ == "__main__":
    kwargs = {}

    cin = input().split()
    kwargs["l"], kwargs["r"], kwargs["d"] = [int(i) for i in cin]

    cout = main(kwargs)
    print(cout)

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
sys.setrecursionlimit(700000)

def s_in():
    return input()

def n_in():
    return int(input())

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

l,r,d = l_in()

print(sum(i%d ==0 for i in range(l,r+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):
import sys
sys.setrecursionlimit(10**6)


def main(input, print):
    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(sys.stdin.readline, print)

Solution (Python):
import math

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

Solution (Python):
import math

import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit


ipt = stdin.readline
setrecursionlimit(10**7)

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

    return None

if __name__ == '__main__':
    main()

Solution (Python):
def resolve():
    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__':
    resolve()

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

a = sum(1 if d <= n and n % d == 0 else 0 for n in range(l, r+1))
print(a)

Solution (Python):
from math import *
l,r,d=map(int,input().split())
print(floor(r/d)-ceil(l/d)+1)

Solution (Python):
L, R, d = [int(i) for i in input().split()]
print((R//d)-(L//d)+(L%d==0))

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

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

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

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

Solution (Python):

import sys
import numpy as np
input = sys.stdin.readline

 
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

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

print(result)

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

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

ans = 0
for i in range(200):
    if L <= d * i <= R:
        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
    else:
        pass

print(ans)

Solution (Python):
l, r, d = (int(each) for each in 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())

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

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):
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())
print(len([i 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):
n,m,l=list(map(int,input().split()))
count=0
for i in range(n,m+1):
  if i%l==0:
    count+=1
print(count)

Solution (Python):

import collections
import sys


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


def main():
    L, R, d = LI()
    cn = 0
    for i in range(L, R+1):
        if i % d == 0:
            cn += 1
    print(cn)


if __name__ == '__main__':
    main()

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

ans = 0

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

print(ans)

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


def main():
    input = lambda: stdin.readline()[:-1]
    L, R, D = map(int, input().split())

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


main()

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

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

def calc(x,d):
    return x//d

print(calc(r,d)-calc(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):
N, M, d = map(int, input().split())
cnt = 0
for i in range(N, M + 1):
    if i % d == 0: cnt += 1
print(cnt)

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

counter = L
answer = 0
while counter <= R:
    if counter % d == 0:
        answer += 1
    counter += 1
print(answer)

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

rr = r//d
ll = (l-1)//d

print(rr-ll)

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

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):
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 = 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):
def i():
	return int(input())
def i2():
	return map(int,input().split())
def s():
	return str(input())
def l():
	return list(input())
def intl():
	return list(int(k) for k in input().split())

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

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