Geben Sie bei zwei positiven Ganzzahlen aund bzwei positive Ganzzahlen aus, cund zwar dso, dass:

• c teilt a
• d teilt b
• cund dsind Co-Prime
• Das kleinste gemeinsame Vielfache von cund ist dgleich dem kleinsten gemeinsamen Vielfachen von aund b.

Wenn es mehr als eine mögliche Antwort gibt, können Sie nur eine oder alle Antworten ausgeben.

Testfälle:

 a  b  c  d
12 18  4  9
18 12  9  4
 5  7  5  7
 3  6  1  6 or 3 2
 9  9  9  1 or 1 9
 6 15  2 15 or 6 5
 1  1  1  1

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt.

Jelly , 21 13 Bytes

ÆEz®0iṂ$¦€ZÆẸ

Probieren Sie es online!

Wenn a = 2 ^A · 3 ^B · 5 ^C ·… und b = 2 ^α · 3 ^β · 5 ^γ ·… , dann berechnen wir

• c = 2 ^{A> α? A:} 0,3 ^{B> β? B:} 0,5 ^{C> γ? C: 0} …

• d = 2 ^{A> α? 0: α} · 3 ^{B> β? 0: β} · 5 ^{C> γ? 0: γ} ·…

Jetzt ist lcm (c, d) = 2 ^{max (A> α? A: 0, A> α? 0: α)} ·… = 2 ^{max (A, α)} · 3 ^{max (B, β)} ·… = lcm ( a, b)

und gcd (c, d) = 2 ^{min (A> & agr;} & ^{agr; A: 0, A> & agr;} & ^{agr; 0: & agr;)} · ... = 2 ⁰ · 3 ⁰ · 5 ⁰ · ... = 1 .

Mit anderen Worten: Beginnen Sie mit (c, d) = (a, b) . Teilen Sie dann für jede Primzahl diese Primzahl ganz aus der Faktorisierung von c oder d heraus : je nachdem, welcher Wert den kleinsten Exponenten für diese Primzahl hat. (In dieser Implementierung verliert c bei einem Gleichstand seinen Exponenten.)

Also, wenn a = 2250 = 2 ¹ · 3 ² · 5 ³ und b = 360 = 2 ³ · 3 ² · 5 ¹ ,

dann ist c = 2 ⁰ · 3 ⁰ · 5 ³ = 125 und d = 2 ³ · 3 ² · 5 ⁰ = 72 .

Jonathan Allan hat satte 8 Bytes Golf gespielt! Vielen Dank ~

R 143 139 123 Bytes

f=function(a,b,q=1:(a*b))for(i in 1:a)for(j in 1:b)if(!a%%i+b%%j&max(q[!i%%q+j%%q])<2&i*j==min(q[!q%%a+q%%b]))cat(i,j,"\n")

(Danke an @ Giuseppe für diese 19 Bytes!)

Mit Einrückungen, Zeilenumbrüchen und einigen Erläuterungen:

f=function(a,b,
           q=1:(a*b)) #Defined as function arguments defaults to avoid having to use curly brackets
    for(i in 1:a)
        for(j in 1:b)
            if(!a%%i + b%%j & #Is a divided by c and b divided by d
               max(q[!i%%q+j%%q])<2 & #Are c and d coprimes
               i*j==min(q[!q%%a+q%%b])) #Is this the same lcm
                   cat(i,j,"\n") #Then print

Testfälle:

> f=function(a,b,q=1:(a*b))for(i in 1:a)for(j in 1:b)if(!a%%i+b%%j&max(q[!i%%q+j%%q])<2&i*j==min(q[!q%%a+q%%b]))cat(i,j,"\n")
> f(5,7)
5 7 
> f(12,18)
4 9 
> f(6,15)
2 15 
6 5 
> f(1,1)
1 1 

Schale , 10 Bytes

→ÖF§-⌋⌉ΠmḊ

Rohe Gewalt. Nimmt Listen auf und gibt sie zurück und funktioniert auch für mehr als zwei Zahlen. Probieren Sie es online!

Erläuterung

