तर्कसंगत संख्याओं के अनुपात के रूप में तर्कसंगत संख्या लिखना

नोट: इस चुनौती को सैंडबॉक्स पर पोस्ट किया गया है ।

परिचय

यह चुनौती 2009 के पुत्तनम बी 1 से प्रेरित है , जो एक स्नातक गणित प्रतियोगिता में एक समस्या है। समस्या इस प्रकार है:

दिखाएँ कि प्रत्येक सकारात्मक परिमेय संख्या को (जरूरी नहीं कि विशिष्ट) अपराधों के भाज्य उत्पादों के भागफल के रूप में लिखा जा सकता है। उदाहरण के लिए,

$$ \ frac {10} 9 = \ frac {2! \ cdot 5!} {3! \ cdot 3! \ cdot 3!} $।$

चुनौती

आपकी चुनौती अपेक्षाकृत प्रमुख सकारात्मक पूर्णांक की एक जोड़ी लेना है, जो इनपुट के रूप में एक सकारात्मक परिमेय संख्या (या केवल तर्कसंगत संख्या) के अंश और भाजक का प्रतिनिधित्व करती है, और अभाज्य संख्याओं की दो सूचियों (या सरणियों, आदि) का उत्पादन करती है ताकि इनपुट की गई परिमेय संख्या पहली सूची में primes के factorials के उत्पाद के अनुपात के बराबर है, दूसरी सूची में primes के factorials के उत्पाद के लिए।

ऐसा कोई भी अपराध नहीं हो सकता है जिसमें पहली सूची में और दूसरी सूची में दोनों शामिल हों; हालाँकि, किसी भी सूची में एक अभिलाषा जितनी बार चाहे उतनी बार दिखाई दे सकती है।
इनपुट 1 और 65535 के बीच प्रत्येक (नॉन स्ट्रिक्टली) माना जा सकता है; हालाँकि, यह नहीं माना जा सकता है कि जिन संख्याओं के आउटपुट आपको आउटपुट की आवश्यकता होगी, वे इस सीमा में होंगे।

उदाहरण इनपुट और आउटपुट

यहां कानूनी इनपुट्स और आउटपुट के उदाहरण दिए गए हैं।

input=>output
10,9 => [2,5],[3,3,3]
2,1 => [2],[]
3,1 => [3],[2]
1,5 => [2,3,2],[5]     (elements of a list may be in any order)
3,2 => [3],[2,2]
6,1 => [3],[]

इनपुट्स (2,2), (0,3), (3,0), (3,6) और (1,65536) गैरकानूनी इनपुट्स हैं (अर्थात आपके प्रोग्राम को उन पर किसी विशेष तरीके से व्यवहार करने की आवश्यकता नहीं है। )। यहाँ अवैध आउटपुट के कुछ उदाहरण दिए गए हैं:

1,2 => [2],[2,2] (2 is in both returned lists)
5,2 => [5],[2,4] (4 is not prime)
2,1 => [2],[1] (1 is not prime either)
3,2 => [3],[2] (3!/2! = 3, not 3/2)

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम स्कोर जीतता है!

— कार्ल शिल्डक्राट
स्रोत

क्या घटना को कम से कम तर्कसंगत रूप से कम करने की आवश्यकता है, जवाब देने के कई तरीके हैं? उदाहरण के लिए 10/9= [2*5]/[3*3]= [(2!/1!) * (5!/4!)] / [(3!/2!) * (3!/2!)]= [2! * 5! * 2! * 2!] / [3! * 3! * 1! * 4!]= (2! * 2! * 2! *5!) / (3! * 3! * 4!)।

— डिजिटल ट्रामा

@DigitalTrauma नहीं; हालाँकि, 4 प्रधान नहीं है, इसलिए दूसरा वैध नहीं होगा। मेरा मानना है (और यदि आप चाहें तो प्रश्न में एक प्रमाण लिख सकते हैं) कि कोई प्रतिनिधित्व अद्वितीय है।

— कार्ल शिल्डक्राट

10/9संख्याओं की एक जोड़ी के बजाय अंश के रूप में इनपुट लेना ठीक है 10और 9?

— मिशा लावरोव

@ मिशालोवरोव ज़रूर। मैं उस प्रश्न को संपादित करने के लिए संपादित करूँगा।

— कार्ल शिल्डक्राट

@CarlSchildkraut धन्यवाद - हाँ जो मदद करता है - मुझे लगा कि मुझे कुछ याद आ रहा है

— डिजिटल ट्रॉमा

जवाबों:

05AB1E , 54 53 48 46 40 35 33 32 28 बाइट्स

