सबसे तेजी से उल्लेखनीय पूर्णांक कारक

Question

कार्य एक समग्र संख्या के गैर-तुच्छ कारक को खोजना है।

कोड लिखें जो आपके कोड के लिए जितनी जल्दी हो सके एक गैर-तुच्छ कारक को अपने कोड के अधीन 140 बाइट्स से अधिक लंबे समय तक नहीं पाता है। आउटपुट केवल आपके द्वारा पाया गया कारक होना चाहिए।

आपका कोड इनपुट ले सकता है और किसी भी तरह से आउटपुट दे सकता है जो कि एक फ़ंक्शन के लिए तर्क के रूप में उदाहरण सहित सुविधाजनक है।

सभी मामलों को सूचीबद्ध करने वाले परीक्षण मामले (आपको केवल एक आउटपुट की आवश्यकता है)

187: 11 17
1679: 23 73
14369648346682547857: 1500450271 9576890767
34747575467581863011: 3628273133 9576890767
52634041113150420921061348357: 2860486313 5463458053 3367900313
82312263010898855308580978867: 264575131106459 311111111111113
205255454905325730631914319249: 2860486313 71755440315342536873 
1233457775854251160763811229216063007: 1110111110111 1000000000063 1111111999999
1751952685614616185916001760791655006749: 36413321723440003717 48112959837082048697

मैं निम्नलिखित कठिन परीक्षा के मामले में आपका जवाब नहीं दूंगा जो परीक्षण के लिए रूचि का हो सकता है:

513231721363284898797712130584280850383: 40206835204840513073 12764787846358441471

स्कोर

आपका स्कोर प्रत्येक असफल कारक के लिए 10 मिनट के दंड के साथ उपरोक्त सभी परीक्षण मामलों को संयुक्त करने का समय है (सभी निकटतम दूसरे के लिए गोल)। आपका कोड अन्य पूर्णांकों के लिए भी काम करना चाहिए, जो कि केवल इन उत्तरों को हार्डकोड नहीं करना चाहिए।

मैं 10 मिनट के बाद आपका कोड बंद कर दूंगा।

अगर दो लोगों को समान स्कोर मिलता है तो पहला उत्तर जीत जाता है।

प्रतिबंध

आपका कोड किसी भी बिलिन या लाइब्रेरी फ़ंक्शन का उपयोग नहीं कर सकता है जो पूर्णांक फैक्टराइजेशन करता है। आप मान सकते हैं कि इनपुट 256 बिट से कम है। सभी इनपुट नंबर समग्र होंगे।

मैं समय कैसे दूंगा?

मैं time ./myprogटाइमिंग करने के लिए अपने उबंटू सिस्टम पर शाब्दिक रूप से चलूंगा इसलिए कृपया मुझे चलाने के लिए एक पूरा कार्यक्रम भी प्रदान करें जिसमें आपके द्वारा परिभाषित कोई भी फ़ंक्शन शामिल हो।

संकलित भाषाओं के लिए एक नोट

संकलन का समय मेरी मशीन पर 1 मिनट से अधिक नहीं होना चाहिए।

क्या यह वास्तव में संभव है?

यदि आप अंतरिक्ष की कमी को अनदेखा करते हैं, तो प्रत्येक को शुद्ध पायथन कोड + पिपी का उपयोग करके मेरे कंप्यूटर पर 2 सेकंड से भी कम समय में फैक्टर किया जा सकता है।

तो एक गैर तुच्छ फैक्टरिंग एल्गोरिथ्म क्या है?

पोलार्ड का आरएच एल्गोरिथ्म तेज और गोल्फ के लिए उपयुक्त है। बेशक एक पूर्णांक कारक के रूप में अच्छी तरह से करने के लिए अन्य तरीके के बहुत सारे हैं ।

इससे भी तेज द्विघात चलनी है । यह 140 बाइट्स में निचोड़ करने के लिए एक गंभीर चुनौती की तरह दिखता है।

अग्रणी स्कोर

• SEJPM , आखिरी टेस्ट केस के लिए 10 मिनट की सजा + 16 सेकंड हास्केल में

Comments

तो, हमें एक नंबर दिया जा सकता है जैसे 2 ** 1024?

— कॉनर ओ'ब्रायन

@ ConorO'Brien आपको परीक्षण मामलों की तुलना में अधिक अंकों के साथ कुछ भी नहीं दिया जाएगा।

तो, परिशुद्धता के संदर्भ में, 256 बिट्स से अधिक कुछ नहीं।

— कॉनर ओ'ब्रायन

4 जैसे इनपुट के लिए, आउटपुट होना चाहिए 2या 2, 2?

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

@AndersKaseorg I ने आपके सुझाव के बाद प्रश्न को अपडेट किया। धन्यवाद।