→ÖF§-⌋⌉ΠmḊ  Implicit input, say [6,15]
        mḊ  Map divisors: [[1,2,3,6],[1,3,5,15]]
       Π    Cartesian product:[[1,1],[2,1],[1,3],[2,3],[3,1],[1,5],[3,3],[6,1],[1,15],[2,5],[3,5],[6,3],[2,15],[6,5],[3,15],[6,15]]
 Ö          Sort by
  F         reduce by
     ⌉      lcm
   -⌋       minus gcd: [[1,1],[3,3],[2,1],[1,3],[3,1],[6,3],[1,5],[2,3],[6,1],[2,5],[3,15],[1,15],[3,5],[6,15],[2,15],[6,5]]
→           Get last element: [6,5]

Mathematica, 82 Bytes

#&@@Select[Subsets[Flatten@Divisors[{t=#,r=#2}],{2}],GCD@@#==1&&LCM@@#==t~LCM~r&]&

JavaScript (ES6), 90 84 80 Bytes

Übernimmt Eingaben in der Currying-Syntax (a)(b)und gibt ein Array mit 2 Ganzzahlen zurück.

a=>g=(b,c=1)=>(G=(a,b)=>b?G(b,a%b):a)(c,d=a*b/G(a,b)/c)-1|a%c|b%d?g(b,c+1):[c,d]

Testfälle

let f =

a=>g=(b,c=1)=>(G=(a,b)=>b?G(b,a%b):a)(c,d=a*b/G(a,b)/c)-1|a%c|b%d?g(b,c+1):[c,d]

console.log(JSON.stringify(f(12)(18))) // [ 4,  9 ]
console.log(JSON.stringify(f(18)(12))) // [ 9,  4 ]
console.log(JSON.stringify(f( 5)( 7))) // [ 5,  7 ]
console.log(JSON.stringify(f( 3)( 6))) // [ 1,  6 ] or [ 3, 2 ]
console.log(JSON.stringify(f( 9)( 9))) // [ 9,  1 ] or [ 1, 9 ]
console.log(JSON.stringify(f( 6)(15))) // [ 2, 15 ] or [ 6, 5 ]
console.log(JSON.stringify(f( 1)( 1))) // [ 1,  1 ]

Wie?

a =>                            // a = first input
  g = (                         // g = recursive function that takes:
    b,                          //   b = second input
    c = 1                       //   c = first output divisor, initially set to 1
  ) =>                          //
    (G = (a, b) =>              // G = function that takes a and b
      b ? G(b, a % b) : a       //     and returns the greatest common divisor
    )(                          // we call it with:
      c,                        //   - c
      d = a * b / G(a, b) / c   //   - d = LCM(a, b) / c = a * b / GCD(a, b) / c
    ) - 1 |                     // if the result is not 1 (i.e. c and d are not coprime)
    a % c |                     // or c does not divide a
    b % d ?                     // or d does not divide b:
      g(b, c + 1)               //   do a recursive call with c + 1
    :                           // else:
      [c, d]                    //   return [c, d], a valid factorization of the LCM

MATL , 17 16 Bytes

&YFt&X>2:!=*^!Xp

Probieren Sie es online!

Gleiche Methode wie Lynn's Jelly-Lösung

Es ist schon eine Weile her, dass ich MATL (oder Matlab für diese Angelegenheit) verwendet habe, so dass wahrscheinlich viele Verbesserungen möglich sind.

Haskell ,50 48 47 45 42 Bytes

(?)=gcd;a!b|c<-div a$a?b=(c*c?b,div b$c?b)

Idee: Mir ist das aufgefallen c*d = a*b/gcd(a,b). Der Algorithmus führt also zwei Schritte aus:

1. Beginnen Sie mit c' = a/gcd(a,b)und d' = b. Dies erfüllt alle Anforderungen mit Ausnahme dieser c'und d'muss Co-Prime sein.
2. Um sie zum Co-Prime zu machen, berechne ich e = gcd(c',d')und setze c = c'*eund d = d'/e. Dies behält alle Eigenschaften bei (da die kombinierten Faktoren gleich bleiben), aber da ich alle gemeinsamen Faktoren von entferne d, mache ich cund dkoprime.

