चुनौती

एक फ़ंक्शन या प्रोग्राम लिखें जो एक सकारात्मक दशमलव संख्या लेता है, इसे A कहें , और दो सकारात्मक संख्याओं, B और C को आउटपुट करें , जैसे:

ए == बी बिट्कोर सी
B और C के दशमलव में 0, 3 या 7 अंक नहीं होने चाहिए।

उदाहरण

>>> decompose(3)
1, 2
>>> decompose(7)
1, 6
>>> decompose(718)
121, 695
>>> decompose(99997)
2, 99999
>>> decompose(4294967296)
4294968218, 922
>>> decompose(5296080632396965608312971217160142474083606142654386510789497504098664630388377556711796340247136376)
6291484486961499292662848846261496489294168969458648464915998254691295448225881546425551225669515922,
1191982455588299219648819556299554251659915414942295896926425126251962564256469862862114191986258666

चूंकि अपघटन अद्वितीय नहीं है, इसलिए आपके फ़ंक्शन / प्रोग्राम को इन समान उदाहरणों के समान सटीक परिणाम देने की आवश्यकता नहीं है।

बहुत विस्तृत नियम

प्रस्तुतियाँ एक पूर्ण कार्य या कार्यक्रम के रूप में होनी चाहिए । importबयान करते अंतिम स्कोर की गणना में शामिल।
आप मान सकते हैं कि इनपुट A में हमेशा 0, 3 या 7 का अंक होता है।
आप मान सकते हैं कि एक अपघटन हमेशा मौजूद होता है।
यदि आप भाषा के मानक पुस्तकालयों का हिस्सा हैं, तो आप BigInt का उपयोग कर सकते हैं या भाषा के de jure पैकेज मैनेजर के माध्यम से स्थापित किए जा सकते हैं ।
फ़ंक्शन तेज होना चाहिए। 100-अंकीय संख्या के खिलाए जाने पर, आधुनिक कंप्यूटर पर चलने में 20 सेकंड से अधिक नहीं होना चाहिए , और 10-अंकीय संख्या को खिलाए जाने पर 2 सेकंड से अधिक नहीं होना चाहिए ।
फ़ंक्शन / प्रोग्राम को कम से कम 100 अंकों तक इनपुट का समर्थन करना चाहिए ।
- यदि फ़ंक्शन / प्रोग्राम केवल एन <100 अंकों तक पूर्णांकों का समर्थन कर सकता है, तो अंतिम स्कोर पर + 10 × (100 / एन - 1) बाइट का जुर्माना होगा । यह गोल्फरों को प्रोत्साहित करने के लिए संख्याओं की एक विस्तृत श्रृंखला का समर्थन करने के लिए प्रोत्साहित करना है, भले ही आयात क्रिया हो सकता है।
नहीं है प्रस्तुति पर कोई प्रतिबंध नहीं इनपुट / आउटपुट के रूप में लंबे समय के रूप में वे दशमलव प्रतिनिधित्व स्पष्ट रूप से कर रहे हैं।
- फ़ंक्शन इनपुट और आउटपुट स्ट्रिंग्स / BigInts हो सकता है यदि अंतर्निहित पूर्णांक प्रकार पर्याप्त नहीं हैं।
- इनपुट फ़ंक्शन पैरामीटर, कमांड लाइन तर्क या एसटीडीआईएन से आ सकता है।
- फ़ंक्शन परिणाम वापस कर सकता है, या बस परिणाम को सीधे STDOUT में प्रिंट कर सकता है।
- हालाँकि, इनपुट / आउटपुट में हस्ताक्षरित अतिप्रवाह की अनुमति नहीं है।
- अनुमानित उत्तर बर्दाश्त नहीं किए जाते हैं, इनपुट / आउटपुट सटीक होना चाहिए।

स्कोरिंग

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

यदि प्रोग्राम केवल 100 अंकों से कम संख्या का समर्थन कर सकता है तो एक जुर्माना है:

64-बिट पूर्णांक (19 अंक) = +42 बाइट्स
63-बिट पूर्णांक (18 अंक) = +45 बाइट्स
53-बिट पूर्णांक (15 अंक) = +56 बाइट्स
31/32-बिट पूर्णांक (9 अंक) = +101 बाइट्स

code-golf number

— kennytm
स्रोत

2

क्या आप सुनिश्चित हैं कि इस तरह का अपघटन हमेशा संभव है? क्या आप मुझे एक सबूत दे सकते हैं?

— जॉन ड्वोरक

कोई व्यक्ति 1, 5, 9 को 95 मूवी क्वेश् स में सवाल करता है ।

— jimmy23013

3