Answer 1

हास्केल, 100 97 91 89 87 72 67 बाइट्स

यह ऑनलाइन की कोशिश करो!

-3 बाइट्स धन्यवाद @flawr
-6 बाइट्स के लिए धन्यवाद @flawr फिर
-2 बाइट्स के लिए धन्यवाद @flawr करने के लिए धन्यवाद फिर से
-2 बाइट्स मापदंडों के एक अनुकूलित सेट के
लिए धन्यवाद -1 बाइट के लिए धन्यवाद @flawrs अभी तक एक और
-14 बाइट्स आवश्यकता के लिए धन्यवाद केवल एक कारक -5 बाइट्स का उत्पादन
करने के लिए @AndersKaseorg धन्यवाद

f n|let s x=mod(x*x+7)n;a#b|d<-gcd(b-a)n,d>1=d|c<-s b=s a#s c=5#s 5

यह पहले 5 परीक्षण मामलों के लिए अचूक समय में काम करता है।
यह संभवत: सबसे बड़े परीक्षण मामले पर टाइम-आउट होगा।

सामान्य तौर पर यह आमतौर पर सबसे छोटे कारक के वर्गमूल के आनुपातिक में एक गैर-तुच्छ कारक को वापस कर देगा।
यह हर इनपुट पर काम नहीं करेगा क्योंकि यह बहुपद में अंतर नहीं करता है और असाधारण मामले का पता लगाना 140 बाइट्स में करना मुश्किल है।
यह भी पूर्ण कारक का उत्पादन नहीं करेगा, बल्कि एक गैर-तुच्छ कारक और इस कारक द्वारा इनपुट का विभाजन करेगा।
यह आकार के अनुसार कारकों को भी नहीं छांटेगा।

उपयोग की गई विधि पोलार्ड-आरएचओ-फैक्टरिंग है जो 2 के मानक शुरुआती मूल्य ( x^2+1एक बार लागू मानक बहुपद के साथ ) और 7 के गैर-मानक बहुपद निरंतर कारक (क्योंकि 11679 के साथ काम नहीं किया) सभी आगे के मूल्यांकन के लिए।

पूरा कार्यक्रम ( factor.hs):

import System.Environment(getArgs)

f n|let s x=mod(x*x+7)n;a#b|d<-gcd(b-a)n,d>1=d|c<-s b=s a#s c=5#s 5

main= do
      args <- getArgs
      print$f (read $ head args :: Integer)

संकलन $ ghc factor.hs(आवश्यकतानुसार ghcस्थापित)।
के रूप में चलाएँ $ ./factor <number>।

उदाहरण रन:

$ ./factor 187
11

---

अघोषित कोड:

f n=g 5 (s 5)
   where s x=mod(x*x+7)n
         g a b = if d>1 then d else g(s a)(s(s b))
               where d=gcd(b-a)n

