Il multiplo meno comune di un insieme di numeri interi positivi Aè il numero intero postivo più piccolo in modo Btale che, per ogni kin A, esiste un numero intero positivo ntale che k*n = B.

Dati almeno due numeri interi positivi come input, producono il loro multiplo meno comune.

Regole

• I builtin sono consentiti, ma se la soluzione ne utilizza uno, si consiglia di includere una soluzione alternativa che non utilizza i builtin GCD / LCM. Tuttavia, la soluzione alternativa non verrà considerata per il tuo punteggio, quindi è del tutto facoltativa.
• Tutti gli ingressi e le uscite rientreranno nell'intervallo rappresentabile in modo nativo per la tua lingua. Se la tua lingua è nativamente in grado di numeri interi arbitrariamente grandi, la tua soluzione deve funzionare con input e output arbitrariamente grandi.

Casi 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

In realtà, 12 1 byte

I suggerimenti sul golf sono ancora ben accetti, anche se non sono sicuro di come migliorare il sistema LCM grezzo incorporato. Provalo online!

▲

Una versione a 12 byte senza built-in. Suggerimenti di golf benvenuti. Provalo online!

╗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 byte

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

A partire da 1è il primo numero che può essere diviso per tutti.

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 byte

.¿

Provalo online! in 05AB1E
o 2sable

Jelly , 3 byte

æl/

Riduce di LCM. Provalo online! o verifica tutti i casi di test .

Versione alternativa, 6 byte

ÆE»/ÆẸ

Provalo online!o verifica tutti i casi di test .

Come funziona

Æ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 byte

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

2 byte salvati grazie a Dennis!

Soluzione ricorsiva piuttosto semplice, sarà necessario aumentare leggermente il limite di ricorsione per far funzionare alcuni dei casi di test.

MATL , 7 byte

&YFX>^p

Nessun built-in.

Provalo online!

Spiegazione

Prendiamo l'input [8, 2, 1, 10]come esempio.

&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 giugno 2017): YFcon due uscite è stato modificato nella versione 20.1.0 : i numeri primi non fattoriali e i loro (zero) esponenti vengono saltati. Ciò non influisce sul codice sopra, che funziona senza richiedere alcuna modifica.

Julia (3 byte) [lavorando su non incorporato]

lcm     # Using LCM built-in (3 Bytes)

Come ha sottolineato Dennis, continuo a dimenticare che Julia vettorializza automaticamente gli input.

Esempio:

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

PowerShell v2 +, 73 60 byte

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

Accetta input $a, scorre verso l'alto da $i=1con $i++, in base a un condizionale. La condizione è ($a|?{!($i%$_)}).countessendo -not equal a $a.count. Significato, il ciclo termina quando gli elementi di $ache sono divisori di $iè uguale agli elementi di $a. Quindi, un solitario $iviene lasciato sulla tubazione e l'output è implicito.

Casi 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 byte

LCM

Uso:

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

Out[1]= 2520

Cheddar, 33 byte

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

Niente di nuovo.

Ungolfed

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

Fondamentalmente questo inizia da uno e continua ad aumentare fino a quando non trova un LCM

JavaScript (ES6), 63 59 byte

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

Trova ricorsivamente l'LCM degli ultimi due elementi.

Dyalog APL, 2 byte

∧/

Riduce di LCM. Provalo su TryAPL .

JavaScript (ES6), 52 byte

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

I reduced questa risposta tanto quanto ho potuto, ma io non sono, ovviamente, sta per arrivare da nessuna parte vicino la semplicità di @ risposta di Hedi.

Java 8, 75 59 121 89 byte

Utilizza l'algoritmo euclideo e il fatto che LCM (A, B) = A * B / GCD (A, B)

• 16 byte di sconto. Grazie a @carusocomputing
• Aggiunto multi-input + 62 byte
• 32 byte di sconto. Grazie a @Olivier Grégoire

Codice:

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

Rimuovi interruzioni di riga:

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 byte

&Zm

Questo utilizza la funzione integrata con input di array.

Provalo online!

Brachylog , 17 byte

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

Provalo online!

Spiegazione

,.#>=               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 byte

{[lcm] @_}

sostanzialmente uguale a:

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

J, 11 byte

>./&.(_&q:)

Esiste una soluzione per 3 byte utilizzando l' integrato LCM.

*./

Spiegazione

>./&.(_&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 byte

1 byte salvato grazie a Martin Ender.

Incrementare fino a quando non viene trovata la LCM.

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

Provalo online

Racchetta 13 byte

mcm è una funzione integrata nella racchetta:

(apply lcm l)

test:

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

Produzione:

14
8
24
40
90
35
1144
3080
420
1260
2520

R, 36 byte (non incorporato)

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

Accetta l'input. Quindi testa ogni intero positivo prendendo il mod.

Pyth, 9 byte

.U/*bZibZ

Un programma che accetta l'inserimento di un elenco su STDIN e stampa il risultato.

Provalo online o verifica tutti i casi di test

Come funziona

.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 byte

foldr1 lcm

Esempio di utilizzo: foldl1 lcm [5,2,9,10,3,4,4,4,7]-> 1260.

C #, 50 + 18 = 68 byte

50 byte per la definizione del metodo, +18 byte per l'importazione LINQ.

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

Praticamente uguale a molte altre risposte. Conta ricorsivamente fino a quando non trova l'LCM. Sono rimasto un po 'sorpreso dal fatto che non ho ricevuto StackOverflowException, quindi ho anche una versione non ricorsiva che in realtà è solo 1 byte più lunga.

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 byte

W$+o%g++oo

Utilizza la strategia "prova ogni numero fino a quando non funziona". Provalo online!

            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 byte

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

dritto:
loop $fda 1 in su; se si $f*$adivide $bsenza resto, viene trovato il LCM.

Avevo totalmente letto il at least... ecco il codice per qualsiasi numero di parametri:

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

Ripeti $fda 1 in su mentre il ciclo interno non è stato eseguito a $ argc.
Ripeti $ida 2a $argc-1mentre si $f*$argv[1]divide $argv[$i]senza resto.
entrambi i loop sono rotti: stampa $f*$argument 1.

Prolog (SWI) , 46 byte

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

Provalo online!

Un'altra soluzione, 59 byte:

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

Python 3, 83 byte

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

Brachylog v2, 8 byte

{×↙Xℕ₁}ᵛ

Provalo online!

È divertente quanto direttamente si associ alla definizione fornita nella sfida.

{     }ᵛ    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.

Una soluzione sospettosamente lenta ma significativamente più breve:

Brachylog v2, 5 byte

f⊇p~d

Provalo online!

Riceve input attraverso la variabile di output e fornisce output attraverso la variabile di input. Passa attraverso i primi quattro casi di test, ma sto ancora aspettando il quinto ... Di solito, lo farei ancora la mia soluzione principale e confido che funzioni correttamente, ma non so perché non ha ha confermato che 90 è il LCM di 9, 6, 2, 1, 5quando l'ho dato 90 venti minuti fa.

(Modifica: ha confermato la risposta dopo non più di 16 ore e l'ha generata a fianco dell'LCM 5, 5, 7, 1, 1dopo circa due giorni.)

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

E un altro predicato completamente diverso che accidentalmente più o meno traduce la soluzione Brachylog v1 di Fatalize:

Brachylog v2, 10 byte

;.gᵗ↔z%ᵛ0<

Provalo online!

This was salvaged from a solution I'd made for this challenge before I realized the output wasn't restricted to being an integer.

 .            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 bytes

No builtin.

*F{sPM

Try it online here.