[Question]
  [
You are given three parameters: start(int), end(int) and list(of int);
Make a function that returns the amount of times all the numbers between **start** and **end** are multiples of the elements in the **list**.
example:
```
start = 15; end = 18; list = [2, 4, 3];
15 => 1 (is multiple of 3)
16 => 2 (is multiple of 2 and 4)
17 => 0
18 => 2 (is multiple of 2 and 3)
result = 5
```
The function should accept two positive integer numbers and an array of integers as parameters, returning the total integer number. Assume that start is less <= end.
examples: 
```
Multiple(1, 10, [1, 2]); => 15
Multiple(1, 800, [7, 8]); => 214
Multiple(301, 5000,[13, 5]); => 1301
```
The shortest solution is the victor!!! May he odds be ever in your favor...
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
ŸÑ˜åO
```
[Try it online!](https://tio.run/##yy9OTMpM/f//6I7DE0/PObzU//9/YwNDLlMDAwOuaENjHdNYAA "05AB1E – Try It Online")
---
### Explanation
```
Ÿ       - the numbers between start and end 
 Ñ      - get their divisors
  ˜     - deep flatten this list
   å    - find the instances of the elements in the list in these divisors
    O   - Sum this
```
[Answer]
# [Haskell](https://www.haskell.org/), 33 bytes
```
(a#b)x=sum[1|0<-mod<$>[a..b]<*>x]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/XyNROUmzwra4NDfasMbARjc3P8VGxS46UU8vKdZGy64i9n9uYmaegq1CQVFmXomCioKGoamyoYVmtJGOiY5x7H8A "Haskell – Try It Online")
Explanation:
```
(a#b)x                            --take two values a and b and the list x
                      [a..b]      --generate the range a, a+1, ... , b
                mod<$>[a..b]      --partially apply "mod" to each entry of the list
                mod<$>[a..b]<*>x  --apply the partially applied functions to all values of the list x
          [1|0<-mod<$>[a..b]<*>x] --generate a new list with a one for every zero in the previously computed list
(a#b)x=sum[1|0<-mod<$>[a..b]<*>x] --sum it all up
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 44 bytes
```
(a,x,y)=>a.map(n=>t+=y/n-(~-x/n|0)|0,t=0)&&t
```
[Try it online!](https://tio.run/##XcxBCoMwFATQfU/xV5LQH/OjDXUTL1K6CFZLiyZSQ1GQXj1NEbpwNgPDY572bafm9RiDcP7Wxs5EZnHGhZva5oMdmTN1OJpFOsE@YpZuJb4SBkM8y0JsvJt83@a9v7OOXRRCcUVIpYhz2CIlKH3YyTNCtcmK/jTJQp32VJUIOtmSkta08d9pGuIX "JavaScript (Node.js) – Try It Online")
---
# [Python 2](https://docs.python.org/2/), 38 bytes
```
lambda a,x,y:sum(y/i-~-x/i for i in a)
```
[Try it online!](https://tio.run/##RcxBCoMwFATQfU8x4CaBLyaxoVLwJG0XKSU0UKOoBbPx6umHgJ3NMPCYKa3vMZrs@3v@uOH5cnC0Ubou30GkJtR7vTUBfpwRECKczNMc4iq8uGmCeRC4tJISJRW0PR3kQugK6dRhKhh9/hvdEiyjVjGzqji@4Z1/ "Python 2 – Try It Online")
\$ \sum \_{i \in list} \lfloor \frac{end}{i} \rfloor - \lfloor \frac{start-1}{i} \rfloor \$
The answer seems trivial and naive. So am I misunderstand something?
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 21 bytes
```
{sum $^a..$^b X%%@^c}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/urg0V0ElLlFPTyUuSSFCVdUhLrn2vzVXcWKlQpqGoY6hgU60oY5RrCZCyMIAKGauY4EQMzYw1FEwNQCJGxrrmAIl/gMA "Perl 6 – Try It Online")
### Explanation
```
{                   }   # Anonymous codeblock returning
 sum                    # The sum of
     $^a..$^b           # How many numbers in the range a to b
              X%%       # Are divisible by any of
                 @^c    # The third parameter
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 5 bytes
```
:i\~z
```
Inputs are a cell array containing the `start` and `end` values, and then a column vector defining `list`.
[Try it online!](https://tio.run/##y00syfn/3yozpq7q//9qQ1MFQ4tarmgjawUTawXjWAA "MATL – Try It Online") Or [verify all test cases](https://tio.run/##y00syfn/3yozpq7q//9qQ1MdBUOLWq5oI2sFE2sF41gA).
### Explanation
```
:    % Range, with implicit input: cell array {start, end}. This gives the range
     % from start to end
i    % Input: list of numbers in the form of a column vector
\    % Modulo, with boradcast. This gives a matrix with each number in the range
     % modulo each number in the list
~    % Logical negation 
z    % Number of nonzero entries. Implicit display
```
[Answer]
# Python 3, 54 bytes
```
lambda s,e,L:sum(n%l<1for n in range(s,e+1)for l in L)
```
[Try It Online!](https://tio.run/##VclBDsIgEIXhfU/BxgTixDDFRmL0Br1B46IqVRIYGqCLnh7pxuhL3ub75zW/A6li/RxiZmlNTf0hmRzNY4nJBnLW28xR1okyXd3o78@RJTDQn9PiOe3cBacQGTFLLI70MrzWPYoN3Ya9KHO0lPnEsQPUMLRwBHUTovk6oIQBof1HLaueQP@qkgid3AIq6GopHw)
[Answer]
# APL+WIN, ~~20~~ 15 bytes
5 bytes saved thanks to Adam.
Prompts for end integer, start integer and then list:
```
+/,0=⎕∘.|⎕↓0,⍳⎕
```
[Try it online! Courtesy of Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcQJanP5BlyPWooz3tv7a@joEtUOxRxwy9GhDdNtlA51HvZiDzP1DB/zQuQwsuQ1MuIwUTBWMuIM@Ay5DLUMEIyLQwALHNFSyAbFMDIMfYAChlrGAKAA "APL (Dyalog Classic) – Try It Online")
Could be reduced to 9 bytes if we could enter two lists and not have to generate the first:
```
+/,0=⎕∘.|⎕
```
[Answer]
# [R](https://www.r-project.org/), 35 bytes
```
function(a,b,l)sum(b%/%l-(a-1)%/%l)
```
[Try it online!](https://tio.run/##K/qfpmD7P600L7kkMz9PI1EnSSdHs7g0VyNJVV81R1cjUddQE8TS/J@mYaijYGgAxFZGmlxgnoUBkGtuZQHiGhsABUwNQCLJGobGQLam5n8A "R – Try It Online")
Implementation of [tsh's method](https://codegolf.stackexchange.com/a/196599/67312) by [Giuseppe](https://codegolf.stackexchange.com/users/67312/giuseppe). 3 bytes shorter than the previous version:
# [R](https://www.r-project.org/), ~~45~~ 38 bytes
-7 bytes thanks to Nick Kennedy and Xi'an.
```
function(a,b,l)sum(!outer(a:b,l,`%%`))
```
[Try it online!](https://tio.run/##K/qfpmD7P600L7kkMz9PI1EnSSdHs7g0V0Mxv7QktUgj0QoooJOgqpqgqfk/TcNQR8HQAIitjDS5wDwLAyDX3MoCxDU2AAqYGoBEkjUMjYFsoB4A "R – Try It Online")
Boils down to summing the values of `!(x %% y)` for `x` in `a:b` and `y` in `l` (`%%` is \$mod\$ in R, so `x %% y == 0` iff `x` is a multiple of `y`).
[Answer]
# [C++ (clang)](http://clang.llvm.org/), ~~113~~ ~~110~~ ~~109~~ ~~108~~ ~~106~~ ~~100~~ ~~93~~ ~~99~~ ~~91~~ 89 bytes
```
using I=int;I s;void f(I a,I b,I*l,I z,I&s){for(s=0;a<=b;++a)for(I i=z;i--;)s+=a%l[i]<1;}
```
[Try it online!](https://tio.run/##lc9Ba4MwGMbxu5/igbGhM0LUyqQxu@czSA@p2hJIYzG6Q8XP7pIquw22S0L@h9/7prnfk0ZLc13XySpzheDKjEzAsq9etbiEApIInIl41@5@EPFmo/nSD6HllMmKn1kcy8gHAcUfTCUJi2zM5auu1alK2bK@KNPoqe1Qqd6OQydvn4GbgptUJowwB/AvXZ845ozgQJAvLHCz04IgLQm0KwQ2ctGO7fHY9NOIqoJ9Hr50ptUs2KG0PsFRKUG2O46hjvHlH062OR8E5Y9TUg9lf4Q2J9/3cX8oNiinjiro08p/s/weQzdOgwFlwbJ@Aw "C++ (clang) – Try It Online")
Saved 3 bytes thanks to @AZTECCO!!!  
Saved ~~6~~ 13 bytes thanks to @bznein!!!  
~~Added 6~~ Saved 8 bytes thanks to @AZTECCO (and now it's playing by the rules)!!!
[Answer]
# [Ruby](https://www.ruby-lang.org/), 41 bytes
```
->a,e,l{l.sum{|x|(a..e).count{|r|r%x<1}}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y5RJ1UnpzpHr7g0t7qmokYjUU8vVVMvOb80r6S6pqimSLXCxrC2tvZ/gUJatKGOoYEOkDSKjf0PAA "Ruby – Try It Online")
[Answer]
# JavaScript (ES6), 47 bytes
Takes input as `(list, start)(end)`.
```
(a,x,s=0)=>g=y=>y<x?s:g(y-1,a.map(c=>y%c||s++))
```
[Try it online!](https://tio.run/##XczRCoIwGIbh865iJ8GGv7pfG0k0u5DoYCwdhjlpEQ6897UYdOB3@PLwPdRHOf0a5nc@2XsXehmoggWc5Ey2RnrZ@vNycSdDfY6giqeaqY5xr9fVZRljQdvJ2bErRmtoT68IpLoBQUaRM0bSypKg2G3kEUiTZMP/NMoKD1uKNRARbc2jFjzx32kM4Qs "JavaScript (Node.js) – Try It Online")
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 16 bytes
```
{+//~z!\:x_!1+y}
```
[Try it online!](https://tio.run/##Hcc7DoAgEAXAqyyVEKLsA4mEvYqJHQ2FrZ/o1ZHYzdRxr62VfFvn3kut@dgU7Pm0Mg1aIwqSeJopGNEQsID8z8QsC6XuwJDIvQgUjWkf "K (oK) – Try It Online")
## Explanation:
```
{+//~z!\:x_!1+y} - function with 3 arguments [x;y;z] <- (start; end; list)
           !1+y  - a list 0 to end (inclusive)
         x_      - drop the first start numbers
     z!\:        - find the modulo of each number in the range start..end with each of list
    ~            - negate (0 becomes 1, non-zero becomes 0)
 +//             - reduce by addition and converge (repeat until result stops changing)
```
# [J](http://jsoftware.com/), 22 bytes
```
1#.1#.0=[|/(}.i.,])/@]
```
[Try it online!](https://tio.run/##LcixCsIwFEDRPV9x0aEWyut7xmAoBPofpZMY1MWha/vtMUjgTOdT8pYEZUKLnaXStOzj5ZC3DGs/zmvp3UnocpKOgWMib849H68vXLnhyVjAYjurWwfTFnfiP6K2MU@o49UIqlp@ "J – Try It Online")
## Explanation:
The verbs (functions) in [J](http://jsoftware.com/) can take one (right) or two (left and right) arguments. The left argument is the `list`, the right one - a list of the `start` and `end` numbers. 
```
           (       )/@     insert the verb in () between the elements of
                      ]    the right argument (start and end)
                 ,         append
               i.          a list 0..end-1
                  ]        to the right argument (end)
             }.            drop start elements
          |/               insert modulo verb between the above list and 
         [                 the left argument (the list)
       0=                  compare each with 0
    1#.                    sum by base 1 conversion 
 1#.                       sum by base 1 conversion 
                           (we do it twice, because the result of |/ is a table)
```
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 9 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Full program, prompting for **end**, **start**, **list**, from stdin.
```
≢⍸=⎕|\⎕…⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/qKO94P@jzkWPenfYPuqbWhMDJB41LAOSIKn/CmBQwGVowWVoymWkYKJgzAUX4zI04DJUMEISsDAw4DJXsICLGBsYcpkaAAUNjRVMAQ "APL (Dyalog Extended) – Try It Online")
`⎕` prompt for **end**
`⎕…` prompt for **start** and generate progression vector
`⎕|\` prompt for \*\*list\* and make division remainder table
`=` Boolean mask indicating where equal to zero
`⍸` get the indices of the Trues
`≢` tally them
[Answer]
# [Python 2](https://docs.python.org/2/), 54 bytes
```
f=lambda n,m,l:m/n and sum(n%i<1for i in l)+f(n+1,m,l)
```
[Try it online!](https://tio.run/##VcpBDoIwEIXhvaeYjUkbJtoBicToSQgLFBonoVPSlgWnr7Ax@pJ/8@XNa3p7KTO72YcEcY2HrVMcUxhfS4jsZWLHSZHZprN9TL17Dj0IOpxu7izQywBxcUqOfCfrAzCwwKQLq6Sg/abzHFgSWEU1UoNtiResOn34MpLBlrD8s8ZseMXmBytDWJvdqcK60/kD "Python 2 – Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 40 bytes
```
eval set !\$[{$1..$2}%{$3}]+;echo $[$*0]
```
[Try it online!](https://tio.run/##S0oszvj/P7UsMUehOLVEQTFGJbpaxVBPT8WoVrVaxbg2Vts6NTkjX0ElWkXLIPb////GBob/TQ0MDP4bGuuYAgA "Bash – Try It Online")
[Answer]
# APL(NARS), chars 13, bytes 26
```
{+/∊0=⍺∣../⍵}
```
⍺ it is the list of divisors, ⍵ it is the range. Test:
```
  1 2{+/∊0=⍺∣../⍵}1 10
15
  7 8{+/∊0=⍺∣../⍵}1 800
214
  13 5{+/∊0=⍺∣../⍵}301 5000
1301
  13 5 3 11{+/∊0=⍺∣../⍵}301 5000
3294
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
r/ḍ@€FS
```
[Try it online!](https://tio.run/##y0rNyan8/79I/@GOXodHTWvcgv///29oqmNo8d9Ix0THGAA "Jelly – Try It Online")
A dyadic link taking a list of `[start, end]` as the left argument and the list of possible divisors as the right argument. Returns an integer indicating the total number of possible divisions.
[Answer]
# Java (JDK), ~~115~~ 67 bytes
```
(s,e,d)->{int t=0;for(;s<=e;s++)for(int j:d)t+=s%j<1?1:0;return t;}
```
*48 bytes saved thanks to Olivier*
[Try it online!](https://tio.run/##hY7BasMwDIbvfQpdBjZxg7OsrNRN@wQ59Th28BKnOEucYisdI@TZMzsYxgZjFwn90ie@Vt7ltq3fl9v41ukKqk46B6XUBqYNgEOJPtUGlW1kpaBcYwgJNCRUx9ZBre3lFWoq/MX8DZfQQwELcUyxmm5PUzjHgotmsES4Y6GESxIaprBpDzXFpHAP7TE7ZwcurMLRGkAxL@FzFI3P74Ouofe65IJWm6sXkPbqaNS8fDpUfTqMmN78GjtD@rQh2Y5Btmdg1Ee0nh4ZPDHIZ7rq/00y2HP@g3z20X9Yzj2447/ILPdhROfNvHwB "Java (JDK) – Try It Online")
First time golfing in Java, so this is a new experience for me. 
[Answer]
# [Icon](https://github.com/gtownsend/icon), 59 bytes
```
procedure f(a,b,l)
n:=0
(a to b)%!l<1&n+:=1&\z
return n
end
```
[Try it online!](https://tio.run/##Zc5BCsMgEIXhvaewiwals3BipRKak6RdmMSAkIxFDIVePo27kr7tx4M/DJG27ZXi4Mc1eT4JBz3MklHTKiYcz5H38nya71jRpWmxenxY8nlNxIl5Gn@@iwskJOP73ilkLyaBBtBCV8MV9FMeDFBBh1D/g1W73MAeRSsEowqiBm4Kl4Qv "Icon – Try It Online")
[Answer]
# Python 54 bytes
```
lambda K,M,H:sum(n%l<1for n in range(K,M+1)for l in H)
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-x`](https://codegolf.meta.stackexchange.com/a/14339/), ~~7~~ 6 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
rõ ïvV
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LXg&code=cvUg73ZW&input=WzE1LDE4XQpbMiw0LDNd)
```
rõ ïvV     :Implicit input of arrays U=[start,end] and V=list
           > e.g., U=[15,18] V=[2,4,3]
r          :Reduce U by
 õ         :  Inclusive range
           > [15,16,17,18]
   ï V     :Cartesian product with V
           > [[15,2],[15,4],[15,3],[16,2],[16,4],[16,3],[17,2],[17,4],[17,3],[18,2],[18,4],[18,3]]
    v      :Reduce each pair by testing the divisibility of the first by the second
           > [0,0,1,1,1,0,0,0,0,1,0,1]
           :Implicit output of sum of resulting array
           > 5
```
[Answer]
# [Kotlin](https://kotlinlang.org), 69 bytes
```
{s:Int,e:Int,l:List<Int>->(s..e).toList().sumBy{v->l.count{v%it==0}}}
```
[Try it online!](https://tio.run/##lVbbbttGEH3XV6yFFCVRhrbsyEnlyEWSJmiABHlIXgrDD2tpJW1DclnuUrYg6NvdMzNLWrKDFjUEmuQezuXM9bsLha3uj4/Vx6puw0RVLqxstVQL1yjXNmpuFrotggrGBzXT3vgBwDgMq8YY5Ws9w9XUutHBzNXCmmLuc/VtZXDf@EBo65VWja6WQAbdBGWrYJamEZg3M1fNGURgwRl6Iyho0oGOC93ExwoXQ2AWJ2JgdiNS1MyVpX4wioCFhflu0cn07B@EqNp5b28KWKtnwTU@HxD8XWPEHUZB6MzNjVq6YqFmK10UBjZOCLgKofaT42M6p@McFs2@mzugAMlhyfHfx6Nfz8fnY4L/4W5VqauNCrY0PlO6IcPNRpXg2NaF8b8pNuBP1/Lh0q5NFbkmd0oTYP1EHE/gTZoRHHTxg9LgjXxNxNf0gk4/6@8GtCzaahasq4TQxoS2qTyToEvXVsQPodk0BSf5qGrLG@LrxoRbA1MkgKQGOglOVvbWE8X0lSlMaargYQM/k0k5G3qnSwAnffDUVI3GFxxv3L26kEhN1dVppl5k6uyaPRiN1fRSjVSCUHTKSNdZyqfndHr65PSU7XwhmJeEOYGKf8OKvMZ4SvmpGnMsOJc77vzKtcVc6dnM1KiKW0cZZAPCxJkeU7ZjjWQiW3XT6M1@@jFxfi@iWYwHlR4RFlzQRQcntEjM1Rvv29JICGMxoTKM9@r1lFjcZ9kzzZ@jl8koU6OTTF3h/@l1esGMjh8jXp0Q5CVuIuR09OIAc3YC1PgEsKvRGe46SXjfswWSGm4Y3hUt02Yl0daWiuzo6EjScqPwzs3nlF7KrEEc8mVDbWeh167Jc6nG93c1iKRy7KJwa8OKy5yTTJKOy1yXN3OtWg9wcKR@bWIBd2XLBL1zFbQFtkkazqJxZSQUH8b24zhOkr3qa1uqtu7TGUooWNyzAmR49IpSS305tTQifK2L1qAffnAcRaNnq644MjhAVXdQL3AF7kuLtUtbIQlYGcd7btd2zkRVxaa3j4@igHwAilTduBkyImF3Jujs0AWP5G6g8EcyJ59weY1Xl6ma8lv5IM@BTfPg6DxJc@Tb243aiivq@SVDOyG5@BBPf7KomimqbKd2HLkPfctxsN7XBUJO/loaNlIerg24Z4@ld0gMxZP4zf/wZDvAawj7JJnw0MC7@GMuGOE8ZpXg@9TSNw45Q991@ZUDAfdUzTQBe/6rutkgv@@3fkKGGL4WD2Y8v0w8aHxM4nb9/LIQxrZrcDWdnux2u3uW@fsTdpAfXRMWSjLiSyzY51K6FVtZN0iKokqGyTNmLFPPwFamhr8M9kL2l7PVN/c1ALxMhjjF74ou18O0Aw5TKupn2zqJglgOfZ7uhulgt2fEQGoZldtz@JR1CWcJVIIpjgH2hlriazFiL2zfmg0c0vOuD6KSm5/94zVDsN1M73YOHnOhWzyoNwvuycw/mGFdyTGUe0Gu/muhOFB/IF56V9wkGPZOwwcaAlgKMDKIHvyi4oUtTIadqzqwNKP9ylbIOTvvTPoCw5tb600m0FjjygbSE0DblkO35rGB/MH4IiI/2cok6dFRjljZkAwR2R7XDWDGX51cI12RvckDQKayHI@eHsdRLeen152KbJjmpa6jQfQHI@O36Av8YqESEo6ZxUakEYpFBxvSR@TMUhdvmmVLBfi@Iy7pBQ7f6rlsrEfRn4NOsZ@uMbG@7AWAOi/mI6UsJUFHZZ8FD7tun1S0f5G4PokEydo8q/NcnjH4gpW2z8D9xi9LkfNRYtYZEJVTOycLKK47mBFmq8Q0jWsmSEvQo7GtppHcvuCJDwm7jKW4tvujH4SbtH5ZJKMx9gH@YXQ/jnmHeSU7A28FNPSfBD8C47@4tKXZwZAgQdg50qx7ovXiBxhaJ1LRQCxjo52bO2JL5hIeLXjqcuUg4leMveZIdPe9fNEQX6dMKw/tjfQx6kr3/wA "Kotlin – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 6 bytes
```
#0×`%…
```
[Try it online!](https://tio.run/##yygtzv6fm18enJp/bnfxo6bGIkXDQzuLFI1AhLFm@aFt/5UNDk9PUH3UsOz///@GpgqGFgrRRjomOsaxXIYKhgYK0YY6RiCmhQGQba5jEctlbGCoYGoA4hoa65jGAgA "Husk – Try It Online") Nothing very special.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `d`, ~~5~~ 4 bytes
```
ṡ$vḊ
```
*-1 byte thanks to @lyxal*
[Try it online!](https://vyxal.pythonanywhere.com/#WyJkIiwiIiwi4bmhJHbhuIoiLCIiLCIxXG44MDBcbls3LDhdIl0=)
Explanation:
```
ṡ     # Range from a to b
 $    # Swap (last input is now on top)
  vḊ  # For each in the range, test for divisibility with the last input
      # Deep flatten and sum with the d flag
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 11 bytes
```
Ｉ⁻Σ÷ηζΣ÷⊖θζ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwzczr7RYI7g0V8Mzr8QlsywzJVUjQ0ehSlNTRwFV1CU1uSg1NzWvJDVFo1ATrAQIrP//jzY2MNRRMDUwMNBRiDY0BjJjY//rluUAAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
    η       Second input (End)
     ζ      Third input (List)
   ÷        Vectorised integer division
  Σ         Sum
         θ  First input (Start)
        ⊖   Decremented
          ζ Third input (List)
       ÷    Vectorised integer division
      Σ     Sum
 ⁻          Subtract
Ｉ           Cast to string
            Implicitly print
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 15 bytes
```
/.nm%LdeQ}.*PQ0
```
[Try it online!](https://tio.run/##K6gsyfj/X18vL1fVJyU1sFZPKyDQ4P9/Q1MdQwudaCMdEx3jWAA "Pyth – Try It Online")
Takes input as `start, end, list`
Explanation:
```
         }        # Inclusive range
          .*      # Splat (list becomes list of arguments)
            PQ    # All but the last element of the input
                  # --> inclusive range from start to end
   m              # map each number of that
     L eQ         # to a map of each member of Q[-1] = list
    % d           # remainder modulo member (2, 4, 3 in example)
                  # --> List of lists of remainders
 .n               # flatten
/              0  # count zeroes
```
[Answer]
# [Perl 5](https://www.perl.org/) (`-ap`), 33 bytes
```
for$i(<>..<>){$i%$_||$\++for@F}}{
```
[Try it online!](https://tio.run/##K0gtyjH9/z8tv0glU8PGTk/Pxk6zWiVTVSW@pkYlRlsbKOHgVltb/f@/obGCKZexgSGXqYGBwb/8gpLM/Lzi/7qJBQA "Perl 5 – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 54 bytes
```
(a,b,l)=>l.Where(x=>a%x<1).Count()+(++a>b?0:f(a,b,l));
```
[Try it online!](https://tio.run/##ZcxLC4JAFAXgvb/iboIRbzKjSZKPFlEQtHcRLVRGEmwCHzAq/XabqRZii3MXh@@evFnnTTmdOpGHpWhR53wU3YPXaVZx3cUI@kIB0URSzLAyo7iykzuvOZFRnK5kyEz78OxES0yLWFYaZ3u6K37YDCb1f72BhAhgZAjOKzCSumz5pRScFERVjKJU0jC@tFd0dBA2CO4Se0r72M/0oPUWwf/f9SlFGOb2g5mL3gK7VHGPKj9oP70B "C# (Visual C# Interactive Compiler) – Try It Online")
Recursive approach
[Answer]
# SimpleTemplate, 86 bytes
Yeah, kinda long, but it works!  
Receives 2 numbers (in any order) and an array/string of 1-digit numbers (e.g.: `"243"`), passed to the `render()` method of the compiler.
```
{@fori fromargv.0 toargv.1}{@eachargv.2}{@ifi is multiple_}{@incR}{@/}{@/}{@/}{@echoR}
```
Displays the result or nothing, if none is
---
**Ungolfed**
```
{@set count 0}
{@for i from argv.0 to argv.1}
    {@each argv.2 as number}
        {@if i is multiple of number}
            {@inc by 1 count}
        {@/}
    {@/}
{@/}
{@echo count}
```
Should be mostly straightforward.
---
You can try it on <http://sandbox.onlinephpfunctions.com/code/b26cd7f75e0c4676038573c4274180891a890895>
Change line 986 to test the golfed and ungolfed versions, and line 988 to get the input.
[Answer]
## Mathematica, 52 bytes
```
f[s_,e_,l_]:=(q=Quotient;Total[q[e,#]-q[s-1,#]&/@l])
```
This uses the simplification formula from @tsh 
A less clever solution at 66 bytes but more directly following the OP:
```
f[s_,e_,l_]:=Total[Length@Intersection[Divisors@#,l]&/@Range[s,e]]
```
]