프로젝트 오일러의 첫 번째 질문과 거의 동일합니다.

3 또는 5의 배수 인 10 미만의 모든 자연수를 나열하면 3, 5, 6 및 9가됩니다.이 배수의 합은 23입니다.

1000보다 작은 3 또는 5의 배수의 합을 구합니다.

도전:

양의 정수 N와 적어도 하나의 양의 정수 집합이 주어지면, 적어도 하나의 일원의 배수 A보다 작은 모든 양의 정수의 합을 출력합니다 .NA

예를 들어 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

젤리 , 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.

파이썬, 59 55 바이트

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

반복

이름없는 함수는 정수 n와 정수 목록을 가져옵니다 l. 목록 의 정수 에 대해 0으로 나눈 후 나머지를 가진 자연수 (0을 더한 값)까지 포함 n하고 합 하지 않는 범위까지 트래킹 합니다 . 조건부 대신 곱셈을 사용하여 3 바이트를 절약합니다.sum(...)v%m<1anyml

옥타브, 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(2 회)를 사용하면 2 바이트가 절약됩니다.

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 적어도 하나 개의 값이 0 인 열을 위해, 그리고 false모든 값은 0이 아닌 곳 :

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

그만큼 ,1 숫자가 하나만있는 경우 필요합니다 y. 그렇지 않으면 숫자 단위가 아닌 전체 벡터에 작용합니다.

이것을 수직 행렬로 바꾸고 행렬 곱셈을 사용하면 명시 적 합산이 필요없이 올바른 답을 얻을 수 있습니다.

자바 스크립트 (ES6), 40 39 36 바이트

입력 : 카레 구문을 사용하는 정수 n및 정수 배열a(n)(a)

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

테스트 사례

let f =

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

console.log(f(50)([2]));        // 600
console.log(f(10)([3, 5]));     // 23
console.log(f(28)([4, 2]));     // 182
console.log(f(19)([7, 5]));     // 51
console.log(f(50)([2, 3, 5]));  // 857

MATL , 9 바이트

q:ti\~*us

온라인으로 사용해보십시오!

망막 , 34 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

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

입력 형식은

50
2,3,5

온라인으로 사용해보십시오!

파이썬, 67 바이트

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

이것을 작성한 후 내 코드가 기존 파이썬 답변과 비슷하다는 것을 알았지 만 독립적으로 생각해 냈고 어쨌든 게시하고 있습니다.

매스 매 티카, 37 27 바이트

바이트를 크게 절약 할 수있는 날카로운 관찰을 해준 Martin Ender에게 감사합니다!

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

Unnamed 함수 #는 정수 (원하는 제수 A) 목록 과 정수 ( #2상한 ) 목록 을 사용 하여 정수 N를 반환합니다. 리스트의 Range[#,#2-1,#]각 요소 d에 대해 작거나 같은 (따라서) #의 모든 배수를 제공합니다 . 그런 다음이 목록의 합집합을 계산하고와 합합니다 .d#-1#Tr

이전 버전:

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

펄 6 , 25 바이트

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

입력 숫자를 인수로 취하는 람다. (N에 대한 하나의 인수 및 A에 대한 임의의 수의 인수).

( 온라인으로 시도하십시오. )

설명:

• { ... }: 람다.
• $^a: 람다의 첫 번째 주장.
• @_: 람다의 나머지 인수 ( "variadic parameter").
• ^$^a:에서 0까지의 범위$^a - 1 입니다.
• * %% @_.any: 또 다른 람다 - 목록의 정션 에 대해 *나누기 연산자를 사용하여 인수 를 테스트 합니다.%%any@_ .
• grep PREDICATE, RANGE: 숫자 범위를 반복하고 술어가 참인 숫자를 리턴합니다.

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. 각각에 대해 stepsize 를 사용 a하여 시퀀스 a를 만듭니다 . 그런 다음 해당 벡터의 모든 고유 항목의 합계를 가져옵니다.N-1a

하스켈, 42 39 바이트

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

용법:

Main> 50![2,3,5]
857

3 바이트 동안 @Zgarb에게 감사합니다

05AB1E , 9 바이트

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

옥타브, 49 37 바이트

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

