Temukan jumlah semua angka di bawah n yang merupakan kelipatan dari sejumlah himpunan angka


Hampir setara dengan pertanyaan pertama Project Euler:

Jika kita mendaftar semua bilangan alami di bawah 10 yang merupakan kelipatan 3 atau 5, kita mendapatkan 3, 5, 6 dan 9. Jumlah kelipatan ini adalah 23.

Temukan jumlah semua kelipatan 3 atau 5 di bawah 1000.


Dengan bilangan bulat positif Ndan sekurang-kurangnya satu bilangan bulat positif A, hasilkan jumlah dari semua bilangan bulat positif kurang dari Nitu adalah kelipatan dari setidaknya satu anggota A.

Misalnya, untuk kasus Project Euler, inputnya adalah:


Kasus uji:

Input : 50, [2]
Output: 600

Input : 10, [3, 5]
Output: 23

Input : 28, [4, 2]
Output: 182

Input : 19, [7, 5]
Output: 51

Input : 50, [2, 3, 5]
Output: 857

1) Apakah kita menghitung angka yang merupakan kelipatan dari keduanya dua kali? 2) Bisakah kita mendapatkan dua nomor lainnya? atau berapa jumlah yang dikatakan satu atau 3?
Wheat Wizard

Bisakah Anda memberikan beberapa test case? Jelas tidak memposting jawaban untuk PE, tetapi bagaimana dengan contoh lain?

@WheatWizard: Kata "atau" menyiratkan bahwa setiap angka dihitung hanya sekali, paling banyak. Saya setuju bahwa pertanyaannya perlu memperjelas berapa banyak "angka untuk memeriksa kelipatan" argumen yang harus didukung. Tepatnya dua? Satu atau lebih? Nol atau lebih?

Can we take "numbers equal to or below 10", or take 9 as input instead of 10?
Stewie Griffin

"and a set of at least one positive integer A" how big can the set be?



Jelly, 6 bytes


Try it online!

How it works

ḍþṖḅTS  Main link. Left argument: D (array). Right argument: n (integer)

ḍþ       Divisible table; test each k in [1, ..., n] for divisibility by all
        integers d in D.
  Ṗ     Pop; discard the last Boolean array, which corresponds to n.
   ḅ    Unbase; convert the Boolean arrays of base n to integer. This yields a 
        non-zero value (truthy) and and only if the corresponding integer k is 
        divisible by at least one d in D.
    T   Truth; yield the array of all indices of truthy elements.
     S  Compute their sum.

Of course @Dennis has to come with something that will make you wonder what you're doing on ppcg
Grajdeanu Alex.


Python, 59 55 bytes

lambda n,l:sum(v*any(v%m<1for m in l)for v in range(n))


Unnamed function taking an integer, n and a list of integers l. Traverses a range of the Natural numbers (plus zero) up to but not including n and sums (sum(...)) those that have a remainder after division of zero (v%m<1) for any of the integers m in the list l. Uses multiplication rather than a conditional to save 3 bytes.


Octave, 38 36 33 bytes


Take input as: f(10, [3;5]). This would be 2 bytes shorter if the input could be f(9,[3;5]) for the same test case.

Verify all test cases here.


@(x,y)        % Anonymous function that takes two inputs, x and y
              % x is a scalar and y is a vertical vector with the set of numbers
(1:--x)*      % Pre-decrement x and create a vector 1 2 ... x-1    

Octave can pre-decrement, so using 1:--x instead of 1:x-1 (two times) saves two bytes.

mod(a,b) gives 1 2 0 1 2 0 1 2 0 for mod(1:9,3). If the second argument is a vertical vector, it will replicate the first input vertically and take the modulus for each of the values in the second input argument. So, for input mod(1:9, [3;5]) this gives:

1 2 0 1 2 0 1 2 0
1 2 3 4 0 1 2 3 4

Taking ~all(_,1) on this gives true for the columns where at least one value is zero, and false where all values are non-zero:

0 0 1 0 1 1 0 0 1

The ,1 is needed in case there is only one number in y. Otherwise it would act on the entire vector instead of number-by-number.

Transposing this to a vertical matrix and use matrix multiplication, will give us the correct answer, without the need for explicit summing:

Oh that's cruel: I had to add 2 bytes because of the difference between x and x–1, but you had to add 4 bytes, and I'm now ahead by 1 byte >:)
Greg Martin


JavaScript (ES6), 40 39 36 bytes

Input: integer n and array of integer(s) a with currying syntax (n)(a)


