Cho hai số nguyên dương avà b, xuất ra hai số nguyên dương cvà dsao cho:

• c chia a
• d chia b
• cvà dlà đồng nguyên tố
• các bội số chung nhỏ nhất của cvà dbằng với bội số chung nhỏ nhất của avà b.

Nếu có nhiều hơn một câu trả lời có thể, bạn chỉ có thể xuất một hoặc tất cả chúng.

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

 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

Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng.

Thạch , 21 13 byte

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

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

Nếu a = 2 ^A · 3 ^B · 5 ^C · Mạnh và b = 2 ^α · 3 ^β · 5 ^γ · ^Trà , thì chúng tôi tính toán

• c = 2 ^{A> α? A: 0} · 3 ^{B>? B: 0} · 5 ^{C>? C: 0} · Cách

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

Bây giờ lcm (c, d) = 2 ^{max (A> α? A: 0, A> α? 0: α)} · Ném = 2 ^{max (A, α)} · 3 ^{max (B, β)} · cách = lcm ( a, b)

và gcd (c, d) = 2 ^{min (A> α? A: 0, A> α? 0: α)} · Riêu = 2 ⁰ · 3 ⁰ · 5 ⁰ · ^Lỗi = 1 .

Nói cách khác: bắt đầu từ (c, d) = (a, b) . Sau đó, với mỗi số nguyên tố, hãy chia số nguyên tố đó ra khỏi hệ số của c hoặc d : bất kỳ số nào có số mũ nhỏ nhất cho số nguyên tố đó. (Trong triển khai này, trong trường hợp hòa, c mất số mũ của nó.)

Vậy nếu a = 2250 = 2 ¹ · 3 ² · 5 ³ và b = 360 = 2 ³ · 3 ² · 5 ¹ ,

thì c = 2 ⁰ · 3 ⁰ · 5 ³ = 125 và d = 2 ³ · 3 ² · 5 ⁰ = 72 .

Jonathan Allan đánh gôn xuống 8 byte! Cảm ơn bạn

R, 143 139 123 byte

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

(Cảm ơn @Giuseppe vì đã tắt 19 byte!)

Với các vết lõm, dòng mới và một số giải thích:

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

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

> 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 

Husk , 10 byte

→ÖF§-⌋⌉ΠmḊ

Lực lượng vũ phu. Lấy và trả về danh sách, và cũng hoạt động với hơn hai số. Hãy thử trực tuyến!

Giải trình

→Ö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]

Toán học, 82 byte

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

JavaScript (ES6), 90 84 80 byte

Lấy đầu vào theo cú pháp currying (a)(b)và trả về một mảng gồm 2 số nguyên.

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]

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

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 ]

Làm sao?

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 byte

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

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

Phương pháp tương tự như giải pháp Lynn của Jelly

Đã được một thời gian kể từ khi tôi sử dụng bất kỳ MATL (hoặc matlab nào cho vấn đề đó) nên có thể có nhiều cải tiến.

Haskell ,50 48 47 45 42 byte

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

Ý tưởng: Tôi nhận thấy rằng c*d = a*b/gcd(a,b). Vì vậy, thuật toán thực hiện hai bước:

1. Bắt đầu với c' = a/gcd(a,b)và d' = b. Điều này đáp ứng tất cả các yêu cầu ngoại trừ điều đó c'và d'phải là đồng nguyên tố.
2. Để làm cho chúng đồng nguyên tố, tôi tính toán e = gcd(c',d')và sau đó thiết lập c = c'*evà d = d'/e. Điều này giữ cho tất cả các thuộc tính (vì các yếu tố kết hợp giữ nguyên), nhưng vì tôi loại bỏ tất cả các yếu tố được chia sẻ khỏi d, tôi thực hiện cvà dđồng thời.

Trong thực hiện của tôi, c'chỉ được gọi c.

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

-3 byte nhờ Laikoni

05AB1E , 12 byte

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

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

R , 126 byte

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

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

Điều này cần một cách tiếp cận khác (và dường như ít chơi gôn hơn) để tìm các giá trị so với câu trả lời R khác .

Giải trình:

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
}

ngoại trừ tôi đánh bóng tất cả các định nghĩa làm đối số mặc định và thực hiện tất cả các phép tính trên một dòng cho tính golf.

J , 19 byte

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

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

Dựa trên giải pháp của @ Lynn .

Giải trình

(*/:"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 byte

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]

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

Đã lưu 17 byte nhờ Laikoni

Python 2 , 75 byte

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]

Đầu vào được lấy dưới dạng một danh sách, mà chức năng sửa đổi tại chỗ.

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

Python 3 , 129 byte

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*

Hãy thử trực tuyến! hoặc Thử bộ kiểm tra.

Xuất ra tất cả các kết hợp có thể dưới dạng một danh sách lồng nhau.

Thạch ,  19 15  14 byte

-4 với con trỏ từ Leaky Nun (sử dụng ước số tích hợp)

^{Tôi gần như chắc chắn 100% đây không phải là cách để thực sự làm điều này, nhưng đây là một nỗ lực đầu tiên.
Chúng ta hãy xem ai vượt qua nó bằng bảy hoặc tám lần!
Đúng ... xem câu trả lời của Lynn với lời giải thích!}

g/־l/
ÆDp/ÇÐṂ

Một liên kết đơn âm lấy danh sách hai số và trả về danh sách các danh sách các khả năng.

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

Làm sao?

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 byte

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

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

Đưa ra một danh sách (a, b). Trả về một danh sách tất cả các danh sách có thể (c, d).

Giải trình:

-> @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] $_) == [*] $_ }
}

Con trăn 2 , 126 121 byte

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

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

Python 2 + sympy , 148 byte

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

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

-1 cảm ơn Jonathan Frech .

Câu trả lời này hoạt động trong Python 2 (không phải Python 3), sử dụng sympy.gcdvà sympy.lcmthay vì math.gcdvà math.lcmchỉ có sẵn trong Python 3. Và vâng, đây là vũ lực :)

Thạch , 13 byte

Ụ€’×
ÆEz0ÇZÆẸ

Hãy thử trực tuyến! Câu trả lời Jelly đầu tiên của tôi! Chỉnh sửa: ÆEz0µỤ€’×µZÆẸcũng hoạt động cho 13 byte. Giải trình:

Æ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 byte

Đây chỉ là những gì Lynn nói trong câu trả lời của mình:

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]

If I do not count the f(a,b)= part, it is 79 bytes.

05AB1E, 32 26 24 22 20 19 bytes

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

Try it online! I still have no idea how to write in this language, but at least it's not a brute-force algorithm. Explanation:

Ó                       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