gप्रारंभिक मूल्यों के साथ कॉल करके गैर-तुच्छ कारक की गणना करता है । बहुपद को यहां 2 पर पहले से लागू किया जाता है और परिणाम (5) पर फिर से लागू किया जाता है ताकि gcd-test के लिए इनपुट g( "जहां" "खंड" में हमेशा आसानी से उपयोग किया जा सके। g(गोल्फ संस्करण infix का उपयोग करता है #) तो एक गैर-तुच्छ कारक की गणना करने की कोशिश करता है d(जहां अन-गॉल्फर्ड संस्करण में क्लॉज, गोल्फ-इन में एक-लाइन) दोनों आदानों के बीच के अंतर के रूप में g, अगर यह रिटर्न करने में सफल होता है तो कारक कहा जाता है। , और फिर से प्रयास करता है। यहां यह nआउटपुट के रूप में उत्पन्न हो सकता है यदि a==bऔर इस प्रकार केवल एक तुच्छ कारक देता है, तो इसे संभालने के लिए उचित दृष्टिकोण या तो इस घटना पर शुरुआती मूल्यों को अलग कर सकता है या बहुपद को बदल सकता है।

Comments

|1<2=s a#(s$s b)बदला जा सकता है के साथ |c<-s b=s a#s c: मुझे लगता है :) (क्यों आप एक पोस्ट न करें भी TIO लिंक?)

— flawr

मैंने टिप्पणी के सुझावों के बाद सवाल अपडेट किया। अब आपको केवल एक कारक का उत्पादन करने की आवश्यकता है और संख्याओं को समग्र होने की गारंटी है।

पुनश्च: हम क्यों गोल्फ कर रहे हैं, यह भी कोड-गोल्फ नहीं है

— त्रुटी

अब आपके पास 53 बाइट्स हैं जिसमें एक और भी अधिक परिष्कृत फैक्टरिंग एल्गोरिथ्म को लागू करना है :)

इसके अलावा आप बाहर ले जा सकते हैं abs , क्योंकि bहमेशा nonnegative है। (शायद आपका मतलब था abs$b-a, लेकिन gcdनकारात्मक तर्कों को स्वीकार करता है और हमेशा एक nonnegative परिणाम पैदा करता है।) जो इसे आधे से भी कम ट्वीट में लाता है!

— एंडर्स कासोर्ग

Answer 2

परी / जीपी , 137 बाइट्स, ~ 5 सेकंड

जीपी के अंतर्निहित अण्डाकार वक्र संचालन _{(और कुछ अंडरहैंड पैरामीटर ट्यूनिंग) का उपयोग करना} :

ecm(n)=iferr(if(n%2==0,2,n%3==0,3,for(a=1,n,ellmul(ellinit(Mod([a,a^2-a-1],n)),[1,a],lcm([1..ceil(4^a^0.5)])))),e,gcd(n,lift(Vec(e)[3])))

ecmएक ऐसा कार्य है जो एक कारक को लौटाना चाहिए। इसे ऑनलाइन आज़माएं!

परीक्षा:

ecm(n)=iferr(if(n%2==0,2,n%3==0,3,for(a=1,n,ellmul(ellinit(Mod([a,a^2-a-1],n)),[1,a],lcm([1..ceil(4^a^0.5)])))),e,gcd(n,lift(Vec(e)[3])))

{
ns = [
  187,
  1679,
  14369648346682547857,
  34747575467581863011,
  52634041113150420921061348357,
  82312263010898855308580978867,
  205255454905325730631914319249,
  1233457775854251160763811229216063007,
  1751952685614616185916001760791655006749
  ]
}

test(n) = {
    d = ecm(n);
    if (!(1<d && d<n && n%d==0), error(d));
    print(n, ": ", d)
}

apply(test, ns)

quit

Ungolfed:

ecm(n) = {
  iferr(if(n%2 == 0, 2,
           n%3 == 0, 3,
           for(a = 1, n,
               /* x^3 + A*x + B = y^2 */
               E = ellinit(Mod([a, a^2-a-1], n)); /* [A, B] */
               x0 = [1, a]; /* [x, y] */
               B = ceil(4^a^0.5); /* ~ exp(sqrt(log(p))), p ~= exp(a) */
               print("a=", a, ", B=", B);
               ellmul(E, x0, lcm([1..B]))
              )
          ),
         ERR, gcd(n, lift(Vec(ERR)[3] /* = Mod(d, n) */)),
         errname(ERR)=="e_INV")
}

अफसोस की बात है, कारकों 2 और 3 को संभालने से कई बाइट्स का उपयोग होता है। बाइट्स जिनका उपयोग चरण 2 को जोड़ने के लिए किया जा सकता था:

ecm(n)=iferr(for(a=1,n,Y=X=ellmul(E=ellinit(Mod([a,1],n)),[0,1],(B=ceil(4^a^0.5))!);for(z=0,9*B,Y=elladd(E,Y,X))),e,gcd(n,lift(Vec(e)[3])))

Answer 3

Axiom, 137 बाइट्स 9 मिनट

p(n:PI):PI==(j:=1;a:=3;s:=n^.2;repeat(b:=j:=nextPrime(j);repeat(b<s=>(b:=b*j);break);a:=powmod(a,b,n);d:=gcd(a-1,n);d>1 or j>n=>break);d)

फ़ंक्शन p () के ऊपर जो कि p पर परीक्षण के लिए फ़ाइल में कॉपी करने के लिए नीचे फैक्टरिंग के लिए p-1 एल्गो को लागू करेगा।

-- one has to copy this below text in a file name for example file.input
-- in one window where there is Axiom one could write 
-- )read C:\absolutepathwherethereisthatfile\file
-- and call the function test()
-- test()
-- the first character of all function and array must be afther a new line "\n"
)cl all
)time on
vA:=[187,1679,14369648346682547857,34747575467581863011,52634041113150420921061348357,82312263010898855308580978867,205255454905325730631914319249,1233457775854251160763811229216063007, 1751952685614616185916001760791655006749]

p(n:PI):PI==(j:=1;a:=3;s:=n^.2;repeat(b:=j:=nextPrime(j);repeat(b<s=>(b:=b*j);break);a:=powmod(a,b,n);d:=gcd(a-1,n);d>1 or j>n=>break);d)

-- this would try to factor n with p-1 Pollard method
pm1(n:PI):PI==
   j:=1;a:=3;s:=n^.2
   repeat
      b:=j:=nextPrime(j)
      repeat(b<s=>(b:=b*j);break)
      a:=powmod(a,b,n)
      d:=gcd(a-1,n);d>1 or j>n=>break
   d

