Le plus petit multiple commun d'un ensemble d'entiers positifs Aest le plus petit entier positif Btel que, pour chaque kentrée A, il existe un entier positif ntel que k*n = B.

Étant donné au moins deux entiers positifs en entrée, sortez leur multiple le moins commun.

Règles

• Les prédéfinitions sont autorisées, mais si votre solution en utilise une, vous êtes encouragé à inclure une autre solution qui n'utilise pas les prédéfinitions GCD / LCM. Cependant, la solution alternative ne comptera pas du tout dans votre score, elle est donc entièrement facultative.
• Toutes les entrées et sorties seront dans la plage représentable en natif pour votre langue. Si votre langage est nativement capable d'entiers arbitrairement grands, alors votre solution doit fonctionner avec des entrées et des sorties arbitrairement grandes.

Cas de test

[7, 2] -> 14
[8, 1] -> 8
[6, 4, 8] -> 24
[8, 2, 1, 10] -> 40
[9, 6, 2, 1, 5] -> 90
[5, 5, 7, 1, 1] -> 35
[4, 13, 8, 8, 11, 1] -> 1144
[7, 2, 2, 11, 11, 8, 5] -> 3080
[1, 6, 10, 3, 4, 10, 7] -> 420
[5, 2, 9, 10, 3, 4, 4, 4, 7] -> 1260
[9, 7, 10, 9, 7, 8, 5, 10, 1] -> 2520

En fait, 12 1 octet

Les suggestions de golf sont toujours les bienvenues, mais je ne sais pas comment améliorer le LCM brut intégré. Essayez-le en ligne!

▲

Une version 12 octets sans le intégré. Les suggestions de golf sont les bienvenues. Essayez-le en ligne!

╗2`╜@♀%ΣY`╓N

Ungolfing

          Implicit input array.
╗         Save array in register 0.
2`...`╓   Starting with f(0), find the first (two) x where f(x) returns a truthy value.
          These two values will be 0 and our LCM.
  ╜         Push array from register 0.
  @         Swap the top two values. Stack: x, array
  ♀%        Map % over x and array, returning (x % item) for each item in array.
  ΣY        If the sum of all the modulos equals 0, x is either 0 or our LCM.

N         Push the last (second) value of our results. This is our LCM.
          Implicit return.

JavaScript (ES6), 36 octets

f=(a,i=1)=>a.some(v=>i%v)?f(a,i+1):i

À partir de 1c'est le premier nombre qui peut être divisé par tous.

f=(a,i=1)=>a.some(v=>i%v)?f(a,i+1):i
;

console.log(f([7, 2]));
console.log(f([8, 1]));
console.log(f([6, 4, 8]));
console.log(f([8, 2, 1, 10]));
console.log(f([9, 6, 2, 1, 5]));
console.log(f([5, 5, 7, 1, 1]));
console.log(f([4, 13, 8, 8, 11, 1]));
console.log(f([7, 2, 2, 11, 11, 8, 5]));
console.log(f([1, 6, 10, 3, 4, 10, 7]));
console.log(f([5, 2, 9, 10, 3, 4, 4, 4, 7]));
console.log(f([9, 7, 10, 9, 7, 8, 5, 10, 1]));

05AB1E / 2sable , 2 octets

.¿

Essayez-le en ligne! en 05AB1E
ou 2sable

Gelée , 3 octets

æl/

Réduit de LCM. Essayez-le en ligne! ou vérifier tous les cas de test .

Version alternative, 6 octets

ÆE»/ÆẸ

Essayez-le en ligne! ou vérifier tous les cas de test .

Comment ça marche

ÆE»/ÆẸ  Main link. Argument: A (array)

ÆE      Yield all prime exponents of each integer in A.
  »/    Reduce columns (exponents that correspond to the same prime) by maximum.
    ÆẸ  Turn the resulting array of prime exponents into the corresponding integer.

Python, 69 65 52 50 octets

A=lambda l,i=1:any(i%a for a in l)and A(l,i+1)or i

2 octets économisés grâce à Dennis!

