求n以下所有数字的总和，这些数字是某些数字的倍数

31

几乎等同于欧拉计划的第一个问题：

如果我们列出所有低于10的自然数，它们是3或5的倍数，则得到3、5、6和9。这些倍数的总和为23。

找出1000以下3或5的所有倍数的总和。

挑战：

给定一个正整数N和一组至少一个正整数的A，输出所有的正整数的总和小于N那些中的至少一个构件的倍数A。

例如，对于Project Euler情况，输入为：

1000

3

5

测试用例：

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

4

1)我们是否计算两个数字的倍数？2)我们只能得到另外两个数字吗？或任何金额说一或三？

3

你能给出一些测试用例吗？显然不要将答案发布到PE上，但是其他示例呢？

1

@WheatWizard：单词“或”表示每个数字最多只能计数一次。我同意，这个问题需要弄清楚必须支持多少个“数字以检查参数的倍数”。就是两个？一个或多个？零或更多？

1

我们可以接受等于或低于10的数字，还是接受9而不是10？

“并且至少有一个正整数A的集合”该集合有多大？

Answers:

13

果冻，6个字节

ḍþṖḅTS

怎么运行的

ḍþṖḅ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.

3

当然，@ Dennis必须附带一些使您想知道您在ppcg上正在做什么的东西

8

Python，59 55字节

lambdan,l:sum(v*any(v%m<1forminl)forvinrange(n))

带有整数n和整数列表的未命名函数l。遍历一个自然数(加零)的范围，但不包括n和求和(sum(...))那些用零(v%m<1)除以列表中any整数的余数。使用乘法而不是条件式来节省3个字节。ml

8

八度，38 36 33字节

@(x,y)(1:--x)*~all(mod(1:x,y),1)'

输入为：f(10, [3;5])。如果输入可以f(9,[3;5])用于相同的测试用例，则将短2个字节。

说明：

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

八度可以预先减小，因此使用1:--x代替1:x-1(两次)可以节省两个字节。

mod(a,b)给出1 2 0 1 2 0 1 2 0的mod(1:9,3)。如果第二个参数是垂直向量，它将垂直复制第一个输入，并为第二个输入参数中的每个值取模。因此，对于输入，mod(1:9, [3;5])它给出：

1 2 0 1 2 0 1 2 0

1 2 3 4 0 1 2 3 4

以~all(_,1)在这给true了其中至少有一个值为零列，false其中所有的值不为零：

~all(mod(1:x,y),1)

0 0 1 0 1 1 0 0 1

在,1需要的情况下，存在只有一个号码y。否则，它将作用于整个向量，而不是作用于数字。

将其转换为垂直矩阵并使用矩阵乘法，将为我们提供正确的答案，而无需显式求和：

哦，这很残酷：由于x和x–1之间的差异，我不得不添加2个字节，但是您必须添加4个字节，我现在领先1个字节> :)

6

JavaScript(ES6)，40 39 36字节

输入：具有整数n和整数数组，a具有柯林语法(n)(a)

n=>F=a=>n--&&!a.every(v=>n%v)*n+F(a)

测试用例

letf=n=>F=a=>n--&&!a.every(v=>n%v)*n+F(a)console.log(f(50)([2]));// 600console.log(f(10)([3,5]));// 23console.log(f(28)([4,2]));// 182console.log(f(19)([7,5]));// 51console.log(f(50)([2,3,5]));// 857

运行代码段隐藏结果

对于相同的长度，我的公式略有不同：f=(n,a)=>n--&&a.some(v=>n%v<1)*n+f(n,a)。我最好可以非递归地做的是61个字节。

@Neil您的评论鼓励我寻找另一种提法。有趣的是，该循环语法节省了3个字节。

5

MATL，9个字节

q:ti\~*us

1

只是检查我是否阅读正确(无需检查文档)。您正在递减，创建了一个vector 1 2 ...。您将其复制并取模数作为其他输入。您取反并与向量相乘1 2 ..，使用unique消除重复项并最终求和...

究竟！我在移动设备上，因此未提供解释。现在没有必要了：-)

5

视网膜，34字节

字节数假定为ISO 8859-1编码。

\d+

$*

