กำหนดจำนวนเต็มบวกสองค่าaและแสดงbผลจำนวนเต็มบวกสองค่าcและdเช่น:

• c แบ่ง a
• d แบ่ง b
• cและdเป็นนายกร่วม
• ตัวคูณร่วมน้อยของcและdเท่ากับตัวคูณร่วมน้อยของและab

หากมีคำตอบมากกว่าหนึ่งคำตอบคุณสามารถส่งออกได้หนึ่งหรือทั้งหมดเท่านั้น

กรณีทดสอบ:

 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

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

เยลลี่ , 21 13 ไบต์

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

ลองออนไลน์!

ถ้าa = 2 ^A · 3 ^B · 5 ^C ·…และb = 2 ^α · 3 ^β · 5 ^γ ·…จากนั้นเราคำนวณ

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

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

ตอนนี้lcm (c, d) = 2 ^{สูงสุด (A> α? A: 0, A> α? 0: α)} ·… = 2 ^{สูงสุด (A, α)} · 3 ^{สูงสุด (B, β)} ·… = lcm ( a, b)

และGCD (C, D) = 2 ^{นาที (A> α A: 0, A> α 0: α)} · ... = 2 ⁰ · 3 ⁰ · 5 ⁰ · ... = 1

ในคำอื่น ๆ : เริ่มต้นจาก(C, D) = (A, B) จากนั้นสำหรับนายกแต่ละคนให้แบ่งนายกนั้นออกจากการแยกตัวประกอบของcหรือd : แล้วแต่จำนวนใดจะมีเลขชี้กำลังน้อยที่สุดสำหรับนายกนั้น (ในการดำเนินการนี้ในกรณีที่เสมอกัน, cสูญเสียเลขชี้กำลังของมัน)

ดังนั้นถ้าA = 2250 = 2 ¹ · 3 ² · 5 ³และข = 360 = 2 ³ · 3 ² · 5 ¹ ,

แล้วc = 2 ⁰ · 3 ⁰ · 5 ³ = 125และd = 2 ³ · 3 ² · 5 ⁰ = 72

โจนาธานอัลลันลงสนาม 8 ไบต์! ขอบคุณ ~

R, 143 139 123 ไบต์

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

(ขอบคุณ @Giuseppe สำหรับขนาด 19 ไบต์!)

ด้วยการเยื้องบรรทัดใหม่และคำอธิบายบางอย่าง:

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

กรณีทดสอบ:

> 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 ไบต์

→ÖF§-⌋⌉ΠmḊ

กำลังดุร้าย. รับและส่งคืนรายการและใช้งานได้มากกว่าสองตัวเลขเช่นกัน ลองออนไลน์!

คำอธิบาย

→Ö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 ไบต์

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

JavaScript (ES6), 90 84 80 ไบต์

รับอินพุตในรูปแบบ currying (a)(b)และส่งคืนอาร์เรย์จำนวนเต็ม 2 จำนวน

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]

กรณีทดสอบ

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 ]

อย่างไร?

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 ไบต์

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

ลองออนไลน์!

วิธีการเดียวกับโซลูชัน Jelly ของ Lynn

ไม่นานมานี้เนื่องจากฉันใช้ MATL ใด ๆ (หรือ matlab สำหรับเรื่องนั้น) ดังนั้นการปรับปรุงหลายอย่างน่าจะเป็นไปได้

Haskell ,50 48 47 45 42 ไบต์

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

ความคิด: c*d = a*b/gcd(a,b)ผมสังเกตเห็นว่า ดังนั้นอัลกอริทึมจึงดำเนินการสองขั้นตอน:

1. เริ่มต้นด้วยและc' = a/gcd(a,b) d' = bสิ่งนี้ตอบสนองความต้องการทั้งหมดยกเว้นสิ่งนั้นc'และd'จะต้องเป็นแบบร่วมกัน
2. จะทำให้พวกเขาร่วมที่สำคัญผมคำนวณe = gcd(c',d')แล้วตั้งและc = c'*e d = d'/eสิ่งนี้จะเก็บคุณสมบัติทั้งหมดไว้ (เนื่องจากปัจจัยที่รวมกันยังคงเหมือนเดิม) แต่เนื่องจากฉันลบปัจจัยที่ใช้ร่วมกันทั้งหมดออกdฉันจะสร้างcและdcoprime