Test cases

I had a slightly different formulation for the same length: f=(n,a)=>n--&&a.some(v=>n%v<1)*n+f(n,a). Best I could do nonrecursively was 61 bytes.

@Neil Your comment encouraged me to look for yet another formulation. Interestingly, the currying syntax saves 3 bytes.


MATL, 9 bytes


Try it online!

Just checking if I read this right (without checking the docs). You're decrementing, creating a vector 1 2 .... You duplicate it and take modulus the other input. You negate it and multiply with the vector 1 2 .., use unique to get rid of duplicates and finally summing it...
Stewie Griffin

Exactly! I'm on the mobile so I didn't include an explanation. Now it's not necessary :-)
Luis Mendo


Python, 67 bytes

exec("if x%c<1or 1>x%b:y+=x\nx+=1\n"*a)
print y

After writing this I noticed my code was similar to the existing python answer, however I came up with it independently and am posting it anyway.

You don't need the semicolon in the exec, since you have a line break after it anyway. I knew my answer could be outgolfed!

The spec says "a set of at least one positive integer"; this seems to only handle the case where the set is two integers. Also having x=y=0 on a separate line would save four bytes.
Jonathan Allan

@JonathanAllan cool, thanks a lot!


Mathematica, 37 27 bytes

Thanks to Martin Ender for a shrewd observation that led to big byte savings!


Unnamed function taking two arguments, a list # of integers (the desired divisors A) and an integer #2 (the upper bound N) , and returning an integer. Range[#,#2-1,#] gives, for each element d of the list #, all the multiples of d less than or equal to #-1 (hence less than #); the union of these lists is then computed and summed with Tr.

Previous version:


