Najmniejszą wspólną wielokrotnością (LCM) zbioru liczb Ajest najmniejsza liczba całkowita btaka, która b/ajest liczbą całkowitą dla wszystkich liczb całkowitych aw A. Definicję tę można rozszerzyć na liczby wymierne!

Zadanie

Znajdź najmniejsze pozytywne wymierne, b takie b/ajak liczba całkowita dla wszystkich wymiernych a danych wejściowych.

Zasady

• Standardowe luki są zabronione.
• Możesz wprowadzić liczniki i mianowniki osobno na wejściu, ale nie możesz brać liczb podwójnych, liczb zmiennoprzecinkowych itp.
• Dane wejściowe mogą nie zostać w pełni zmniejszone.
• Możesz przyjmować liczby całkowite jako racjonalne o mianowniku 1.
• Zgłoszenia, które podawałyby racjonalne liczby do wbudowanego LCM / GCD są dozwolone, ale nie konkurują.

Przypadki testowe

In:  3
Out: 3

In:  1/17
Out: 1/17

In:  1/2, 3/4
Out: 3/2

In:  1/3, 2/8
Out: 1

In:  1/4, 3
Out: 3

In:  2/5, 3
Out: 6

In:  1/2, 3/4, 5/6, 7/8
Out: 105/2

To jest golf golfowy , więc wygrane są przy użyciu najmniejszej ilości bajtów!

Galaretka , 19 bajtów

g/:@$€Z©Ḣæl/;®Ḣg/$¤

Wypróbuj online!

J, 3 bajty, niekonkurujące.

*./

Biorąc pod uwagę listę racjonalnych danych wejściowych, składa się ona przez LCM.

sed, 374 (373 + 1) bajtów

^{-EFlaga sed liczy się jako jeden bajt. Uwaga: jeszcze nie próbowałem grać w golfa i zapewne nie zrobię tego przez dłuższy czas.}
Dane wejściowe przyjmowane są w jednostkowej, a dane wyjściowe w jednostkowej. Przestrzenie muszą otaczać każdą frakcję. Przykład: echo " 1/111 111/11111 111111/111 ".

:d;s, (1*)/\1(1*), \1/\22,;s,(1*)(1*)/\2 ,2\1/\2 ,;td;s,1*(1/22*),\1,g;s,(22*/1)1*,\1,g;:r;s,((1*)/1*)2,\1\2,;s,2(1*/(1*)),\2\1,;tr;h;s,1*/,,g;:g;s/^(1*) 1(1*) 1(1*)/1\1 \2 \3/;tg;s/  */ /g;s/^/ /;/1 1/bg;x;s,/1*,,g;s/^( 1*)( 1*)/\1\2\2/;:l;s/^(1*) (1*) \2(1*)/\1\2 \2 \3/;tl;/  $/be;/  /{s/^(1*) 1*  1*( 1*)/ \1\2\2/;bl};s/^(1* 1* )(1*) (1*)/\1\2\3 \3/;bl;:e;G;s, *\n *,/,

Wypróbuj online!

Python 2 , 65 bajtów (niekonkurencyjny)

lambda x:reduce(lambda x,y:x*y/gcd(x,y),x)
from fractions import*

Wypróbuj online!

JavaScript (ES6), 85 bajtów

a=>a.reduce(([b,c],[d,e,g=(b,c)=>c?g(c,b%c):b,h=g(b*e,c*d),i=g(b*d,h)])=>[b*d/i,h/i])

Nie szukaj wbudowanych! Bez wątpienia ktoś pokona to, stosując podejście rekurencyjne lub coś takiego.

Pari / GP , 3 bajty, niekonkurujące

lcm

Wypróbuj online!

Perl 6 ,  46  42 bajtów

{[lcm](@_».numerator)/[gcd] @_».denominator}

Sprawdź to

{[lcm](($/=@_».nude)[*;0])/[gcd] $/[*;1]}

Sprawdź to

Dane wejściowe to lista liczb wymiernych .

Rozszerzony:

{ # bare block lambda with implicit parameter list ｢@_｣

  [lcm](            # reduce using &infix:<lcm>
    (
      $/ = @_».nude # store in ｢$/｣ a list of the NUmerators and DEnominiators
                    # ((1,2), (3,4))

    )[
      *;            # from all of the first level ｢*｣,
      0             # but only the 0th of the second level (numerators)
    ]
  )
  /
  [gcd] $/[ *; 1 ]  # gcd of the denominators
}

Siatkówka , 117 bajtów

