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

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

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

Solution (Python):

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


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

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

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

Solution (Python):
from math import ceil,floor,comb,factorial,gcd,pow,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from copy import deepcopy
from time import time
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT()   : return int(input())
def MAP()   : return map(int,input().split())
def LIST()  : return list(MAP())

l, r, d = MAP()

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

print(ans)

Solution (Python):



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

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

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def s(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

l,r,d = I()
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
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
from decimal import Decimal
from operator import mul

INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)



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 dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


def factorization(n):
    arr = []
    temp = n
    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 combinations_count(n, r):
    if n < r:
        return 0
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret

def make_divisors(n):
    lower_divisors , upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-1]




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):
ma = lambda :map(int,input().split())
ni = lambda:int(input())
import collections
import math
import itertools
gcd = math.gcd
l,r,d = ma()
c= 0
for i in range(l,r+1):
    if i%d==0:
        c+=1
print(c)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


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


if __name__ == '__main__':
    resolve()

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

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

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

print(res)

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  

L,R,d = LI()

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

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

Solution (Python):
def INT():
    return int(input())

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

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

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

Solution (Python):

import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import copy
import decimal


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [Scanner.string() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [Scanner.int() for i in range(n)]


def pop_count(x):
    x = x - ((x >> 1) & 0x5555555555555555)
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    x = x + (x >> 32)
    return x & 0x0000007f


def solve():
    L, R, D = Scanner.map_int()
    ans = 0
    for i in range(L, R+1):
        if i % D == 0:
            ans += 1
    print(ans)


def main():
    
    
    
    
    
    
    solve()


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

print(ans)

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

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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


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

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

    print(ans)
    return


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

Solution (Python):
import sys

input = sys.stdin.readline


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

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

    print(ans)


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



from fractions import gcd
from itertools import combinations,permutations,accumulate 

from collections import deque,defaultdict,Counter
import decimal
import re











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

def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
l,r,d = readInts()
print(r//d - (l-1)//d)

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

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

Solution (Python):
L,R,d = list(map(int,input().split()))
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
sys.setrecursionlimit(10**7)
input = sys.stdin.readline

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 n in range(L, R + 1):
    if n % 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):
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
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque, defaultdict


from collections import Counter

from itertools import accumulate,combinations,permutations,product

from heapq import heapify,heappop,heappush


from functools import reduce,lru_cache

from decimal import Decimal

def input(): 
    x=sys.stdin.readline()
    return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
    mod = 1000000007
    

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

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




if __name__ == "__main__":
    main()

Solution (Python):
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

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

def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  l,r,d=LI()
  ans=0

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

  return ans


print(main())

Solution (Python):
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))

l,r,d=nii()

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,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
	return list(map(int,input().split()))
def m(): 
	return map(int,input().split())
def onem(): 
	return int(input())
def s(x): 
	a = []
	if len(x) == 0:
		return []
	aa = x[0]
	su = 1
	for i in range(len(x)-1):
		if aa != x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a
def jo(x): 
	return " ".join(map(str,x))
def max2(x): 
	return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
	ll = 0
	rr = r
	while True:
		mid = (ll+rr)//2

	if rr == mid:
		return ll
	if (ここに評価入れる):
		rr = mid
	else:
		ll = mid+1
"""

l,r,d = m()

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


import sys

class ANumberOfMultiples:
    def solve(self, tc=0):
        l, r, d = [int(_) for _ in input().split()]

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


solver = ANumberOfMultiples()
input = sys.stdin.readline

solver.solve()

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

Solution (Python):

import sys
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
from itertools import accumulate

sys.setrecursionlimit(10**6)
INF = 10**12
m = 10**9 + 7

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


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().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
input = sys.stdin.readline
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())
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())
acc = 0
for i in range(l, r+1):
  if i % d == 0:
    acc += 1
print(acc)

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

Solution (Python):
import sys
from operator import itemgetter

sys.setrecursionlimit(10**9)
input = sys.stdin.readline

def ii(): return int(input())
def mi(): return map(int, input().split())
def lmi(): return list(map(int, input().split()))
def iif(n): return [int(input()) for _ in range(n)]
def lmif(n): return [list(map(int, input().split())) for _ in range(n)]
def ss(): return input().split()

def main():
    mod = 1000000007
    
    l, r, d = mi()

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

    return

main()

Solution (Python):
import sys, os, math, bisect, itertools, collections, heapq, queue

from decimal import Decimal
from collections import defaultdict, deque

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    L, R, d = il()

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


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

def solve():
    input = sys.stdin.readline
    L, R, d = map(int, input().split())
    print(R // d - (L - 1) // d)

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):
from collections import defaultdict
from collections import deque
from collections import Counter
import itertools
import math

def readInt():
	return int(input())
def readInts():
	return list(map(int, input().split()))
def readChar():
	return input()
def readChars():
	return input().split()

l,r,d = readInts()

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

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

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


if __name__ == '__main__':
    main()

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return [LIST() for _ in range(n)]
def NSTR(n): return [input() for _ in range(n)]


INF = float("inf")
MOD = 10**9 + 7


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

    return


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

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
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()
    ans = 0
    for i in range(l,r+1):
        if i%d ==0 :
            ans += 1
    print(ans)
    return


if __name__ == "__main__":
    solve()

Solution (Python):
import sys
sys.setrecursionlimit(500000)
MOD = 10**9+7

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

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

def ii():
    return int(input())

def i2(n):
    tmp = [list(mi()) for i in range(n)]
    return [list(i) for i in zip(*tmp)]


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

if __name__ == '__main__':
    main()

Solution (Python):
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

l,r,d = map(int,input().split())
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 = [int(hoge) for hoge 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):
S=lambda:input()
I=lambda:int(input())
L=lambda:list(map(int,input().split()))
LS=lambda:list(map(str,input().split()))

l,r,d=L()
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):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

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

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
from collections import Counter, deque, defaultdict
from math import floor, ceil
from bisect import bisect_left
from itertools import combinations
setrecursionlimit(100000)

INF = int(1e10)
MOD = int(1e9 + 7)

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.buffer.readline()[:-1]
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

L, R, d = MAP()
print(R//d-(L-1)//d)

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

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

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