अपने कम से कम बहु को संरक्षित करते हुए दो संख्याओं को सह-प्रधान बनाएं

Question

दो सकारात्मक पूर्णांकों को देखते हुए aऔर b, दो सकारात्मक पूर्णांकों का उत्पादन cऔर dऐसा:

• c विभाजित a
• d विभाजित b
• cऔर dसह-प्रमुख हैं
• सबसे छोटा आम गुणक की cऔर dसे सबसे छोटा आम गुणक के बराबर होती है aऔर b।

यदि एक से अधिक संभावित उत्तर हैं, तो आप उनमें से केवल एक या सभी आउटपुट कर सकते हैं।

परीक्षण के मामलों:

 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

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब।

Comments

मुझे लौटने से रोकने के लिए क्या है (1, एलसीएम)?

— नील

@Neil आवश्यकता जो dविभाजित होती हैb

— लीक नून

हो सकता है कि आपको एलसीएम को परिभाषित करना चाहिए या कम से कम परिचित का उपयोग नहीं करना चाहिए। मुझे नहीं पता था कि मुझसे क्या मांगा जा रहा है।

— गेहूं जादूगर

Answer 1

जेली , 21 13 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यदि एक = 2 ^एक · 3 ^बी · 5 ^सी · ... और ख = 2 ^α · 3 ^β · 5 ^γ · ... , तो हम गणना

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

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

अब lcm (c, d) = 2 ^{अधिकतम (A> α? A: 0, A> α? 0: α)} ·… = 2 ^{अधिकतम (A, α)} · 3 ^{अधिकतम (B, β)} ·… = lcm (?) ए, बी)

और gcd (c, d) = 2 ^{मिनट (A> α? A: 0, A> α? 0: α)} ·… = 2 ² · 3 ⁰ · 5 ⁰ · · = = 1 ।

दूसरे शब्दों में: से शुरू (सी, डी) = (ए, बी) । फिर, प्रत्येक अभाज्य के लिए, उस अभाज्य को c या d के गुणन के बाहर सभी तरह से विभाजित करें : जो भी उस प्रधान के लिए सबसे छोटा घातांक है। (इस कार्यान्वयन में, टाई के मामले में, c अपने घातांक को खो देता है।)

अतः यदि a = 2250 = 2 ¹ · 3 ² · 5 ³ और b = 360 = 2 ³ · 3 ² · 5 ¹ ,

तो ग = 2 ⁰ · 3 ⁰ · 5 ³ = 125 और घ = 2 ³ · 3 ² · 5 ⁰ = 72 ।

जोनाथन एलन एक भारी 8 बाइट्स नीचे गोल्फ! धन्यवाद ~

Comments

यह मेरा मूल एल्गोरिथ्म है ... पर्ल एल्गोरिथ्म बेहतर है।

— लीक नून

बहुत अच्छा। यहाँ यह 12 बाइट्स में है

— जोनाथन एलन

यहाँ एक और 12 बाईटर हैÆEZ×Ụ’$€$ZÆẸ

— मील

यह अब देता [1,18]है [15,18]। प्रारंभिक संस्करण सही उत्तर ( [5,18]) दे रहा था ।

— अरनौलद

आह - हाँ, हमें स्थानान्तरण पर शून्य के भराव की आवश्यकता होगी। ÆEz®0iṂ$¦€ZÆẸ13. के लिए चाल करना चाहिए

— जोनाथन एलन

Answer 2

आर, 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")

(उन 19 बाइट्स के लिए @Giuseppe को धन्यवाद!)

इंडेंटेशन, नईलाइन्स और कुछ स्पष्टीकरणों के साथ:

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 

Comments

!की तुलना में अधिक पूर्वता है &और |इससे कम +और *; आप इस तरह से कुछ बाइट्स नीचे गोल्फ में सक्षम होना चाहिए; यानी, !i%%q&j%%qसमान होना चाहिए!i%%q+j%%q

— Giuseppe

ठीक से अच्छी तरह से अवलोकन: यदि GCD(c,d)==1, तो LCM(c,d)==c*d। इसलिए हम परीक्षण कर सकते हैं GCD(c,d)==1और फिर जांच सकते हैं कि c*d==a*b/GCD(a,b)बाद वाला क्या है LCM(a,b)...

— Giuseppe

वास्तव में! (हालांकि गणना a*b/GCD(a,b)से कम नहीं है LCM(a,b))।

