यहां एक जवाब है जो सीपीयू की कीमत पर निरंतर मेमोरी के साथ चलता है। यह मूल प्रश्न (यानी एक साक्षात्कार के दौरान उत्तर) के संदर्भ में एक अच्छा जवाब नहीं है। लेकिन अगर साक्षात्कार 24 घंटे लंबा है, तो यह इतना बुरा नहीं है। ;)
विचार यह है कि यदि मेरे पास n है जो कि एक मान्य उत्तर है, तो अनुक्रम में अगला n दो की शक्ति से n गुना होने वाला है, जिसे 5 की शक्ति से विभाजित किया जाता है। या फिर n की 5 की शक्ति से विभाजित किया जाता है, दो की शक्ति। बशर्ते यह समान रूप से विभाजित हो। ((या भाजक 1 हो सकता है?) जिस स्थिति में आप सिर्फ 2 या 5 से गुणा कर रहे हैं)
उदाहरण के लिए, 625 से 640 तक जाने के लिए, 5 ** 4/2 ** 7. से गुणा करें, या अधिक, आमतौर पर, 2 ** m * 5 ** nकुछ m के लिए कुछ मान से गुणा करें , जहां एक सकारात्मक है और एक नकारात्मक या शून्य है, और गुणक संख्या को समान रूप से विभाजित करता है।
अब, मुश्किल हिस्सा गुणक पाया जाता है। लेकिन हम जानते हैं कि ए) विभाजक को संख्या को समान रूप से विभाजित करना चाहिए, बी) गुणक एक से अधिक होना चाहिए (संख्या बढ़ती रहती है), और सी) अगर हम सबसे कम गुणक को 1 से अधिक लेते हैं (यानी 1 <एफ <अन्य सभी अन्य एफ) ), तो यह हमारा अगला कदम होने की गारंटी है। उसके बाद का कदम यह सबसे कम कदम होगा।
गंदा हिस्सा मी, एन का मान पा रहा है। केवल लॉग (n) की संभावनाएं हैं, क्योंकि छोड़ने के लिए केवल 2 या 5 के बहुत सारे हैं, लेकिन मुझे राउंडऑफ से निपटने के लिए एक मैला रास्ता के रूप में -1 से +1 का एक कारक जोड़ना पड़ा। इसलिए हमें केवल O (लॉग (n)) प्रत्येक चरण के माध्यम से पुनरावृत्त करना होगा। तो यह ओ (एन लॉग (एन)) समग्र है।
अच्छी खबर यह है, क्योंकि यह एक मूल्य लेता है और अगले मूल्य को पाता है, आप अनुक्रम में कहीं भी शुरू कर सकते हैं। इसलिए यदि आप 1 बिलियन के बाद अगला चाहते हैं, तो यह केवल 2/5 या 5/2 के माध्यम से पुनरावृत्ति करके और 1 से अधिक छोटे गुणक को चुनकर पा सकते हैं।
(अजगर)
MAX = 30
F = - math.log(2) / math.log(5)
def val(i, j):
return 2 ** i * 5 ** j
def best(i, j):
f = 100
m = 0
n = 0
max_i = (int)(math.log(val(i, j)) / math.log(2) + 1) if i + j else 1
#print((val(i, j), max_i, x))
for mm in range(-i, max_i + 1):
for rr in {-1, 0, 1}:
nn = (int)(mm * F + rr)
if nn < -j: continue
ff = val(mm, nn)
#print(' ' + str((ff, mm, nn, rr)))
if ff > 1 and ff < f:
f = ff
m = mm
n = nn
return m, n
def detSeq():
i = 0
j = 0
got = [val(i, j)]
while len(got) < MAX:
m, n = best(i, j)
i += m
j += n
got.append(val(i, j))
#print('* ' + str((val(i, j), m, n)))
#print('- ' + str((v, i, j)))
return got
मैंने पहले 10,000 की संख्या को मान्य किया था जो कि छांटे गए सूची समाधान द्वारा उत्पन्न पहले 10,000 के खिलाफ उत्पन्न होती है, और यह कम से कम अब तक काम करती है।
एक खरब के बाद BTW अगले एक 1,024,000,000,000 लगता है।
...
हम्म। मैं ओ (एन) प्रदर्शन - ओ (1) प्रति मूल्य (!) - और ओ (लॉग एन) स्मृति उपयोग को best()लुकअप टेबल के रूप में मान सकता हूं कि मैं वेतन वृद्धि का विस्तार करता हूं। अभी यह हर बार पुनरावृत्ति करके स्मृति को बचाता है, लेकिन यह बहुत अधिक अनावश्यक गणना कर रहा है। उन मध्यवर्ती मूल्यों को पकड़कर - और न्यूनतम मूल्यों की एक सूची - मैं डुप्लिकेट कार्य से बच सकता हूं और इसे बहुत तेज कर सकता हूं। हालांकि, मध्यवर्ती मूल्यों की सूची n के साथ बढ़ेगी, इसलिए ओ (लॉग एन) मेमोरी।