이 함수는 다음과 같이 호출됩니다 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)

행렬에 반복되는 요소가 있으므로 고유 한 값을 추출하여 합산합니다.

이전 답변 : (N == 1 인 경우이 솔루션은 실패합니다)

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

함수는 다음과 같이 호출되어야합니다 f(unit64([2 3 4]),uint64(50))

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

T-SQL, 87 바이트

이만큼 작동 @i2,048 이하의 값이

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)<@i

사용해보십시오

APL (Dyalog Unicode) , 12 바이트

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

온라인으로 사용해보십시오!

익명의 암묵적 기능. 3 바이트를 줄여주는 @ Adám에게 감사드립니다. 사용합니다 ⎕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

핍 , 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

파이썬 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

커먼 리스프, 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 바이트

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

온라인으로 사용해보십시오!

반복 솔루션. 입력을 숫자 $a와 리터럴 배열로 취합니다 $b. 연산자를 사용하여 1최대 1 개 (아래 $a를 통해 --$a) 반복Where-Object|?{...}절을 사용하여 특정 숫자를 선택 를 합니다.

이 절은 $i입력 배열 $b을 다른 배열 로 보내기 전에 현재 숫자로 설정 |?{...}합니다. 여기서 현재 숫자가의 숫자 중 하나 이상으로 균등하게 나누어지는 항목을 선택합니다 $b. $b균등하게 분할되는 요소 는 파이프 라인에 남아 있습니다.

따라서의 요소가 하나 이상 있으면 $b파이프 라인에 요소가 포함되므로 외부 요소 Where가 $true있고 현재 번호가 파이프 라인에 남아 있습니다. 그렇지 않으면 $b파이프 라인에 요소가 없으면 외부 Where는$false 이므로 현재 번호가 파이프 라인에 배치되지 않습니다.

이 숫자는 모두 괄호 안에 모여 표시 -join와 함께 모여 (와 짧게 및 유사)로 +파이프됩니다 . 합산 결과는 파이프 라인에 남아 있으며 출력은 암시 적입니다.|iexInvoke-Expressioneval

PHP, 78 76 74 바이트

for(;++$i<$argv[$f=$k=1];$s+=$i*!$f)for(;$v=$argv[++$k];)$f*=$i%$v;echo$s;

외부 루프가 실행되는 $i1 번째의 인수 이하로하고 추가 $i로 $s경우 $f되어 있지 세트.
내부 루프의 승산 $f(함께 $i모든 인수를위한 모듈로 인수)의 설정 $f에 0있다면$i 그 중 하나의 배수이다.

로 실행하십시오 -r.

스칼라, 47 바이트

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

n은 첫 번째 인수를 포함하는 List이고 N나머지는A

하나 이상의 A가 존재하지 않는 숫자를 걸러 내고 합산합니다. 엄밀히 말하면 우리는 n.tail.exists클로저 내부에서 사용해야 하지만, i는 항상 N보다 작으므로 N의 배수는 아니므로 솔루션은 여전히 ​​이것없이 완료됩니다.

자바 8, 75 바이트

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

이것에 대한 메소드 서명은 int f(int N, List<Integer> A)

루비, 52 48 46 바이트

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

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

동일한 폴더 에이 헤더 세트가 필요 하며 fnv-hash라이브러리에서도 찾을 수 있습니다. 컴파일gcc 1.c ../fnv-hash/libfnv.a -o 1 -DNODEBUG

테스트 프로그램 :

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

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

출력

23
23
23

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

s 속말 v2 , 178 바이트

> 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

온라인으로 사용해보십시오!

구조 트리 :

작동 원리

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 $\alpha$ denotes the set of numbers given as input:

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 $\alpha$ to $\beta$ according to the following rule:

where $\alpha_i$ denotes the $i$th element of $\alpha$, and the same for $\beta$. Finally, we can simply take the sum of $\beta$, as the $0$ elements do not affect the sum.

K (oK), 15 14 bytes

Solution:

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

Try it online!

Examples:

{+/&|/~y!\:!x}[50;,2]
600
{+/&|/~y!\:!x}[10;3 5]
23

Explanation:

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

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

Try it online!

Explanation:

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

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.