— प्लेनेपस

120 बाइट्स - अज्ञात फ़ंक्शन + शाब्दिक न्यू लाइन के लिए -3 बाइट्स

— ग्यूसेप

Answer 3

भूसी , 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]

Answer 4

गणितज्ञ, 82 बाइट्स

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

Comments

मुझे यकीन नहीं है, लेकिन क्या आप बाइट को बचाने के Select[...][[1]]बजाय सूची अनुक्रमण का उपयोग नहीं कर सकते हैं First@Select[...]?

— जोनाथन फ्रीच

हाँ, लेकिन तब मैं एक और बचाने #&@@के [[1]]लिए इस्तेमाल कर सकता था ;-)

— J42161217

Answer 5

जावास्क्रिप्ट (ईएस 6), 90 84 80 बाइट्स

करी सिंटैक्स में इनपुट लेता है (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

Answer 6

MATL , 17 16 बाइट्स

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

इसे ऑनलाइन आज़माएं!

लिन के जेली समाधान के रूप में एक ही विधि

जब से मैंने किसी MATL (या उस मामले के लिए matlab) का उपयोग किया है, तब से बहुत सारे सुधार संभव हैं।

Answer 7

हास्केल ,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और dमैथुन करता हूं ।

मेरे कार्यान्वयन में, c'बस कहा जाता है c।

इसे ऑनलाइन आज़माएं!

-3 बाइट्स लाईकोनी के लिए धन्यवाद

Comments

बांधने के लिए एक पैटर्न गार्ड का उपयोग करके c3 बाइट्स बचाता है: इसे ऑनलाइन आज़माएं!

— लकोनी

@ लिकोनी ऊह, मुझे वह चाल भी नहीं पता थी। धन्यवाद!

— सचान

Answer 8

05AB1E , 12 बाइट्स

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

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

Comments

अभी भी एक क्रूर बल: सी

— लीक नून

@LeakyNun: हाँ, शायद ऐसा करने का एक गणितीय तरीका है :)

— Emigna

Answer 9

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

इसे ऑनलाइन आज़माएं!

यह अन्य आर उत्तर की तुलना में मूल्यों को खोजने के लिए एक अलग (और जाहिर तौर पर कम गोल्फ) दृष्टिकोण लेता है ।

स्पष्टीकरण:

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
}

सिवाय मैं सभी परिभाषाओं को डिफ़ॉल्ट तर्क के रूप में ढालता हूं और गोल्फ के लिए एक पंक्ति पर सभी गणना करता हूं।

Answer 10

जे , 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

Answer 11

हास्केल , 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 करने के लिए धन्यवाद बाइट्स

Comments

u*v`div`gcd u vएक बाइट बचाता है।

— लिन

क्या अंतर्निहित lcmकार्य का उपयोग करने का कोई कारण नहीं है ?

— लकोनी

rem a x+rem b y+gcd x y<2काम भी करना चाहिए।

— लकोनी

@ लिकोनी एक बहुत अच्छा कारण है: मुझे यह भी नहीं पता था कि बिलिन का lcmअस्तित्व है। rem a x+rem b y+gcd x y<2काम करता है, और मुझे आश्चर्य है कि अगरrem a x+rem b y+gcd x y+lcm a b-lcm x y<2 काम करता है। नहीं है हो सकता है एक (गणितीय) गारंटी नहीं है कि lcm a b>=lcm x y।

— जफरार्ड

दरअसल, lcm a b>=lcm x yक्योंकि 1. x=x1*...*xi(प्रधान अपघटन) y=y1*...yj, lcm x y=z1*...*zkजहां z1,...,zkआम हैं x1,...,xiऔर y1,...,yj। 2. a=u1*...*um*x1*...*xi(प्रधान अपघटन) b=v1*...vn*y1*...yj, lcm a b=t1*...*tlजहाँt1,...,tl लिए आम हैं u1*...*um*x1*...*xiऔर v1*...vn*y1*...yj। यह स्पष्ट है कि t1,...,tlहोता है z1,...,zk, इस प्रकार lcm a b>=lcm x y। लेकिन यह शर्त के रूप में राशि लिखने के लिए उपयोगी नहीं है।

— 9

Answer 12

पायथन 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]

इनपुट को एक सूची के रूप में लिया जाता है, जिसे फ़ंक्शन जगह में संशोधित करता है।