In meiner Implementierung c'heißt das nur c.

Probieren Sie es online!

-3 Bytes dank Laikoni

05AB1E , 12 Bytes

Ñ`âʒ.¿I.¿Q}н

Probieren Sie es online! oder als Testsuite

R , 126 Bytes

function(a,b,g=function(x,y)ifelse(o<-x%%y,g(y,o),y),l=a*b/g(a,b))matrix(c(C<-(1:l)[!l%%1:l],D<-l/C),,2)[g(C,D)<2&!a%%C+b%%D,]

Probieren Sie es online!

Dies erfordert einen anderen (und anscheinend weniger golferischen) Ansatz zum Finden der Werte als die andere R-Antwort .

Erläuterung:

function(a,b){
 G <- function(x,y)ifelse(o<-x%%y,G(y,o),y) #gcd function, vectorized for x,y
 l <- a*b/g(a,b)                            #lcm of a,b
 C <- (1:l)[!l%%1:l]                        #divisors of l
 D <- l/C                                   #l/C is the other half of the pair
 rel_prime <- G(C, D) < 2                   #pairs where C,D are relatively prime, lol, GCD
 a_div <- !a%%C                             #divisors of a
 b_div <- !b%%D                             #divisors of b
 C <- C[rel_prime & a_div & b_div]
 D <- D[rel_prime & a_div & b_div]          #filter out the bad pairs
 matrix(c(C,D),,ncol = 2)                   #matrix of pairs, returned
}

mit der Ausnahme, dass ich alle Definitionen als Standardargumente aufgeschlüsselt und alle Berechnungen für die Golfiness in einer Zeile ausgeführt habe.

J , 19 Bytes

(*/:"1)&.|:&.(_&q:)

Probieren Sie es online!

Basierend auf @Lynns Lösung .

Erläuterung

(*/:"1)&.|:&.(_&q:)  Input: [a, b]
              _&q:   Get exponenets of each prime
         |:&         Transpose
  /:"1 &             Grade each row
 *                   Multiply elementwise
       &.|:          Transpose
           &. _&q:   Convert exponents back to numbers

Haskell , 91 74 Bytes

a!b=[(x,y)|x<-[1..a],y<-[1..b],rem a x+rem b y+gcd x y<2,lcm a b==lcm x y]

Probieren Sie es online!

Gespeichert 17 Bytes dank Laikoni

Python 2 , 75 Bytes

def f(x):n=1;exec'n+=1;j=k=1\nwhile x[j]%k<1:k*=n**j;j^=1\nx[j]/=k/n;'*x[0]

Die Eingabe wird als Liste genommen, die die Funktion an Ort und Stelle ändert.

Probieren Sie es online!

Python 3 , 129 Bytes

lambda a,b:[[c,d]for c in range(1,-~a)for d in range(1,-~b)if((gcd(c,d)<2)*a*b/gcd(a,b)==c*d/gcd(c,d))>a%c+b%d]
from math import*

Probieren Sie es online! oder Probieren Sie die Testsuite aus.

Gibt alle möglichen Kombinationen in Form einer verschachtelten Liste aus.

Jelly ,  19 15  14 Bytes

-4 mit Zeiger von Leaky Nun (Divisor eingebaut verwenden)

^{Ich bin fast zu 100% sicher, dass dies nicht der richtige Weg ist, aber hier ist ein erster Versuch.
Mal sehen, wer es mit einem Sieben- oder Acht-Byte übertrifft!
Ja ... siehe Lynns Antwort mit Erklärung!}

g/־l/
ÆDp/ÇÐṂ

Ein monadischer Link, der eine Liste der beiden Zahlen erstellt und eine Liste der Möglichkeiten zurückgibt.

Probieren Sie es online!

Wie?

g/־l/  - Link: gcd divided by lcm: list [x, y]
g/      - reduce by gcd = gcd(x, y)
   æl/  - reduce by lcm = lcm(x,y)
  ÷     - divide

ÆDp/ÇÐṂ - Main link: list [a, b]    e.g. [160, 90]
ÆD      - divisors (vectorises)          [[1,2,4,5,8,10,16,20,32,40,80,160],[1,2,3,5,6,9,10,15,18,30,45,90]]
  p/    - reduce by Cartesian product    [[1,1],[1,2],...,[1,90],[2,1],[2,2],...,[2,90],....,[160,90]]
     ÐṂ - entries for which this is minimal:
    Ç   -   call the last link (1) as a monad

Perl 6 , 72 Bytes

{([X] map {grep $_%%*,1..$_},@^a).grep:{([lcm] @a)==([lcm] $_)==[*] $_}}

Probieren Sie es online!

Nimmt eine Liste (a, b). Gibt eine Liste aller möglichen Listen zurück (c, d).

Erläuterung:

-> @ab {
    # Generate all pairs (c, d)
    ([X]
         # where c divides a and d divides b.
         map { grep $_%%*, 1..$_ }, @ab)
    # Only keep pairs with lcm(a, b) = lcm(c, d) and lcm(c, d) = c * d.
    # The latter implies gcd(c, d) = 1.
    .grep: { ([lcm] @ab) == ([lcm] $_) == [*] $_ }
}

Python 2 , 126 121 Bytes

def f(a,b):
 c=[1,1];p=2
 while p<=a*b:
	t=m=1
	while(a*b)%p<1:m*=p;t=b%p<1;a/=p**(a%p<1);b/=p**t
	p+=1;c[t]*=m
 return c

Probieren Sie es online!

Python 2 + Sympy , 148 Bytes

from sympy import*
a,b=input()
c=d=z=1
while(a/c*c+b/d*d<a+b)+gcd(c,d)-1+(lcm(c,d)!=lcm(a,b)):E=c==d==z;Q=c==z;d=+E or Q+d;c=+Q or-~c;z+=E
print c,d

Probieren Sie es online!

-1 Danke an Jonathan Frech .

Diese Antwort funktioniert in Python 2 (nicht in Python 3) mit sympy.gcdund sympy.lcmanstelle von math.gcdund, math.lcmdie nur in Python 3 verfügbar sind. Und ja, das ist Brute Force :)

Jelly , 13 Bytes

Ụ€’×
ÆEz0ÇZÆẸ

Probieren Sie es online! Meine erste Gelee Antwort! Bearbeiten: Funktioniert ÆEz0µỤ€’×µZÆẸauch für 13 Bytes. Erläuterung:

ÆE              Get prime factor exponents of both values (vectorises)
  z0            Zip but fill the shorter array with 0
    µ           New monadic link
     Ụ€         Grade up each pair (1-indexed)
       ’        Convert to 0-indexing (vectorises)
        ×       Multiply each pair by its grade (vectorises)
         µ      New monadic link
          Z     Zip back into separate lists of prime factor exponents
           ÆẸ   Turn prime exponent lists back into values (vectorises)

PARI / GP, 86 Bytes

Das macht genau das, was Lynn in ihrer Antwort sagt:

f(a,b)=forprime(p=2,a*b,v=valuation(a,p);w=valuation(b,p);if(w<v,b/=p^w,a/=p^v));[a,b]

Wenn ich den f(a,b)=Teil nicht zähle , sind es 79 Bytes.

05AB1E , 32 26 24 22 20 19 Bytes

Ó0ζεD`›0sǝ}øεā<ØsmP

Probieren Sie es online! Ich habe noch keine Ahnung, wie man in dieser Sprache schreibt, aber es ist zumindest kein Brute-Force-Algorithmus. Erläuterung:

Ó                       Get exponents of prime factors (vectorised)
 0ζ                     Zip, filling with 0
   ε      }             For each prime
    D`                  Extract the pair of exponents
      ›0sǝ              Overwrite the smaller with 0
           ø            Zip back into two lists of prime exponents
            ε           For each list (} implied)
             ā<Ø        Get a list of primes
                sm      Raise each prime to the exponent
                  P     Take the product