फ़र्मेट का कारकत्व सहायक

Question

हम एक सेमीप्राइम को कारक बनाना चाहते हैं । इस चुनौती का लक्ष्य दो छोटे पूर्णांक और को खोजना है, ताकि को Fermat की विधि के साथ तुच्छ रूप से कारक जा सके, इस प्रकार के कारकों को आसानी से घटाया जा सकता है ।यू वी यू वी एन $N$$u$$v$$uvN$$N$

काम

एक सेमी और एक सकारात्मक पूर्णांक को देखते हुए , हम और को इस प्रकार परिभाषित करते हैं :के एक्स $N$$k$$x$$y$

y=x2-k

$$x=\lceil\sqrt{kN}\rceil$$ $$y=x^2-kN$$

चरण # 1 - खोजें$k$

आपको सबसे पहले का सबसे छोटा संभव मान ज्ञात करने की आवश्यकता है जैसे कि एक वर्ग संख्या ( उर्फ सही वर्ग) है।$k$$y$

यह को फेटर्म के फैक्टराइजेशन विधि के एकल पुनरावृत्ति के साथ कारक बनाने की अनुमति देता है । अधिक संक्षेप में, यह तुरंत होता है:$kN$

$$kN=(x+\sqrt{y})\times(x-\sqrt{y})$$

(अपडेट: यह क्रम अब A316780 के रूप में प्रकाशित हुआ है )

चरण # 2 - फैक्टराइज़$k$

फिर आपको दो पॉजिटिव पूर्णांक और जैसे खोजने होंगे :$u$$v$

सी यू = एक्स +

$$uv=k$$ घवी=एक्स- $$cu=x+\sqrt{y}$$ $$dv=x-\sqrt{y}$$

जहाँ और के मुख्य कारक हैं ।डी $c$$d$$N$

सारांश

आपका काम एक प्रोग्राम या फ़ंक्शन लिखना है जो को इनपुट के रूप में लेता है और किसी भी क्रम और किसी भी उचित प्रारूप में और आउटपुट करता है।यू $N$$u$$v$

उदाहरण

आइए विचार करें$N = 199163$

चरण 1

का सबसे छोटा संभव मान , जो देता है:$k$$40$

y=28232-40×199,163=+७९६९३२९-+७९,६६,५२०=2809=532कश्मीरएन=(2823+53)×(2823-53)kएन=2876×

$$x = \lceil(\sqrt{40 \times 199163})\rceil = 2823$$ $$y = 2823^2 - 40 \times 199163 = 7969329 - 7966520 = 2809 = 53^2$$ $$kN = (2823 + 53) \times (2823 - 53)$$ $$kN = 2876 \times 2770$$

चरण 2

का सही गुणनखण्ड , क्योंकि:k = 4 × $k$$k = 4 \times 10$

$$kN = 2876 \times 2770$$ $$kN = (719 \times 4) \times (277 \times 10)$$ $$N = 719 \times 277$$

तो, सही उत्तर या तो या ।$[ 4, 10 ]$$[ 10, 4 ]$

नियम

• ऊपर वर्णित दो चरणों को सख्ती से लागू करने की आवश्यकता नहीं है। आप किसी भी अन्य विधि का उपयोग करने के लिए स्वतंत्र हैं, जब तक कि यह और के सही मूल्यों को नहीं खोज लेता है ।$u$$v$
• आपको अपनी भाषा में अहस्ताक्षरित पूर्णांक के मूल अधिकतम आकार तक सभी मूल्यों का समर्थन करना चाहिए ।$uvN$
• इनपुट को सेमीप्राइम होने की गारंटी है।
• यह कोड-गोल्फ है, इसलिए बाइट्स में सबसे कम जवाब जीतता है।
• मानक खामियों को मना किया जाता है।

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

N          | k    | Output
-----------+------+------------
143        | 1    | [   1,  1 ]
2519       | 19   | [   1, 19 ]
199163     | 40   | [   4, 10 ]
660713     | 1    | [   1,  1 ]
4690243    | 45   | [   9,  5 ]
11755703   | 80   | [  40,  2 ]
35021027   | 287  | [   7, 41 ]
75450611   | 429  | [ 143,  3 ]
806373439  | 176  | [   8, 22 ]
1355814601 | 561  | [  17, 33 ]
3626291857 | 77   | [   7, 11 ]
6149223463 | 255  | [  17, 15 ]
6330897721 | 3256 | [  74, 44 ]

उदाहरण कार्यान्वयन

$f$$N$$u$$v$

$g$$N$$u$$v$$N$$O(1)$

f = N => {
  for(k = 1;; k++) {
    x = Math.ceil(Math.sqrt(k * N));
    y = x * x - k * N;
    ySqrt = Math.round(Math.sqrt(y));
    
    if(ySqrt * ySqrt == y) {
      p = x + ySqrt;

      for(u = 1;; u++) {
        if(!(p % u) && !(N % (p / u))) {
          v = k / u;
          return [ u, v ];
        }
      }
    }
  }
}

