एक गाऊसी पूर्णांक को फैक्टराइज़ करें

Question

एक गाऊसी पूर्णांक एक जटिल संख्या जिसका असली और काल्पनिक भागों पूर्णांक हैं है।

गॉज़ियन पूर्णांक, सामान्य पूर्णांकों की तरह, एक अनोखे तरीके से गौसियन प्रिम्स के उत्पाद के रूप में प्रस्तुत किए जा सकते हैं। यहां चुनौती एक दिए गए गौसियन पूर्णांक के प्रमुख घटकों की गणना करना है।

इनपुट: एक गाऊसी पूर्णांक, जो 0 के बराबर नहीं है और एक इकाई नहीं है (यानी 1, -1, i और -i को इनपुट के रूप में नहीं दिया जा सकता है)। उदाहरण के लिए, किसी भी समझदार प्रारूप का उपयोग करें:

• 4-5i
• -5 * जे 4
• (4, -5)

आउटपुट: गाऊसी पूर्णांकों की एक सूची, जो अभाज्य हैं (अर्थात उनमें से किसी को भी दो गैर-इकाई गौसियन पूर्णांकों के उत्पाद के रूप में प्रस्तुत नहीं किया जा सकता है), और जिसका उत्पाद इनपुट संख्या के बराबर है। आउटपुट सूची के सभी नंबर गैर-तुच्छ होने चाहिए, अर्थात 1, -1, i या -i नहीं। किसी भी समझदार आउटपुट प्रारूप का उपयोग किया जा सकता है; यह आवश्यक रूप से इनपुट प्रारूप के समान नहीं होना चाहिए।

यदि आउटपुट सूची में 1 से अधिक तत्व हैं, तो कई सही आउटपुट संभव हैं। उदाहरण के लिए, इनपुट 9 के लिए आउटपुट [3, 3] या [-3, -3] या [3i, -3i] या [-3i, 3i] हो सकता है।

परीक्षण के मामले, ( इस तालिका से लिया गया ; प्रति परीक्षण मामले में 2 लाइनें)

2
1+i, 1-i

3i
3i

256
1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i

7+9i
1+i,2−i,3+2i

27+15i
1+i,3,7−2i

6840+585i
-1-2i, 1+4i, 2+i, 3, 3, 6+i, 6+i

गौसियन पूर्णांक फैक्टरिंग के लिए अंतर्निहित कार्यों की अनुमति नहीं है। अंतर्निहित कार्यों के द्वारा साधारण पूर्णांक फैक्टरिंग की अनुमति है, हालांकि।

Comments

के 3iरूप में वापस आना चाहिए 3,i, या 3i?

— मूल्य इंक

3iसही उत्तर है क्योंकि iप्रधान नहीं है। मैंने इसे स्पष्ट करने के लिए परीक्षण मामले को अद्यतन किया है।

— एंथोलीग

-3-2j, 2-1j, -1-1j 7 + 9j के गुणन के लिए एक सही उत्तर है?

— mdahmoune

वोल्फ्राम अल्फा के अनुसार, 6840+585iकारकों की गलत सूची है, जैसा 5कि गॉसियन प्राइम नहीं है। इसके बजाय, यह वापस लौटता है -1-2i, 1+4i, 2+i, 3, 3, 6+i, 6+i। स्रोत

— वैल्यू इंक

FYI करें, इसलिए 256=(1+i)**16नहीं (1+i)**8कि 256=2**8=(2i)**8और2i=(1+i)**2

— Shieru Asakoto

Answer 1

जेली , 61 55 बाइट्स