Solution récursive assez simple, vous devrez augmenter la limite de récursivité pour que certains cas de test fonctionnent.

MATL , 7 octets

&YFX>^p

Pas intégré.

Essayez-le en ligne!

Explication

Prenons l' [8, 2, 1, 10]exemple de la saisie .

&YF    % Take array implicitly. Push vector of prime factors and matrix of exponents 
       % of factorization, where each row represents one of the input numbers
       %   STACK: [2 3 5], [3 0 0; 1 0 0; 0 0 0; 1 0 1]
X>     % Maximum of each column
       %   STACK: [2 3 5], [3 0 1]
^      % Element-wise power
       %   STACK: [8 1 5]
p      % Product of array
       %   STACK: 40
       % Implicitly display

EDIT (9 juin 2017): YFavec deux sorties a été modifié dans la version 20.1.0 : les nombres premiers non facteurs et leurs exposants (zéro) sont ignorés. Cela n'affecte pas le code ci-dessus, qui fonctionne sans nécessiter de modifications.

Julia (3 octets) [Travailler sur non intégré]

lcm     # Using LCM built-in (3 Bytes)

Comme l'a souligné Dennis, j'oublie toujours que Julia vectorise automatiquement les entrées.

Exemple:

println(lcm(1,2,3,4,5,6,7,8,9)) #Prints 2520

PowerShell v2 +, 73 60 octets

param($a)for($i=1;($a|?{!($i%$_)}).count-ne$a.count){$i++}$i

Prend l'entrée $a, boucle vers le haut à partir de $i=1avec $i++, en fonction d'un conditionnel. La condition est ($a|?{!($i%$_)}).countétant -not equal à $a.count. Cela signifie que la boucle se termine lorsque les éléments $aqui sont des diviseurs de $isont égaux aux éléments de $a. Ensuite, un solitaire $iest laissé sur le pipeline et la sortie est implicite.

Cas de test

PS C:\Tools\Scripts\golfing> @(7,2),@(8,1),@(6,4,8),@(8,2,1,10),@(9,6,2,1,5),@(5,5,7,1,1),@(4,13,8,8,11,1)|%{($_-join',')+" -> "+(.\least-common-multiple.ps1 $_)}
7,2 -> 14
8,1 -> 8
6,4,8 -> 24
8,2,1,10 -> 40
9,6,2,1,5 -> 90
5,5,7,1,1 -> 35
4,13,8,8,11,1 -> 1144

PS C:\Tools\Scripts\golfing> @(7,2,2,11,11,8,5),@(1,6,10,3,4,10,7),@(5,2,9,10,3,4,4,4,7),@(9,7,10,9,7,8,5,10,1)|%{($_-join',')+" -> "+(.\least-common-multiple.ps1 $_)}
7,2,2,11,11,8,5 -> 3080
1,6,10,3,4,10,7 -> 420
5,2,9,10,3,4,4,4,7 -> 1260
9,7,10,9,7,8,5,10,1 -> 2520

Mathematica, 3 octets

LCM

Usage:

In[1]:= LCM[9, 7, 10, 9, 7, 8, 5, 10, 1]                                        

Out[1]= 2520

Cheddar, 33 octets

(n,i=1)f->n.any(i&(%))?f(n,i+1):i

Rien de super nouveau.

Ungolfed

(n, i = 1) f ->
  n.any(j -> i % j) ?
    f(n, i + 1) :
    i

Fondamentalement, cela commence à un et continue d'augmenter jusqu'à ce qu'il trouve un LCM

JavaScript (ES6), 63 59 octets

f=([x,...a])=>a[0]?x*f(a)/(g=(m,n)=>n?g(n,m%n):m)(x,f(a)):x

Trouve récursivement le LCM des deux derniers éléments.

Dyalog APL, 2 octets

∧/

Réduit de LCM. Testez-le sur TryAPL .

JavaScript (ES6), 52 octets

a=>a.reduce((l,n)=>l*n/(g=(m,n)=>n?g(n,m%n):m)(l,n))

J'ai reduceautant répondu que possible à cette réponse, mais je ne vais évidemment pas me rapprocher de la simplicité de la réponse de @ Hedi.