इसे ऑनलाइन आज़माएं!

Answer 13

पायथन 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*

इसे ऑनलाइन आज़माएं! या परीक्षण सूट की कोशिश करो।

नेस्टेड सूची के रूप में सभी संभव संयोजनों को आउटपुट करता है।

Comments

आप और आपकी बिटवाइज़ सामान ... -~aऔर पठनीयता के -~bरूप में a+1और फिर से लिखा जा सकता b+1है: पी

— स्टीफन

@Stephen आप देख सकते हैं, मैं के विशेषज्ञ कहानियो

— श्री Xcoder

मेरे नए जोड़े गए दूसरे टेस्टकेस के लिए काम नहीं करता है।

— लीकी नून

@LeakyNun वापस लुढ़का। गोल्फ की वैधता की जांच करने का समय नहीं था।

— श्री एक्सकोडर

Answer 14

जेली ,  19 15  14 बाइट्स

-4 लीक नून से सूचक के साथ (उपयोग किए गए विभाजक का उपयोग करके)

^{मैं लगभग 100% निश्चित हूं कि यह वास्तव में ऐसा करने का तरीका नहीं है, लेकिन यहां पहला प्रयास है।
आइए देखें कि सात या आठ बटर के साथ इसे कौन आउट करता है!
हां ... स्पष्टीकरण के साथ लिन का जवाब देखें !}

g/־l/
ÆDp/ÇÐṂ

दो संख्याओं की एक सूची लेने और संभावनाओं की सूची की सूची वापस करने के लिए एक विवादास्पद लिंक।

इसे ऑनलाइन आज़माएं!

कैसे?

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

Comments

आइए देखें कि सात या आठ बटर के साथ इसे कौन आउट करता है! - ऐसा मत सोचो ...

— श्री एक्सकोडर

आपको लगता है कि छह? ...पांच?!

— जोनाथन एलन

: पी नहीं ... मुझे नहीं लगता कि ~ 13-15 से कम संभव है (डेनिस असहमत होगा, बिल्कुल!)

— श्री एक्सकोडर

भाजक में निर्मित

— लीक नून

हाँ, ÆDलेकिन (सिकुड़ा हुआ) मस्तिष्क स्पष्ट रूप से गियर में नहीं ...

— जोनाथन एलन

Answer 15

पर्ल 6 , 72 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक सूची (ए, बी) लेता है। सभी संभावित सूचियों की सूची लौटाता है (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] $_) == [*] $_ }
}

Answer 16

पायथन 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

इसे ऑनलाइन आज़माएं!

Answer 17

पायथन 2 + सिम्पी , 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 जोनाथन फ्रेच को धन्यवाद ।

इस उत्तर अजगर 2 (नहीं अजगर 3) में काम करता है, का उपयोग करते हुए sympy.gcdऔर sympy.lcmके बजाय math.gcdऔर math.lcmजो केवल पायथन 3. में उपलब्ध हैं और हाँ, इस जानवर बल है :)

Comments

प्रगति में गोल्फ ...

— एरिक आउटगॉल्फ

आप को परिभाषित करते हुए एक बाइट को बचाने के लिए सक्षम हो सकता है Q=c==z;, जबकि पाश की शुरुआत में (+7 बाइट्स) और जगह or(c==z)+dके साथ or Q+d(-4 बाइट्स) और c=+(c==z)orके साथ c=+Q or(-4 बाइट्स)। ( टीआईओ )

— जोनाथन फ्रेच

बस एक सवाल के रूप में, आप +ऑपरेटर का उपयोग कर रहे हैं d=+Eया c=+(c==z)बूलियन को पूर्णांक में बदलने के लिए?

— जोनाथन फ्रेच

@JonathanFrech हाँ, मैं हूँ, क्योंकि आप का उपयोग नहीं कर सकते हैं Trueऔर Falseइसके बजाय 1और 0सिम्पी में।

— 1926

यह पहला उदाहरण है जो मैंने कभी देखा कि वनीला +...का कोई उपयोग है।

— जोनाथन फ्रेच

Answer 18

जेली , 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)

Answer 19

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 बाइट्स है।

Answer 20

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

Comments

यह क्या कर रहा है?

— लिन

आपके जैसे ही, लेकिन वास्तव में फैक्टरिंग और तुलना करने वाले और कारकों की पुनर्संयोजन द्वारा।

— नील