Bội số chung Anhỏ nhất (LCM) của một tập hợp số là số nguyên nhỏ nhất bsao cho b/alà số nguyên cho tất cả các số nguyên atrong A. Định nghĩa này có thể được mở rộng đến số hữu tỷ!

Bài tập

Tìm nhỏ tích cực hợp lý b như vậy b/alà một số nguyên cho tất cả rationals a trong đầu vào.

Quy tắc

• Sơ hở tiêu chuẩn bị cấm.
• Bạn có thể lấy tử số và mẫu số riêng biệt trong đầu vào, nhưng có thể không mất gấp đôi, số float, v.v.
• Đầu vào có thể không được giảm hoàn toàn.
• Bạn có thể lấy đầu vào số nguyên làm số hữu tỷ với mẫu số là 1.
• Đệ trình sẽ cung cấp số lượng hợp lý cho một nội dung LCM / GCD được cho phép, nhưng không cạnh tranh.

Các trường hợp thử nghiệm

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

Đây là môn đánh gôn , vì vậy các bài nộp sử dụng ít byte nhất sẽ giành chiến thắng!

Thạch , 19 byte

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

Hãy thử trực tuyến!

J, 3 byte, không cạnh tranh.

*./

Đưa ra một danh sách các đầu vào hợp lý, điều này gấp LCM thông qua nó.

sed, 374 (373 + 1) byte

^{-Ecờ của sed được tính là một byte. Lưu ý: Tôi chưa thử chơi golf này và có lẽ sẽ không lâu nữa.}
Đầu vào được thực hiện trong unary, và đầu ra là unary. Không gian phải bao quanh mọi phân số. Ví dụ : 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 *,/,

Hãy thử trực tuyến!

Python 2 , 65 byte (không cạnh tranh)

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

Hãy thử trực tuyến!

JavaScript (ES6), 85 byte

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

Nhìn không có nội dung! Không có nghi ngờ ai đó sẽ đánh bại điều này bằng cách sử dụng một cách tiếp cận đệ quy hoặc một cái gì đó.

Pari / GP , 3 byte, không cạnh tranh

lcm

Hãy thử trực tuyến!

Perl 6 ,  46  42 byte

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

kiểm tra nó

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

kiểm tra nó

Đầu vào là danh sách các số Rational .

Mở rộng:

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

Võng mạc , 117 byte

\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+
$.&

Hãy thử trực tuyến! Đưa đầu vào thành một chuỗi các phân số không chính xác được phân tách bằng dấu cách (không có số nguyên hoặc số hỗn hợp). Giải trình:

\d+
$*

Chuyển đổi số thập phân thành đơn nguyên.

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

Điều này làm giảm từng phần đến các điều khoản thấp nhất của nó. Nhóm chụp 1 đại diện cho GCD của tử số và mẫu số, vì vậy chúng tôi đếm số lần chụp trước và sau /. \b(1+)+/(\1)+\bdường như không đếm được số lần chụp chính xác vì một số lý do, vì vậy tôi sử dụng một nhóm chụp thêm và thêm 1 vào kết quả.

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

Điều này làm một số điều. Nhóm chụp 2 đại diện cho GCD của tử số của hai phân số đầu tiên, trong khi nhóm chụp 3 đại diện cho GCD của mẫu số. $#4do đó tử số thứ hai chia cho GCD của chúng. (Một lần nữa, tôi không thể chụp số tử số đầu tiên, nhưng tôi chỉ cần chia một tử số cho GCD của họ, vì vậy nó không làm tôi tốn quá nhiều.)

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

Bây giờ tử số thứ hai đã được chia cho GCD của chúng, chúng ta chỉ cần sử dụng biểu thức này từ hướng dẫn số học đơn nguyên để nhân hai số đó với nhau, dẫn đến LCM. Sau đó chúng tôi lặp lại bài tập cho bất kỳ phân số còn lại.

1+
$.&

Chuyển đổi unary trở lại thập phân.

Lisp thường gặp, 154 byte

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

Thuật toán sử dụng (được chỉ định cho số nguyên, nhưng cũng hoạt động cho các tỷ lệ hợp lý).

Trước tiên, hãy tạo một danh sách kết hợp các dữ liệu đầu vào với chính nó, để theo dõi các giá trị ban đầu của các phần tử, do đó trình tự vận hành được đưa ra bởi danh sách của xe car.

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

Các trường hợp thử nghiệm:

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

Lưu ý: Giải pháp là không sử dụng các số nguyên xây dựng lcmvà gcdchấp nhận số nguyên.

Mathicala, 3 byte, không cạnh tranh

LCM

LCMHàm tích hợp của Mathematica có khả năng xử lý các đầu vào số hợp lý.

PHP , 194 byte

<?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 byte với PHP> = 7.1 [$n,$d]=$_GETthay vìlist($n,$d)=$_GET

Hãy thử trực tuyến!

Lisp thông thường, 87 78 byte

Sử dụng lcmvàgcd , có đầu vào số nguyên:

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

Chơi gôn nhiều hơn:

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