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

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

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

Solution (Python):

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

print(ans)

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


def read():
    L, R, D = map(int, input().strip().split())
    return L, R, D


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


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))

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

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

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

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

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

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

print( ans )

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

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

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

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):
import sys
import math
import heapq
from collections import defaultdict, deque
from decimal import *
def r():
    return int(input())
def rm():
    return map(int,input().split())
def rl():
    return list(map(int,input().split()))

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

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

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

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)

resolve()

Solution (Python):
import sys, io, os, re
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from pprint import pprint
from math import sin, cos, pi, radians, sqrt, floor, ceil
from copy import copy, deepcopy
from collections import deque
from fractions import gcd
from functools import reduce
from itertools import groupby
from heapq import heapify, heappush, heappop



n1 = lambda: int(sys.stdin.readline().strip())
nn = lambda: list(map(int, sys.stdin.readline().strip().split()))
f1 = lambda: float(sys.stdin.readline().strip())
fn = lambda: list(map(float, sys.stdin.readline().strip().split()))
s1 = lambda: sys.stdin.readline().strip()
sn = lambda: list(sys.stdin.readline().strip().split())
nl = lambda n: [n1() for _ in range(n)]
fl = lambda n: [f1() for _ in range(n)]
sl = lambda n: [s1() for _ in range(n)]
nm = lambda n: [nn() for _ in range(n)]
fm = lambda n: [fn() for _ in range(n)]
sm = lambda n: [sn() for _ in range(n)]

def array1(n, d=0): return [d] * n
def array2(n, m, d=0): return [[d] * m for x in range(n)]
def array3(n, m, l, d=0): return [[[d] * l for y in xrange(m)] for x in xrange(n)]
def linc(A, d=1): return map(lambda x: x + d, A)
def ldec(A, d=1): return map(lambda x: x - d, A)

L, R, d = nn()

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 solve(*args: str) -> str:
    l, r, d = map(int, args[0].split())
    count = 0
    for i in range(l, r+1):
        if i % d == 0:
            count += 1
    return str(count)


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

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
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7

    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__':
    solve()

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,io,os,time
from collections import defaultdict
from collections import OrderedDict
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect,math,heapq
alphabet = "abcdefghijklmnopqrstuvwxyz"

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

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

print(cnt)

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

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


X,Y,D=map(int,input().split())
count=0
for i in range(X,Y+1):
    if i%D==0:
        count+=1
print(count)

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

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

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

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

Solution (Python):
import sys
import math
import statistics
import itertools
from collections import deque


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





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

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

Solution (Python):
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter

from functools import lru_cache

sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7


def inp():
    '''
    一つの整数
    '''
    return int(input())


def inpl():
    '''
    一行に複数の整数
    '''
    return list(map(int, input().split()))


def str_inp():
    '''
    文字列をリストとして読み込む
    '''
    return list(input()[:-1])


l, r, d = inpl()
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):

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

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

Solution (Python):
from sys import stdin
input = 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())
ans=0
for i in range(l,r+1):
  if i%d==0:
    ans+=1
print(ans)

Solution (Python):

import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub


import sys


buff_readline = sys.stdin.readline
readline = sys.stdin.readline

INF = 2**62-1


def read_int():
    return int(buff_readline())


def read_int_n():
    return list(map(int, buff_readline().split()))


def read_float():
    return float(buff_readline())


def read_float_n():
    return list(map(float, buff_readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()

def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(L, R, D):
    ans = 0
    for i in range(L, R+1):
        if i % D == 0:
            ans += 1
    return ans


def main():
    L, R, D = read_int_n()
    print(slv(L, R, D))


if __name__ == '__main__':
    main()

Solution (Python):

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

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

print(count)

Solution (Python):

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)

main()

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



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

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

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

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

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

print(ans)

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

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

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

ans = 0

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

Solution (Python):
import sys
import math
import bisect

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

if __name__ == "__main__":
    main()

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

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

print(cnt)

Solution (Python):
L,R,d=map(int,input().split())
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())
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())

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

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

Solution (Python):
import sys

import math
import itertools
import random
L,R,d = map(int, input().split())
cnt=0
for i in  range(L,R+1):
    if(i%d==0):
        cnt+=1
print(cnt)

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

c=0

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

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

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

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

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

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

print(ans)

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

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

Solution (Python):


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



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

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

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

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

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

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

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


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

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


if(__name__ == '__main__'):
  main()

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

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 10 ** 9 + 7
EPS = 10 ** -10

l, r, d = MAP()

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

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

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

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

ans = 0

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

print(ans)

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

resolve()

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

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

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

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

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

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

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

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

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

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

print(result_sum)

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):
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
readlines = sys.stdin.readlines

def main():
    L,R,d = map(int, readline().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())
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())

Sum = 0

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

print(Sum)

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

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

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

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


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

Solution (Python):

a,b,m = map(int, raw_input().split())
c = 0
for i in range(a,b+1): 
	if i % m == 0: c+=1
print c

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

Solution (Python):









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

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

    return count


def main():
    print(solve())


if __name__ == "__main__":
    main()

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
stdin = sys.stdin


def ni(): return int(ns())


def na(): return list(map(int, stdin.readline().split()))


def naa(N): return [na() for _ in range(N)]


def ns(): return stdin.readline().rstrip()  


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

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

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

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

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

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

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

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

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

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

print(res)

Solution (Python):
"""    Arnab Chanda    """

from collections import defaultdict, deque
from itertools import permutations
from sys import stdin,stdout
from bisect import bisect_left, bisect_right
from copy import deepcopy
import heapq

int_input=lambda : int(stdin.readline())
string_input=lambda : stdin.readline().split()
multi_int_input =lambda : map(int, stdin.readline().split())
multi_input = lambda : stdin.readline().split()
list_input=lambda : list(map(int,stdin.readline().split()))
string_list_input=lambda: list(string_input())
MOD = pow(10,9)+7


count  = 0
l, r, d = multi_int_input()

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

print (count)

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

Solution (Python):
tok = input().split()
l = int(tok[0])
r = int(tok[1])
d = int(tok[2])

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

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

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

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

Solution (Python):
import sys



from bisect import bisect_left, bisect_right





input = sys.stdin.readline

getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]

INF = 10 ** 20
MOD = 1000000007

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

    print(ans)



def main():
    n = getN()
    for _ in range(n):
        solve()
if __name__ == "__main__":
    
    solve()

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):
import math
import itertools
import collections
import bisect
import heapq

def IN(): return int(input())
def sIN(): return input()
def MAP(): return map(int,input().split())
def LMAP(): return list(map(int,input().split()))
def TATE(n): return [input() for i in range(n)]
MOD = 10**9 + 7

l,r,d = MAP()
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 = 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 x in range(L, R+1):
    if x % 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 x in range(L, R + 1):
    if not x % D:
        ans += 1
print(ans)

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

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

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

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

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

print(ans)

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

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

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

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

print(c)

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

print(ans)

Solution (Python):
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext

def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []

def main():
    l, r, d = i_map()

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

    print(count)

if __name__ == '__main__':
    main()

Solution (Python):


LI = lambda: list(map(int, input().split()))


L, R, d = LI()


def main():
    a = (L - 1) // d
    b = R // d
    ans = b - a
    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 - 1) // d)

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




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

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

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

print(ans)

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

Solution (Python):
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
input=lambda: sys.stdin.readline().rstrip()
l,r,d=map(int,input().split())
ans=r//d-(l-1)//d
print(ans)