Sayı kümesinin en küçük ortak katı (LCM) Atamsayı küçüğüdür bböyle b/abütün tamsayılar için bir tam sayıdır aiçinde A. Bu tanım rasyonel sayılara genişletilebilir!

Görev

En küçük pozitif bul rasyonel b şekilde b/abir olan tamsayı herkes için rationals a girişinde.

kurallar

• Standart boşluklar yasaktır.
• Girişte pay ve paydaları ayrı olarak alabilir, ancak çiftler, şamandıralar vb.
• Giriş tam olarak azaltılamaz.
• Tamsayı girişlerini paydası ile rasyonel olarak alabilirsiniz 1.
• Rasyonel sayıları bir LCM / GCD yerleşkesine besleyecek gönderimlere izin verilir, ancak rakip değildir.

Test Durumları

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

Bu kod golf , bu yüzden en az bayt kullanarak gönderme kazanmak!

Jöle , 19 bayt

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

Çevrimiçi deneyin!

J, 3 byte, rakip değil.

*./

Rasyonel girdilerin bir listesi verildiğinde, bu LCM'yi katlar.

sed, 374 (373 + 1) bayt

^{sed'in -Ebayrağı bir bayt olarak sayılır. Not: Henüz golf oynamaya çalışmadım ve muhtemelen bir süredir olmayacak.}
Giriş tekli alınır ve çıktı tekli olur. Boşluklar her kesiri çevrelemelidir. Örnek: 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 *,/,

Çevrimiçi deneyin!

Python 2,65 bayt (rakip olmayan)

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

Çevrimiçi deneyin!

JavaScript (ES6), 85 bayt

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

Bakın yerleşimler yok! Kuşkusuz, birisi bunu tekrarlayan bir yaklaşım veya benzeri bir şey kullanarak yenecektir.

Pari / GP , 3 bayt, rakip olmayan

lcm

Çevrimiçi deneyin!

Perl 6 ,  46  42 bayt

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

Dene

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

Dene

Girdi Rasyonel sayıların bir listesidir .

Expanded:

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

Retina , 117 bayt

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

Çevrimiçi deneyin! Girdiyi boşlukla ayrılmış uygunsuz kesirler dizisi olarak alır (tamsayı veya karışık sayı yok). Açıklama:

\d+
$*

Ondalık değeri tekli olarak dönüştürür.

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

Bu, her kesiri en düşük terimlere indirger. Yakalama grubu 1, payın ve paydanın GCD'sini temsil eder, bu nedenle önce ve sonra yakalama sayısını sayarız /. \b(1+)+/(\1)+\bherhangi bir nedenle yakalama sayısını doğru saymıyor gibi görünüyor, bu yüzden ekstra bir yakalama grubu kullanıyorum ve sonuca 1 ekliyorum.

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

Bu birkaç şey yapar. Yakalama grubu 2, ilk iki fraksiyonun paylarının GCD'sini temsil ederken, yakalama grubu 3 paydaların GCD'sini temsil eder. $#4bu nedenle ikinci pay GCD'lerine bölünür. (Yine, ilk payın yakalama sayısını yapamadım, ancak sadece bir payı GCD'lerine bölmem gerekiyor, bu yüzden bana çok pahalıya mal olmaz.)

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

Şimdi ikinci pay GCD'lerine bölündüğüne göre, bu ifadeyi tekli aritmetik öğreticiden kullanarak ikisini birlikte çoğaltarak LCM'ye yol açıyoruz. Daha sonra egzersizi kalan fraksiyonlar için tekrarlıyoruz.

1+
$.&

Tekliyi tekrar ondalığa çevirir.

Ortak Lisp, 154 bayt

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

Kullanılan algoritma (tamsayılar için belirtilir, ancak gerekçeler için de çalışır).

Öncelikle, elemanların başlangıç ​​değerlerini takip etmek için giriş verilerinin kendisiyle ilişkilendirilebilir bir liste yapın, böylece çalışma sırası listenin "araba" ları tarafından verilir.

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

Test senaryoları:

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

Not: Çözüm, bina kullanmadan lcmve gcdtamsayıları kabul eder.

Mathematica, 3 bayt, rakip olmayan

LCM

Mathematica'nın yerleşik LCMişlevi rasyonel sayı girişlerini işleyebilir.

PHP , 194 bayt

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

PHP [$n,$d]=$_GETyerine -4 baytlist($n,$d)=$_GET

Çevrimiçi deneyin!

Yaygın Lisp, 87 78 bayt

Kullanma lcmve gcdtam sayı giriş sahip olan:

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

Daha fazla golf:

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