Presque équivalent à la première question du projet Euler:

Si nous listons tous les nombres naturels inférieurs à 10 qui sont des multiples de 3 ou 5, nous obtenons 3, 5, 6 et 9. La somme de ces multiples est 23.

Trouvez la somme de tous les multiples de 3 ou 5 en dessous de 1000.

Défi:

Étant donné un entier positif Net un ensemble d'au moins un entier positif A, sortez la somme de tous les entiers positifs inférieurs à ceux Nqui sont des multiples d'au moins un membre de A.

Par exemple, pour le cas Project Euler, l'entrée serait:

1000
3
5

Cas de test:

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

Gelée , 6 octets

ḍþṖḅTS

Essayez-le en ligne!

Comment ça marche

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

Python, 59 55 octets

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

repl.it

Fonction sans nom prenant un entier net une liste d'entiers l. Parcourt une plage de nombres naturels (plus zéro) jusqu'à mais non inclus net additionne ( sum(...)) ceux qui ont un reste après la division de zéro ( v%m<1) pour anyles entiers mde la liste l. Utilise la multiplication plutôt qu'une conditionnelle pour économiser 3 octets.

Octave, 38 36 33 octets

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

Prenez entrée comme: f(10, [3;5]). Ce serait 2 octets plus court si l'entrée pouvait être f(9,[3;5])pour le même cas de test.

Vérifiez tous les cas de test ici.

Explication:

@(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 peut pré-décrémenter, donc utiliser 1:--xau lieu de 1:x-1(deux fois) économise deux octets.

mod(a,b)donne 1 2 0 1 2 0 1 2 0pour mod(1:9,3). Si le deuxième argument est un vecteur vertical, il répliquera la première entrée verticalement et prendra le module pour chacune des valeurs du deuxième argument d'entrée. Donc, pour l'entrée, mod(1:9, [3;5])cela donne:

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

Prendre ~all(_,1)cela donne truepour les colonnes où au moins une valeur est zéro et falseoù toutes les valeurs sont non nulles:

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

Le ,1est nécessaire dans le cas où il n'y a qu'un seul numéro y. Sinon, il agirait sur le vecteur entier au lieu de numéro par numéro.

Transposer cela en une matrice verticale et utiliser la multiplication matricielle, nous donnera la bonne réponse, sans avoir besoin d'une sommation explicite:

JavaScript (ES6), 40 39 36 octets

Entrée: entier net tableau d'entiers aavec syntaxe de curry(n)(a)

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

Cas de test

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 octets

q:ti\~*us

Essayez-le en ligne!

Rétine , 34 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Le format d'entrée est

50
2,3,5

Essayez-le en ligne!

Python, 67 octets

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

Après avoir écrit ceci, j'ai remarqué que mon code était similaire à la réponse python existante, mais je l'ai trouvé indépendamment et je le poste quand même.

Mathematica, 37 27 octets

Merci à Martin Ender pour une observation astucieuse qui a permis de grosses économies d'octets!

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

Fonction sans nom prenant deux arguments, une liste #d'entiers (les diviseurs souhaités A) et un entier #2(la borne supérieure N), et renvoyant un entier. Range[#,#2-1,#]donne, pour chaque élément dde la liste #, tous les multiples dinférieurs ou égaux #-1(donc inférieurs à #); l'union de ces listes est ensuite calculée et additionnée deTr .

La version précédente:

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

Perl 6 , 25 octets

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

Un lambda qui prend les nombres en entrée comme arguments. (Un argument pour N et un nombre arbitraire d'arguments pour A).

( Essayez-le en ligne. )

Explication:

• { ... }: Un lambda.
• $^a: Premier argument de la lambda.
• @_: Arguments restants du lambda ("paramètre variadique").
• ^$^a: Plage de 0à $^a - 1.
• * %% @_.any: Un autre lambda, qui teste son argument en *utilisant l'opérateur divisible par %%une any- Jonction de la liste @_.
• grep PREDICATE, RANGE: itère la plage de nombres et retourne ceux pour lesquels le prédicat est vrai.

R, 67 octets

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

Prend un vecteur pour STDIN dans le format suivant: [N, a_1, a_2, ...] . Prend en charge n'importe quel nombre de a. Pour chaque a, crée la séquence aà N-1avec StepSize a. Prend ensuite la somme de toutes les entrées uniques de ce vecteur.

Haskell, 42 39 octets

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

Usage:

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

Merci à @Zgarb pour 3 octets

05AB1E , 9 octets

FND²%P_*O

Essayez-le en ligne!

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

Octave, 49 37 octets

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

la fonction sera appelée comme f([2 3 4],50)

Supposons que A=[2 3 4];nous ayons besoin d'avoir une somme de nombres

sum(
2,4,6...,50-1 ,
3,6,9...,50-1,
4,8,12,...50-1)

nous pouvons multiplier [2 3 4]par 1:50pour obtenir la matrice(1:N)'.*A

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

puis extrayez de la matrice celles qui sont inférieures à 50: z(z<N)

Puisqu'il y a des éléments répétés dans la matrice, nous extrayons des valeurs uniques et les additionnons.

réponse précédente : (cette solution échouera si N == 1)

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

la fonction doit être appelée comme f(unit64([2 3 4]),uint64(50))

Pyth, 10 octets

s{sm:0hQdt

Explication

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 octets

Cela fonctionnera tant qu'il @ia une valeur de 2048 ou moins

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

Essaye le

APL (Dyalog Unicode) , 12 octets

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

Essayez-le en ligne!

Fonction tacite anonyme. Merci à @ Adám de m'avoir aidé à en raser 3 octets. Les usages⎕IO←0 .

Comment:

+/⊢∘⍳∩∘∊×∘⍳¨ ⍝ 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 octets

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

Essayez-le en ligne!

Explication:

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

Python 2, 80 octets

C'est très long. Peut certainement être raccourci. Prendre les 3 nombres comme entrées séparées nuit définitivement au score.

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

Lisp commun, 77

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

Ungolfed

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

PowerShell , 57 octets

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

Essayez-le en ligne!

Solution itérative. Prend l'entrée sous forme de nombre $aet de tableau littéral $b. Boucles allant 1jusqu'à une en dessous $a(via --$a), à l'aide d'un Where-Objectopérateur|?{...} avec une clause pour sélectionner certains nombres.

La clause définit $ile nombre actuel avant d'envoyer le tableau d'entrée $bdans un autre |?{...}, en sélectionnant ici les éléments où le nombre actuel est divisé également par au moins l'un des nombres de$b . Ces éléments $bqui se divisent également sont laissés sur le pipeline.

Ainsi, s'il y a au moins un élément de $b, le pipeline contient un élément, donc l'extérieur Whereest $trueet le numéro actuel est laissé sur le pipeline. Sinon, sans aucun élément du $bpipeline, l'extérieur l' Whereest $false, donc le numéro actuel n'est pas placé sur le pipeline.

Ces nombres sont tous rassemblés en parens, édités -joinavec des +signes, et canalisés vers |iex(abréviation de Invoke-Expressionet similaire à eval). Le résultat de la somme est laissé sur le pipeline et la sortie est implicite.

PHP, 78 76 74 octets

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

La boucle externe s'étend $ide 1 au-dessous du premier argument et s'ajoute $ià $sif $fn'est pas défini.
La boucle interne se multiplie $fpar ( $iargument modulo) pour tous les arguments suivants, définissant $fsur 0if$i est le multiple de l' un d'eux.

Courez avec -r.

Scala, 47 octets

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

n est une liste qui contient un premier argument N, les autres sont des éléments deA

Fonctionne en filtrant les nombres là où il n'existe pas au moins un A dont i est un multiple, puis en additionnant. À strictement parler, nous devrions utiliser n.tail.existsà l'intérieur de la fermeture, mais comme i est toujours inférieur à N et donc jamais un multiple de N, la solution est toujours complète sans cela.

Java 8, 75 octets

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

La signature de méthode pour cela est int f(int N, List<Integer> A)

Rubis, 52 48 46 octets

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

C11, 177 octets

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

Nécessite cet ensemble d'en-têtes dans le même dossier et la fnv-hashbibliothèque qui s'y trouve également. Compiler commegcc 1.c ../fnv-hash/libfnv.a -o 1 -DNODEBUG

Programme de test:

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

les sorties

23
23
23

Japt -x, 9 7 6 octets

Ç*VøZâ

L'essayer

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

> 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

Essayez-le en ligne!

Arbre de structure:

Comment ça marche

Très simplement, nous mettons chaque nombre (les lignes avec Eachdessus) à travers une série de fonctions (les lignes avec Ldessus), puis, en nous basant sur les résultats de ces fonctions, nous éliminons certains nombres et gardons le reste, avant de finalement les additionner . En fait, nous pouvons définir ces fonctions, où$\alpha$ désigne l'ensemble des nombres donnés en entrée:

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.