Ḟ,Ċ1ḍP
Ḟ,ĊḤp/-,1p`¤×€×1,ıFs2S€⁸÷ÇÐfỊÐḟ1;Ṫð,÷@\ḟ1
Ç€F$ÐL

इसे ऑनलाइन आज़माएं! (हैडर और फुटर आउटपुट को प्रारूपित करता है)

-6 बाइट्स @EricTheOutgolfer की बदौलत

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

Ḟ,Ċ1ḍP  - helper function: determines if a complex number is Gaussian
Ḟ,Ċ       - real, complex components
   1ḍ     - set each to if 1 divides them
     P    - all

Ḟ,ĊḤp/-,1p`¤×€×1,ıFs2S€⁸÷ÇÐfỊÐḟ1;Ṫð,÷@\ḟ1 - helper: outputs a factor pair of the input
Ḟ,ĊḤp/                   - creates a list of possible factors a+bi, a,b>=0
      -,1p`¤×€           - extend to the other three quadrants 
              ×1,ıFs2S€  - convert to  actual complex numbers 
⁸÷                       - get quotient with input complex number
  ÇÐf                    - keep only Gaussian numbers (using helper function)
     ỊÐḟ                 - remove units (i,-i,1,-1)
        1;               - append a 1 to deal with primes having no non-unit factors
          Ṫð,÷@\         - convert to a factor pair
                ḟ1       - remove 1s
Ç€F$ÐL
Ç€      - factor each number
   $    - and
  F     - flatten the list
    ÐL  - until factoring each number and flattening does not change the list

Comments

आप नीचे 6 बाइट्स प्राप्त कर सकते हैं ... और अपने हेडर और फुटर को बहुत अधिक से गोल्फ कर सकते हैं!

— आउटगॉल्फ जूल

जब यह कहता है कि "केवल गॉसियन रखो" का अर्थ है "केवल प्राइम्स रखना"?

— उज्ज्वल

@donbright नहीं, यह पूर्णांक वास्तविक और जटिल घटकों के साथ केवल उन जटिल संख्याओं को रखने के लिए संदर्भित करता है

— fireflame241

@ fireflame241 ओह अब मैं देख रहा हूँ! बहुत बहुत धन्यवाद

— उज्ज्वल

Answer 2

रूबी , 258 256 249 246 + 8 = 264 257 254 बाइट्स

-rprimeझंडे का उपयोग करता है ।

Geez, क्या गड़बड़ है।

इस एल्गोरिथ्म का उपयोग स्टैकओवरफ़्लो से करता है।

->c{m=->x,y{x-y*eval("%d+%di"%(x/y).rect)};a=c.abs2.prime_division.flat_map{|b,e|b%4<2?(1..e).map{k=(2..d=b).find{|n|n**(~-b/2)%b==b-1}**(~-b/4)%b+1i;d,k=k,m[d,k]while k!=0;c/=d=m[c,d]==0?d:d.conj;d}:(c/=b<3?(b=1+1i)**e:b**e/=2;[b]*e)};a[0]*=c;a}

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

Answer 3

पायथन 2 , 250 239 223 215 बाइट्स

e,i,w=complex,int,abs
def f(*Z):
 if Z:
	z=Z[0];q=i(w(z));Q=4*q*q
	while Q>0:
 	 a=Q/q-q;b=Q%q-q;x=e(a,b)
 	 if w(x)>1:
		y=z/x
		if w(y)>1 and y==e(i(y.real),i(y.imag)):f(x,y);z=Q=0
 	 Q-=1
	if z:print z
	f(*Z[1:])

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

• एकाधिक फ़ंक्शन तर्क का उपयोग करते समय -11 बाइट्स
• जोड़े को पार्स करने के लिए एक चर का उपयोग करते समय -2 * when बाइट्स (a,b)
• -2 बाइट्स जब टैब और स्पेस को मिलाते हैं: ओव्स के लिए धन्यवाद

जब तक कोई अपघटन संभव नहीं होता है, तब तक कुछ स्पष्टीकरण जटिल से दो परिसरों तक विघटित हो जाते हैं ...

Comments

खैर, यह बड़े आदानों पर टीआईओ में कई बार निकला है, लेकिन यह मेरे रूबी जवाब से छोटा है ... अभी के लिए । इसके अलावा, def f(Z,s=[])आपको एक चरित्र को सहेजना चाहिए

— वैल्यू इंक

@ValueInk हाँ यह आपके रूबी समाधान की तुलना में धीमा है

— mdahmoune

इंडेंटेशन के साथ दिलचस्प पैटर्न ...

— एरिक द आउटग्राफर

@ValueInk कई समारोह तर्क अधिक बाइट बचाता है :)

— mdahmoune

आप टैब और रिक्त स्थान

— Ov

Answer 4

जंग - 212 बाइट्स

use num::complex::Complex as C;fn f(a:&mut Vec<C<i64>>){for _ in 0..2{for x in -999..0{for y in 1..999{for i in 0..a.len(){let b=C::new(x,y);if(a[i]%b).norm_sqr()==0&&(a[i]/b).norm_sqr()>1{a[i]/=b;a.push(b)}}}}}}

अगर यह 100% सही काम करता है तो मुझे 100% यकीन नहीं है, लेकिन यह परीक्षण की एक बड़ी श्रृंखला के लिए सही प्रतीत होता है। यह जेली से छोटा नहीं है, लेकिन कम से कम यह व्याख्या की गई भाषाओं (अब तक) से छोटा है। यह भी तेज प्रतीत होता है और एक सेकंड से भी कम समय में एक अरब परिमाण के इनपुट के माध्यम से काम कर सकता है। उदाहरण के लिए 1234567890 + 3141592650i कारक (-9487 + 7990i) (- 1 + -1i) (- 395 + 336i) (2 + -1i) (1 + 1i) (3 + 0i) (3 + 0i) (4+) 1 मैं) (- 1 + 1 मैं) (- 1 + 2i), (वुल्फराम अल्फा पर परीक्षण करने के लिए यहां क्लिक करें)

यह पूर्णांक के भोले तथ्य के रूप में एक ही विचार के रूप में शुरू हुआ, प्रश्न में पूर्णांक के नीचे प्रत्येक संख्या के माध्यम से जाने के लिए, यह देखें कि क्या यह विभाजित होता है, जब तक दोहराएं। फिर, अन्य उत्तरों से प्रेरित होकर, यह रूपांतरित हुआ ... यह एक वेक्टर में बार-बार कारकों को जोड़ता है। यह कई बार ऐसा करता है, लेकिन 'कुछ भी' होने तक नहीं। उचित आदानों का एक अच्छा हिस्सा कवर करने के लिए पुनरावृत्तियों की संख्या को चुना गया है।

यह अभी भी परीक्षण करने के लिए "(एक मॉड बी) == 0" का उपयोग करता है कि क्या एक पूर्णांक दूसरे को विभाजित करता है (गौसियंस के लिए, हम बिल्ट रस्ट गाऊसी मोडुलो का उपयोग करते हैं, और "0" को मानदंड == 0) मानते हैं, हालांकि 'मानक' के लिए जांच करें a / b)! = 1 '"बहुत अधिक" को विभाजित करने से रोकता है, मूल रूप से परिणामी वेक्टर को केवल प्राइम से भरने की अनुमति देता है, लेकिन वेक्टर के किसी भी तत्व को एकता में नहीं ले जा रहा है (0-i, 0 + i, -1 + 0i, 1 + 0i) (जो प्रश्न से निषिद्ध है)।

प्रयोग के माध्यम से लूप की सीमाएं पाई गईं। डिवाइड-बाय-ज़ीरो पैनिक को रोकने के लिए y 1 से ऊपर जाता है, और x -999 से 0 तक जा सकता है। क्वैडेंट्स के ऊपर गॉसियंस के मिररिंग के लिए धन्यवाद (मुझे लगता है?)। सीमाओं के संबंध में, मूल प्रश्न इनपुट / आउटपुट की एक वैध सीमा का संकेत नहीं देता है, इसलिए "उचित इनपुट आकार" माना जाता है ... (संपादित करें ... हालांकि मुझे यह निश्चित नहीं है कि यह किस संख्या में गणना की जाएगी "असफल" होना शुरू करें, मुझे लगता है कि गॉसियन पूर्णांक हैं जो 999 से नीचे की किसी भी चीज से विभाज्य नहीं हैं, लेकिन मेरे लिए अभी भी आश्चर्यजनक रूप से छोटे हैं)

पर कुछ हद तक ungolfed संस्करण का प्रयास करें play.rust-lang.org

Answer 5

पर्ल 6 , 141 124 बाइट्स

-17 बाइट्स के लिए जो किंग को धन्यवाद

sub f($_){{$!=0+|sqrt .abs²-$^a²;{($!=$_/my \w=$^b+$a*i)==$!.floor&&.abs>w.abs>1>return f w&$!}for -$!..$!}for ^.abs;.say}

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

Comments

यह कैसे काम करता है? मंजिल एक कस्टम निर्मित modulo है?

— उज्ज्वल

@donbright floorभाग की जाँच कर रहा है अगर $_/w(यानी एक संख्या से विभाजित वर्तमान कारक) एक पूरी संख्या है

— जो राजा

Answer 6

पायथ , 54 51 45 42 36 बाइट्स

 .W>H1cZ
h+.aDf!%cZT1>#1.jM^s_BM.aZ2

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

फॉर्म में इनपुट स्वीकार करता है 1+2j- विशुद्ध रूप से वास्तविक या काल्पनिक संख्या अन्य घटक (जैसे 9, 2j) को छोड़ सकती है । आउटपुट फॉर्म में जटिल संख्याओं की एक नई-अलग-अलग सूची है(1+2j) , वास्तविक रूप से शुद्ध काल्पनिक संख्याओं के साथ।

यह सरल ट्रेल डिवीजन का उपयोग करता है, सभी गॉसियन पूर्णांकों को 1 से अधिक परिमाण के साथ उत्पन्न करता है और वर्तमान मूल्य से कम है, साथ ही साथ मान भी। इन्हें उन लोगों को रखने के लिए फ़िल्टर किया जाता है जो मूल्य के एक कारक हैं, और परिमाण द्वारा सबसे छोटा अगले प्रमुख कारक के रूप में चुना जाता है। यह आउटपुट है, और अगले पुनरावृत्ति के लिए मूल्य का उत्पादन करने के लिए इसे मूल्य से विभाजित किया गया है।

इसके अलावा, पाइथ ने जैली, की पिटाई की (मुझे हालांकि इसकी उम्मीद नहीं है)

 .W>H1cZ¶h+.aDf!%cZT1>#1.jM^s_BM.aZ2ZQ   Implicit: Q=eval(input())
                                         Newline replaced with ¶, trailing ZQ inferred
 .W                                  Q   While <condition>, execute <inner>, with starting value Q
   >H1                                   Condition function, input H
   >H1                                     Is magnitude of H > 1?
                                           This ensures loop continues until H is a unit, i.e. 1, -1, j, or -j)
      cZ¶h+.aDf!%cZT1>#1.jM^s_BM.aZ2Z    Inner function, input Z
                                .aZ        Take magnitude of Z

                             _BM           Pair each number in 0-indexed range with its negation
                            s              Flatten
                           ^       2       Cartesian product of the above with itself
                        .jM                Convert each pair to a complex number
                      #                    Filter the above to keep those element where...
                     > 1                   ... the magnitude is greater than 1 (removes units)
              f                            Filter the above, as T, to keep where:
                 cZT                         Divide Z by T
                %   1                        Mod real and imaginary parts by 1 separately
                                             If result of division is a gaussian integer, the mod will give (0+0j)
               !                             Logical NOT - maps (0+0j) to true, all else to false
                                           Result of filter are those gaussian integers which evenly divide Z
           .aD                             Sort the above by their magnitudes
          +                         Z      Append Z - if Z is ±1±1j, the filtered list will be empty
         h                                 Take first element, i.e. smallest factor
        ¶                                  Print with a newline
      cZ                                   Divide Z by that factor - this is new input for next iteration
                                         Output of the while loop is always 1 (or -1, j, or -j) - leading space suppesses output

Comments

यह बहुत दिलचस्प है लेकिन यह 6840 + 585j पर मध्यांतर प्रतीत होता है

— उज्ज्वल

@donbright यह TIO पर करता है, क्योंकि इसमें 60 के दशक की प्रोसेसिंग सीमा है। यह अधिक समय के साथ काम करेगा, इसलिए यदि आप इसे स्थानीय रूप से चला रहे हैं तो इसे बिना किसी समस्या के काम करना चाहिए।

— सोक