ตัวคูณร่วมน้อย (LCM) ของชุดของตัวเลขAเป็นที่เล็กที่สุดจำนวนเต็มbเช่นว่าb/aเป็นจำนวนเต็มสำหรับจำนวนเต็มทั้งหมดในa Aคำจำกัดความนี้สามารถขยายไปถึงตัวเลขที่มีเหตุผล!

งาน

ค้นหาที่เล็กที่สุดในเชิงบวกที่มีเหตุผล bดังกล่าวที่b/aเป็นจำนวนเต็มสำหรับทุกrationals aในการป้อนข้อมูล

กฎระเบียบ

• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• คุณอาจนำตัวเศษและตัวส่วนแยกจากกันในอินพุต แต่ไม่สามารถใช้คู่ผสมลอย ฯลฯ
• อินพุตอาจไม่ลดลงจนสุด
• คุณอาจจะใช้ปัจจัยการผลิตที่เป็นจำนวนเต็ม rationals 1กับส่วนของ
• การส่งที่จะป้อนตัวเลขที่มีเหตุผลไปยัง LCM / GCD ในตัวได้รับอนุญาต แต่ไม่สามารถแข่งขันได้

กรณีทดสอบ

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

นี่คือโค้ดกอล์ฟดังนั้นการส่งโดยใช้ไบต์น้อยที่สุดชนะ!

เยลลี่ขนาด 19 ไบต์

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

ลองออนไลน์!

J, 3 ไบต์, ไม่ใช่การแข่งขัน

*./

รับรายการอินพุตที่มีเหตุผลซึ่งจะพับ LCM ผ่านมัน

sed, 374 (373 + 1) ไบต์

^{-Eธงของ sed นับเป็นหนึ่งไบต์ หมายเหตุ: ฉันยังไม่ได้ลองเล่นกอล์ฟและอาจจะไม่ได้ค่อนข้างนาน}
อินพุตถูกใช้เป็น unary และเอาต์พุตจะเป็น unary ช่องว่างจะต้องล้อมรอบทุกส่วน ตัวอย่าง: 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 *,/,

ลองออนไลน์!

Python 2 , 65 ไบต์ (ไม่แข่งขัน)

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

ลองออนไลน์!

JavaScript (ES6), 85 ไบต์

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

ไม่ต้องมองหาตัวอาคาร! ไม่ต้องสงสัยเลยว่าบางคนจะเอาชนะสิ่งนี้ได้โดยใช้วิธีเรียกซ้ำหรืออะไรทำนองนั้น

Pari / GP , 3 ไบต์, ไม่มีการแข่งขัน

lcm

ลองออนไลน์!

Perl 6 ,  46  42 ไบต์

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

ทดสอบมัน

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

ทดสอบมัน

อินพุตเป็นรายการของตัวเลขที่มีเหตุผล

ขยาย:

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

เรติน่า 117 ไบต์

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

ลองออนไลน์! ใช้อินพุตเป็นชุดของเศษส่วนที่ไม่เหมาะสมซึ่งคั่นด้วยช่องว่าง (ไม่มีจำนวนเต็มหรือตัวเลขผสม) คำอธิบาย:

\d+
$*

แปลงทศนิยมเป็นเอก

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

สิ่งนี้จะลดเศษส่วนแต่ละส่วนให้เป็นเงื่อนไขต่ำสุด กลุ่มการจับภาพที่ 1 แสดงให้เห็นถึง GCD /ของเศษและส่วนดังนั้นเรานับจำนวนของการจับภาพก่อนและหลัง \b(1+)+/(\1)+\bดูเหมือนจะไม่นับจำนวนการจับอย่างถูกต้องด้วยเหตุผลบางอย่างดังนั้นฉันใช้กลุ่มการจับภาพพิเศษและเพิ่ม 1 ลงในผลลัพธ์

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

สิ่งนี้ทำหลายสิ่งหลายอย่าง กลุ่มการจับ 2 หมายถึง GCD ของตัวเศษของสองเศษส่วนแรกในขณะที่กลุ่มการจับ 3 หมายถึง GCD ของตัวส่วน $#4ดังนั้นจึงเป็นตัวเศษที่สองหารด้วย GCD (อีกครั้งฉันไม่สามารถจับจำนวนของตัวเศษแรกได้ แต่ฉันต้องหารตัวเศษหนึ่งส่วนด้วย GCD ของพวกมันดังนั้นค่าใช้จ่ายฉันก็ไม่มากนัก)

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

ตอนนี้ตัวเศษที่สองถูกหารด้วย GCD ของพวกเขาเราแค่ใช้นิพจน์นี้จากการสอนเลขคณิตเลขคณิตเพื่อคูณสองตัวเข้าด้วยกันส่งผลให้ LCM จากนั้นเราจะทำการฝึกซ้ำสำหรับเศษส่วนที่เหลืออยู่

1+
$.&

แปลงค่าย้อนกลับเป็นทศนิยม

เสียงกระเพื่อมสามัญ 154 ไบต์

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

อัลกอริธึมที่ใช้ (ระบุสำหรับจำนวนเต็ม แต่ใช้ได้กับ rationals ด้วย)

ก่อนอื่นให้สร้างรายการที่เชื่อมโยงของข้อมูลอินพุตด้วยตัวเองเพื่อติดตามค่าเริ่มต้นขององค์ประกอบดังนั้นลำดับการปฏิบัติการจะได้รับจาก "รถยนต์" ของรายการ

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

กรณีทดสอบ:

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

หมายเหตุ: การแก้ปัญหาคือโดยไม่ต้องใช้การสร้างlcmและgcdที่รับจำนวนเต็ม

Mathematica 3 ไบต์ไม่ใช่การแข่งขัน

LCM

LCMฟังก์ชันในตัวของ Mathematica มีความสามารถในการจัดการอินพุตจำนวนตรรกยะ

PHP , 194 ไบต์

<?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 ไบต์ด้วย PHP> = 7.1 [$n,$d]=$_GETแทนlist($n,$d)=$_GET

ลองออนไลน์!

เสียงกระเพื่อมสามัญ, 87 78 ไบต์

การใช้lcmและgcdซึ่งมีอินพุตจำนวนเต็ม:

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

golfed เพิ่มเติม:

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