Java 8, 75 59 121 89 octets

Utilise l'algorithme euclidien et le fait que LCM (A, B) = A * B / GCD (A, B)

• 16 octets éteints. Merci à @carusocomputing
• Ajout de plusieurs entrées + 62 octets
• 32 octets éteints. Merci à @Olivier Grégoire

Code:

public static int lcm(int l, int c){
  for(int i=1;i<=l&&i<=c;++i) 
    if (i%l==0&&i%c==0)
      return l*c/i;
}
public static int lcm(int...x){
  int y=x[0];
  for(int j:x){
    y=lcm(j,y);
  }
  return y;
}

Supprimer les sauts de ligne:

int g(int a,int b){return b<1?a:g(b,a%b);}

l->{int l=1;for(int n:a)l=l*n/g(l,n);return l;}

MATL , 3 octets

&Zm

Cela utilise la fonction intégrée avec entrée de tableau.

Essayez-le en ligne!

Brachylog , 17 octets

,.#>=g:?z:%a#=h0,

Essayez-le en ligne!

Explication

,.#>=               Output is a strictly positive integer
     g:?z           Zip the Output with the Input
         :%a        Compute Output mod I for each I in the Input
            #=h0,   All results must be equal to 0

Perl 6 , 10 octets

{[lcm] @_}

essentiellement le même que:

sub ( *@_ ) { @_.reduce: &infix:< lcm > }

J, 11 octets

>./&.(_&q:)

Il existe une solution pour 3 octets utilisant le LCM intégré.

*./

Explication

>./&.(_&q:)  Input: array of integers A
      _&q:   Get the prime exponents of each integer in A
>./&         Reduce by maximum on the lists
   &. _&q:   Convert the list of exponents back to an integer

*./  Input: array of integers A
  /  Reduce using
*.     LCM

CJam, 18 17 16 octets

1 octet économisé grâce à Martin Ender.

Incrémentation jusqu'à ce que le LCM soit trouvé.

q~0{)_2$f%:+}g\;

Essayez-le en ligne

Raquette 13 octets

lcm est une fonction intégrée dans Racket:

(apply lcm l)

Essai:

(define (f l)
   (apply lcm l))

(f (list 7 2)) 
(f (list 8 1)) 
(f (list 6 4 8)) 
(f (list 8 2 1 10)) 
(f (list 9 6 2 1 5))
(f (list 5 5 7 1 1)) 
(f (list 4 13 8 8 11 1))
(f (list 7 2 2 11 11 8 5))
(f (list 1 6 10 3 4 10 7))
(f (list 5 2 9 10 3 4 4 4 7)) 
(f (list 9 7 10 9 7 8 5 10 1))

Sortie:

14
8
24
40
90
35
1144
3080
420
1260
2520

R, 36 octets (non intégré)

v=scan();i=1;while(any(i%%v))i=i+1;i

Prend l'entrée. Teste ensuite chaque entier positif en prenant le mod.

Pyth, 9 octets