100 अंक? इसका मतलब यह है कि पायथन सीधे जीतता है, क्योंकि यह यहां आमतौर पर इस्तेमाल की जाने वाली भाषा है जो मनमाने ढंग से सटीक पूर्णांक का समर्थन करती है। क्यों नहीं 19 अंक, जो एक 64-लेकिन अहस्ताक्षरित पूर्णांक में फिट बैठता है? (2 ^ 64 = 18 446 744 073 709 551 616)

— लेवल रिवर सेंट

5

@steveverrill Mathematica ... GolfScript ... CJam ...

— मार्टिन

1

और जावा (यह कहना था)

— यपनीप एनएन

2

सीजेएम, 70 बाइट्स

ri:Q{;Qmr_Q^`1$`+730`&}g_Q^p

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

रैंडम रूप से पूर्णांकों का चयन तब तक करता है जब तक कि वह एक मैच नहीं पाता। यह बमुश्किल 64-बिट पूर्णांक (जावा दुभाषिया का उपयोग करके) के लिए 20 दूसरी सीमा का अनुपालन करता है, इसलिए मैंने वास्तविक बाइट गिनती में 42 जोड़ दिए हैं।

उदाहरण चलाते हैं

$ cjam t <<< 7777777777; echo
2695665494
6161166119

— डेनिस
स्रोत

10

आम लिस्प, 240 224 183 173 169 बाइट्स

आम लिस्प गोल्फिंग के लिए एक बिट क्रिया है। हालांकि, यह एक सेकंड के तहत 100-अंकीय संख्याओं को घटाता है, और 200-अंकीय पूर्णांक दस सेकंड से भी कम समय में होता है, इसलिए दंड की आवश्यकता नहीं है। एल्गोरिथ्म निर्धारक है।

(defun s(z)(and #1=(some(lambda(q)(position q(format()"~a"z)))"037")(+ z(floor z(expt 10 #1#)))))
(defun d(x)(do((y x(or(s y)(s #3=(logxor x y))(return`(,y,#3#)))))(())))

कार्यों के बीच लाइन फ़ीड केवल टाइपोग्राफिक उद्देश्यों के लिए है। 100 अंकों के संदर्भ इनपुट के साथ टेस्ट रन:

(time (d 5296080632396965608312971217160142474083606142654386510789497504098664630388377556711796340247136376))
took 677,000 microseconds (0.677000 seconds) to run.
      20,989 microseconds (0.020989 seconds, 3.10%) of which was spent in GC.
During that period, and with 8 available CPU cores,
     671,875 microseconds (0.671875 seconds) were spent in user mode
           0 microseconds (0.000000 seconds) were spent in system mode
 54,221,104 bytes of memory allocated.
(1864921261592819619661568919418981552559955289196969112566252282429216186594265918444566258544614425
 5891958562486995519825158818455999516899524658151445485616155916296966645869599949958954491929662561)

एक बोनस के रूप में, मैं उस कोड के एक संस्करण को शामिल करता हूं जो इंक्रीमेंटल समाधान टॉप-डाउन बनाता है। यह दस सेकंड से भी कम समय में 1000 अंकों की संख्या का प्रबंधन कर सकता है, लेकिन अतिरिक्त कोड के कारण गोल्फ में प्रतिस्पर्धा नहीं कर सकता।

(defun decompose (x)
  (flet ((s (z)
           (mapcan #'(lambda (c) (and #1=(position c #2=(format () "~a" z))
                                 (list (- (length #2#) #1# 1))))
                   '(#\0 #\3 #\7))))
    (do ((y x (let ((p (nconc (s y) (s #3=(logxor x y)))))
                (or p (return`(,y,#3#)))
                (+ y (expt 10 (apply #'max p))))))
        (nil))))

* (time (decompose (parse-integer (make-string 1000 :initial-element #\7))))
took 9,226,000 microseconds (9.226000 seconds) to run.
        90,966 microseconds (0.090966 seconds, 0.99%) of which was spent in GC.
During that period, and with 8 available CPU cores,
     9,234,375 microseconds (9.234375 seconds) were spent in user mode
             0 microseconds (0.000000 seconds) were spent in system mode
 487,434,560 bytes of memory allocated.
(8889898889152488921298888992819221914229899249999918899888899888888889999989141219898898888988988898888888888899142442899924898918898898988988895189988898888924192198992454114198911989191888889898888918888988988998888891421118891899122898888998989898888898988898888999988918888898889189918889888888899888989219188898998888988892119889198888988888894888912188898989952999888888888898899998988898889228918998949999998898898991141888898999988912121292118899889998989899999892889941898888911888898889118998898888911889889888891452888998889288921141888888942189888899988891918889118888888888989892198899199914111188988889421111188889118888918989988912989999998989891119888898888888892621229888988888999619888952462219889189899998899888889989898891118989218888888898962988891188899888888888999888888888888888888888891269188921288888888998898899214191188888888898992188998898889919888889989889899988892115549998888898889218899988998911898989199918898918988898888891889888989119899888889888998918889112189998
 4184469818464841952189561886965821566229261221619858498284264289194458622668559698924621446851546256444641488616184155821914881485164244662156846141894655485889656891849662551896595944656451462198891289692696856414192264846811616261884188919426294584158925218559295881946496911489245664261126565546419851585441144861859822815144162828551969425529258169849412525611662488849586554989254181228254465226521648916188265491499166186964881248156451994924294646681548996645996894665198811511522424996844864211629888924642289925565591484541149414914699289441561496451494562955652129199261462268846144518142486845251946444998812988291119592418684842524648484689261441456645518518812265495165189812912919529151991611962525419626921619824496626511954895189658691229655648659252448158451924925658586522262194585891859285841914968868466462442488528641466655911199816288496111884591648442984864269495264612518852292965985888414945855422266658614684922884216851481646226111486498155591649619266595911992489425412191)
* (apply #'logxor *)
7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777

— jlahd
स्रोत

2

पायथन 2, 103 + 42 = 145 बाइट्स

पायथन मूल रूप से बड़े संकेतों का समर्थन करता है, लेकिन यह कार्यक्रम 100-अंकीय संख्या के लिए 20 सेकंड से अधिक है। हालाँकि, यह लगभग 2 सेकंड में 64-बिट पूर्णांक को विघटित करता है।

from random import *
def d(a):
 b=c=0
 while set(`b`+`c`)&set('037'):
    b=randint(1,a);c=a^b
 return b,c

— रेमी
स्रोत

1

यादृच्छिकता का उपयोग करते हुए चतुर विचार। यदि आप किसी फ़ंक्शन को परिभाषित कर रहे हैं, तो आपको whileयादृच्छिक मानों को रखने के लिए लूप की आवश्यकता नहीं है - आप केवल फ़ंक्शन को फिर से कॉल कर सकते हैं। नियंत्रण संरचना की आवश्यकता के बिना, फिर आप फ़ंक्शन को ए lambdaऔर टर्नरी को ध्वस्त कर सकते हैं from random import* d=lambda a,b=0:set(`b`+`a^b`)&set(\'037\')and d(a,randint(1,a))or(b,a^b):। हालांकि आप सिर्फ एक फ़ंक्शन का उपयोग नहीं कर बेहतर हो सकते हैं।

— Xnor

मैंने पुनरावृत्ति पर विचार किया, लेकिन यह बड़ी संख्या (यहां तक कि सिर्फ 11 अंकों) के लिए एक ढेर अतिप्रवाह का कारण बनता है।

— रेमी

1

पायथन 3 (132 बाइट्स)

(यह सिर्फ बेहतर समाधानों को प्रोत्साहित करने के लिए है। एएससीआईआई फिल्म में मूल समस्या को हल करते समय यह मेरा समाधान है।)

def d(a):
 l=len(str(a));s=int('1'*l);u=10**(l-1)
 while u:
  while set(str(s)+str((a^s)//u))&set('037'):s+=u
  u//=10
 print(s,a^s)

यद्यपि दशमलव प्रणाली में बिटव्यू एक्सर का व्यवहार बहुत जटिल है, एक प्रमुख अवलोकन है: कम अंकों को संशोधित करना उच्च अंकों को प्रभावित नहीं करेगा । इसलिए, हम टॉप-डाउन काम कर सकते हैं: शीर्ष अंकों को 0, 3, 7 से मुक्त करने का प्रयास करें, और फिर अगले अंक पर काम करें, जब तक कि पूरी संख्या काम न हो जाए। यह तो एक हजार अंकों की संख्या के प्रसंस्करण 1 सेकंड के तहत पूरा कर सकते हैं हमें रैखिक समय में चलाने के लिए अनुमति देता है। (कॉमन लिस्प समाधान भी उसी तकनीक का उपयोग कर रहा है जो मुझे विश्वास है।)

— kennytm
स्रोत

लेकिन कम अंकों को ठीक करने से उच्च अंक प्रभावित हो सकते हैं। उदाहरण के लिए, 997^8 == 1005। मुझे लगता है कि यहाँ एक विचार का एक कर्नेल है, लेकिन यह स्पष्ट नहीं है।

— कीथ रान्डेल

@KeithRandall: हाँ यह सिर्फ 999 ... 999 + 1 की तरह है, लेकिन, की पसंद को देखते हुए {1,2,4,5,6,8,9}, उनमें से कुछ ऐसे होंगे जो उच्च अंकों को प्रभावित नहीं करेंगे। (जैसे 997^2 == 999)। आंतरिक whileलूप उस थकावट को खोजने के लिए करता है जो उच्च अंकों को वैध रखता है।

— kennytm

सही है, लेकिन तब यह स्पष्ट नहीं है (मेरे लिए, कम से कम) कि निश्चित रूप से एक अंक है जो काम करेगा।