ನಾನು ಅಲ್ಗಾರಿದಮ್‌ಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅಧ್ಯಯನ ಮಾಡುವಾಗ, ನಾನು ಇದನ್ನು ನೋಡಿದೆ . ಇದು ದೊಡ್ಡ ತಂತ್ರಜ್ಞಾನ ನಿಗಮಗಳಲ್ಲಿ ಸಂದರ್ಶನಗಳನ್ನು ಹೇಗೆ ನಡೆಸುತ್ತದೆ ಎಂಬುದರ ಕಲ್ಪನೆಯನ್ನು ನೀಡುವುದಲ್ಲದೆ, ಅಲ್ಗಾರಿದಮಿಕ್ ಸಮಸ್ಯೆಗಳನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹೇಗೆ ಪರಿಹರಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಈ ಲೇಖನವು ವೀಡಿಯೊಗೆ ಒಂದು ರೀತಿಯ ಪಕ್ಕವಾದ್ಯವಾಗಿದೆ. ಇದರಲ್ಲಿ ನಾನು ತೋರಿಸಿರುವ ಎಲ್ಲಾ ಪರಿಹಾರಗಳ ಕುರಿತು ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತೇನೆ, ಜೊತೆಗೆ JavaScript ನಲ್ಲಿ ನನ್ನ ಸ್ವಂತ ಪರಿಹಾರದ ಆವೃತ್ತಿಯನ್ನು ಒದಗಿಸುತ್ತೇನೆ. ಪ್ರತಿ ಅಲ್ಗಾರಿದಮ್‌ನ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಸಹ ಚರ್ಚಿಸಲಾಗಿದೆ.
ನಾವು ನೆನಪಿಸುತ್ತೇವೆ: ಎಲ್ಲಾ Habr ಓದುಗರಿಗೆ - Habr ಪ್ರೊಮೊ ಕೋಡ್ ಬಳಸಿಕೊಂಡು ಯಾವುದೇ ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಕೋರ್ಸ್‌ಗೆ ದಾಖಲಾಗುವಾಗ 10 ರೂಬಲ್ ರಿಯಾಯಿತಿ.
ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ: ಪ್ರಾಯೋಗಿಕ ಕೋರ್ಸ್ .
ಸಮಸ್ಯೆ ಹೇಳಿಕೆ
ನಮಗೆ ಆರ್ಡರ್ ಮಾಡಿದ ಅರೇ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ನೀಡಲಾಗಿದೆ. ಸರಣಿಯಲ್ಲಿನ ಯಾವುದೇ ಎರಡು ಸಂಖ್ಯೆಗಳ ಮೊತ್ತವು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆಯೇ ಎಂಬುದರ ಆಧಾರದ ಮೇಲೆ ಸರಿ ಅಥವಾ ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುವ ಕಾರ್ಯವನ್ನು ರಚಿಸಲು ಕೇಳಲಾಗುತ್ತದೆ.
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಸರಣಿಯಲ್ಲಿ ಎರಡು ಪೂರ್ಣಾಂಕಗಳಿವೆ, x ಮತ್ತು y, ಒಟ್ಟಿಗೆ ಸೇರಿಸಿದಾಗ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಮೌಲ್ಯಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ?
ಉದಾಹರಣೆ ಎ
ನಮಗೆ ಅರೇ [1, 2, 4, 9] ನೀಡಿದರೆ ಮತ್ತು ಮೌಲ್ಯವು 8 ಆಗಿದ್ದರೆ, ಕಾರ್ಯವು ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಸರಣಿಯಲ್ಲಿ ಯಾವುದೇ ಎರಡು ಸಂಖ್ಯೆಗಳು 8 ಕ್ಕೆ ಸೇರಿಸಲಾಗುವುದಿಲ್ಲ.
ಉದಾಹರಣೆ ಬಿ
ಆದರೆ ಇದು ಒಂದು ಶ್ರೇಣಿಯ [1, 2, 4, 4] ಆಗಿದ್ದರೆ ಮತ್ತು ಮೌಲ್ಯವು 8 ಆಗಿದ್ದರೆ, ಕಾರ್ಯವು ನಿಜವಾಗಿ ಹಿಂತಿರುಗಬೇಕು ಏಕೆಂದರೆ 4 + 4 = 8.
ಪರಿಹಾರ 1: ವಿವೇಚನಾರಹಿತ ಶಕ್ತಿ
ಸಮಯದ ಸಂಕೀರ್ಣತೆ: O(N²).
ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ: O(1).
ಒಂದು ಜೋಡಿ ನೆಸ್ಟೆಡ್ ಲೂಪ್‌ಗಳನ್ನು ಬಳಸುವುದು ಅತ್ಯಂತ ಸ್ಪಷ್ಟವಾದ ಅರ್ಥವಾಗಿದೆ.
const findSum = (arr, val) => {
for (let i = 0; i < arr.length; i++) {
for (let j = 0; j < arr.length; j++) {
if (i !== j && arr[i] + arr[j] === val) {
return true;
};
};
};
return false;
};ಈ ಪರಿಹಾರವು ಪರಿಣಾಮಕಾರಿಯಾಗಿಲ್ಲ ಏಕೆಂದರೆ ಇದು ರಚನೆಯಲ್ಲಿನ ಎರಡು ಅಂಶಗಳ ಪ್ರತಿಯೊಂದು ಸಂಭವನೀಯ ಮೊತ್ತವನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ಜೋಡಿ ಸೂಚ್ಯಂಕಗಳನ್ನು ಎರಡು ಬಾರಿ ಹೋಲಿಸುತ್ತದೆ. (ಉದಾಹರಣೆಗೆ, i = 1 ಮತ್ತು j = 2 ವಾಸ್ತವವಾಗಿ i = 2 ಮತ್ತು j = 1 ರೊಂದಿಗೆ ಹೋಲಿಸಿದಾಗ ಒಂದೇ ಆಗಿರುತ್ತದೆ, ಆದರೆ ಈ ಪರಿಹಾರದಲ್ಲಿ ನಾವು ಎರಡೂ ಆಯ್ಕೆಗಳನ್ನು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ).
ನಮ್ಮ ಪರಿಹಾರವು ಲೂಪ್‌ಗಳಿಗಾಗಿ ಒಂದು ಜೋಡಿ ನೆಸ್ಟೆಡ್ ಅನ್ನು ಬಳಸುವುದರಿಂದ, ಇದು O(N²) ಸಮಯದ ಸಂಕೀರ್ಣತೆಯೊಂದಿಗೆ ಚತುರ್ಭುಜವಾಗಿದೆ.
ಪರಿಹಾರ 2: ಬೈನರಿ ಹುಡುಕಾಟ
ಸಮಯದ ಸಂಕೀರ್ಣತೆ: O(Nlog(N)).
ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ: O(1).
ಸರಣಿಗಳನ್ನು ಕ್ರಮಗೊಳಿಸಿರುವುದರಿಂದ, ಬೈನರಿ ಹುಡುಕಾಟವನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಪರಿಹಾರವನ್ನು ಹುಡುಕಬಹುದು. ಆರ್ಡರ್ ಮಾಡಿದ ಅರೇಗಳಿಗೆ ಇದು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಅಲ್ಗಾರಿದಮ್ ಆಗಿದೆ. ಬೈನರಿ ಹುಡುಕಾಟವು O(log(N)) ನ ಚಾಲನೆಯಲ್ಲಿರುವ ಸಮಯವನ್ನು ಹೊಂದಿದೆ. ಆದಾಗ್ಯೂ, ಎಲ್ಲಾ ಇತರ ಮೌಲ್ಯಗಳ ವಿರುದ್ಧ ಪ್ರತಿ ಅಂಶವನ್ನು ಪರಿಶೀಲಿಸಲು ನೀವು ಇನ್ನೂ ಫಾರ್ ಲೂಪ್ ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ.
ಪರಿಹಾರವು ಹೇಗಿರಬಹುದು ಎಂಬುದು ಇಲ್ಲಿದೆ. ವಿಷಯಗಳನ್ನು ಸ್ಪಷ್ಟಪಡಿಸಲು, ಬೈನರಿ ಹುಡುಕಾಟವನ್ನು ನಿಯಂತ್ರಿಸಲು ನಾವು ಪ್ರತ್ಯೇಕ ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತೇವೆ. ಮತ್ತು ತೆಗೆದುಹಾಕುಇಂಡೆಕ್ಸ್() ಫಂಕ್ಷನ್, ಇದು ರಚನೆಯ ಆವೃತ್ತಿಯನ್ನು ನೀಡಲಾದ ಸೂಚ್ಯಂಕವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
const findSum = (arr, val) => {
for (let i = 0; i < arr.length; i++){
if (binarySearch(removeIndex(arr, i), val - arr[i])) {
return true;
}
};
return false;
};
const removeIndex = (arr, i) => {
return arr.slice(0, i).concat(arr.slice(i + 1, arr.length));
};
const binarySearch = (arr, val) => {
let start = 0;
let end = arr.length - 1;
let pivot = Math.floor(arr.length / 2);
while (start < end) {
if (val < arr[pivot]) {
end = pivot - 1;
} else if (val > arr[pivot]) {
start = pivot + 1;
};
pivot = Math.floor((start + end) / 2);
if (arr[pivot] === val) {
return true;
}
};
return false;
};ಅಲ್ಗಾರಿದಮ್ ಸೂಚ್ಯಂಕ [0] ನಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಇದು ಮೊದಲ ಸೂಚ್ಯಂಕವನ್ನು ಹೊರತುಪಡಿಸಿ ರಚನೆಯ ಆವೃತ್ತಿಯನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಅಪೇಕ್ಷಿತ ಮೊತ್ತವನ್ನು ಉತ್ಪಾದಿಸಲು ಯಾವುದೇ ಉಳಿದ ಮೌಲ್ಯಗಳನ್ನು ಅರೇಗೆ ಸೇರಿಸಬಹುದೇ ಎಂದು ನೋಡಲು ಬೈನರಿ ಹುಡುಕಾಟವನ್ನು ಬಳಸುತ್ತದೆ. ಈ ಕ್ರಿಯೆಯನ್ನು ರಚನೆಯ ಪ್ರತಿ ಅಂಶಕ್ಕೆ ಒಮ್ಮೆ ನಡೆಸಲಾಗುತ್ತದೆ.
ಫಾರ್ ಲೂಪ್ ಸ್ವತಃ O(N) ನ ರೇಖೀಯ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಆದರೆ for loop ನ ಒಳಗೆ ನಾವು ಬೈನರಿ ಹುಡುಕಾಟವನ್ನು ನಡೆಸುತ್ತೇವೆ, ಇದು O(Nlog(N)) ನ ಒಟ್ಟಾರೆ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯನ್ನು ನೀಡುತ್ತದೆ. ಈ ಪರಿಹಾರವು ಹಿಂದಿನದಕ್ಕಿಂತ ಉತ್ತಮವಾಗಿದೆ, ಆದರೆ ಸುಧಾರಣೆಗೆ ಇನ್ನೂ ಅವಕಾಶವಿದೆ.
ಪರಿಹಾರ 3: ರೇಖೀಯ ಸಮಯ
ಸಮಯದ ಸಂಕೀರ್ಣತೆ: O(N).
ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ: O(1).
ಈಗ ನಾವು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತೇವೆ, ರಚನೆಯನ್ನು ವಿಂಗಡಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ. ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದು ಪರಿಹಾರವಾಗಿದೆ: ಒಂದು ಆರಂಭದಲ್ಲಿ ಮತ್ತು ಒಂದು ಕೊನೆಯಲ್ಲಿ. ಫಲಿತಾಂಶವು ಅಗತ್ಯಕ್ಕಿಂತ ಭಿನ್ನವಾಗಿದ್ದರೆ, ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತ್ಯದ ಬಿಂದುಗಳನ್ನು ಬದಲಾಯಿಸಿ.
ಅಂತಿಮವಾಗಿ ನಾವು ಬಯಸಿದ ಮೌಲ್ಯವನ್ನು ಎದುರಿಸುತ್ತೇವೆ ಮತ್ತು ನಿಜವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ ಅಥವಾ ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತ್ಯದ ಬಿಂದುಗಳು ಒಮ್ಮುಖವಾಗುತ್ತವೆ ಮತ್ತು ತಪ್ಪಾಗಿ ಹಿಂತಿರುಗುತ್ತವೆ.
const findSum = (arr, val) => {
let start = 0;
let end = arr.length - 1;
while (start < end) {
let sum = arr[start] + arr[end];
if (sum > val) {
end -= 1;
} else if (sum < val) {
start += 1;
} else {
return true;
};
};
return false;
};
ಈಗ ಎಲ್ಲವೂ ಉತ್ತಮವಾಗಿದೆ, ಪರಿಹಾರವು ಅತ್ಯುತ್ತಮವಾಗಿದೆ ಎಂದು ತೋರುತ್ತದೆ. ಆದರೆ ಶ್ರೇಣಿಯನ್ನು ಆದೇಶಿಸಲಾಗಿದೆ ಎಂದು ಯಾರು ಖಾತರಿಪಡಿಸಬಹುದು?
ಹಾಗಾದರೆ ಏನು?
ಮೊದಲ ನೋಟದಲ್ಲಿ, ನಾವು ಸರಳವಾಗಿ ರಚನೆಯನ್ನು ಮೊದಲು ಆರ್ಡರ್ ಮಾಡಿ ನಂತರ ಮೇಲಿನ ಪರಿಹಾರವನ್ನು ಬಳಸಬಹುದಿತ್ತು. ಆದರೆ ಇದು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯದ ಮೇಲೆ ಹೇಗೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ?
ಅತ್ಯುತ್ತಮ ಅಲ್ಗಾರಿದಮ್ ಸಮಯ ಸಂಕೀರ್ಣತೆ O (Nlog (N)) ಜೊತೆಗೆ ಕ್ವಿಕ್‌ಸಾರ್ಟ್ ಆಗಿದೆ. ನಾವು ಅದನ್ನು ನಮ್ಮ ಅತ್ಯುತ್ತಮ ಪರಿಹಾರದಲ್ಲಿ ಬಳಸಿದರೆ, ಅದು ಅದರ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು O(N) ನಿಂದ O(Nlog(N)) ಗೆ ಬದಲಾಯಿಸುತ್ತದೆ. ಅನಿಯಮಿತ ಶ್ರೇಣಿಯೊಂದಿಗೆ ರೇಖೀಯ ಪರಿಹಾರವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಸಾಧ್ಯವೇ?
ಪರಿಹಾರ 4
ಸಮಯದ ಸಂಕೀರ್ಣತೆ: O(N).
ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ: O(N).
ಹೌದು, ಒಂದು ರೇಖಾತ್ಮಕ ಪರಿಹಾರವಿದೆ; ಇದನ್ನು ಮಾಡಲು, ನಾವು ಹುಡುಕುತ್ತಿರುವ ಹೊಂದಾಣಿಕೆಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿರುವ ಹೊಸ ಶ್ರೇಣಿಯನ್ನು ನಾವು ರಚಿಸಬೇಕಾಗಿದೆ. ಇಲ್ಲಿ ಟ್ರೇಡ್-ಆಫ್ ಹೆಚ್ಚು ಮೆಮೊರಿ ಬಳಕೆಯಾಗಿದೆ: O(1) ಗಿಂತ ಹೆಚ್ಚಿನ ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆಯೊಂದಿಗೆ ಕಾಗದದಲ್ಲಿ ಇದು ಏಕೈಕ ಪರಿಹಾರವಾಗಿದೆ.
ಕೊಟ್ಟಿರುವ ರಚನೆಯ ಮೊದಲ ಮೌಲ್ಯವು 1 ಆಗಿದ್ದರೆ ಮತ್ತು ಹುಡುಕಾಟ ಮೌಲ್ಯವು 8 ಆಗಿದ್ದರೆ, ನಾವು ಮೌಲ್ಯ 7 ಅನ್ನು "ಹುಡುಕಾಟ ಮೌಲ್ಯಗಳು" ಶ್ರೇಣಿಗೆ ಸೇರಿಸಬಹುದು.
ನಂತರ, ನಾವು ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಾಗ, ನಾವು "ಹುಡುಕಾಟದ ಮೌಲ್ಯಗಳ" ಶ್ರೇಣಿಯನ್ನು ಪರಿಶೀಲಿಸಬಹುದು ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಒಂದು ನಮ್ಮ ಮೌಲ್ಯಕ್ಕೆ ಸಮಾನವಾಗಿದೆಯೇ ಎಂದು ನೋಡಬಹುದು. ಹೌದು ಎಂದಾದರೆ, ನಿಜ ಎಂದು ಹಿಂತಿರುಗಿ.
const findSum = (arr, val) => {
let searchValues = [val - arr[0]];
for (let i = 1; i < arr.length; i++) {
let searchVal = val - arr[i];
if (searchValues.includes(arr[i])) {
return true;
} else {
searchValues.push(searchVal);
}
};
return false;
};ಪರಿಹಾರದ ಆಧಾರವು ಫಾರ್ ಲೂಪ್ ಆಗಿದೆ, ಇದು ನಾವು ಮೇಲೆ ನೋಡಿದಂತೆ, O (N) ನ ರೇಖೀಯ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯನ್ನು ಹೊಂದಿದೆ.
ನಮ್ಮ ಫಂಕ್ಷನ್‌ನ ಎರಡನೇ ಪುನರಾವರ್ತನೆಯ ಭಾಗವೆಂದರೆ Array.prototype.include(), ಇದು ಒಂದು JavaScript ವಿಧಾನವಾಗಿದ್ದು, ಅರೇ ಕೊಟ್ಟಿರುವ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂಬುದನ್ನು ಅವಲಂಬಿಸಿ ಸರಿ ಅಥವಾ ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
Array.prototype.includes() ಸಮಯದ ಸಂಕೀರ್ಣತೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು, ನಾವು MDN ಒದಗಿಸಿದ ಪಾಲಿಫಿಲ್ ಅನ್ನು ನೋಡಬಹುದು (ಮತ್ತು JavaScript ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ) ಅಥವಾ Google V8 (C++) ನಂತಹ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎಂಜಿನ್‌ನ ಮೂಲ ಕೋಡ್‌ನಲ್ಲಿ ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು.
// https://tc39.github.io/ecma262/#sec-array.prototype.includes
if (!Array.prototype.includes) {
Object.defineProperty(Array.prototype, 'includes', {
value: function(valueToFind, fromIndex) {
if (this == null) {
throw new TypeError('"this" is null or not defined');
}
// 1. Let O be ? ToObject(this value).
var o = Object(this);
// 2. Let len be ? ToLength(? Get(O, "length")).
var len = o.length >>> 0;
// 3. If len is 0, return false.
if (len === 0) {
return false;
}
// 4. Let n be ? ToInteger(fromIndex).
// (If fromIndex is undefined, this step produces the value 0.)
var n = fromIndex | 0;
// 5. If n ≥ 0, then
// a. Let k be n.
// 6. Else n < 0,
// a. Let k be len + n.
// b. If k < 0, let k be 0.
var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
function sameValueZero(x, y) {
return x === y || (typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y));
}
// 7. Repeat, while k < len
while (k < len) {
// a. Let elementK be the result of ? Get(O, ! ToString(k)).
// b. If SameValueZero(valueToFind, elementK) is true, return true.
if (sameValueZero(o[k], valueToFind)) {
return true;
}
// c. Increase k by 1.
k++;
}
// 8. Return false
return false;
}
});
}ಇಲ್ಲಿ Array.prototype.include() ನ ಪುನರಾವರ್ತಿತ ಭಾಗವು ಹಂತ 7 ರಲ್ಲಿನ ಲೂಪ್ ಆಗಿದ್ದು ಅದು (ಬಹುತೇಕ) ನೀಡಲಾದ ರಚನೆಯ ಸಂಪೂರ್ಣ ಉದ್ದವನ್ನು ಹಾದುಹೋಗುತ್ತದೆ. ಇದರರ್ಥ ಅದರ ಸಮಯದ ಸಂಕೀರ್ಣತೆ ಕೂಡ ರೇಖೀಯವಾಗಿದೆ. ಒಳ್ಳೆಯದು, ಇದು ಯಾವಾಗಲೂ ನಮ್ಮ ಮುಖ್ಯ ರಚನೆಯ ಹಿಂದೆ ಒಂದು ಹೆಜ್ಜೆ ಇರುವುದರಿಂದ, ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು O (N + (N - 1)) ಆಗಿದೆ. ಬಿಗ್ ಓ ಸಂಕೇತವನ್ನು ಬಳಸುವುದರಿಂದ, ನಾವು ಅದನ್ನು O(N) ಗೆ ಸರಳಗೊಳಿಸುತ್ತೇವೆ - ಏಕೆಂದರೆ ಇನ್‌ಪುಟ್ ಗಾತ್ರವನ್ನು ಹೆಚ್ಚಿಸುವಾಗ ಅದು N ಆಗಿದೆ.
ಪ್ರಾದೇಶಿಕ ಸಂಕೀರ್ಣತೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಹೆಚ್ಚುವರಿ ರಚನೆಯ ಅಗತ್ಯವಿದೆ, ಅದರ ಉದ್ದವು ಮೂಲ ಶ್ರೇಣಿಯನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ (ಮೈನಸ್ ಒಂದು, ಹೌದು, ಆದರೆ ಅದನ್ನು ನಿರ್ಲಕ್ಷಿಸಬಹುದು), ಇದು O(N) ಪ್ರಾದೇಶಿಕ ಸಂಕೀರ್ಣತೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಅಲ್ಲದೆ, ಹೆಚ್ಚಿದ ಮೆಮೊರಿ ಬಳಕೆಯು ಅಲ್ಗಾರಿದಮ್‌ನ ಗರಿಷ್ಠ ದಕ್ಷತೆಯನ್ನು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ.
ನಿಮ್ಮ ವೀಡಿಯೊ ಸಂದರ್ಶನಕ್ಕೆ ಪೂರಕವಾಗಿ ಲೇಖನವು ನಿಮಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಬಳಸಿದ ವಿವಿಧ ಪ್ರಮಾಣದ ಸಂಪನ್ಮೂಲಗಳೊಂದಿಗೆ (ಸಮಯ, ಸ್ಮರಣೆ) ಸರಳವಾದ ಸಮಸ್ಯೆಯನ್ನು ಹಲವಾರು ರೀತಿಯಲ್ಲಿ ಪರಿಹರಿಸಬಹುದು ಎಂದು ಇದು ತೋರಿಸುತ್ತದೆ.
ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ:
- ಆನ್‌ಲೈನ್ ಕೋರ್ಸ್ ಅನ್ನು ಅನ್ವಯಿಸಲಾಗಿದೆ .
- ಆನ್‌ಲೈನ್ ಕೋರ್ಸ್ .
- ಪ್ರಾಯೋಗಿಕ ಒಂದು ವರ್ಷದ ಕೋರ್ಸ್ .
ಮೂಲ: www.habr.com