.U/*bZibZ

Un programme qui prend l'entrée d'une liste sur STDIN et imprime le résultat.

Essayez-le en ligne ou vérifiez tous les cas de test

Comment ça marche

.U/*bZibZ  Program. Input: Q
.U         Reduce Q by (implicit input fill):
   *bZ      Product of current and next value
  /   ibZ   divided by GCD of current and next value
           Implicitly print

Haskell, 10 octets

foldr1 lcm

Exemple d'utilisation: foldl1 lcm [5,2,9,10,3,4,4,4,7]-> 1260.

C #, 50 + 18 = 68 octets

50 octets pour la définition de méthode, +18 octets pour l'importation LINQ.

using System.Linq;int L(int[]n,int i=1)=>n.All(x=>1>i%x)?i:L(n,i+1);

À peu près la même chose que beaucoup d'autres réponses. Compte de manière récursive jusqu'à ce qu'il trouve le LCM. J'ai été un peu surpris que cela n'ait pas eu d'exception StackOverflowException, j'ai donc également une version non récursive qui n'est en fait que d'un octet de plus.

using System.Linq;n=>{for(int i=1;;i++)if(n.All(x=>1>i%x))return i;};

Ungolfed:

using System.Linq;            // Import LINQ
int L(int[] n, int i = 1) =>  // Function declaration
    n.All(x => 1 > i % x)     // Check if each x in n divides i
        ? i                   // And if so return i
        : L(n, i + 1)         // Otherwise increment i and recurse
;

Pip , 10 octets

W$+o%g++oo

Utilise la stratégie "essayer chaque numéro jusqu'à ce que l'on fonctionne". Essayez-le en ligne!

            o is preinitialized to 1, g is list of cmdline args
   o%g      Mod o by each arg
 $+         Sum (truthy if any nonzero, falsy if all zero)
W           Loop while that expression is truthy:
      ++o     Increment o
         o  Autoprint o

PHP, 42 74 octets

for(;($p=++$f*$argv[1])%$argv[2];);echo$p;

simple:
boucle $fde 1 vers le haut; si $f*$adivise $bsans reste, le LCM est trouvé.

J'avais totalement dépassé le at least... voici le code pour un certain nombre de paramètres:

for(;$i<$argc;)for($p=$argv[$i=1]*++$f;++$i<$argc&$p%$argv[$i]<1;);echo$p;

Boucle $fde 1 vers le haut alors que la boucle intérieure n'a pas fonctionné sur $ argc.
Boucle $ide 2à $argc-1tandis que se $f*$argv[1]divise $argv[$i]sans reste.
les deux boucles cassées: impression $f*$argument 1.

Prolog (SWI) , 46 octets

l([],1).
l([X|Y],P):-l(Y,Q),P is X*Q/gcd(X,Q).

Essayez-le en ligne!

Une autre solution, 59 octets:

l(A,X):-between(1,inf,X),forall(member(Y,A),X mod Y=:=0),!.

Python 3, 83 octets

import math,functools as i
t=lambda t:i.reduce(lambda a,b:int(a*b/math.gcd(a,b)),t)

Brachylog v2, 8 octets

{×↙Xℕ₁}ᵛ

Essayez-le en ligne!

C'est drôle à quel point cela correspond directement à la définition donnée dans le défi.

{     }ᵛ    Each element of
            the input
 ×          multiplied by
  ↙X        some arbitrary and inconsistent integer
    ℕ₁      is a natural number,
       ᵛ    which is the same for each element,
            and is the output.

Une solution étrangement lente mais nettement plus courte:

Brachylog v2, 5 octets

f⊇p~d

Essayez-le en ligne!

Prend l'entrée via la variable de sortie et donne la sortie via la variable d'entrée. Déchire les quatre premiers cas de test, mais j'attends toujours le cinquième ... Habituellement, j'en ferais toujours ma solution principale et j'espère simplement que cela fonctionne correctement, mais je ne sais pas pourquoi il ne l'a pas a confirmé que 90 est le LCM 9, 6, 2, 1, 5lorsque je lui ai donné 90 il y a vingt minutes.

(Edit: Il a confirmé la réponse après pas plus de 16 heures, et l'a généré aux côtés du LCM 5, 5, 7, 1, 1après environ deux jours.)

         The output variable
   ~d    with duplicates removed
  p      is a permutation of
 ⊇       a sublist of
f        the factors of
         the input variable.

Et un autre prédicat complètement différent qui traduit accidentellement plus ou moins la solution Brachylog v1 de Fatalize:

Brachylog v2, 10 octets

;.gᵗ↔z%ᵛ0<

Essayez-le en ligne!

Cela a été récupéré d'une solution que j'avais faite pour ce défi avant de réaliser que la sortie n'était pas limitée à un entier.

 .            The output
; gᵗ↔z        paired with each element of
              the input,
      %ᵛ      when the first element of each pair is taken mod the second, is always
        0     zero.
              Furthermore, the output
         <    is strictly greater than
        0     zero.

Pyth - 7 6 octets

Pas intégré.

*F{sPM

Essayez-le en ligne ici .