test()==(for i in 1..#vA repeat output [vA.i, p(vA.i)])

यहाँ परिणाम:

(5) -> test()
   [187,11]
   [1679,73]
   [14369648346682547857,9576890767]
   [34747575467581863011,9576890767]
   [52634041113150420921061348357,2860486313]
   [82312263010898855308580978867,311111111111113]
   [205255454905325730631914319249,2860486313]
   [1233457775854251160763811229216063007,1111111999999]
   [1751952685614616185916001760791655006749,36413321723440003717]
                                                               Type: Void
                              Time: 496.78 (EV) + 53.05 (GC) = 549.83 sec

Comments

क्या आप यह बता सकते हैं कि इस कोड को ubuntu कृपया कमांड लाइन से कैसे चलाएं? मैंने स्वयंसिद्ध स्थापित किया है और इसमें आपके गैर-गोल्फ कोड के साथ foo.ax नामक एक फ़ाइल बनाई है।

@Lembik 1) foo.input 2 में fop.ax का नाम बदलकर) एक टर्मिनल में एक्सोम को चलाते हैं या xterm 3) उस Axiom टर्मिनल में फॉलो कमांड "" पढ़े C: Absolutepath \ foo "4" लिखने के लिए Axiom के टर्मिनल में कॉल करें। परीक्षण करने के लिए ()। यह विंडोज में कैसे किया जाता है, यह मुझे एक Axiom सत्र खोलने के लिए सुराग लगता है और फ़ाइल को ") पढ़ें" कमांड

— RosLuP

@ लेम्बिक अगर फ़ाइलों के साथ कोई समस्या है तो मुझे लगता है कि यह भी ठीक होगा: 1) रन एक्सिओम 2) लेखन) समय पर <वापसी> एक्सिकॉम प्रोग्राम 3 में) कॉपी पेस्ट और प्रेस के प्रत्येक "कॉपी पेस्ट" को एक्सिस प्रोग्राम में दबाएं:

— ऐसोम

@ लिम्बिक तो क्या समय लगता है?

— RosLuP

Answer 4

Axiom, 10 मिनट + 31 सेकंड

A(a)==>a:=(a*a+7)rem n;z(n)==(p:=a:=b:=101;for i in 1..repeat(A(a);A(b);A(b);p:=mulmod(p,a-b,n);i rem 999<9=>(p:=gcd(p,n);p>1=>break));p)

z () फ़ंक्शन आरएचओ है, एक 137 बाइट्स फ़ंक्शन; ungolfed z () और इसे rho () कहते हैं। ऐसा लगता है कि gcd (0, n) = n इतना लूप बंद हो जाता है और असफल n पर वापस आ जाता है।

)time on    
rho(n)==
  p:=a:=b:=101
  for i in 1..repeat
          A(a);A(b);A(b)
          p:=mulmod(p,a-b,n)
          i rem 999<9=>(p:=gcd(p,n);p>1=>break)
  p

va1:=[187,1679,14369648346682547857,34747575467581863011,52634041113150420921061348357,82312263010898855308580978867,205255454905325730631914319249,1233457775854251160763811229216063007, 1751952685614616185916001760791655006749]
p1()==(for i in 1..#va1-1 repeat output [va1.i,z(va1.i)]) 

परिणाम (z) सभी के लिए ठीक है, लेकिन अंतिम संख्या 1751952685614616185916001760791655006749 तथ्यात्मक नहीं है (10 मिनट)

(6) -> p1()
   [187,17]
   [1679,23]
   [14369648346682547857,1500450271]
   [34747575467581863011,3628273133]
   [52634041113150420921061348357,2860486313]
   [82312263010898855308580978867,264575131106459]
   [205255454905325730631914319249,2860486313]
   [1233457775854251160763811229216063007,1111111999999]
                                                               Type: Void
                                 Time: 30.38 (EV) + 1.38 (GC) = 31.77 sec

(8) -> z(1679)
   (8)  23
                                                    Type: PositiveInteger
                                                              Time: 0 sec

Answer 5

पायथन 3 , 100 99 बाइट्स, 45 40 39 सेकंड + 10 मिनट जुर्माना

import math
def f(n):
 x=y=2;d=1
 while d<2:y=y*y+1;x,y=1+x*x%n,y*y%n+1;d=math.gcd(x-y,n)
 return d

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

प्रारंभिक मूल्य 2 और बहुपद x ^ 2 + 1 के साथ पोलार्ड-आरएचओ का उपयोग करता है।

Comments

आप powअपनी निष्पादन गति को बेहतर बनाने के लिए (3 तर्क के साथ) का उपयोग कर सकते हैं ।

— mbomb007