\d+
$*
\b(1+)(\1)*/(\1)+\b
$#2$*11/$#3$*
{`^((1+)\2*)/(1+)+ (\2)+/\3+\b
$1 $#4$*1/$3
}`\G1(?=1* (1+))|\G 1+
$1
1+
$.&

Wypróbuj online! Pobiera dane wejściowe jako serię niepoprawnych ułamków oddzielonych spacją (bez liczb całkowitych lub liczb mieszanych). Wyjaśnienie:

\d+
$*

Konwertuje liczbę dziesiętną na jedność.

\b(1+)(\1)*/(\1)+\b
$#2$*11/$#3$*

To zmniejsza każdą frakcję do najniższych warunków. Grupa przechwytywania 1 reprezentuje GCD licznika i mianownika, dlatego liczymy liczbę przechwyceń przed i po /. \b(1+)+/(\1)+\bz jakiegoś powodu nie wydaje się poprawnie zliczać liczby przechwytywania, więc używam dodatkowej grupy przechwytywania i dodaję 1 do wyniku.

{`^((1+)\2*)/(1+)+ (\2)+/\3+\b
$1 $#4$*1/$3

Robi to wiele rzeczy. Grupa przechwytywania 2 reprezentuje GCD liczników pierwszych dwóch frakcji, podczas gdy grupa przechwytywania 3 reprezentuje GCD mianowników. $#4jest zatem drugim licznikiem podzielonym przez ich GCD. (Ponownie nie mogłem liczby przechwyceń pierwszego licznika, ale muszę tylko podzielić jeden licznik przez ich GCD, więc nie kosztuje mnie to tak dużo.)

}`\G1(?=1* (1+))|\G 1+
$1

Teraz, gdy drugi licznik został podzielony przez ich GCD, po prostu używamy tego wyrażenia z jednorzędnego samouczka arytmetycznego, aby pomnożyć je razem, co daje LCM. Następnie powtarzamy ćwiczenie dla pozostałych ułamków.

1+
$.&

Konwertuje unary z powrotem na dziesiętne.

Common Lisp, 154 bajty

(defun f(l &aux(s(pairlis l l)))(loop(and(eval`(=,@(mapcar'car s)))(return(caar s)))(let((x(assoc(reduce'min s :key'car)s)))(rplaca x(+(car x)(cdr x))))))

Używany algorytm (określony dla liczb całkowitych, ale działa również dla wymiernych).

Najpierw utwórz ze sobą asocjatywną listę danych wejściowych, aby śledzić początkowe wartości elementów, tak aby kolejność operacji była określona przez „samochód” z listy.

(defun f(l &aux (s (pairlis l l)))        ; make the associative list
  (loop
     (when (eval `(= ,@(mapcar 'car s))) ; when the car are all equal
       (return (caar s)))                 ; exit with the first one
     (let ((x (assoc (reduce 'min s :key 'car) s))) ; find the (first) least element
       (rplaca x (+ (car x) (cdr x))))))  ; replace its car adding the original value (cdr)

Przypadki testowe:

CL-USER> (f '(3))
3
CL-USER> (f '(1/17))
1/17
CL-USER> (f '(1/2 3/4))
3/2
CL-USER> (f '(1/3 2/8))
1
CL-USER> (f '(1/4 3))
3
CL-USER> (f '(2/5 3))
6
CL-USER> (f '(1/2 3/4 5/6 7/8))
105/2

Uwaga: Rozwiązanie nie wymaga budowania lcmi gcdakceptuje liczby całkowite.

Mathematica, 3 bajty, niekonkurujące

LCM

Wbudowana LCMfunkcja Mathematica jest w stanie obsłużyć dane racjonalne.

PHP , 194 bajty

<?for(list($n,$d)=$_GET,$p=array_product($d);$x=$n[+$k];)$r[]=$x*$p/$d[+$k++];for($l=1;$l&&++$i;$l=!$l)foreach($r as$v)$l*=$i%$v<1;for($t=1+$i;$p%--$t||$i%$t;);echo$p/$t>1?$i/$t."/".$p/$t:$i/$t;

-4 Bajty z PHP> = 7.1 [$n,$d]=$_GETzamiastlist($n,$d)=$_GET

Wypróbuj online!

Common Lisp, 87 78 bajtów

Za pomocą lcmi gcd, które mają liczby całkowite:

(defun l(a)(/(apply #'lcm(mapcar #'numerator a))(apply #'gcd(mapcar #'denominator a))))

Więcej golfa:

(defun l(a)(eval`(/(lcm,@(mapcar'numerator a))(gcd,@(mapcar'denominator a))))