यदि आप केवल यह गिनने की कोशिश कर रहे हैं कि यह कितनी बार कम हो गया है और विशेष रूप से पुनरावृत्ति की परवाह नहीं कर रहा है ... तो आप केवल पुनरावर्तन को हटा सकते हैं। नीचे दिया गया कोड मूल पोस्ट के लिए वफादार रहता है क्योंकि इसकी num <= 9
आवश्यकता में कमी नहीं आती है। इसलिए, singleDigit(8)
होगा count = 0
, और singleDigit(39)
होगा count = 3
, बस ओपी और स्वीकार किए जाते हैं जवाब प्रदर्शन कर रहे हैं की तरह:
const singleDigit = (num) => {
let count = 0, ret, x;
while (num > 9) {
ret = 1;
while (num > 9) {
x = num % 10;
num = (num - x) / 10;
ret *= x;
}
num *= ret;
count++;
console.log(num);
}
console.log("Answer = " + num + ", count = " + count);
return num;
}
यह संख्या 9 या उससे कम (यानी। num <= 9
) संसाधित करने के लिए अनावश्यक है । दुर्भाग्य से ओपी कोड प्रक्रिया करेगा num <= 9
यहां तक कि इसे गिनता भी नहीं है। उपरोक्त कोड बिल्कुल भी प्रोसेस या काउंट नहीं करेगा num <= 9
। यह बस इसे गुजरता है।
मैं उपयोग नहीं करने का चयन करता हूं .reduce
क्योंकि वास्तविक गणित निष्पादित करने के लिए बहुत तेज था। और, मेरे लिए, समझना आसान है।
आगे की सोच गति पर
मुझे लगता है कि अच्छा कोड भी तेज है। यदि आप इस प्रकार की कमी का उपयोग कर रहे हैं (जिसका उपयोग अंक ज्योतिष में किया जाता है) तो आपको भारी मात्रा में डेटा पर इसका उपयोग करने की आवश्यकता हो सकती है। इस मामले में, गति सबसे महत्वपूर्ण बन जाएगी।
दोनों का उपयोग करना .map(Number)
और console.log
(प्रत्येक कमी कदम पर) दोनों बहुत बहुत लंबे निष्पादित और अनावश्यक के लिए कर रहे हैं। बस .map(Number)
ओपी से हटाने के बारे में 4.38x तक इसे गिरा दिया। console.log
इसे हटाने के लिए इसे इतना कम करना ठीक से परीक्षण करना लगभग असंभव था (मैं इसके लिए इंतजार नहीं करना चाहता था)।
तो, customcommander के जवाब के समान है , न .map(Number)
ही उपयोग और न ही console.log
परिणामों को एक सरणी में धकेलना और बहुत अधिक तेजी से उपयोग .length
करना count
। दुर्भाग्य के लिए customcommander के जवाब है, एक का उपयोग कर जनरेटर समारोह वास्तव में बहुत धीमी गति से (है कि इसका जवाब 2.68x के बारे में बिना ओपी की तुलना में धीमी है .map(Number)
औरconsole.log
)
इसके अलावा, .reduce
मैंने केवल वास्तविक गणित का उपयोग करने के बजाय उपयोग किया। इस अकेले परिवर्तन ने फ़ंक्शन के मेरे संस्करण को 3.59x के एक कारक द्वारा फैलाया।
अंत में, पुनरावृत्ति धीमा है, यह स्टैक स्पेस लेता है, अधिक मेमोरी का उपयोग करता है, और इसकी एक सीमा है कि यह कितनी बार "पुनरावृत्ति" कर सकता है। या, इस मामले में, कमी के कितने चरण इसका उपयोग पूर्ण कमी को पूरा करने के लिए कर सकते हैं। पुनरावृत्त छोरों के लिए अपनी पुनरावृत्ति को बाहर निकालना यह सब स्टैक पर एक ही जगह पर रखता है और इसकी कोई सैद्धांतिक सीमा नहीं है कि इसे खत्म करने के लिए कितने कमी चरणों का उपयोग किया जा सकता है। इस प्रकार, यहां ये फ़ंक्शन लगभग किसी भी आकार के पूर्णांक को "कम" कर सकते हैं, केवल निष्पादन समय तक सीमित है और एक सरणी कितनी लंबी हो सकती है।
यह सब ...
const singleDigit2 = (num) => {
let red, x, arr = [];
do {
red = 1;
while (num > 9) {
x = num % 10;
num = (num - x) / 10;
red *= x;
}
num *= red;
arr.push(num);
} while (num > 9);
return arr;
}
let ans = singleDigit2(39);
console.log("singleDigit2(39) = [" + ans + "], count = " + ans.length );
// Output: singleDigit2(39) = [27,14,4], count = 3
उपरोक्त फ़ंक्शन बहुत तेज़ चलता है। यह ओपी से (बिना तेजी 3.13x के बारे में है .map(Number)
और console.log
तेजी से) और 8.4x के बारे में customcommander के जवाब। ध्यान रखें कि console.log
ओपी को हटाने से यह कमी के प्रत्येक चरण में एक नंबर उत्पन्न करने से रोकता है। इसलिए, इन परिणामों को एक सरणी में धकेलने के लिए यहाँ की आवश्यकता है।
पीटी
.map(Number)
*
ऑपरेटर बेमानी है क्योंकि ऑपरेटर किसी भी तरह से संख्याओं का मान रखता है। ;-)