[D¿÷Z#DÓ€gZD<ØŠQ*DˆR!*]¯øεʒĀ

इसे ऑनलाइन आज़माएं! संपादित करें: @ ASCII- केवल के लिए 2 बाइट्स सहेजे गए। सहेजा गया 1 2 3 4 @Emigna करने के लिए धन्यवाद बाइट्स। (मुझे केवल एक और बचाने की आवश्यकता है और मैं अपनी मूल बाइट संख्या से आधी तक नीचे जा रहा हूं!) स्पष्टीकरण:

[       Begin an infinite loop
D¿÷     Reduce to lowest terms
Z#      Exit the loop if the (largest) value is 1
DÓ€g    Find the index of the largest prime factor of each value
Z       Take the maximum
D<ØŠ    Convert index back to prime and save for later
Q       Convert to an pair of which value had the largest prime factor
*       Convert to an pair with that prime factor and zero
Dˆ      Save the pair in the global array for later
R!*     Multiply the other input value by the factorial of the prime
]       End of infinite loop
¯ø      Collect all the saved primes
εʒĀ     Forget all the saved 0s

— नील
स्रोत

मुझे "इमोशनल" स्क्रिप्ट पसंद है -¦D

— RedClover

46 बाइट्स

— केवल

39 बाइट्स

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

गणितज्ञ, 175 177 169 154 108 बाइट्स

Join@@@Table[x[[1]],{s,{1,-1}},{x,r@#},x[[2]]s]&@*(If[#==1,1,{p,e}=Last@(r=FactorInteger)@#;p^e#0[p!^-e#]]&)

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

यह काम किस प्रकार करता है

यह दो कार्यों की रचना है। पहला, जो ungolfs करने के लिए

If[# == 1,
  1,
  {p,e} = Last[FactorInteger[#]];
  p^e * #0[p!^-e * #]
]&

वास्तव में वांछित कारक की गणना के लिए एक पुनरावर्ती कार्य है। विशेष रूप से, एक तर्कसंगत इनपुट को देखते हुए x, हम उन अपराधों की गणना करते हैं जिनके भाज्य अंश और हर में होने चाहिए, और उन सभी अपराधों को एक साथ गुणा करके वापस लौटाएं। (उदाहरण के लिए, इनपुट पर 10/9 = 2!*5!/(3!*3!*3!), हम वापस लौटते हैं 10/27 = 2*5/(3*3*3)।)

हम हर कदम पर सबसे बड़े प्रमुख कारक के साथ काम करते हैं: यदि पी^e x के गुणन में होता है, तो हम सुनिश्चित करते हैं कि p! ^ई , भाज्य-कारक में होता है, और x को p से विभाजित करता है! ^ई ।

(इससे पहले, मेरे पास एक अधिक चतुर रणनीति थी जो पी से पहले की पिछली संख्या को देखकर बड़ी संख्या से बचती है, लेकिन गणितज्ञ संख्या को 65521 के रूप में बड़ी आसानी से संभाल सकता है। इसलिए, इसका कोई मतलब नहीं है। पुराना संस्करण जो आपको इतिहास में मिल सकता है। बहुत तेजी से: मेरे कंप्यूटर पर, यह इनपुट पर 0.05 सेकंड लेता है जिसे यह संस्करण 1.6 सेकंड में संभालता है।)

दूसरा फ़ंक्शन पहले फ़ंक्शन के आउटपुट को primes की सूची में बदल देता है।

Join @@@ 
  Table[x[[1]],
    {s,{1,-1}},
    {x,FactorInteger[#]},
    x[[2]]*s
  ]&

के लिए s=1(सकारात्मक शक्तियों) और s=-1(नकारात्मक शक्तियों), और प्रत्येक अवधि के लिए{prime,exponent} गुणन में r@#, हम अभाज्य संख्या दोहराने prime exponent*sकई बार।

109 के साथ नॉनकंपेटिंग संस्करण 62 बाइट के

If[#==1,∇1=1,{p,e}=Last@FactorInteger@#;(∇p)^e#0[p!^-e#]]&

उपरोक्त के समान, लेकिन एक सूची के रूप में आउटपुट देने के बजाय, फैक्टरियल के लिए स्टैंड-इन के रूप में (ऑपरेटर (क्योंकि इसका कोई अंतर्निहित अर्थ नहीं है) का उपयोग करके, एक अभिव्यक्ति के रूप में आउटपुट देता है। इस प्रकार, का एक इनपुट10/9(∇2*∇5)/(∇3)^3 प्रतिनिधित्व करने के लिए आउटपुट देता है (2!*5!)/(3!)^3।

यह छोटा है क्योंकि हम फ़ंक्शन के दूसरे भाग को छोड़ देते हैं।

+2 बाइट्स: असाइनमेंट f=First गणितज्ञ को परेशान होने से रोकने के को सही जगह पर करना होगा।

-8 बाइट्स: पूर्णांक आउटपुट के लिए एक बग तय किया, जिसने वास्तव में कोड को छोटा कर दिया।

-15 बाइट्स: FactorInteger रिटर्न सॉर्ट किए गए आउटपुट, जिनका हम लाभ उठा सकते हैं।

-46 बाइट्स: हमें वास्तव में चालाक होने की आवश्यकता नहीं है।

— मिशा लावरोव
स्रोत

पायथन 2, 220 202 195 183 बाइट्स

g=lambda a,b:a and g(b%a,a)or b;n,d=input();m=c=()
while n+d>2:
 t=n*d;f=p=2
 while t>p:
	if t%p:p+=1;f*=p
	else:t/=p
 if n%p:c+=p,;n*=f
 else:m+=p,;d*=f
 t=g(n,d);n/=t;d/=t
print m,c

इसे ऑनलाइन आज़माएं! संपादित करें: @ Mr.Xcoder के लिए 18 25 बाइट्स सहेजे गए। @JonathanFrech के लिए 12 बाइट्स धन्यवाद सहेजे गए।

— नील
स्रोत

202 बाइट्स

— मि। एक्सकोडर

आप इसे पायथन 2 में और भी छोटा कर सकते हैं, क्योंकि आप कई स्थानों को इंडेंटेशन में टैब के साथ बदल सकते हैं

— मिस्टर एक्सकोडर

189 बाइट्स ।

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

183 बाइट्स ।

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