ಜಾವಾದಲ್ಲಿನ ಪುನರಾವರ್ತನೆಯ ಕುರಿತಾದ ಈ ಆಳವಾದ ಟ್ಯುಟೋರಿಯಲ್ ಉದಾಹರಣೆಗಳು, ಪ್ರಕಾರಗಳು ಮತ್ತು ಸಂಬಂಧಿತ ಪರಿಕಲ್ಪನೆಗಳೊಂದಿಗೆ ಪುನರಾವರ್ತನೆ ಎಂದರೇನು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಇದು ಪುನರಾವರ್ತನೆ Vs ಪುನರಾವರ್ತನೆಯನ್ನು ಸಹ ಒಳಗೊಂಡಿದೆ:
ಜಾವಾದಲ್ಲಿನ ನಮ್ಮ ಹಿಂದಿನ ಟ್ಯುಟೋರಿಯಲ್‌ಗಳಿಂದ, ನಾವು ಪುನರಾವರ್ತಿತ ವಿಧಾನವನ್ನು ನೋಡಿದ್ದೇವೆ, ಇದರಲ್ಲಿ ನಾವು ಲೂಪ್ ಅನ್ನು ಘೋಷಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಒಂದು ಅಂಶವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಮೂಲಕ ಪುನರಾವರ್ತಿತ ರೀತಿಯಲ್ಲಿ ಡೇಟಾ ರಚನೆಯ ಮೂಲಕ ಚಲಿಸುತ್ತೇವೆ ಒಂದು ಸಮಯ.
ನಾವು ಷರತ್ತುಬದ್ಧ ಹರಿವನ್ನು ಸಹ ನೋಡಿದ್ದೇವೆ, ಅಲ್ಲಿ ನಾವು ಮತ್ತೆ ಒಂದು ಲೂಪ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಇರಿಸುತ್ತೇವೆ ಮತ್ತು ಲೂಪ್ ವೇರಿಯೇಬಲ್ ಸ್ಥಿತಿಯನ್ನು ಪೂರೈಸುವವರೆಗೆ ಕೋಡ್‌ನ ತುಂಡನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತೇವೆ. ಫಂಕ್ಷನ್ ಕರೆಗಳಿಗೆ ಬಂದಾಗ, ಫಂಕ್ಷನ್ ಕರೆಗಳಿಗೆ ಪುನರಾವರ್ತಿತ ವಿಧಾನವನ್ನು ನಾವು ಅನ್ವೇಷಿಸಿದ್ದೇವೆ> ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ನಾವು ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ವಿಭಿನ್ನ ವಿಧಾನವನ್ನು ಅಂದರೆ ಪುನರಾವರ್ತಿತ ವಿಧಾನವನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ.
ಜಾವಾದಲ್ಲಿ ಪುನರಾವರ್ತನೆ ಎಂದರೇನು?
ಪುನರಾವರ್ತನೆಯು ಒಂದು ಕಾರ್ಯ ಅಥವಾ ವಿಧಾನದ ಮೂಲಕ ಮತ್ತೆ ಮತ್ತೆ ಕರೆದುಕೊಳ್ಳುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ. ನೇರವಾಗಿ ಅಥವಾ ಪರೋಕ್ಷವಾಗಿ ಮತ್ತೆ ಮತ್ತೆ ಕರೆಯಲಾಗುವ ಈ ಕಾರ್ಯವನ್ನು "ರಿಕರ್ಸಿವ್ ಫಂಕ್ಷನ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.
ನಾವು ಪುನರಾವರ್ತನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ವಿವಿಧ ಉದಾಹರಣೆಗಳನ್ನು ನೋಡುತ್ತೇವೆ. ಈಗ ಪುನರಾವರ್ತನೆಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ನೋಡೋಣ.
Recursion Syntax
Recursion ಅನ್ನು ಅಳವಡಿಸುವ ಯಾವುದೇ ವಿಧಾನವು ಎರಡು ಮೂಲಭೂತ ಭಾಗಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ:
- ಸ್ವತಃ ಕರೆ ಮಾಡಬಹುದಾದ ವಿಧಾನ ಕರೆ ಅಂದರೆ ಪುನರಾವರ್ತಿತ
- ಪುನರಾವರ್ತನೆಯನ್ನು ನಿಲ್ಲಿಸುವ ಪೂರ್ವಾಪೇಕ್ಷಿತ.
ನಾವು ಮಾಡದಿದ್ದಲ್ಲಿ ಯಾವುದೇ ಪುನರಾವರ್ತಿತ ವಿಧಾನಕ್ಕೆ ಪೂರ್ವಾಪೇಕ್ಷಿತವು ಅವಶ್ಯಕವಾಗಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ ಮುರಿಯಿರಿಪುನರಾವರ್ತನೆ ನಂತರ ಅದು ಅನಂತವಾಗಿ ಚಾಲನೆಯಲ್ಲಿದೆ ಮತ್ತು ಸ್ಟಾಕ್ ಓವರ್‌ಫ್ಲೋಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
ಪುನರಾವರ್ತನೆಯ ಸಾಮಾನ್ಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:
methodName (T parameters…) { if (precondition == true) //precondition or base condition { return result; } return methodName (T parameters…); //recursive call } ಪೂರ್ವಸ್ಥಿತಿಯನ್ನು ಸಹ ಕರೆಯಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ ಮೂಲ ಸ್ಥಿತಿ. ನಾವು ಮುಂದಿನ ವಿಭಾಗದಲ್ಲಿ ಮೂಲ ಸ್ಥಿತಿಯ ಕುರಿತು ಹೆಚ್ಚಿನದನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ.
ಜಾವಾದಲ್ಲಿ ಪುನರಾವರ್ತನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಈ ವಿಭಾಗದಲ್ಲಿ, ನಾವು ಪುನರಾವರ್ತನೆಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ ಮತ್ತು ಅದು ಹೇಗೆ ನಡೆಯುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ. ನಾವು ಮೂಲ ಸ್ಥಿತಿ, ಸ್ಟ್ಯಾಕ್ ಓವರ್‌ಫ್ಲೋ ಬಗ್ಗೆ ಕಲಿಯುತ್ತೇವೆ ಮತ್ತು ಪುನರಾವರ್ತನೆ ಮತ್ತು ಇತರ ವಿವರಗಳೊಂದಿಗೆ ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಯನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಬಹುದು ಎಂಬುದನ್ನು ನೋಡುತ್ತೇವೆ.
ಪುನರಾವರ್ತಿತ ಮೂಲ ಸ್ಥಿತಿ
ರಿಕರ್ಸಿವ್ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯುವಾಗ, ನಾವು ಮಾಡಬೇಕು ಮೊದಲು ಬೇಸ್ ಕೇಸ್‌ಗೆ ಪರಿಹಾರವನ್ನು ಒದಗಿಸಿ. ನಂತರ ನಾವು ಚಿಕ್ಕ ಸಮಸ್ಯೆಗಳ ವಿಷಯದಲ್ಲಿ ದೊಡ್ಡ ಸಮಸ್ಯೆಯನ್ನು ವ್ಯಕ್ತಪಡಿಸುತ್ತೇವೆ.
ಉದಾಹರಣೆಯಾಗಿ, ನಾವು ಸಂಖ್ಯೆಯ ಅಪವರ್ತನವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಕ್ಲಾಸಿಕ್ ಸಮಸ್ಯೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. n ಸಂಖ್ಯೆಯನ್ನು ನೀಡಿದರೆ, ನಾವು n ನಿಂದ ಸೂಚಿಸಲಾದ n ನ ಅಪವರ್ತನವನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು!
ಈಗ ನಾವು ಪುನರಾವರ್ತನೆಯನ್ನು ಬಳಸಿಕೊಂಡು n ಅಪವರ್ತನೀಯ (n!) ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸೋಣ.
public class Main{ static int fact(int n) { if (n == 1) // base condition return 1; else return n*fact(n-1); } public static void main(String[] args) { int result = fact(10); System.out.println("10! = " + result); } }ಔಟ್‌ಪುಟ್
ಈ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ, ಸ್ಥಿತಿ (n=1) ಮೂಲ ಸ್ಥಿತಿ ಎಂದು ನಾವು ನೋಡಬಹುದು ಮತ್ತು ಈ ಸ್ಥಿತಿಯನ್ನು ತಲುಪಿದಾಗ, ಕಾರ್ಯವು 1 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಕಾರ್ಯದ ಇತರ ಭಾಗವು ಪುನರಾವರ್ತಿತ ಕರೆಯಾಗಿದೆ. ಆದರೆ ಪ್ರತಿ ಬಾರಿ ಪುನರಾವರ್ತಿತ ವಿಧಾನವನ್ನು ಕರೆಯುವಾಗ, n ಅನ್ನು 1 ರಿಂದ ಕಡಿಮೆಗೊಳಿಸಲಾಗುತ್ತದೆ.
ಹೀಗೆ ನಾವು ಅಂತಿಮವಾಗಿ n ನ ಮೌಲ್ಯವು 1 ಅಥವಾ 1 ಕ್ಕಿಂತ ಕಡಿಮೆ ಆಗುತ್ತದೆ ಎಂದು ತೀರ್ಮಾನಿಸಬಹುದು.ಪಾಯಿಂಟ್, ವಿಧಾನವು ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ 1. ಈ ಮೂಲ ಸ್ಥಿತಿಯನ್ನು ತಲುಪಲಾಗುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯವು ನಿಲ್ಲುತ್ತದೆ. ಮೂಲ ಸ್ಥಿತಿಯನ್ನು ಪೂರೈಸುವವರೆಗೆ n ನ ಮೌಲ್ಯವು ಯಾವುದಾದರೂ ಆಗಿರಬಹುದು ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
ಪುನರಾವರ್ತನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸಮಸ್ಯೆ-ಪರಿಹರಿಸುವುದು
ಪುನರಾವರ್ತನೆಯನ್ನು ಬಳಸುವ ಹಿಂದಿನ ಮೂಲಭೂತ ಉಪಾಯವೆಂದರೆ ದೊಡ್ಡ ಸಮಸ್ಯೆಯನ್ನು ವ್ಯಕ್ತಪಡಿಸುವುದು ಸಣ್ಣ ಸಮಸ್ಯೆಗಳು. ಅಲ್ಲದೆ, ನಾವು ಪುನರಾವರ್ತನೆಯಿಂದ ಹೊರಬರಲು ನಾವು ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಬೇಸ್ ಷರತ್ತುಗಳನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ.
ಇದು ಈಗಾಗಲೇ ಮೇಲಿನ ಅಪವರ್ತನೀಯ ಉದಾಹರಣೆಯಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲ್ಪಟ್ಟಿದೆ. ಈ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ, ನಾವು n ಅಪವರ್ತನೀಯ (n!) ಅನ್ನು ಸಣ್ಣ ಮೌಲ್ಯಗಳ ಪರಿಭಾಷೆಯಲ್ಲಿ ವ್ಯಕ್ತಪಡಿಸಿದ್ದೇವೆ ಮತ್ತು ಮೂಲ ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿದ್ದೇವೆ (n =1) ಆದ್ದರಿಂದ n 1 ಅನ್ನು ತಲುಪಿದಾಗ, ನಾವು ಪುನರಾವರ್ತಿತ ವಿಧಾನವನ್ನು ತೊರೆಯಬಹುದು.
ಪುನರಾವರ್ತನೆಯಲ್ಲಿ ಸ್ಟಾಕ್ ಓವರ್‌ಫ್ಲೋ ದೋಷ
ಯಾವುದೇ ವಿಧಾನ ಅಥವಾ ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆದಾಗ, ಫಂಕ್ಷನ್‌ನ ಸ್ಥಿತಿಯನ್ನು ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಫಂಕ್ಷನ್ ಹಿಂತಿರುಗಿದಾಗ ಅದನ್ನು ಹಿಂಪಡೆಯಲಾಗುತ್ತದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ. ಸ್ಟಾಕ್ ಅನ್ನು ಪುನರಾವರ್ತಿತ ವಿಧಾನಕ್ಕೂ ಬಳಸಲಾಗುತ್ತದೆ.
ಆದರೆ ಪುನರಾವರ್ತನೆಯ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಮೂಲ ಸ್ಥಿತಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸದಿದ್ದರೆ ಅಥವಾ ಮೂಲ ಸ್ಥಿತಿಯನ್ನು ಹೇಗಾದರೂ ತಲುಪದಿದ್ದರೆ ಅಥವಾ ಕಾರ್ಯಗತಗೊಳಿಸದಿದ್ದರೆ ಸಮಸ್ಯೆ ಸಂಭವಿಸಬಹುದು. ಈ ಪರಿಸ್ಥಿತಿಯು ಸಂಭವಿಸಿದಲ್ಲಿ ಸ್ಟಾಕ್ ಓವರ್‌ಫ್ಲೋ ಉಂಟಾಗಬಹುದು.
ನಾವು ಅಪವರ್ತನೀಯ ಸಂಕೇತದ ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸೋಣ.
ಇಲ್ಲಿ ನಾವು ತಪ್ಪು ಮೂಲ ಸ್ಥಿತಿಯನ್ನು ನೀಡಿದ್ದೇವೆ, n==100.
public class Main { static int fact(int n) { if (n == 100) // base condition resulting in stack overflow return 1; else return n*fact(n-1); } public static void main(String[] args) { int result = fact(10); System.out.println("10! = " + result); } }ಆದ್ದರಿಂದ n > 100 ವಿಧಾನವು 1 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಆದರೆ ಪುನರಾವರ್ತನೆಯು ನಿಲ್ಲುವುದಿಲ್ಲ. n ನ ಮೌಲ್ಯವು ಅನಿರ್ದಿಷ್ಟವಾಗಿ ಇಳಿಮುಖವಾಗುತ್ತಲೇ ಇರುತ್ತದೆಅದನ್ನು ನಿಲ್ಲಿಸಲು ಬೇರೆ ಯಾವುದೇ ಷರತ್ತುಗಳಿಲ್ಲ. ಸ್ಟಾಕ್ ಓವರ್‌ಫ್ಲೋ ಆಗುವವರೆಗೆ ಇದು ಮುಂದುವರಿಯುತ್ತದೆ.
ಇನ್ನೊಂದು ಸಂದರ್ಭದಲ್ಲಿ n 100. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಹಾಗೆಯೇ ವಿಧಾನವು ಎಂದಿಗೂ ಮೂಲ ಸ್ಥಿತಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದಿಲ್ಲ ಮತ್ತು ಸ್ಟಾಕ್ ಓವರ್‌ಫ್ಲೋಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
ಜಾವಾದಲ್ಲಿ ಮರುಕಳಿಸುವ ಉದಾಹರಣೆಗಳು
ಈ ವಿಭಾಗದಲ್ಲಿ, ನಾವು ಈ ಕೆಳಗಿನ ಉದಾಹರಣೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ ಪುನರಾವರ್ತನೆ.
#1) ರಿಕರ್ಶನ್ ಬಳಸಿ ಫಿಬೊನಾಕಿ ಸರಣಿ
ಫೈಬೊನಾಕಿ ಸರಣಿಯನ್ನು,
1,1,2,3,5,8,13,21, ಮೂಲಕ ನೀಡಲಾಗಿದೆ 34,55,…
ಪ್ರಸ್ತುತ ಅಂಶವು ಹಿಂದಿನ ಎರಡು ಅಂಶಗಳ ಮೊತ್ತವಾಗಿದೆ ಎಂದು ಮೇಲಿನ ಅನುಕ್ರಮವು ತೋರಿಸುತ್ತದೆ. ಅಲ್ಲದೆ, ಫಿಬೊನಾಕಿ ಸರಣಿಯಲ್ಲಿನ ಮೊದಲ ಅಂಶವು 1 ಆಗಿದೆ.
ಆದ್ದರಿಂದ ಸಾಮಾನ್ಯವಾಗಿ n ಪ್ರಸ್ತುತ ಸಂಖ್ಯೆಯಾಗಿದ್ದರೆ, ಅದನ್ನು (n-1) ಮತ್ತು (n-2) ಮೊತ್ತದಿಂದ ನೀಡಲಾಗುತ್ತದೆ. ಪ್ರಸ್ತುತ ಅಂಶವನ್ನು ಹಿಂದಿನ ಅಂಶಗಳ ಪರಿಭಾಷೆಯಲ್ಲಿ ವ್ಯಕ್ತಪಡಿಸಿದಂತೆ, ನಾವು ಪುನರಾವರ್ತನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಸಮಸ್ಯೆಯನ್ನು ವ್ಯಕ್ತಪಡಿಸಬಹುದು.
ಫೈಬೊನಾಕಿ ಸರಣಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ:
public class Main { //method to calculate fibonacci series static int fibonacci(int n) { if (n = 1) { return n; } return fibonacci(n-1) + fibonacci(n-2); } public static void main(String[] args) { int number = 10; //print first 10 numbers of fibonacci series System.out.println ("Fibonacci Series: First 10 numbers:"); for (int i = 1; i = number; i++) { System.out.print(fibonacci(i) + " "); } } } ಔಟ್‌ಪುಟ್
#2) ಪುನರಾವರ್ತನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದು ಸಂಖ್ಯೆಯು ಪಾಲಿಂಡ್ರೋಮ್ ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ
ಪಾಲಿಂಡ್ರೋಮ್ ಒಂದು ಅನುಕ್ರಮವಾಗಿದ್ದು ಅದು ನಾವು ಸಮಾನವಾಗಿರುತ್ತದೆ ಅದನ್ನು ಎಡದಿಂದ ಬಲಕ್ಕೆ ಅಥವಾ ಬಲದಿಂದ ಎಡಕ್ಕೆ ಓದಿ.
121 ಸಂಖ್ಯೆಯನ್ನು ನೀಡಿದರೆ, ನಾವು ಅದನ್ನು ಎಡದಿಂದ ಬಲಕ್ಕೆ ಮತ್ತು ಬಲದಿಂದ ಎಡಕ್ಕೆ ಓದಿದಾಗ ಅದು ಸಮಾನವಾಗಿರುತ್ತದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ. ಆದ್ದರಿಂದ ಸಂಖ್ಯೆ 121 ಒಂದು ಪಾಲಿಂಡ್ರೋಮ್ ಆಗಿದೆ.
ಇನ್ನೊಂದು ಸಂಖ್ಯೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ, 1242. ನಾವು ಅದನ್ನು ಎಡದಿಂದ ಬಲಕ್ಕೆ ಓದಿದಾಗ ಅದು 1242 ಮತ್ತು ಬಲದಿಂದ ಎಡಕ್ಕೆ ಓದಿದಾಗ ಅದು 2421 ಎಂದು ಓದುತ್ತದೆ. ಹೀಗಾಗಿ ಇದು ಪಾಲಿಂಡ್ರೋಮ್ ಅಲ್ಲ.
ನಾವುಸಂಖ್ಯೆಗಳ ಅಂಕೆಗಳನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುವ ಮೂಲಕ ಪಾಲಿಂಡ್ರೋಮ್ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ ಮತ್ತು ನೀಡಿರುವ ಸಂಖ್ಯೆಯನ್ನು ಅದರ ಹಿಮ್ಮುಖ ಪ್ರಾತಿನಿಧ್ಯಕ್ಕೆ ಮರುಕಳಿಸುವ ಮೂಲಕ ಹೋಲಿಸಿ.
ಕೆಳಗಿನ ಪ್ರೋಗ್ರಾಂ ಪಾಲಿಂಡ್ರೋಮ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.
import java.io.*; import java.util.*; public class Main { // check if num contains only one digit public static int oneDigit(int num) { if ((num >= 0) && (num 10)) return 1; else return 0; } //palindrome utility function public static int isPalindrome_util (int num, int revNum) throws Exception { // base condition; return if num=0 if (num == 0) { return revNum; } else { //call utility function recursively revNum = isPalindrome_util(num / 10, revNum); } // Check if first digit of num and revNum are equal if (num % 10 == revNum % 10) { // if yes, revNum will move with num return revNum / 10; } else { // exit throw new Exception(); } } //method to check if a given number is palindrome using palindrome utility function public static int isPalindrome(int num) throws Exception { if (num 0) num = (-num); int revNum = (num); return isPalindrome_util(num, revNum); } public static void main(String args[]) { int n = 1242; try { isPalindrome(n); System.out.println("Yes, the given number " + n + " is a palindrome."); } catch (Exception e) { System.out.println("No, the given number " + n + " is not a palindrome."); } n = 1221; try { isPalindrome(n); System.out.println("Yes, the given number " + n + " is a palindrome."); } catch (Exception e) { System.out.println("No, the given number " + n + " is not a palindrome."); } } }ಔಟ್‌ಪುಟ್
#3) ರಿವರ್ಸ್ ಸ್ಟ್ರಿಂಗ್ ರಿಕರ್ಷನ್ ಜಾವಾ
“ಹಲೋ” ಎಂಬ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನೀಡಿದರೆ ನಾವು ಅದನ್ನು ರಿವರ್ಸ್ ಮಾಡಬೇಕು ಆದ್ದರಿಂದ ಫಲಿತಾಂಶದ ಸ್ಟ್ರಿಂಗ್ "olleH" ಆಗಿದೆ.
ಇದನ್ನು ರಿಕರ್ಶನ್ ಬಳಸಿ ಮಾಡಲಾಗುತ್ತದೆ. ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿನ ಕೊನೆಯ ಅಕ್ಷರದಿಂದ ಪ್ರಾರಂಭಿಸಿ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಅಕ್ಷರಗಳು ಖಾಲಿಯಾಗುವವರೆಗೆ ನಾವು ಪ್ರತಿ ಅಕ್ಷರವನ್ನು ಪುನರಾವರ್ತಿತವಾಗಿ ಮುದ್ರಿಸುತ್ತೇವೆ.
ಕೆಳಗಿನ ಪ್ರೋಗ್ರಾಂ ನೀಡಿದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರಿವರ್ಸ್ ಮಾಡಲು ರಿಕರ್ಶನ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.
class String_Reverse { //recursive method to reverse a given string void reverseString(String str) { //base condition; return if string is null or with 1 or less character if ((str==null)||(str.length() = 1)) System.out.println(str); else { //recursively print each character in the string from the end System.out.print(str.charAt(str.length()-1)); reverseString(str.substring(0,str.length()-1)); } } } class Main{ public static void main(String[] args) { String inputstr = "SoftwareTestingHelp"; System.out.println("The given string: " + inputstr); String_Reverse obj = new String_Reverse(); System.out.print("The reversed string: "); obj.reverseString(inputstr); } } ಔಟ್‌ಪುಟ್
#4) ಬೈನರಿ ಸರ್ಚ್ ಜಾವಾ ರಿಕರ್ಶನ್
ಬೈನರಿ ಸರ್ಚ್ ಅಲ್ಗಾರಿದಮ್ ಹುಡುಕಾಟಕ್ಕೆ ಪ್ರಸಿದ್ಧ ಅಲ್ಗಾರಿದಮ್ ಆಗಿದೆ. ಈ ಅಲ್ಗಾರಿದಮ್‌ನಲ್ಲಿ, n ಅಂಶಗಳ ವಿಂಗಡಿಸಲಾದ ಶ್ರೇಣಿಯನ್ನು ನೀಡಲಾಗಿದೆ, ನಾವು ನೀಡಿದ ಪ್ರಮುಖ ಅಂಶಕ್ಕಾಗಿ ಈ ಶ್ರೇಣಿಯನ್ನು ಹುಡುಕುತ್ತೇವೆ. ಆರಂಭದಲ್ಲಿ, ರಚನೆಯ ಮಧ್ಯದ ಅಂಶವನ್ನು ಕಂಡುಹಿಡಿಯುವ ಮೂಲಕ ನಾವು ಸರಣಿಯನ್ನು ಎರಡು ಭಾಗಗಳಾಗಿ ವಿಭಜಿಸುತ್ತೇವೆ.
ನಂತರ ಕೀ ಮಧ್ಯದಲ್ಲಿ ನಾವು ನಮ್ಮ ಹುಡುಕಾಟವನ್ನು ಸರಣಿಯ ಮೊದಲ ಅಥವಾ ದ್ವಿತೀಯಾರ್ಧದಲ್ಲಿ ಮಿತಿಗೊಳಿಸುತ್ತೇವೆ. ಈ ರೀತಿಯಲ್ಲಿ ಪ್ರಮುಖ ಅಂಶಗಳ ಸ್ಥಳವನ್ನು ಕಂಡುಹಿಡಿಯುವವರೆಗೆ ಅದೇ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸಲಾಗುತ್ತದೆ.
ನಾವು ಇಲ್ಲಿ ಪುನರಾವರ್ತನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ.
import java.util.*; class Binary_Search { // recursive binary search int binarySearch(int numArray[], int left, int right, int key) { if (right >= left) { //calculate mid of the array int mid = left + (right - left) / 2; // if the key is at mid, return mid if (numArray[mid] == key) return mid; // if key key) return binarySearch(numArray, left, mid - 1, key); // Else recursively search in the right subarray return binarySearch(numArray, mid + 1, right, key); } // no elements in the array, return -1 return -1; } } class Main{ public static void main(String args[]) { Binary_Search ob = new Binary_Search(); //declare and print the array int numArray[] = { 4,6,12,16,22}; System.out.println("The given array : " + Arrays.toString(numArray)); int len = numArray.length; //length of the array int key = 16; //key to be searched int result = ob.binarySearch(numArray, 0, len - 1, key); if (result == -1) System.out.println("Element " + key + " not present"); else System.out.println("Element " + key + " found at index " + result); } } ಔಟ್‌ಪುಟ್
#5) ಪುನರಾವರ್ತನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಅರೇಯಲ್ಲಿ ಕನಿಷ್ಠ ಮೌಲ್ಯವನ್ನು ಹುಡುಕಿ
ರಿಕರ್ಶನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ರಚನೆಯಲ್ಲಿ ಕನಿಷ್ಠ ಮೌಲ್ಯವನ್ನು ಸಹ ಕಾಣಬಹುದು.
ದಿರಚನೆಯಲ್ಲಿ ಕನಿಷ್ಠ ಮೌಲ್ಯವನ್ನು ಕಂಡುಹಿಡಿಯಲು Java ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ.
import java.util.*; class Main { static int getMin(int numArray[], int i, int n) { //return first element if only one element or minimum of the array elements return (n == 1) ? numArray[i] : Math.min(numArray[i], getMin(numArray,i + 1 , n - 1)); } public static void main(String[] args) { int numArray[] = { 7,32,64,2,10,23 }; System.out.println("Given Array : " + Arrays.toString(numArray)); int n = numArray.length; System.out.print("Minimum element of array: " + getMin(numArray, 0, n) + "\n"); } }ಔಟ್‌ಪುಟ್
ಇವುಗಳಲ್ಲಿ ಕೆಲವು ಪುನರಾವರ್ತನೆಯ ಉದಾಹರಣೆಗಳು. ಈ ಉದಾಹರಣೆಗಳ ಹೊರತಾಗಿ, ಸಾಫ್ಟ್‌ವೇರ್‌ನಲ್ಲಿನ ಬಹಳಷ್ಟು ಇತರ ಸಮಸ್ಯೆಗಳನ್ನು ಪುನರಾವರ್ತಿತ ತಂತ್ರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.
ಪುನರಾವರ್ತನೆಯ ವಿಧಗಳು
ಕರೆ ಮಾಡಿದಾಗ ಪುನರಾವರ್ತನೆಯು ಎರಡು ವಿಧವಾಗಿದೆ ರಿಕರ್ಸಿವ್ ವಿಧಾನ ಪುನರಾವರ್ತಿತ ವಿಧಾನದ ಒಳಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಇದನ್ನು "ಟೈಲ್ ರಿಕರ್ಷನ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.
ಟೈಲ್ ರಿಕರ್ಶನ್‌ನಲ್ಲಿ, ಪುನರಾವರ್ತಿತ ಕರೆ ಹೇಳಿಕೆಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ವಿಧಾನದ ರಿಟರ್ನ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ನೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.
ಟೈಲ್ ಪುನರಾವರ್ತನೆಗಾಗಿ ಸಾಮಾನ್ಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ:
methodName ( T parameters…){ { if (base_condition == true) { return result; } return methodName (T parameters …) //tail recursion } #2) ಹೆಡ್ ರಿಕರ್ಷನ್
ಹೆಡ್ ರಿಕರ್ಶನ್ ಯಾವುದೇ ಪುನರಾವರ್ತಿತ ವಿಧಾನವಾಗಿದ್ದು ಅದು ಟೈಲ್ ರಿಕರ್ಶನ್ ಅಲ್ಲ. ಆದ್ದರಿಂದ ಸಾಮಾನ್ಯ ಪುನರಾವರ್ತನೆಯು ಸಹ ಪುನರಾವರ್ತನೆಯ ಮುಂದಿದೆ.
ತಲೆಯ ಪುನರಾವರ್ತನೆಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ಈ ಕೆಳಗಿನಂತಿದೆ:
methodName (T parameters…){ if (some_condition == true) { return methodName (T parameters…); } return result; } ಜಾವಾದಲ್ಲಿ ಪುನರಾವರ್ತನೆ Vs ಪುನರಾವರ್ತನೆ
| ಪುನರಾವರ್ತನೆ | |
|---|---|
| ಪ್ರಕ್ರಿಯೆಯು ಮೂಲ ಸ್ಥಿತಿಯನ್ನು ಪೂರೈಸುವವರೆಗೆ ಒಂದು ವಿಧಾನವು ಪುನರಾವರ್ತಿತವಾಗಿ ತನ್ನನ್ನು ತಾನೇ ಕರೆದುಕೊಳ್ಳುತ್ತದೆ. | ಪುನರಾವರ್ತನೆ ಒಂದು ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ ಕೋಡ್‌ನ ತುಂಡನ್ನು ಸೀಮಿತ ಸಂಖ್ಯೆಯ ಬಾರಿ ಅಥವಾ ಷರತ್ತು ಪೂರೈಸುವವರೆಗೆ ಪುನರಾವರ್ತಿತವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. |
| ಕಾರ್ಯಗಳಿಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ. | ಅನ್ವಯವಾಗುತ್ತದೆ ಲೂಪ್‌ಗಳಿಗಾಗಿ. |
| ಇದಕ್ಕಾಗಿ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆಚಿಕ್ಕ ಕೋಡ್ ಗಾತ್ರ. | ದೊಡ್ಡ ಕೋಡ್ ಗಾತ್ರಕ್ಕೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. |
| ಪ್ರತಿ ಪುನರಾವರ್ತಿತ ಕರೆಯನ್ನು ಸ್ಟಾಕ್‌ಗೆ ತಳ್ಳಿದಾಗ ಹೆಚ್ಚು ಮೆಮೊರಿಯನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ | ತುಲನಾತ್ಮಕವಾಗಿ ಕಡಿಮೆ ಮೆಮೊರಿ ಬಳಸಲಾಗಿದೆ. |
| ಡೀಬಗ್ ಮಾಡಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಕಷ್ಟ | ಡೀಬಗ್ ಮಾಡಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭ |
| ಬೇಸ್ ವೇಳೆ ಸ್ಟಾಕ್ ಓವರ್‌ಫ್ಲೋ ಫಲಿತಾಂಶಗಳು ಸ್ಥಿತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿಲ್ಲ ಅಥವಾ ತಲುಪಿಲ್ಲ. | ಅನಂತವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಆದರೆ ಅಂತಿಮವಾಗಿ ಯಾವುದೇ ಮೆಮೊರಿ ದೋಷಗಳೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ |
| ಸಮಯದ ಸಂಕೀರ್ಣತೆ ತುಂಬಾ ಹೆಚ್ಚಾಗಿದೆ. | ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು ತುಲನಾತ್ಮಕವಾಗಿ ಕೆಳ ಭಾಗದಲ್ಲಿದೆ. |
ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು
Q #1) ಜಾವಾದಲ್ಲಿ ರಿಕರ್ಶನ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?
ಉತ್ತರ: ಪುನರಾವರ್ತನೆಯಲ್ಲಿ, ಮೂಲ ಸ್ಥಿತಿಯನ್ನು ಪೂರೈಸುವವರೆಗೆ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯವು ಪುನರಾವರ್ತಿತವಾಗಿ ಸ್ವತಃ ಕರೆ ಮಾಡುತ್ತದೆ. ಕರೆ ಕಾರ್ಯಕ್ಕಾಗಿ ಮೆಮೊರಿಯನ್ನು ಕರೆ ಕಾರ್ಯಕ್ಕಾಗಿ ಮೆಮೊರಿಯ ಮೇಲ್ಭಾಗದಲ್ಲಿರುವ ಸ್ಟಾಕ್‌ಗೆ ತಳ್ಳಲಾಗುತ್ತದೆ. ಪ್ರತಿ ಫಂಕ್ಷನ್ ಕರೆಗೆ, ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್‌ಗಳ ಪ್ರತ್ಯೇಕ ನಕಲನ್ನು ತಯಾರಿಸಲಾಗುತ್ತದೆ.
Q #2) ರಿಕರ್ಶನ್ ಅನ್ನು ಏಕೆ ಬಳಸಲಾಗಿದೆ?
ಉತ್ತರ: ರಿಕರ್ಶನ್ ಅನ್ನು ಚಿಕ್ಕದಾಗಿ ವಿಭಜಿಸಬಹುದಾದ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಸಂಪೂರ್ಣ ಸಮಸ್ಯೆಯನ್ನು ಸಣ್ಣ ಸಮಸ್ಯೆಯ ರೂಪದಲ್ಲಿ ವ್ಯಕ್ತಪಡಿಸಬಹುದು.
ಅತ್ಯಂತ ಸಮಸ್ಯೆಗಳಿಗೆ ಮರುಕಳಿಕೆಯನ್ನು ಸಹ ಬಳಸಲಾಗುತ್ತದೆ. ಪುನರಾವರ್ತಿತ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಪರಿಹರಿಸಬೇಕಾದ ಸಂಕೀರ್ಣ. ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು ಸಮಸ್ಯೆಯಾಗದ ಸಮಸ್ಯೆಗಳ ಜೊತೆಗೆ, ಪುನರಾವರ್ತನೆಯನ್ನು ಬಳಸಿ.
Q #3) ಇದರ ಪ್ರಯೋಜನಗಳು ಯಾವುವುಪುನರಾವರ್ತನೆ?
ಉತ್ತರ:
ಪುನರಾವರ್ತನೆಯ ಪ್ರಯೋಜನಗಳು ಸೇರಿವೆ:
- ಪುನರಾವರ್ತನೆಯು ಅನಗತ್ಯ ಕರೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಕಾರ್ಯದ.
- ಪುನರಾವರ್ತನೆಯ ವಿಧಾನಕ್ಕೆ ಹೋಲಿಸಿದರೆ ಪುನರಾವರ್ತನೆಯು ಸಮಸ್ಯೆಗಳನ್ನು ಸುಲಭವಾಗಿ ಪರಿಹರಿಸಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
Q #4) ಯಾವುದು ಉತ್ತಮ - ಪುನರಾವರ್ತನೆ ಅಥವಾ ಪುನರಾವರ್ತನೆ?
ಉತ್ತರ: ಮೂಲ ಕಾರ್ಯವನ್ನು ತಲುಪುವವರೆಗೆ ಪುನರಾವರ್ತನೆಯು ಪುನರಾವರ್ತಿತ ಕರೆಗಳನ್ನು ಮಾಡುತ್ತದೆ. ಪ್ರತಿ ಫಂಕ್ಷನ್ ಕರೆಗೆ ಮೆಮೊರಿಯನ್ನು ಸ್ಟಾಕ್‌ಗೆ ತಳ್ಳುವುದರಿಂದ ಮೆಮೊರಿ ಓವರ್‌ಹೆಡ್ ಇರುತ್ತದೆ.
ಮತ್ತೊಂದೆಡೆ ಪುನರಾವರ್ತನೆಯು ಹೆಚ್ಚಿನ ಮೆಮೊರಿ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಹೊಂದಿಲ್ಲ. ಪುನರಾವರ್ತನೆಯ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಪುನರಾವರ್ತನೆಯ ವಿಧಾನಕ್ಕಿಂತ ನಿಧಾನವಾಗಿರುತ್ತದೆ. ಪುನರಾವರ್ತನೆಯು ಕೋಡ್‌ನ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಆದರೆ ಪುನರಾವರ್ತನೆಯ ವಿಧಾನವು ಕೋಡ್ ಅನ್ನು ದೊಡ್ಡದಾಗಿಸುತ್ತದೆ.
Q #5) ಪುನರಾವರ್ತನೆಯ ಮೇಲೆ ಪುನರಾವರ್ತನೆಯ ಪ್ರಯೋಜನಗಳೇನು?
ಉತ್ತರ:
- ಪುನರಾವರ್ತನೆಯು ಕೋಡ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಮತ್ತು ಕಡಿಮೆಗೊಳಿಸುತ್ತದೆ.
- ಹನೋಯಿ ಗೋಪುರ, ಮರದಂತಹ ಸಮಸ್ಯೆಗಳಿಗೆ ಪುನರಾವರ್ತನೆಯ ವಿಧಾನಕ್ಕಿಂತ ಪುನರಾವರ್ತನೆಯು ಉತ್ತಮವಾಗಿದೆ ಟ್ರಾವರ್ಸಲ್‌ಗಳು, ಇತ್ಯಾದಿ.
- ಪ್ರತಿ ಫಂಕ್ಷನ್ ಕರೆಯು ಮೆಮೊರಿಯನ್ನು ಸ್ಟಾಕ್‌ಗೆ ತಳ್ಳಿದಂತೆ, ಪುನರಾವರ್ತನೆಯು ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ಬಳಸುತ್ತದೆ.
- ಪುನರಾವರ್ತನೆಯ ಕಾರ್ಯನಿರ್ವಹಣೆಯು ಪುನರಾವರ್ತಿತ ವಿಧಾನಕ್ಕಿಂತ ನಿಧಾನವಾಗಿರುತ್ತದೆ.
ತೀರ್ಮಾನ
ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯ ಹೊರತಾಗಿಯೂ ಸಾಫ್ಟ್‌ವೇರ್‌ನಲ್ಲಿ ಪುನರಾವರ್ತನೆಯು ಬಹಳ ಮುಖ್ಯವಾದ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ. ಹನೋಯಿ ಗೋಪುರಗಳು, ಟ್ರೀ ಟ್ರಾವರ್ಸಲ್‌ಗಳು, ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್‌ಗಳು ಮುಂತಾದ ಡೇಟಾ ರಚನೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವಲ್ಲಿ ಪುನರಾವರ್ತನೆಯನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದರೂ,ಪುನರಾವರ್ತನೆಯು ಕೋಡ್ ಅನ್ನು ಸರಳ ಮತ್ತು ಸ್ಪಷ್ಟಗೊಳಿಸುತ್ತದೆ.
ನಾವು ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ಪುನರಾವರ್ತನೆಯ ಬಗ್ಗೆ ಎಲ್ಲವನ್ನೂ ಅನ್ವೇಷಿಸಿದ್ದೇವೆ. ಪರಿಕಲ್ಪನೆಯ ಉತ್ತಮ ತಿಳುವಳಿಕೆಗಾಗಿ ನಾವು ಹಲವಾರು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಉದಾಹರಣೆಗಳನ್ನು ಸಹ ಅಳವಡಿಸಿದ್ದೇವೆ.