M&!`(.+)\1*(?=1¶.*\b\1\b)

1

输入格式为

50

2,3,5

4

Python，67个字节

a,b,c=input()

x=y=0

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

print y

编写完此代码后，我注意到我的代码与现有的python答案相似，但是我独立提出了该代码，并且无论如何都将其发布。

您不需要在exec中使用分号，因为无论如何它后面都有换行符。我知道我的答案可能超出预期！

规范说“一组至少一个正整数”；这似乎只能处理集合是两个整数的情况。另外x=y=0在单独的行上将节省四个字节。

@JonathanAllan太好了，非常感谢！

4

Mathematica，37 27字节

感谢马丁·恩德(Martin Ender)精明的观察，它节省了大量字节！

Tr[Union@@Range[#,#2-1,#]]&

未命名函数采用两个参数，一个#整数列表(所需的除数A)和一个整数#2(上限N)，并返回一个整数。Range[#,#2-1,#]对于d列表的每个元素，给出小于或等于(因此小于)的#所有倍数；然后计算这些列表的联合并与求和。d#-1#Tr

先前版本：

Tr[x=#;Union@@(Range[#,x-1,#]&/@#2)]&

1

Range是可列出的：(Tr[Union@@Range[#2,#-1,#2]]&然后通过交换输入的顺序来保存另一个字节)

4

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

以输入数字作为参数的lambda。(对于N，一个参数，对于A，任意数量的参数)。

说明：

{ ... }：lambda。

$^a：lambda的第一个参数。

@_：lambda的其余参数(“可变参数”)。

^$^a：范围从0到$^a - 1。

* %% @_.any：另一个lambda，测试它的参数*使用整除，由运营商%%对一个any- 结名单@_。

grep PREDICATE, RANGE：迭代数字范围并返回谓词为true的数字。

我认为添加^声明一个占位符参数是相当明确的。特别是因为您可以稍后在代码块中像使用它一样$a。我认为只能$_ @_ %_ self将其视为隐式声明。我想我该行应显示为“ 声明第一个参数为占位符 ”

@ BradGilbertb2gills：我的意思是说，即使代码没有在lambda的主体之前引入签名，它也隐含地成为lambda签名的一部分。@_和%_功能方面在这方面没有什么不同：如果它们出现在体内，它们也只会成为签名的一部分。默认情况下，只有$_ (和in self和%_in方法)可以成为签名的一部分。

PS：不过，由于不需要理解代码，因此我现在删除了“隐式声明”一词。

3

R，67个字节

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

采用以下格式将向量带入STDIN ：[N, a_1, a_2, ...]。支持任意数量的a。对于每一个a，创建序列a，以N-1与步长a。然后取该向量中所有唯一项的总和。

3

Haskell，42个 39字节

a!b=sum[x|x

用法：

Main> 50![2,3,5]

857

感谢@Zgarb 3个字节

(x`mod`)与相同mod x。

@Zgarb哎呦:)

3

FND²%P_*O

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字节或8字节。(不过，当您发布答案时，不可能进行第一个8次循环。因为à(最大)现在弹出列表，但之前没有。)

3

八度，49 37字节

@(A,N)sum(unique((z=(1:N)'.*A)(z

该函数将被称为 f([2 3 4],50)

假设A=[2 3 4];我们要求数字之和为

sum(

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

3,6,9...,50-1,

4,8,12,...50-1)

我们可以乘[2 3 4]用1:50得到矩阵(1:N)'.*A

[2 4 6 ... 2*50

3 6 9 ... 3*50

4 8 12 ...4*50]

然后从矩阵中提取小于50的那些： z(z

由于矩阵中存在重复的元素，因此我们提取唯一值并将其求和。

先前的答案：(如果N == 1，此解决方案将失败)

@(A,N)sum((k=uint64(1:N-1))(any(k==(k./A').*A')))

函数应称为 f(unit64([2 3 4]),uint64(50))

1

非常好！几乎和其他八度音阶的答案一样，但方法却完全不同。这根本没让我想到！也许可以从一些解释中获得好处，也许还可以联系到ideone，但是您已经获得我的投票了：-)

2

Pyth，10个字节

s{sm:0hQdt

说明

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

2

T-SQL，87个字节

只要@i其值为2048或更低，它将起作用

USE master--needed for databases not using master as default

DECLARE @i INT=50

DECLARE @ table(a int)

INSERT @ values(2),(3),(5)

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

2

+/⊢∘⍳∩∘∊×∘⍳¨

匿名默认功能。感谢@Adám帮助我节省了3个字节。用途⎕IO←0。

怎么样：

+/⊢∘⍳∩∘∊×∘⍳¨⍝Tacitfunction.Leftandright arguments will be called⍺and⍵respectively.×∘⍳¨⍝Multiply⍺witheach element of[0..⍵-1]∊⍝Enlist(flattens the vector)∩∘⍝Then,getthe intersection of that vectorwith⊢∘⍳⍝Thevector[0..⍵-1].+/⍝Thensum

2

点，43 41 39 35字节

b^:sFc,a{f:0Fdb{f?0c%d?0(f:i+:c)}}i

说明：

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

哎呀！我读得太快了

好多了。好答案！

1

Python 2，80字节

这很长。绝对可以缩短。将3个数字作为单独的输入肯定会损害得分。

i=input

x=i();y=i();z=i();s=c=0

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

print s

您可以x,y,z=input()以的形式进行输入(1000,3,5)。

1

常见的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))

1

param($a,$b)(1..--$a|?{$i=$_;$b|?{!($i%$_)}})-join'+'|iex

迭代解决方案。将输入作为数字$a和文字数组$b。使用带有子句的运算符选择某些数字，从()循环1到下面的一个。$a--$aWhere-Object|?{...}

该子句$i在将输入数组发送$b到另一个数组之前设置为当前数字|?{...}，在这里挑选出当前数字被至少一个中的一个平均划分的项目$b。那些$b确实平均分配的元素留在管道上。

因此，如果中有至少一个元素$b，则管道包含一个元素，因此外部Where为$true，并且当前数字保留在管道上。否则，$b在管道上没有任何元素时，外部Where为$false，因此当前编号不会放在管道上。

这些数字全部收集在括号中，-join与+符号一起编辑，并通过管道传递给|iex(，Invoke-Expression与相似eval)。求和结果留在管道上，并且输出是隐式的。

1

PHP，78 76 74字节

for(;++$i

外部循环运行$i从1到低于第一个参数，并添加$i到$s如果$f是不设置。

内部循环对所有后续参数乘以$f($i模数参数)，并将if 设置$f为其中任何一个的倍数。0$i

用运行-r。

1

Scala，47个字节

n=>1.to(n(0)-1).filter(i=>n.exists(i%_==0)).sum

n是一个包含第一个参数的列表N，其余为A

通过滤除不存在至少一个A是i的倍数的数字，然后求和来工作。严格来说，我们应该n.tail.exists在闭包内部使用，但是由于i始终小于N，因此决不能是N的倍数，否则，解决方案仍然是完整的。

1

Java 8，75字节

(N,A)->IntStream.range(1,N).filter(x->A.stream().anyMatch(y->x%y==0)).sum()

为此的方法签名是 int f(int N, List A)

1

Ruby，52 48 46字节

->b{b[s=0].times{|x|b.find{|y|x%y<1&&s+=x}};s}

1

C11，177字节

#include"object.h"

#define S size_t

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

在同一文件夹中需要这组标题，并且在此文件夹中也fnv-hash找到库。像编译gcc 1.c ../fnv-hash/libfnv.a -o 1 -DNODEBUG

测试程序：

#include "../calc/object/object.h"

#include

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

define_array_new_fromctype(size_t);

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

array_destruct(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;iidx+1;l*=i%(S)(*array_get_ref(d,j++,NULL))->fwi->value);s+=l?0:i;}return s;}

输出

23

23

23

1

Japt -x，9 7 6个字节

Ç*VøZâ

: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

1

> 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

结构树：

怎么运行的

EachLαα

f(x)g(x)h(x)={i|(i|x),i∈N}=f(x)∪α=|g(x)|>0i.e. the set of divisors ofxi.e. the union of the divisors ofxwithαi.e.g(x)is not emptyf(x)={i|(i|x),i∈N}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

ααββ

βi={αi0h(αi)⊤h(αi)⊥βi={αih(αi)⊤0h(αi)⊥

αiαiiiααββββ00

1

K(oK)，15 14字节

解：

{+/&|/~y!\:!x}

例子：

{+/&|/~y!\:!x}[50;,2]

600

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

23

说明：

{+/&|/~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

0

实际上，13个字节

DR∙`i;)%Y*`MΣ

说明：

DR∙`i;)%Y*`MΣ

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

0

处理中，88字节

int q(int a,int[]b){int s=0,i=0;for(;++i

使用简单的for-loop方法，将所有倍数相加并返回。输入的是格式int，int[]数组。