ในการดำเนินงานของฉันจะเรียกว่าเพียงแค่c'c

ลองออนไลน์!

-3 ไบต์ขอบคุณ Laikoni

05AB1E , 12 ไบต์

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

ลองออนไลน์! หรือเป็นชุดทดสอบ

R , 126 ไบต์

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

ลองออนไลน์!

นี้จะใช้เวลาที่แตกต่างกัน (และเห็นได้ชัดว่า golfy น้อยกว่า) วิธีการหาค่ากว่าคำตอบที่ R อื่น ๆ

คำอธิบาย:

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
}

ยกเว้นฉันจะใส่นิยามทั้งหมดเป็นอาร์กิวเมนต์เริ่มต้นและทำการคำนวณทั้งหมดในหนึ่งบรรทัดสำหรับ golfiness

J , 19 ไบต์

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

ลองออนไลน์!

ขึ้นอยู่กับลินน์ @ วิธีการแก้ปัญหา

คำอธิบาย

(*/:"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 ไบต์

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]

ลองออนไลน์!

บันทึกแล้ว17ไบต์ขอบคุณ Laikoni

Python 2 , 75 ไบต์

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]

อินพุตถูกใช้เป็นรายการซึ่งฟังก์ชันปรับเปลี่ยนให้เข้าที่

ลองออนไลน์!

Python 3 , 129 ไบต์

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*

ลองออนไลน์! หรือลองชุดทดสอบ

เอาต์พุตชุดค่าผสมที่เป็นไปได้ทั้งหมดในรูปแบบของรายการแบบซ้อน

เยลลี่ ,  19 15  14 ไบต์

-4 พร้อมตัวชี้จากLeaky Nun (ใช้ตัวหารในตัว)

^{ฉันเกือบ 100% มั่นใจว่านี่ไม่ใช่วิธีการทำสิ่งนี้จริง ๆ แต่นี่เป็นความพยายามครั้งแรก
เรามาดูกันดีกว่าว่าใครชนะด้วยเจ็ดหรือแปด byter!
ใช่ ... ดูคำตอบของลินน์พร้อมคำอธิบาย!}

g/־l/
ÆDp/ÇÐṂ

ลิงก์ monadic ที่รับรายการของตัวเลขสองตัวและส่งกลับรายการของความเป็นไปได้

ลองออนไลน์!

อย่างไร?

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 ไบต์

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

ลองออนไลน์!

ใช้รายการ (a, b) ส่งคืนรายการของรายการที่เป็นไปได้ทั้งหมด (c, d)

คำอธิบาย:

-> @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 ไบต์

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

ลองออนไลน์!

Python 2 + sympy , 148 ไบต์

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

ลองออนไลน์!

-1 ขอบคุณที่โจนาธาน Frech

คำตอบนี้ใช้ได้ใน Python 2 (ไม่ใช่ Python 3) ใช้sympy.gcdและsympy.lcmแทนmath.gcdและmath.lcmใช้ได้เฉพาะใน Python 3 เท่านั้นและใช่นี่คือแรงเดรัจฉาน :)

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

Ụ€’×
ÆEz0ÇZÆẸ

ลองออนไลน์! คำตอบเยลลี่แรกของฉัน! แก้ไข: ใช้ÆEz0µỤ€’×µZÆẸงานได้ 13 ไบต์ คำอธิบาย:

Æ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 ไบต์

นี่เป็นสิ่งที่ลินน์พูดในคำตอบของเธอ:

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]

หากฉันไม่นับf(a,b)=ส่วนนี้จะเป็น 79 ไบต์

05AB1E , 32 26 24 22 20 19 ไบต์

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

ลองออนไลน์! ฉันยังไม่รู้ว่าจะเขียนภาษานี้อย่างไร แต่อย่างน้อยก็ไม่ใช่อัลกอริธึมที่ไร้เดียงสา คำอธิบาย:

Ó                       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