Das kleinste gemeinsame Vielfache (LCM) eines Satzes von Zahlen Aist die kleinste Ganzzahl b, b/adh eine Ganzzahl für alle Ganzzahlen ain A. Diese Definition kann auf rationale Zahlen erweitert werden!

Aufgabe

Suchen Sie das kleinste positive Rational b , b/adas eine Ganzzahl für alle Rationalen a in der Eingabe ist.

Regeln

• Standardlücken sind verboten.
• Sie können Zähler und Nenner in der Eingabe getrennt verwenden, dürfen jedoch keine Doubles, Floats usw. verwenden.
• Die Eingabe wird möglicherweise nicht vollständig reduziert.
• Sie können Ganzzahleingaben als Rationale mit dem Nenner von verwenden 1.
• Einsendungen, die einer eingebauten LCM / GCD rationale Zahlen zuführen würden, sind zulässig, aber nicht konkurrierend.

Testfälle

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

Das ist Code-Golf , also gewinnen Einsendungen mit den wenigsten Bytes!

Jelly , 19 Bytes

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

Probieren Sie es online!

J, 3 Bytes, nicht konkurrierend.

*./

Mit einer Liste rationaler Eingaben faltet dies LCM durch.

sed, 374 (373 + 1) Bytes

^{Die -EFlagge von sed zählt als ein Byte. Hinweis: Ich habe noch nicht versucht, Golf zu spielen, und wahrscheinlich schon seit einiger Zeit nicht mehr.}
Die Eingabe ist unär und die Ausgabe ist unär. Leerzeichen müssen jeden Bruch umgeben. Beispiel: 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 *,/,

Probieren Sie es online!

Python 2 , 65 Bytes (nicht konkurrierend)

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

Probieren Sie es online!

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

Guck mal keine eingebauten! Kein Zweifel, jemand wird dies mit einem rekursiven Ansatz oder so etwas schlagen.

Pari / GP , 3 Bytes, nicht konkurrierend

lcm

Probieren Sie es online!

Perl 6 ,  46  42 Bytes

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

Probier es aus

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

Probier es aus

Die Eingabe ist eine Liste von rationalen Zahlen.

Erweitert:

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

Netzhaut , 117 Bytes

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

Probieren Sie es online! Nimmt Eingaben als durch Leerzeichen getrennte Folge von falschen Brüchen (keine ganzen Zahlen oder gemischten Zahlen). Erläuterung:

\d+
$*

Konvertiert Dezimalzahlen in Unärzahlen.

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

Dies reduziert jeden Bruch auf die niedrigsten Werte. Die Erfassungsgruppe 1 stellt die GCD des Zählers und Nenners dar, daher zählen wir die Anzahl der Erfassungen vor und nach dem /. \b(1+)+/(\1)+\bAus irgendeinem Grund scheint die Anzahl der Erfassungen nicht richtig zu sein. Daher verwende ich eine zusätzliche Erfassungsgruppe und addiere 1 zum Ergebnis.

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

Dies macht eine Reihe von Dingen. Die Erfassungsgruppe 2 repräsentiert die GCD der Zähler der ersten beiden Brüche, während die Erfassungsgruppe 3 die GCD der Nenner repräsentiert. $#4ist daher der zweite Zähler geteilt durch ihre GCD. (Auch hier konnte ich die Anzahl der Erfassungen des ersten Zählers nicht ermitteln, aber ich muss nur einen Zähler durch die GCD teilen, was mich nicht so viel kostet.)

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

Nachdem der zweite Zähler durch die GCD geteilt wurde, verwenden wir diesen Ausdruck aus dem Tutorial für die unäre Arithmetik, um die beiden zu multiplizieren, was zur LCM führt. Anschließend wiederholen wir die Übung für alle verbleibenden Brüche.

1+
$.&

Wandelt unary zurück in decimal um.

Common Lisp, 154 Bytes

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

Algorithmus verwendet (angegeben für ganze Zahlen, funktioniert aber auch für rationale Zahlen).

Erstellen Sie zunächst eine assoziative Liste der Eingabedaten mit sich selbst, um die Anfangswerte der Elemente zu verfolgen, sodass die Betriebssequenz durch die "Autos" der Liste gegeben ist.

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

Testfälle:

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

Anmerkung: Die Lösung ist ohne die Verwendung von building lcmund gcd, die ganze Zahlen akzeptieren.

Mathematica, 3 Bytes, nicht konkurrierend

LCM

Die eingebaute LCMFunktion von Mathematica ist in der Lage, rationale Zahleneingaben zu verarbeiten.

PHP , 194 Bytes

<?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 Bytes mit PHP> = 7.1 [$n,$d]=$_GETstattlist($n,$d)=$_GET

Probieren Sie es online!

Common Lisp, 87 78 Bytes

Verwenden von lcmund gcd, die Integer-Eingaben haben:

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

Mehr Golf:

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