g = (N, u, v) => {
  x = Math.ceil(Math.sqrt(u * v * N));
  y = x * x - u * v * N;
  ySqrt = Math.round(Math.sqrt(y));
  p = x + ySqrt;
  q = x - ySqrt;
  return [ p / u, q / v ];
}

[
  143, 2519, 199163, 660713, 4690243, 11755703,
  35021027, 75450611, 806373439, 1355814601,
  3626291857, 6149223463, 6330897721
]
.map(N => {
  [u, v] = f(N);
  [c, d] = g(N, u, v);
  console.log(
    'N = ' + N + ', ' +
    'u = ' + u + ', ' +
    'v = ' + v + ', ' +
    'N = ' + c + ' * ' + d
  );
});

Comments

क्या हम इस बात की गारंटी देते हैं कि इनपुट Nवास्तव में एक सेमीप्राइम होगा?

— ग्रेग मार्टिन

@GregMartin हाँ आप हैं।

— Arnauld

Answer 1

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

2 बाइट्स बचाने के लिए मार्टिन एंडर को धन्यवाद!

(c=Ceiling;For[j=0;z=E,c@z>z,p=(x=c@Sqrt[j+=#])+{z=Sqrt[x^2-j],-z}];p/#~GCD~p)&

शुद्ध फ़ंक्शन इनपुट के रूप में एक अर्धवृत्त ले रहा है और सकारात्मक पूर्णांकों की एक जोड़ी को वापस कर रहा है। Forपाश लागू सटीक प्रक्रिया प्रश्न में वर्णित (का उपयोग कर #के स्थान पर इनपुट के लिए nके साथ), xके रूप में वहाँ परिभाषित है, हालांकि हम स्टोर j = k*nकरने के बजाय kखुद को और z=Sqrt[y]के बजाय yखुद को। हम लूप के p={x+z,x-z}अंदर भी गणना करते हैं For, जो एक बाइट (सातवें प्रयास की तरह) की बचत को समाप्त करता है। फिर दो वांछित कारक हैं (x+z)/GCD[#,x+z]और (x-z)/GCD[#,x-z], जो संक्षिप्त अभिव्यक्ति p/#~GCD~pएक आदेशित जोड़ी के रूप में सीधे गणना करता है।

जिज्ञासा: हम zएक पूर्णांक होने तक लूप करना चाहते हैं ; लेकिन जब से हम Ceilingपहले से ही कोड में उपयोग करने जा रहे हैं , यह दो बाइट्स !IntegerQ@zको परिभाषित करने के लिए बचाता है c=Ceiling(जो कि चार बाइट्स खर्च करता है, जैसा कि गणितज्ञ गोल्फर्स जानते हैं) और फिर परीक्षण करें कि क्या c@z>z। हमें कुछ को इनिशियलाइज़ zकरना है, और यह कि कुछ बेहतर नहीं था एक पूर्णांक होना चाहिए ताकि लूप शुरू हो सके; सौभाग्य से, Eएक संक्षिप्त विकल्प है।

Answer 2

जावास्क्रिप्ट (ईएस 7), 86 81 बाइट्स

n=>(g=k=>(y=(n*k)**.5+1|0,y+=(y*y-n*k)**.5)%1?g(k+1):n*u++%y?g(k):[--u,k/u])(u=1)

संपादित करें: @Annauld के लिए 4 बाइट्स सहेजे गए।

Answer 3

अजगर 2, 127 121 117 111 107 104 101 99 बाइट्स

नील और -3 बाइट्स के लिए ओट्स की बदौलत -1 बाइट

N=input()
k=u=1;p=m=.5
while p%1:p=1+(k*N)**m//1;p+=(p*p-k*N)**m;k+=1
while N*u%p:u+=1
print~-k/u,u

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

Curiosities:

pको प्रारंभिक किया गया है .5ताकि पहले पुनरावृत्ति पर लूप की स्थिति सही हो। ध्यान दें कि यह स्टोर करने के लिए कम है p( x+ + sqrt(y)) की तुलना में यह प्रत्येक xऔर yअलग-अलग स्टोर करना है ।

Comments

x*xके बजाय x**2?

— नील

@ नील हां, बिल्कुल। धन्यवाद

— गणित जंकी

Answer 4

Axiom, 131 115 बाइट्स

v(x)==floor(x^.5)::INT;r(n)==(k:=0;repeat(k:=k+1;x:=1+v(k*n);y:=v(x*x-k*n);x^2-y^2=k*n=>break);[w:=gcd(k,x+y),k/w])

प्रश्न को हल करने वाला फ़ंक्शन ऊपर (r) r (n) है। ungolf and test

vv(x)==floor(x^.5)::INT    

--(x-y)*(x+y)=k*n
rr(n)==
  k:=0
  repeat
     k:=k+1
     x:=1+vv(k*n)
     y:=vv(x*x-k*n)
     x^2-y^2=k*n=>break
  [w:=gcd(k,x+y),k/w]


(4) -> [[i,r(i)] for i in [143,2519,199163,660713,4690243,11755703]]
   (4)
   [[143,[1,1]], [2519,[1,19]], [199163,[4,10]], [660713,[1,1]],
    [4690243,[9,5]], [11755703,[40,2]]]
                                                      Type: List List Any