Range is listable: Tr[Union@@Range[#2,#-1,#2]]& (and then save another byte by swapping the order of the inputs)
Martin Ender


Perl 6, 25 bytes

{sum grep *%%@_.any,^$^a}

A lambda that takes the input numbers as arguments. (One argument for N, and an arbitrary number of arguments for A).

(Try it online.)


  • { ... }: A lambda.
  • $^a: First argument of the lambda.
  • @_: Remaining arguments of the lambda ("variadic parameter").
  • ^$^a: Range from 0 to $^a - 1.
  • * %% @_.any: Another lambda, which tests its argument * using the divisible-by operator %% against an any-Junction of the list @_.
  • grep PREDICATE, RANGE: iterates the range of numbers and returns the ones for which the predicate is true.

I think adding ^ to declare a placeholder parameter is fairly explicit. Especially since you could use it later in the block as just $a. I think only $_ @_ %_ self can ever be considered to be implicitly declared. I think I would have that line read "declare first parameter as a placeholder"
Brad Gilbert b2gills

@BradGilbertb2gills: I meant that it implicitly becomes part of the lambda's signature, even though the code didn't introduce a signature before the lambda's body. @_, and %_ in case of functions, are no different in that regard: They too only become part of the signature if they appear in the body. Only $_ (and self and %_ in methods) can become part of a signature by default.

PS: I removed the phrase "implicitly declared" now, though, as it's not necessary for understanding the code.


R, 67 bytes

a=scan();x=c();for(i in a[-1])x=c(x,seq(i,a[1]-1,i));sum(unique(x))

Takes a vector to STDIN in the following format: [N, a_1, a_2, ...]. Supports any number of a. For each a, creates the sequence a to N-1 with stepsize a. Then takes the sum of all the unique entries in that vector.


Haskell, 42 39 bytes

a!b=sum[x|x<-[1..a-1],any((<1).mod x)b]


Main> 50![2,3,5]

Thanks to @Zgarb for 3 bytes

(x`mod`) is the same as mod x.

@Zgarb whoops :)


05AB1E, 9 bytes


Try it online!

F         For N in [0, ..., input[0]-1]
 ND²%     Evaluate N%input[1]; yields an array of results
     P    Take the total product of the array. Yields 0 only if at least one of the value is 0, in other words if N is multiple of at least one of the specified values
      _   Boolean negation, yields 1 if the last value is 0 and yields 0 otherwise
       *  Multiply by N: yields N if the last value is 0 and yields 0 otherwise
        O Display the total sum

8 bytes or 8 bytes alternative using a filter. (The first 8-byter wasn't possible when you posted your answer, though. Since à (maximum) pops the list now, but didn't before.)
Kevin Cruijssen


Octave, 49 37 bytes


the function will be called as f([2 3 4],50)

Assume that A=[2 3 4]; we require to have sum of numbers as

2,4,6...,50-1 ,

we can multiply [2 3 4] by 1:50 to get matrix (1:N)'.*A

[2 4 6 ... 2*50
3 6 9 ... 3*50
4 8 12 ...4*50]

then extract from the matrix those that are smaller than 50 : z(z<N)

Since there are repeated elements in the matrix we extract unique values and sum them.

previous answer: (this solution will fail if N==1)


function should be called as f(unit64([2 3 4]),uint64(50))

Very nice! Almost as sort as the other octave answer, but a completely different approach. This didn't cross my mind at all! Could benefit from having some explanation though and maybe a link to ideone, but you have my vote already :-)
Stewie Griffin

I changed the order of the input, but here's a link ideone.com/8Bljrl
Stewie Griffin


Pyth, 10 bytes



s{sm:0hQdtQ   Implicit input
    :0hQd     Get multiples of d below the bound
   m     tQ   ... for each d given
  s           Concatenate results
 {            Remove repeats
s             Take the sum


T-SQL, 87 bytes

This will work as long as @i has a value of 2048 or lower

USE master--needed for databases not using master as default
DECLARE @ table(a int)
INSERT @ values(2),(3),(5)

SELECT sum(distinct number)FROM spt_values,@ WHERE number%a=0and abs(number)<@i

Try it out


APL (Dyalog Unicode), 12 bytes


Try it online!

Anonymous tacit function. Thanks to @Adám for helping me shave 3 bytes off of this. Uses ⎕IO←0.


+/⊢∘⍳∩∘∊×∘⍳¨  Tacit function. Left and right arguments will be called  and  respectively.

        ×∘⍳¨  Multiply  with each element of [0..⍵-1]
             Enlist (flattens the vector)
     ∩∘       Then, get the intersection of that vector with
  ⊢∘⍳         The vector [0..⍵-1].
+/            Then sum


Pip, 43 41 39 35 bytes


Try it online!


Takes inputs like so:

    arg1 1000
    arg2 3 5

b^:s                      ;read rest of inputs as array
                          ;(s is " " and ^ is split into array on char)
F c ,a{                   ;for(c in range(0,a))
  f:0                     ;flag to prevent double counting 15,30,etc.
  F d b {                 ;forEach(d in b)
    f? 0 c%d? 0 (f:i+:c)  ;if flag {continue}elif c%d {f=i+=c}
                          ;      (i will always be truthy so why not)     
i                         ;print sum

whoops! I read too fast
Kenneth Taylor

Much better. Great answer!


Python 2, 80 Bytes

This is very long. Can definitely be shortened. Taking the 3 numbers as separate inputs is definitely hurting the score.

exec("if c%z<1 or c%y<1:s+=c\nc+=1\n"*x)
print s

You could do x,y,z=input() and give input in the form of (1000,3,5).


Common Lisp, 77

(lambda(n x)(loop for i below n when(some(lambda(u)(zerop(mod i u)))x)sum i))


(lambda (limit seeds)
  (loop for i below limit
        when (some (lambda (u) (zerop (mod i u))) seeds)
          sum i))


PowerShell, 57 bytes


Try it online!

Iterative solution. Takes input as a number $a and as a literal array $b. Loops from 1 up to one below $a (via --$a), using a Where-Object operator |?{...} with a clause to select certain numbers.

The clause sets $i to be the current number before sending input array $b into another |?{...}, here picking out those items where the current number is evenly divided by at least one of the numbers in $b. Those elements of $b that do divide evenly are left on the pipeline.

Thus, if there is at least one element from $b, the pipeline contains an element, so the outer Where is $true and the current number is left on the pipeline. Otherwise, with no elements from $b on the pipeline, the outer Where is $false, so the current number is not placed on the pipeline.

Those numbers are all gathered up in parens, -joined together with + signs, and piped to |iex (short for Invoke-Expression and similar to eval). The summation result is left on the pipeline, and output is implicit.


PHP, 78 76 74 bytes


The outer loop runs $i from 1 to below first argument and adds $i to $s if $f is not set.
The inner loop multiplies $f with ($i modulo argument) for all subsequent arguments, setting $f to 0 if $i is the multiple of any of them.

Run with -r.


Scala, 47 bytes


n is a List which contains of a first argument N, the rest are elements of A

Works by filtering out numbers where there doesn't exist at least one A of which i is a multiple, then summing. Strictly speaking we should use n.tail.exists inside the closure, but as i is always less than N and therefore never a multiple of N the solution is still complete without this.


Java 8, 75 bytes


The method signature for this is int f(int N, List<Integer> A)


Ruby, 52 48 46 bytes



C11, 177 bytes

#define S size_t
S g(S m,array_t*d){S s,i,l,j;for(s=i=0;i<m;i++){for(l=1,j=0;j<d->idx+1;l*=i%(S)(*array_get_ref(d,j++,NULL))->fwi->value);s+=l?0:i;}return s;}

Requires this set of headers in the same folder, and the fnv-hash library found there as well. Compile like gcc 1.c ../fnv-hash/libfnv.a -o 1 -DNODEBUG

Test Program:

#include "../calc/object/object.h"
#include <stdio.h>

size_t f (const size_t max, const size_t a, const size_t b);
size_t f2 (const size_t max, const array_t* const divs);
size_t g (size_t max, array_t* divs);


int main(void) {
  printf("%zu\n", f(10, 3, 5));
  static const size_t a[] = {
    3, 5
  array_t* b = array_new_from_size_t_lit(a, 2, t_realuint);
  printf("%zu\n", f2(10, b));
  printf("%zu\n", g(10, b));
  return 0;

size_t f (const size_t max, const size_t a, const size_t b) {
  size_t sum = 0;
  for (size_t i = 0; i < max; i++) {
    sum += (i % a * i % b) ? 0 : i;
  return sum;

size_t f2 (const size_t max, const array_t* const divs) {
  size_t sum = 0;
  const size_t len = array_length(divs);

  for (size_t i = 0; i < max; i++) {
    size_t mul = 1;
    for (size_t j = 0; j < len; j++) {
      object_t** this = array_get_ref(divs, j, NULL);

      fixwid_t*   num = (*this)->fwi;

      mul *= i % (size_t) num->value;
    sum += mul ? 0 : i;
  return sum;

#define S size_t
S g(S m,array_t*d){S s,i,l,j;for(s=i=0;i<m;i++){for(l=1,j=0;j<d->idx+1;l*=i%(S)(*array_get_ref(d,j++,NULL))->fwi->value);s+=l?0:i;}return s;}




Japt -x, 9 7 6 bytes


Try it

           :Implicit input of integer U and array V
Ç          :Map each Z in the range [0,U)
 *         :  Multiply by
  Vø       :  Does V contain
    Zâ     :   Any of the divisors of Z
           :Implicit output of sum of resulting array


Whispers v2, 178 bytes

> Input
> Input
> ℕ
>> (1)
>> ∤L
>> {L}
>> L∩2
>> #L
>> L∈3
>> L⋅R
>> Each 5 4
>> Each 6 11
>> Each 7 12
>> Each 8 13
>> Each 9 14
>> Each 10 15 4
>> ∑16
>> Output 17

Try it online!

Structure tree:

struct tree

How it works

Very simply, we put each number (the lines with Each on them) through a series of functions (the lines with L on them), then, based off the results of those functions, we discard some numbers and keep the rest, before finally summing them. In fact, we can define those functions, where α denotes the set of numbers given as input:

f(x)={i|(i|x),iN}i.e. the set of divisors ofxg(x)=f(x)αi.e. the union of the divisors ofxwithαh(x)=|g(x)|>0i.e.g(x)is not empty

This is what lines 5 through to 10 represent. Lines 11 through 16 are simply the application of those three functions. Once we've defined all the functions, we then mutate α to β according to the following rule:


where αi denotes the ith element of α, and the same for β. Finally, we can simply take the sum of β, as the 0 elements do not affect the sum.


K (oK), 15 14 bytes



Try it online!


{+/&|/~y!\:!x}[10;3 5]


{+/&|/~y!\:!x} / the solution
{            } / lambda taking implicit x and y
           !x  / range 0..x-1
       y!\:    / modulo (!) x with each-left (\:) item in y
      ~        / not
    |/         / min-over to flatten into single list
   &           / indices where true
 +/            / sum up


Actually, 13 bytes


Try it online!


DR             range(1, N)
  ∙            Cartesian product with A
   `i;)%Y*`M   for each pair:
    i;)          flatten, make a copy of the value from the range
       %Y        test if value from range divides value from A
         *       value from range if above is true else 0
            Σ  sum


Processing, 88 bytes

int q(int a,int[]b){int s=0,i=0;for(;++i<a;)for(int j:b)if(i%j<1){s+=i;break;}return s;}

Uses the simple for-loop approach, sums all the multiples up and returns it. Input is the format int, int[]array.

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.