Corecursion
ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ, ಕೋರ್ಕರ್ಷನ್ ಎಂಬುದು ಪುನರಾವರ್ತನೆಗೆ ದ್ವಿಗುಣವಾಗಿರುವ ಒಂದು ರೀತಿಯ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ. ರಿಕರ್ಶನ್ ವಿಶ್ಲೇಷಣಾತ್ಮಕವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆಯಾದರೂ, ಬೇಸ್ ಕೇಸ್ನಿಂದ ಮತ್ತಷ್ಟು ಡೇಟಾವನ್ನು ಪ್ರಾರಂಭಿಸಿ ಅದನ್ನು ಸಣ್ಣ ಡೇಟಾದಾಗಿ ವಿಭಜಿಸಿ ಮತ್ತು ಬೇಸ್ ಕೇಸ್ ಅನ್ನು ತಲುಪುವವರೆಗೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ, ಕೋರ್ಕರ್ಶನ್ ಕೃತಕವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಬೇಸ್ ಕೇಸ್ನಿಂದ ಪ್ರಾರಂಭಿಸಿ ಅದನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ, ಬೇಸ್ ಕೇಸ್ನಿಂದ ಮತ್ತಷ್ಟು ತೆಗೆದುಹಾಕಲಾದ ಡೇಟಾವನ್ನು ಪುನರಾವರ್ತಿತವಾಗಿ ಉತ್ಪಾದಿಸುತ್ತದೆ. ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಕೋರ್ಕರ್ಸಿವ್ ಅಲ್ಗಾರಿದಮ್ಗಳು ತಾವು ಉತ್ಪಾದಿಸುವ ದತ್ತಾಂಶವನ್ನು, ಅವು ಲಭ್ಯವಾಗುತ್ತಿದ್ದಂತೆ ಮತ್ತು ಅಗತ್ಯವಿರುವಂತೆ, ಹೆಚ್ಚಿನ ದತ್ತಾಂಶದ ತುಣುಕುಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಬಳಸುತ್ತವೆ. ಇದೇ ರೀತಿಯ ಆದರೆ ವಿಶಿಷ್ಟವಾದ ಪರಿಕಲ್ಪನೆಯೆಂದರೆ ಉತ್ಪಾದಕ ಪುನರಾವರ್ತನೆಯಾಗಿದ್ದು, ಇದು ಕೋರ್ಕರ್ಶನ್ ಮತ್ತು ಪುನರಾವರ್ತನೆಯಲ್ಲಿ ಅಂತರ್ಗತವಾಗಿರುವ ನಿರ್ದಿಷ್ಟ "ನಿರ್ದೇಶನ" ವನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ. ಪುನರಾವರ್ತನೆಯು ಪ್ರೋಗ್ರಾಂಗಳಿಗೆ ಅನಿಯಂತ್ರಿತವಾಗಿ ಸಂಕೀರ್ಣವಾದ ಡೇಟಾದ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಟ್ಟರೆ, ಅವುಗಳನ್ನು ಸರಳವಾದ ಡೇಟಾಗೆ (ಬೇಸ್ ಕೇಸ್ಗಳು) ಕಡಿಮೆ ಮಾಡಬಹುದಾದವರೆಗೆ, ಕೋರ್ ಕರ್ಷನ್ ಪ್ರೋಗ್ರಾಂಗಳಿಗೆ ಸ್ಟ್ರೀಮ್ಗಳಂತಹ ಅನಿಯಂತ್ರಿತವಾಗಿ ಸಂಕೀರ್ಣವಾದ ಮತ್ತು ಸಂಭಾವ್ಯವಾಗಿ ಅನಂತವಾದ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಎಲ್ಲಿಯವರೆಗೆ ಅದನ್ನು ಉತ್ಪಾದಿಸಬಹುದು ಸೀಮಿತ ಹಂತಗಳ ಅನುಕ್ರಮದಲ್ಲಿ ಸರಳ ಡೇಟಾದಿಂದ (ಬೇಸ್ ಕೇಸ್ಗಳು). ಪುನರಾವರ್ತನೆಯು ಕೊನೆಗೊಳ್ಳದಿದ್ದಲ್ಲಿ, ಎಂದಿಗೂ ಮೂಲ ಸ್ಥಿತಿಯನ್ನು ತಲುಪದಿದ್ದಲ್ಲಿ, ಕೋರ್ ಕರ್ಷನ್ ಒಂದು ಮೂಲ ಸ್ಥಿತಿಯಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ಮತ್ತು ಇದು ಅನಿರ್ದಿಷ್ಟವಾಗಿ ಮುಂದುವರಿಯಬಹುದಾದರೂ (ಮತ್ತು ಆದ್ದರಿಂದ ಕಟ್ಟುನಿಟ್ಟಾದ ಮೌಲ್ಯಮಾಪನದ ಅಡಿಯಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುವುದಿಲ್ಲ), ಅಥವಾ ಅದು ಉತ್ಪಾದಿಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಿನದನ್ನು ಸೇವಿಸಬಹುದು ಮತ್ತು ಹೀಗಾಗಿ ಉತ್ಪಾದಕವಲ್ಲದಂತಾಗುತ್ತದೆ. ಸಾಂಪ್ರದಾಯಿಕವಾಗಿ ರಿಕರ್ಸಿವ್ ಎಂದು ವಿಶ್ಲೇಷಿಸಲಾಗುವ ಅನೇಕ ಕಾರ್ಯಗಳನ್ನು ಪರ್ಯಾಯವಾಗಿ, ಮತ್ತು ವಾದಯೋಗ್ಯವಾಗಿ ಹೆಚ್ಚು ಸ್ವಾಭಾವಿಕವಾಗಿ, ನಿರ್ದಿಷ್ಟ ಹಂತದಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುವ ಕೋರ್ಕರ್ಸಿವ್ ಕಾರ್ಯಗಳಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ ಫ್ಯಾಕ್ಟೋರಿಯಲ್ನಂತಹ ಪುನರಾವರ್ತಿತ ಸಂಬಂಧಗಳು. ಕೋರೆಕರ್ಶನ್ ಸೀಮಿತ ಮತ್ತು ಅನಂತ ದತ್ತಾಂಶ ರಚನೆಗಳನ್ನು ಫಲಿತಾಂಶಗಳಾಗಿ ಉತ್ಪಾದಿಸಬಹುದು ಮತ್ತು ಸ್ವಯಂ-ಉಲ್ಲೇಖಿತ ದತ್ತಾಂಶ ರಚನೆಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. ಸಂಭಾವ್ಯ ಅನಂತ ರಚನೆಯ ಸೀಮಿತ ಉಪವಿಭಾಗವನ್ನು ಮಾತ್ರ ಉತ್ಪಾದಿಸಲು (ಏಕಕಾಲದಲ್ಲಿ ಸಂಪೂರ್ಣ ಅನಂತ ರಚನೆಯನ್ನು ಉತ್ಪಾದಿಸಲು ಪ್ರಯತ್ನಿಸುವ ಬದಲು) ಕೋರೆಕರ್ಶನ್ ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸೋಮಾರಿಯಾದ ಮೌಲ್ಯಮಾಪನದೊಂದಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ. ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ನಲ್ಲಿ ಕೋರ್ಕರ್ಶನ್ ಒಂದು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ, ಅಲ್ಲಿ ಕೋರ್ಕರ್ಶನ್ ಮತ್ತು ಕೋಡೇಟಾ ಒಟ್ಟು ಭಾಷೆಗಳಿಗೆ ಅನಂತ ದತ್ತಾಂಶ ರಚನೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ. ಉದಾಹರಣೆಗಳು ಕೊರೆಕರ್ಶನ್ ಅನ್ನು ಪುನರಾವರ್ತನೆಗೆ ವ್ಯತಿರಿಕ್ತವಾಗಿ ಅರ್ಥೈಸಿಕೊಳ್ಳಬಹುದು, ಇದು ಹೆಚ್ಚು ಪರಿಚಿತವಾಗಿದೆ. ಕೋರ್ಕರ್ಷನ್ ಪ್ರಾಥಮಿಕವಾಗಿ ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ ಆಸಕ್ತಿಯನ್ನು ಹೊಂದಿದ್ದರೂ, ಪೈಥಾನ್ನಲ್ಲಿ ಜನರೇಟರ್ ಸೌಲಭ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಕೆಳಗೆ ಮಾಡಲಾದ ಕಡ್ಡಾಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ವಿವರಿಸಬಹುದು. ಈ ಉದಾಹರಣೆಗಳಲ್ಲಿ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಮೌಲ್ಯಗಳನ್ನು ಅನಿವಾರ್ಯವಾಗಿ (ವಿನಾಶಕಾರಿಯಾಗಿ) ನಿಗದಿಪಡಿಸಲಾಗುತ್ತದೆ, ಆದರೂ ಇವು ಶುದ್ಧ ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ ಕೋರ್ಕರ್ಷನ್ನಲ್ಲಿ ಅಗತ್ಯವಿಲ್ಲ. ಶುದ್ಧ ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ನಲ್ಲಿ, ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳಿಗೆ ನಿಯೋಜಿಸುವ ಬದಲು, ಈ ಗಣನೆಯ ಮೌಲ್ಯಗಳು ಬದಲಾಗದ ಅನುಕ್ರಮವನ್ನು ರೂಪಿಸುತ್ತವೆ, ಮತ್ತು ಪೂರ್ವ ಮೌಲ್ಯಗಳನ್ನು ಸ್ವಯಂ-ಉಲ್ಲೇಖದಿಂದ ಪ್ರವೇಶಿಸಲಾಗುತ್ತದೆ (ಅನುಕ್ರಮದಲ್ಲಿ ನಂತರದ ಮೌಲ್ಯಗಳು ಗಣನೆಯ ಅನುಕ್ರಮದಲ್ಲಿ ಹಿಂದಿನ ಮೌಲ್ಯಗಳನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತವೆ). ನಿಯೋಜನೆಗಳು ಇದನ್ನು ಅನಿವಾರ್ಯ ಮಾದರಿಯಲ್ಲಿ ಸರಳವಾಗಿ ವ್ಯಕ್ತಪಡಿಸುತ್ತವೆ ಮತ್ತು ಲೆಕ್ಕಾಚಾರಗಳು ಎಲ್ಲಿ ನಡೆಯುತ್ತವೆ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸುತ್ತವೆ, ಇದು ವಿವರಣೆಯನ್ನು ಸ್ಪಷ್ಟಪಡಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಪುನರಾವರ್ತನೆಯ ಒಂದು ಶ್ರೇಷ್ಠ ಉದಾಹರಣೆಯೆಂದರೆ ಅಪವರ್ತನೀಯವನ್ನು ಲೆಕ್ಕ ಹಾಕುವುದು, ಇದನ್ನು ಪುನರಾವರ್ತಿತವಾಗಿ 0 ರಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ! : = 1 ಮತ್ತು n! : = n × (n-1)!. ಕೊಟ್ಟಿರುವ ಇನ್ಪುಟ್ನಲ್ಲಿ ಅದರ ಫಲಿತಾಂಶವನ್ನು ಪುನರಾವರ್ತಿತವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು, ಪುನರಾವರ್ತಿತ ಕಾರ್ಯವು ಬೇರೆ ("ಸಣ್ಣ" ರೀತಿಯಲ್ಲಿ) ಇನ್ಪುಟ್ನೊಂದಿಗೆ ಸ್ವತಃ ಕರೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅದರ ಫಲಿತಾಂಶವನ್ನು ನಿರ್ಮಿಸಲು ಈ ಕರೆಯ ಫಲಿತಾಂಶವನ್ನು ಬಳಸುತ್ತದೆ. ಬೇಸ್ ಕೇಸ್ ಅನ್ನು ತಲುಪದ ಹೊರತು ರಿಕರ್ಸಿವ್ ಕರೆ ಅದೇ ರೀತಿ ಮಾಡುತ್ತದೆ. ಹೀಗಾಗಿ ಈ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಕಾಲ್ ಸ್ಟ್ಯಾಕ್ ಬೆಳೆಯುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಫೇಸ್ (3) ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು, ಇದು ಪುನರಾವರ್ತಿತವಾಗಿ ಫೇಸ್ (2), ಫೇಸ್ (1), ಫೇಸ್ (0) (ಸ್ಟ್ಯಾಕ್ ಅನ್ನು "ವಿಂಡಿಂಗ್ ಅಪ್") ಎಂದು ಕರೆಯುತ್ತದೆ, ಆ ಸಮಯದಲ್ಲಿ ಪುನರಾವರ್ತನೆಯು ಫೇಸ್ (0) = 1 ರೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ನಂತರ ಸ್ಟ್ಯಾಕ್ ಹಿಮ್ಮುಖ ಕ್ರಮದಲ್ಲಿ ಬಿಚ್ಚುತ್ತದೆ ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ಕಾಲ್ ಸ್ಟ್ಯಾಕ್ ಉದ್ದಕ್ಕೂ ಆರಂಭಿಕ ಕಾಲ್ ಫ್ರೇಮ್ ಫೇಸ್ (3) ಗೆ ಹಿಂತಿರುಗುವಾಗ ಲೆಕ್ಕ ಹಾಕಲಾಗುತ್ತದೆ, ಇದು ಫೇಸ್ (2) = 2 ರ ಫಲಿತಾಂಶವನ್ನು ಬಳಸಿಕೊಂಡು ಅಂತಿಮ ಫಲಿತಾಂಶವನ್ನು 3 × 2 = 3 × ಫೇಸ್ (2) =: ಫೇಸ್ (3) ಎಂದು ಲೆಕ್ಕಹಾಕುತ್ತದೆ ಮತ್ತು ಅಂತಿಮವಾಗಿ ಫೇಸ್ (3) = 6 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಒಂದು ಕಾರ್ಯವು ಒಂದೇ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಈ ಸ್ಟ್ಯಾಕ್ ಅನ್ವೈಂಡಿಂಗ್ ಅನ್ನು ವಿವರಿಸಬಹುದು, ಫ್ಯಾಕ್ಟೋರಿಯಲ್ ಕೋರ್ಕರ್ಸಿವ್ ಆಗಿ, ಇಟರೇಟರ್ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು, ಅಲ್ಲಿ ಒಬ್ಬರು ಕೇಸ್ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತಾರೆ, ನಂತರ ಈ ಆರಂಭಿಕ ಮೌಲ್ಯದಿಂದ 2,3 ಸಂಖ್ಯೆಗಳನ್ನು ಹೆಚ್ಚಿಸಲು ಫ್ಯಾಕ್ಟೋರಿಯಲ್ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ. ಮೇಲಿನ ಪುನರಾವರ್ತಿತ ವ್ಯಾಖ್ಯಾನದಲ್ಲಿರುವಂತೆ, "ಸಮಯ ಬಾಣ" ಅನ್ನು ಹಿಮ್ಮುಖವಾಗಿ ಓದುವ ಮೂಲಕ, ಕೋರ್ ಕರ್ಸಿವ್ ಅಲ್ಗಾರಿದಮ್ ಹೀಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಎಲ್ಲಾ ಫ್ಯಾಕ್ಟೋರಿಯಲ್ಗಳ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಇದನ್ನು ಜನರೇಟರ್ ಆಗಿ ನಿರ್ದಿಷ್ಟವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. ಸಾಂಕೇತಿಕವಾಗಿ, ಮುಂದಿನ ಅಪವರ್ತನೀಯ ಮೌಲ್ಯವನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಲು n ಮತ್ತು f (ಹಿಂದಿನ ಅಪವರ್ತನೀಯ ಮೌಲ್ಯ) ಎರಡನ್ನೂ ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿದರೆ, ಇದನ್ನು ಹೀಗೆ ಪ್ರತಿನಿಧಿಸಬಹುದುಃ ಅಥವಾ ಹಾಸ್ಕೆಲ್ನಲ್ಲಿ, (\(n, f)-> (n + 1, f * (n + 1)) 'ಪುನರಾವರ್ತನೆ' (0,1) ಎಂದರೆ, "ಪ್ರತಿ ಹಂತದಿಂದ ಪ್ರಾರಂಭಿಸಿ, ಮುಂದಿನ ಮೌಲ್ಯಗಳನ್ನು ಹೀಗೆ ಲೆಕ್ಕ ಹಾಕಲಾಗುತ್ತದೆ". ಇದು ಗಣಿತಶಾಸ್ತ್ರದಲ್ಲಿ ಸಮಾನವಾಗಿದೆ ಮತ್ತು ಪುನರಾವರ್ತಿತ ವ್ಯಾಖ್ಯಾನಕ್ಕೆ ಬಹುತೇಕ ಹೋಲುತ್ತದೆ, ಆದರೆ ಅಪವರ್ತನೀಯ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ಮಿಸಲಾಗುತ್ತಿದೆ ಎಂದು ಒತ್ತಿಹೇಳುತ್ತದೆ, ಆರಂಭಿಕ ಪ್ರಕರಣದಿಂದ ಮುಂದಕ್ಕೆ ಹೋಗುತ್ತದೆ, ಮೊದಲು ಹಿಂದಕ್ಕೆ ಹೋದ ನಂತರ ಲೆಕ್ಕ ಹಾಕುವ ಬದಲು, ಬೇಸ್ ಕೇಸ್ಗೆ, ಇಳಿಕೆಯೊಂದಿಗೆ. ಕೋರ್ಕರ್ಸಿವ್ ಫಂಕ್ಷನ್ನಿನ ನೇರ ಔಟ್ಪುಟ್ ಕೇವಲ ಅಪವರ್ತನೀಯ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ, ಆದರೆ ಪ್ರತಿ ಮೌಲ್ಯಕ್ಕೂ ಅನುಕ್ರಮದಲ್ಲಿ ಅದರ ಸೂಚ್ಯಂಕ n ನ ಸಹಾಯಕ ದತ್ತಾಂಶವನ್ನು ಸಹ ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಅಗತ್ಯವಿದ್ದಾಗ ಅವುಗಳಲ್ಲಿ ಯಾವುದೇ ಒಂದು ನಿರ್ದಿಷ್ಟ ಫಲಿತಾಂಶವನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು. ಡಿನೋಟೇಶನಲ್ ಶಬ್ದಾರ್ಥದೊಂದಿಗೆ ಒಂದು ಸಂಪರ್ಕವಿದೆ, ಅಲ್ಲಿ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಕ್ರಮಗಳ ಡಿನೋಟೇಶನ್ಗಳನ್ನು ಈ ರೀತಿಯಲ್ಲಿ ಕೋರ್ ಕರ್ಸಿವ್ ಆಗಿ ನಿರ್ಮಿಸಲಾಗಿದೆ. ಪೈಥಾನ್ನಲ್ಲಿ, ಪುನರಾವರ್ತಿತ ಅಪವರ್ತನೀಯ ಕಾರ್ಯವನ್ನು ಹೀಗೆ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದುಃ ಡೆಫ್ ಅಪವರ್ತನೀಯ (n: int)-> int: "ಪುನರಾವರ್ತಿತ ಅಪವರ್ತನೀಯ ಕಾರ್ಯ". n = = 0 ಆಗಿದ್ದರೆಃ 1 ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ ಇಲ್ಲದಿದ್ದರೆಃ n * ಅಪವರ್ತನೀಯ (n-1) ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ ಇದನ್ನು ಉದಾಹರಣೆಗೆ 5 ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಅಪವರ್ತನೀಯ (5) ಎಂದು ಕರೆಯಬಹುದು!. ಅನುಗುಣವಾದ ಕೋರ್ಕರ್ಸಿವ್ ಜನರೇಟರ್ ಅನ್ನು ಹೀಗೆ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದುಃ ಡೆಫ್ ಫ್ಯಾಕ್ಟರಿಯಲ್ಸ್ (): "ಕೋರ್ಕರ್ಸಿವ್ ಜನರೇಟರ್". n, f = 0,1 ಆದರೆ ನಿಜಃ ಇಳುವರಿ f n, f = n + 1, f * (n + 1) ಇದು ಕ್ರಮದಲ್ಲಿ ಅಪವರ್ತನೀಯಗಳ ಅನಂತ ಹರಿವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ; ಅದರ ಒಂದು ಸೀಮಿತ ಭಾಗವನ್ನು ಹೀಗೆ ಉತ್ಪಾದಿಸಬಹುದುಃ ಡೆಫ್ n _ ಫ್ಯಾಕ್ಟೋರಿಯಲ್ಗಳು (n: int): k, f = 0,1 ಆದರೆ k <= n: ಇಳುವರಿ f k, f = k + 1, f * (k + 1) ಇದನ್ನು ನಂತರ 5 ರವರೆಗಿನ ಅಪವರ್ತನೀಯಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಕರೆಯಬಹುದು! ಮೂಲಕಃ ಫಾರ್ f ಇನ್ n _ ಫ್ಯಾಕ್ಟೋರಿಯಲ್ಸ್ (5): ಪ್ರಿಂಟ್ (f) ನಾವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಫ್ಯಾಕ್ಟೋರಿಯಲ್ನಲ್ಲಿ ಮಾತ್ರ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದರೆ, ಕೇವಲ ಕೊನೆಯ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಅಥವಾ ನಾವು ಉತ್ಪಾದನೆ ಮತ್ತು ಪ್ರವೇಶವನ್ನು ಒಂದು ಕಾರ್ಯಕ್ಕೆ ಬೆಸೆಯಬಹುದು, ಡೆಫ್ nth _ ಫ್ಯಾಕ್ಟೋರಿಯಲ್ (n: int): k, f = 0,1 ಆದರೆ k <n: k, f = k + 1, f * (k + 1) ರಿಟರ್ನ್ f. ಹೀಗಾಗಿ ಕೋರ್ ಕರ್ಶನ್ ಪರಿಕಲ್ಪನೆಯು ಅನ್ವಯವಾಗುವಲ್ಲಿ ಪುನರಾವರ್ತಿತ ವ್ಯಾಖ್ಯಾನಗಳ ಮೂಲಕ ಪುನರಾವರ್ತಿತ ಗಣನೆಯ ಪ್ರಕ್ರಿಯೆಗಳ ಸಾಕಾರದ ವಿವರಣೆಯಾಗಿದೆ ಎಂದು ಹೇಳಬಹುದು. ಅದೇ ರೀತಿಯಲ್ಲಿ, ಫಿಬೊನಾಚಿ ಅನುಕ್ರಮವನ್ನು ಈ ರೀತಿ ಪ್ರತಿನಿಧಿಸಬಹುದುಃ ಫಿಬೊನಾಚಿ ಅನುಕ್ರಮವು 2ನೇ ಕ್ರಮದ ಪುನರಾವರ್ತಿತ ಸಂಬಂಧವಾಗಿರುವುದರಿಂದ, ಕೋರ್ಕರ್ಸಿವ್ ಸಂಬಂಧವು ಎರಡು ಅನುಕ್ರಮ ಪದಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಕು, ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಒಂದು ಹಂತದಿಂದ ಮುಂದಕ್ಕೆ ಚಲಿಸುವುದು ಮತ್ತು ಮುಂದಿನ ಪದವನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುವುದು. ಇದನ್ನು ನಂತರ ಈ ಕೆಳಗಿನಂತೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು (ಸಮಾನಾಂತರ ನಿಯೋಜನೆಯನ್ನು ಬಳಸಿ): ಡೆಫ್ ಫೈಬೊನಾಚಿ _ ಸೀಕ್ವೆನ್ಸ್ (): a, b = 0,1 ಆದರೆ ನಿಜಃ a a, b = b, a + b ಅನ್ನು ನೀಡುತ್ತದೆ ಹಾಸ್ಕೆಲ್ನಲ್ಲಿ, ಮ್ಯಾಪ್ fst ((\(a, b)-> (b, a + b)) 'ಇಟರೇಟ್' (0,1)) ಟ್ರೀ ಟ್ರಾವರ್ಸಲ್ ಟ್ರೀ ಟ್ರಾವರ್ಸಲ್ ಡೆಪ್ತ್-ಫಸ್ಟ್ ವಿಧಾನದ ಮೂಲಕ ಪುನರಾವರ್ತನೆಗೆ ಒಂದು ಶ್ರೇಷ್ಠ ಉದಾಹರಣೆಯಾಗಿದೆ. ಎರಡು ರೀತಿಯಲ್ಲಿ, ಅಗಲ-ಮೊದಲ ತಿರುವುಗಳನ್ನು ಕೋರ್ ಕರ್ಷನ್ ಮೂಲಕ ಬಹಳ ಸ್ವಾಭಾವಿಕವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. ಪುನರಾವರ್ತಿತವಾಗಿ, ಒಬ್ಬರು ಮರವನ್ನು ಅದರ ಮೂಲ ನೋಡ್ ಅನ್ನು ದತ್ತಾಂಶ ರಚನೆಯಲ್ಲಿ ಇರಿಸುವ ಮೂಲಕ ಹಾದುಹೋಗಬಹುದು, ನಂತರ ಅದು ಖಾಲಿಯಾಗಿರುವಾಗ ಆ ದತ್ತಾಂಶ ರಚನೆಯೊಂದಿಗೆ ಪುನರಾವರ್ತಿಸಬಹುದು, ಪ್ರತಿ ಹಂತದಲ್ಲೂ ಅದರಿಂದ ಮೊದಲ ನೋಡ್ ಅನ್ನು ತೆಗೆದುಹಾಕಬಹುದು ಮತ್ತು ತೆಗೆದುಹಾಕಲಾದ ನೋಡ್ನ ಚೈಲ್ಡ್ ನೋಡ್ಗಳನ್ನು ಆ ದತ್ತಾಂಶ ರಚನೆಗೆ ಹಿಂತಿರುಗಿಸಬಹುದು. ದತ್ತಾಂಶ ರಚನೆಯು ಸ್ಟ್ಯಾಕ್ (ಎಲ್ಐಎಫ್ಒ) ಆಗಿದ್ದರೆ, ಇದು ಡೆಪ್ತ್-ಫಸ್ಟ್ ಟ್ರಾವರ್ಸಲ್ ಅನ್ನು ನೀಡುತ್ತದೆ, ಮತ್ತು ದತ್ತಾಂಶ ರಚನೆಯು ಕ್ಯೂ (ಎಫ್ಐಎಫ್ಒ) ಆಗಿದ್ದರೆ, ಇದು ಅಗಲ-ಫಸ್ಟ್ ಟ್ರಾವರ್ಸಲ್ ಅನ್ನು ನೀಡುತ್ತದೆಃ ಪುನರಾವರ್ತನೆಯನ್ನು ಬಳಸಿಕೊಂಡು, ಮರದ ಡೆಪ್ತ್-ಫಸ್ಟ್ ಟ್ರಾವರ್ಸಲ್ ಅನ್ನು ರೂಟ್ ನೋಡ್ನ ಚೈಲ್ಡ್ ನೋಡ್ಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದನ್ನೂ ಪುನರಾವರ್ತಿತವಾಗಿ ಹಾದುಹೋಗುವಂತೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಹೀಗಾಗಿ ಮೊದಲ ಚೈಲ್ಡ್ ಸಬ್ಟ್ರೀ ಮುಗಿಯುವವರೆಗೆ ಎರಡನೇ ಚೈಲ್ಡ್ ಸಬ್ಟ್ರೀ ಅನ್ನು ಸಂಸ್ಕರಿಸಲಾಗುವುದಿಲ್ಲ. ರೂಟ್ ನೋಡ್ನ ಮೌಲ್ಯವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ, ಮೊದಲ ಚೈಲ್ಡ್ ಅನ್ನು ಹಾದುಹೋಗುವ ಮೊದಲು (ಪೂರ್ವ-ಆರ್ಡರ್ ಟ್ರಾವರ್ಸಲ್ಗೆ ಕಾರಣವಾಗುತ್ತದೆ), ಮೊದಲನೆಯದು ಮುಗಿದ ನಂತರ ಮತ್ತು ಎರಡನೆಯದು (ಇನ್-ಆರ್ಡರ್) ಮೊದಲು, ಅಥವಾ ಎರಡನೇ ಚೈಲ್ಡ್ ನೋಡ್ ಮುಗಿದ ನಂತರ (ಪೋಸ್ಟ್-ಆರ್ಡರ್)-ಟ್ರೀ ಬೈನರಿ ಎಂದು ಭಾವಿಸಿ, ವಿವರಣೆಯ ಸರಳತೆಗಾಗಿ. ಕರೆ ಸ್ಟ್ಯಾಕ್ (ರಿಕರ್ಸಿವ್ ಟ್ರಾವರ್ಸಲ್ ಫಂಕ್ಷನ್ ಇನ್ವೊಕೇಷನ್ಗಳ) ಮೇಲೆ ತಿಳಿಸಲಾದ ಸ್ಪಷ್ಟವಾದ LIFO ರಚನೆಯ ಕುಶಲತೆಯೊಂದಿಗೆ ಪುನರಾವರ್ತಿಸಲಾಗುವ ಸ್ಟ್ಯಾಕ್ಗೆ ಅನುರೂಪವಾಗಿದೆ. ಸಾಂಕೇತಿಕವಾಗಿ, "ಪುನರಾವರ್ತನೆ" ಇಲ್ಲಿ ಎರಡು ಅರ್ಥಗಳನ್ನು ಹೊಂದಿದೆ. ಮೊದಲನೆಯದಾಗಿ, ಟ್ರೀ ಟ್ರಾವರ್ಸಲ್ ಕಾರ್ಯಗಳ ಪುನರಾವರ್ತಿತ ಆಹ್ವಾನಗಳು. ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿ, ಮೌಲ್ಯಗಳ ಫಲಿತಾಂಶದ ಪಟ್ಟಿಯನ್ನು ಇಲ್ಲಿ ಹೇಗೆ ನಿರ್ಮಿಸಲಾಗಿದೆ ಎಂಬುದರ ಬಗ್ಗೆ ನಾವು ವಾದಿಸಬೇಕಾಗಿದೆ. ಪುನರಾವರ್ತಿತ, ಬಾಟಮ್-ಅಪ್ ಔಟ್ಪುಟ್ ರಚನೆಯು ಬಲದಿಂದ ಎಡಕ್ಕೆ ಟ್ರೀ ಟ್ರಾವರ್ಸಲ್ಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಇದನ್ನು ವಾಸ್ತವವಾಗಿ ಉದ್ದೇಶಿತ ಎಡದಿಂದ ಬಲ ಕ್ರಮದಲ್ಲಿ ನಿರ್ವಹಿಸಲು ಅನುಕ್ರಮವನ್ನು ಕೆಲವು ಬಾಹ್ಯ ವಿಧಾನಗಳಿಂದ ಜಾರಿಗೊಳಿಸಬೇಕಾಗುತ್ತದೆ, ಅಥವಾ ಔಟ್ಪುಟ್ ಅನ್ನು ಮೇಲಿನ-ಕೆಳಗಿನ ಶೈಲಿಯಲ್ಲಿ ನಿರ್ಮಿಸಬೇಕಾದರೆ ಅದನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸಾಧಿಸಲಾಗುತ್ತದೆ. ಕೋರ್ಕರ್ಸಿವ್ ಆಗಿ. ಅಗ್ರ-ಕೆಳಗಿನ ಕ್ರಮದಲ್ಲಿ ತನ್ನ ಔಟ್ಪುಟ್ ಅನ್ನು ರಚಿಸುವ ಅಗಲ-ಮೊದಲ ಟ್ರಾವರ್ಸಲ್ ಅನ್ನು ಮೂಲ ನೋಡ್ನಿಂದ ಪ್ರಾರಂಭಿಸಿ, ಅದರ ಮೌಲ್ಯವನ್ನು ಔಟ್ಪುಟ್ ಮಾಡುವ ಮೂಲಕ, ನಂತರ ಅಗಲ-ಮೊದಲನೆಯದಾಗಿ ಸಬ್ಟ್ರೀಗಳನ್ನು ಹಾದುಹೋಗುವ ಮೂಲಕ ಸಹ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು-ಅಂದರೆ, ಮುಂದಿನ ಹಂತಕ್ಕೆ ಸಬ್ಟ್ರೀಗಳ ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು ಹಾದುಹೋಗುವುದು (ಪುನರಾವರ್ತಿತ ವಿಧಾನದಲ್ಲಿರುವಂತೆ ಒಂದೇ ಸಬ್ಟ್ರೀ ಅಲ್ಲ)-ಮುಂದಿನ ಹಂತದಲ್ಲಿ ಅವುಗಳ ಎಲ್ಲಾ ಮೂಲ ನೋಡ್ಗಳ ಮೌಲ್ಯಗಳನ್ನು ಔಟ್ಪುಟ್ ಮಾಡುವುದು, ನಂತರ ಅವುಗಳ ಚೈಲ್ಡ್ ಸಬ್ಟ್ರೀಗಳನ್ನು ಹಾದುಹೋಗುವುದು ಇತ್ಯಾದಿ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಜನರೇಟರ್ ಕಾರ್ಯವು, ವಾಸ್ತವವಾಗಿ ಔಟ್ಪುಟ್ ಅನುಕ್ರಮವೇ, ಕ್ಯೂ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಮೇಲಿನ ಅಪವರ್ತನೀಯ ಉದಾಹರಣೆಯಲ್ಲಿರುವಂತೆ, ಸೂಚ್ಯಂಕದ ಸಹಾಯಕ ಮಾಹಿತಿಯನ್ನು (ಯಾವ ಹಂತವು ಮೊದಲನೆಯದು, n ಆಗಿತ್ತು) ಮುಂದಕ್ಕೆ ತಳ್ಳಿದಾಗ, n! ನ ನಿಜವಾದ ಔಟ್ಪುಟ್ನ ಜೊತೆಗೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಉಳಿದ ಸಬ್ಟ್ರೀಗಳ ಸಹಾಯಕ ಮಾಹಿತಿಯನ್ನು ನಿಜವಾದ ಔಟ್ಪುಟ್ನ ಜೊತೆಗೆ ಮುಂದಕ್ಕೆ ತಳ್ಳಲಾಗುತ್ತದೆ. ಸಾಂಕೇತಿಕವಾಗಿ, ಅಂದರೆ ಪ್ರತಿ ಹಂತದಲ್ಲೂ, ಒಬ್ಬರು ಈ ಹಂತದ ನೋಡ್ಗಳಲ್ಲಿನ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ಔಟ್ಪುಟ್ ಮಾಡುತ್ತಾರೆ, ನಂತರ ಮುಂದಿನ ಹಂತದ ನೋಡ್ಗಳಿಗೆ ಮುಂದುವರಿಯುತ್ತಾರೆ. ಈ ಅನುಕ್ರಮದಿಂದ ಕೇವಲ ನೋಡ್ ಮೌಲ್ಯಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಸಹಾಯಕ ಚೈಲ್ಡ್ ಟ್ರೀ ಡೇಟಾವನ್ನು ತ್ಯಜಿಸಿ, ನಂತರ ಪಟ್ಟಿಗಳ ಪಟ್ಟಿಯನ್ನು ಸಮತಟ್ಟಾಗಿಸುವುದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ (ಮೌಲ್ಯಗಳನ್ನು ಆರಂಭದಲ್ಲಿ ಮಟ್ಟದಿಂದ (ಆಳ) ವರ್ಗೀಕರಿಸಲಾಗುತ್ತದೆ; ಚಪ್ಪಟೆಯಾಗಿಸುವುದು (ಅನ್ಗ್ರೂಪಿಂಗ್) ಸಮತಟ್ಟಾದ ರೇಖೀಯ ಪಟ್ಟಿಯನ್ನು ನೀಡುತ್ತದೆ). ಇದು ವಿಸ್ತಾರವಾಗಿ ಮೇಲಿನ ವಿವರಣೆಗೆ ಸಮಾನವಾಗಿದೆ. ಹಾಸ್ಕೆಲ್ನಲ್ಲಿ, ಕಾಂಕ್ಯಾಟ್ಮ್ಯಾಪ್ ಎಫ್ಎಸ್ಟಿ (((v, ts)-> (ರೂಟ್ ವ್ಯಾಲ್ಯೂಸ್ ಟಿಎಸ್, ಚೈಲ್ಡ್ಟ್ರೀಸ್ ಟಿಎಸ್)) 'ಇಟರೇಟ್' ([], [ಫುಲ್ ಟ್ರೀ]) ಗಮನಾರ್ಹವಾಗಿ, ಅನಂತ ಮರವನ್ನು ನೀಡಿದರೆ, ಕೋರ್ಕರ್ಸಿವ್ ಅಗಲ-ಮೊದಲ ಟ್ರಾವರ್ಸಲ್ ಎಲ್ಲಾ ನೋಡ್ಗಳನ್ನು ಹಾದುಹೋಗುತ್ತದೆ, ಸೀಮಿತ ಮರದಂತೆಯೇ, ಆದರೆ ರಿಕರ್ಸಿವ್ ಡೆಪ್ತ್-ಮೊದಲ ಟ್ರಾವರ್ಸಲ್ ಒಂದು ಶಾಖೆಯ ಕೆಳಗೆ ಹೋಗುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಾ ನೋಡ್ಗಳನ್ನು ಹಾದುಹೋಗುವುದಿಲ್ಲ, ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಪೋಸ್ಟ್-ಆರ್ಡರ್ ಅನ್ನು ಹಾದುಹೋಗುತ್ತಿದ್ದರೆ, ಈ ಉದಾಹರಣೆಯಲ್ಲಿ (ಅಥವಾ ಕ್ರಮದಲ್ಲಿ), ಅದು ಯಾವುದೇ ನೋಡ್ಗಳನ್ನು ಭೇಟಿ ಮಾಡುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಅದು ಎಂದಿಗೂ ಎಲೆಯನ್ನು ತಲುಪುವುದಿಲ್ಲ. ಇದು ಅನಂತ ದತ್ತಾಂಶ ರಚನೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸಲು ಪುನರಾವರ್ತನೆಯ ಬದಲು ಕೋರ್ಕರ್ಶನ್ನ ಉಪಯುಕ್ತತೆಯನ್ನು ತೋರಿಸುತ್ತದೆ. ಅನಂತ ಕವಲೊಡೆಯುವ ಅಂಶವನ್ನು ಹೊಂದಿರುವ ಮರಗಳಿಗೆ ಇನ್ನೂ ಒಂದು ಎಚ್ಚರಿಕೆ ಉಳಿದಿದೆ, ಜಾಗವನ್ನು ಉತ್ತಮವಾಗಿ ಅನ್ವೇಷಿಸಲು ಹೆಚ್ಚು ಗಮನ ನೀಡುವ ಇಂಟರ್ಲಾಸಿಂಗ್ ಅಗತ್ಯವಿದೆ. ಡೊವೆಟೈಲಿಂಗ್ ಅನ್ನು ನೋಡಿ. ಪೈಥಾನ್ನಲ್ಲಿ, ಇದನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. ಸಾಮಾನ್ಯ ಪೋಸ್ಟ್-ಆರ್ಡರ್ ಡೆಪ್ತ್-ಫಸ್ಟ್ ಟ್ರಾವರ್ಸಲ್ ಅನ್ನು ಹೀಗೆ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದುಃ ಡೆಫ್ ಡಿಎಫ್ (ನೋಡ್): "ಪೋಸ್ಟ್-ಆರ್ಡರ್ ಡೆಪ್ತ್-ಫಸ್ಟ್ ಟ್ರಾವರ್ಸಲ್". ನೋಡ್ ಯಾವುದೂ ಅಲ್ಲದಿದ್ದರೆಃ ಡಿಎಫ್ (node.left) ಡಿಎಫ್ (node.right) ಪ್ರಿಂಟ್ (node.value) ಇದನ್ನು ಡಿಎಫ್ (ಟಿ) ಮೂಲಕ ಕರೆಯಬಹುದು, ನಂತರ ಮರದ ನೋಡ್ಗಳ ಮೌಲ್ಯಗಳನ್ನು ಪೋಸ್ಟ್-ಆರ್ಡರ್ ಡೆಪ್ತ್-ಮೊದಲ ಕ್ರಮದಲ್ಲಿ ಮುದ್ರಿಸಬಹುದು. ಅಗಲ-ಮೊದಲ ಕೋರ್ಕರ್ಸಿವ್ ಜನರೇಟರ್ ಅನ್ನು ಹೀಗೆ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದುಃ ಡೆಫ್ ಬಿಎಫ್ (ಟ್ರೀ): "ಅಗಲ-ಮೊದಲ ಕೋರ್ಕರ್ಸಿವ್ ಜನರೇಟರ್". ಟ್ರೀ _ ಲಿಸ್ಟ್ = [ಟ್ರೀ] ಆದರೆ ಟ್ರೀ _ ಲಿಸ್ಟ್ಃ ನ್ಯೂ _ ಟ್ರೀ _ ಲಿಸ್ಟ್ = [] ಟ್ರೀ _ ಲಿಸ್ಟ್ನಲ್ಲಿರುವ ಟ್ರೀಗೆಃ ಟ್ರೀ ಇಲ್ಲದಿದ್ದರೆ ಯಾವುದೂ ಇಲ್ಲಃ ಇಳುವರಿ tree.value new_tree_list.append (tree.left) new_tree_list.append (tree.right) ಟ್ರೀ _ ಲಿಸ್ಟ್ = ನ್ಯೂ _ ಟ್ರೀ _ ಲಿಸ್ಟ್ ಇದನ್ನು ನಂತರ ಮರದ ನೋಡ್ಗಳ ಮೌಲ್ಯಗಳನ್ನು ಅಗಲ-ಮೊದಲ ಕ್ರಮದಲ್ಲಿ ಮುದ್ರಿಸಲು ಕರೆಯಬಹುದುಃ bf (t) ನಲ್ಲಿರುವ i ಗೆಃ ಮುದ್ರಣ (i) ವ್ಯಾಖ್ಯಾನ ಆರಂಭಿಕ ದತ್ತಾಂಶ ಪ್ರಕಾರಗಳನ್ನು ಕೆಲವು ರೀತಿಯ ಸಮೀಕರಣದ ಕನಿಷ್ಠ ಸ್ಥಿರ ಬಿಂದು (ಐಸೊಮಾರ್ಫಿಸಮ್ ವರೆಗೆ) ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು; ಐಸೊಮಾರ್ಫಿಸಮ್ ಅನ್ನು ನಂತರ ಆರಂಭಿಕ ಬೀಜಗಣಿತದಿಂದ ನೀಡಲಾಗುತ್ತದೆ. ದ್ವಿಮುಖವಾಗಿ, ಅಂತಿಮ (ಅಥವಾ ಅಂತಿಮ) ದತ್ತಾಂಶ ಪ್ರಕಾರಗಳನ್ನು ಒಂದು ರೀತಿಯ ಸಮೀಕರಣದ ಅತಿದೊಡ್ಡ ಸ್ಥಿರಾಂಕವೆಂದು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು; ಐಸೊಮಾರ್ಫಿಸಮ್ ಅನ್ನು ನಂತರ ಅಂತಿಮ ಕಲ್ಲಿದ್ದಲು ಬೀಜಗಣಿತದಿಂದ ನೀಡಲಾಗುತ್ತದೆ. ಪ್ರವಚನದ ಕ್ಷೇತ್ರವು ಸೆಟ್ಗಳು ಮತ್ತು ಒಟ್ಟು ಕಾರ್ಯಗಳ ವರ್ಗವಾಗಿದ್ದರೆ, ಅಂತಿಮ ದತ್ತಾಂಶ ಪ್ರಕಾರಗಳು ಅನಂತ, ಸುಸ್ಥಾಪಿತವಲ್ಲದ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರಬಹುದು, ಆದರೆ ಆರಂಭಿಕ ಪ್ರಕಾರಗಳು ಹೊಂದಿರುವುದಿಲ್ಲ. ಮತ್ತೊಂದೆಡೆ, ಪ್ರವಚನದ ಕ್ಷೇತ್ರವು ಸಂಪೂರ್ಣ ಭಾಗಶಃ ಕ್ರಮಗಳು ಮತ್ತು ನಿರಂತರ ಕಾರ್ಯಗಳ ವರ್ಗವಾಗಿದ್ದರೆ, ಅದು ಸ್ಥೂಲವಾಗಿ ಹ್ಯಾಸ್ಕೆಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗೆ ಅನುಗುಣವಾಗಿದ್ದರೆ, ಅಂತಿಮ ಪ್ರಕಾರಗಳು ಆರಂಭಿಕ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತವೆ ಮತ್ತು ಅನುಗುಣವಾದ ಅಂತಿಮ ಕಲ್ಲಿದ್ದಲು ಬೀಜಗಣಿತ ಮತ್ತು ಆರಂಭಿಕ ಬೀಜಗಣಿತವು ಐಸೊಮಾರ್ಫಿಸಮ್ ಅನ್ನು ರೂಪಿಸುತ್ತದೆ. ಕೋರೆಕರ್ಶನ್ ನಂತರ ಪುನರಾವರ್ತಿತವಾಗಿ ಕಾರ್ಯಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಒಂದು ತಂತ್ರವಾಗಿದ್ದು, ಅದರ ವ್ಯಾಪ್ತಿಯು (ಕೋಡೊಮೈನ್) ಅಂತಿಮ ದತ್ತಾಂಶ ಪ್ರಕಾರವಾಗಿದೆ, ಇದು ಡೊಮೇನ್ ಆರಂಭಿಕ ದತ್ತಾಂಶ ಪ್ರಕಾರವಾಗಿರುವ ಸಾಮಾನ್ಯ ಪುನರಾವರ್ತನೆಯು ಪುನರಾವರ್ತಿತವಾಗಿ ಕಾರ್ಯಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ವಿಧಾನಕ್ಕೆ ದ್ವಿಗುಣವಾಗಿದೆ. ಕೆಳಗಿನ ಚರ್ಚೆಯು ಹಾಸ್ಕೆಲ್ನಲ್ಲಿ ಕೋರ್ಕರ್ಶನ್ ಅನ್ನು ಪ್ರತ್ಯೇಕಿಸುವ ಹಲವಾರು ಉದಾಹರಣೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಸ್ಥೂಲವಾಗಿ ಹೇಳುವುದಾದರೆ, ಈ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಸೆಟ್ಗಳ ವರ್ಗಕ್ಕೆ ಪೋರ್ಟ್ ಮಾಡಿದರೆ, ಅವು ಇನ್ನೂ ಕೋರ್ ಕರ್ಸಿವ್ ಆಗಿರುತ್ತವೆ. ಈ ಅನೌಪಚಾರಿಕ ಬಳಕೆಯು ಹ್ಯಾಸ್ಕೆಲ್ ಬಗ್ಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪಠ್ಯಪುಸ್ತಕಗಳೊಂದಿಗೆ ಸ್ಥಿರವಾಗಿದೆ. ಈ ಲೇಖನದಲ್ಲಿ ಬಳಸಲಾದ ಉದಾಹರಣೆಗಳು ಕೋರ್ ಕರ್ಶನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮತ್ತು ಅದು ಏನು ಎಂಬುದನ್ನು ವಿವರಿಸುವ ಪ್ರಯತ್ನಗಳಿಗೆ ಮುಂಚೆಯೇ ಇವೆ. ಕೋಡಾಟಾ ಮೇಲಿನ ಪ್ರಾಚೀನ ಕೋರ್ ಕರ್ಶನ್ ನಿಯಮವು ದತ್ತಾಂಶದ ಮೇಲಿನ ಪ್ರಾಚೀನ ಪುನರಾವರ್ತನೆಯ ನಿಯಮಕ್ಕೆ ದ್ವಿಗುಣವಾಗಿದೆ. ಅದರ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ಗಳ ಮೇಲೆ ಮಾದರಿಯನ್ನು ಹೊಂದಿಸುವ ಮೂಲಕ ವಾದದ ಮೇಲೆ ಇಳಿಯುವ ಬದಲು (ಮೊದಲು, ಎಲ್ಲೋ ಕರೆಯಲಾಗುತ್ತಿತ್ತು, ಆದ್ದರಿಂದ ನಾವು ರೆಡಿಮೇಡ್ ಡೇಟಮ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ ಮತ್ತು ಅದರ ಘಟಕ ಉಪ-ಭಾಗಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ, ಅಂದರೆ. "ಕ್ಷೇತ್ರಗಳು"), ನಾವು ಅದರ "ಡಿಸ್ಟ್ರಕ್ಟರ್ಗಳನ್ನು" (ಅಥವಾ "ವೀಕ್ಷಕರು", ನಂತರ, ಎಲ್ಲೋ ಕರೆಯಲ್ಪಡುವ ಮೂಲಕ ಫಲಿತಾಂಶದ ಮೇಲೆ ಏರುತ್ತೇವೆ-ಆದ್ದರಿಂದ ನಾವು ವಾಸ್ತವವಾಗಿ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಕರೆಯುತ್ತಿದ್ದೇವೆ, ಫಲಿತಾಂಶದ ಮತ್ತೊಂದು ಬಿಟ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ. ಹೀಗಾಗಿ ಕೋರ್ಕರ್ಷನ್ (ಸಂಭಾವ್ಯವಾಗಿ ಅನಂತ) ಕೋಡಾಟಾ ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ, ಆದರೆ ಸಾಮಾನ್ಯ ಪುನರಾವರ್ತನೆಯು (ಅಗತ್ಯವಾಗಿ ಸೀಮಿತ) ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯ ಪುನರಾವರ್ತನೆಯು ಕೊಡೇಟಾಕ್ಕೆ ಅನ್ವಯಿಸದಿರಬಹುದು ಏಕೆಂದರೆ ಅದು ಕೊನೆಗೊಳ್ಳದಿರಬಹುದು. ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಫಲಿತಾಂಶದ ಪ್ರಕಾರವು ದತ್ತಾಂಶವಾಗಿದ್ದರೆ ಕೋರ್ಕರ್ಶನ್ ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅಗತ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ದತ್ತಾಂಶವು ಸೀಮಿತವಾಗಿರಬೇಕು. "ಕೋಕ್ನಲ್ಲಿನ ಸ್ಟ್ರೀಮ್ಗಳೊಂದಿಗೆ ಪ್ರೊಗ್ರಾಮಿಂಗ್ಃ ಎ ಕೇಸ್ ಸ್ಟಡಿಃ ದಿ ಸೀವ್ ಆಫ್ ಎರಟೋಸ್ಥನೀಸ್" ನಲ್ಲಿ ನಾವು hd (ಕಾಂಕ್ ಎಎಸ್) = a til (ಕಾಂಕ್ ಎಎಸ್) = s (ಜರಡಿ ಪಿಎಸ್) = ಡಿವ್ ಪಿ (ಎಚ್. ಡಿ. ಎಸ್) ಆಗಿದ್ದರೆ ನಂತರ ಜರಡಿ ಪಿ (ಟಿಎಲ್ಎಸ್) ಇಲ್ಲದಿದ್ದರೆ ಕಾಂಕ್ (ಎಚ್. ಡಿ. ಎಸ್) (ಜರಡಿ ಪಿ (ಟಿಎಲ್ಎಸ್)) ಎಚ್. ಡಿ (ಪ್ರೈಮ್ಸ್ ಎಸ್) = (ಎಚ್. ಡಿ. ಎಸ್) ಟಿಎಲ್ (ಪ್ರೈಮ್ಸ್ ಎಸ್) = ಪ್ರೈಮ್ಸ್ (ಜರಡಿ (ಎಚ್. ಡಿ. ಎಸ್) (ಟಿಎಲ್ಎಸ್) ಅಲ್ಲಿ "ಸ್ಟ್ರೀಮ್ಗಳಿಗೆ (ಎನು 2) ಪ್ರೈಮ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಅನ್ವಯಿಸುವ ಮೂಲಕ ಪ್ರೈಮ್ಗಳನ್ನು ಪಡೆಯಲಾಗುತ್ತದೆ". ಮೇಲಿನ ಸಂಕೇತವನ್ನು ಅನುಸರಿಸಿ, ಅವಿಭಾಜ್ಯಗಳ ಅನುಕ್ರಮವನ್ನು (ಅದಕ್ಕೆ ಪೂರ್ವಭಾವಿಯಾಗಿ 0 ಅನ್ನು ಜೋಡಿಸಲಾಗಿರುತ್ತದೆ) ಮತ್ತು ಸಂಖ್ಯೆಗಳ ಹರಿವುಗಳನ್ನು ಹಂತಹಂತವಾಗಿ ಶೋಧಿಸಲಾಗುತ್ತದೆ, ಇದನ್ನು ಹಾಸ್ಕೆಲ್ನಲ್ಲಿ (\(p, s @(h: t))-> (h, ಜಲ್ಲಿಕಾಯಿ ht) 'ಪುನರಾವರ್ತನೆ' (0, [2]) ಎಂದು ಪ್ರತಿನಿಧಿಸಬಹುದು. [5,10.] ಅನ್ನು ಆರಂಭಿಕ ಸ್ಟ್ರೀಮ್ ಎಂದು ಕರೆದರೆ. ಇಲ್ಲಿ ಹಾಸ್ಕೆಲ್ನ ಮತ್ತೊಂದು ಉದಾಹರಣೆಯಾಗಿದೆ. ಈ ಕೆಳಗಿನ ವ್ಯಾಖ್ಯಾನವು ರೈಖಿಕ ಸಮಯದಲ್ಲಿ ಫಿಬೊನಾಚಿ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆಃ ನಾರುಗಳು = 0:1: ಜಿಪ್ (+) ನಾರುಗಳೊಂದಿಗೆ (ಬಾಲದ ನಾರುಗಳು) ಈ ಅನಂತ ಪಟ್ಟಿಯು ಸೋಮಾರಿಯಾದ ಮೌಲ್ಯಮಾಪನವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ; ಅಂಶಗಳನ್ನು ಅಗತ್ಯವಿರುವ ಆಧಾರದ ಮೇಲೆ ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ, ಮತ್ತು ಸೀಮಿತ ಪೂರ್ವಪ್ರತ್ಯಯಗಳನ್ನು ಮಾತ್ರ ಯಾವಾಗಲೂ ಮೆಮೊರಿಯಲ್ಲಿ ಸ್ಪಷ್ಟವಾಗಿ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ. ಈ ವೈಶಿಷ್ಟ್ಯವು ಕೊಡೇಟಾದ ಭಾಗಗಳಲ್ಲಿನ ಕ್ರಮಾವಳಿಗಳನ್ನು ಕೊನೆಗೊಳಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ; ಅಂತಹ ತಂತ್ರಗಳು ಹ್ಯಾಸ್ಕೆಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ನ ಪ್ರಮುಖ ಭಾಗವಾಗಿದೆ. ಇದನ್ನು ಪೈಥಾನ್ನಲ್ಲಿಯೂ ಸಹ ಮಾಡಬಹುದುಃ ಇಟರ್ಟೂಲ್ಗಳಿಂದ ಆಮದು ಟೀ, ಚೈನ್, ಐಲೈಸ್, ಇಮ್ಯಾಪ್ ಡೆಫ್ ಆಡ್ (x, y): ರಿಟರ್ನ್ x + y ಡೆಫ್ ಫೈಬೊನಾಚಿ (): ಡೆಫ್ ಡೆಫರ್ಡ್ _ ಔಟ್ಪುಟ್ (): ಔಟ್ಪುಟ್ನಲ್ಲಿ i ಗಾಗಿಃ ಇಳುವರಿ i ಫಲಿತಾಂಶ, c1, c2 = ಟೀ (ಡೆಫರ್ಡ್ _ ಔಟ್ಪುಟ್ (), 3) ಜೋಡಿಯಾದ = ಇಮ್ಯಾಪ್ (ಆಡ್, c1, ಐಲೈಸ್ (c2,1, ಯಾವುದೂ ಇಲ್ಲ)) ಔಟ್ಪುಟ್ = ಚೈನ್ ([0,1], ಜೋಡಿಯಾದ) ರಿಟರ್ನ್ ಫಲಿತಾಂಶ ಐಲೈಸ್ನಲ್ಲಿ (ಫೈಬೊನಾಚಿ (), 20): ಪ್ರಿಂಟ್ (i) ಜಿಪ್-ವಿತ್ ವ್ಯಾಖ್ಯಾನವನ್ನು ಇನ್ಲೈನ್ ಮಾಡಬಹುದು, ಇದಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆಃ ಫೈಬ್ಸ್ = 0 ಸಾಮಾನ್ಯ ಪುನರಾವರ್ತನೆಯು ಸ್ವಯಂ-ಉಲ್ಲೇಖಿತ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಆದರೆ ಸ್ವಯಂ-ಉಲ್ಲೇಖಿತ ದತ್ತಾಂಶಕ್ಕೆ ಅವಕಾಶ ನೀಡುವುದಿಲ್ಲ. ಆದಾಗ್ಯೂ, ಫಿಬೊನಾಚಿ ಉದಾಹರಣೆಗೆ ಇದು ಅನಿವಾರ್ಯವಲ್ಲ. ಇದನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಪುನಃ ಬರೆಯಬಹುದುಃ ಫೈಬ್ಸ್ = ಫೈಬ್ಜೆನ್ (0,1) ಫೈಬ್ಜೆನ್ (x, y) = x: ಫೈಬ್ಜೆನ್ (y, x + y) ಇದು ಫಲಿತಾಂಶವನ್ನು ನಿರ್ಮಿಸಲು ಸ್ವಯಂ-ಉಲ್ಲೇಖಿತ ಕಾರ್ಯವನ್ನು ಮಾತ್ರ ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ. ಇದನ್ನು ಕಟ್ಟುನಿಟ್ಟಾದ ಪಟ್ಟಿ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ನೊಂದಿಗೆ ಬಳಸಿದರೆ ಅದು ಓಡಿಹೋದ ಪುನರಾವರ್ತನೆಗೆ ಒಂದು ಉದಾಹರಣೆಯಾಗಿರುತ್ತದೆ, ಆದರೆ ಕಟ್ಟುನಿಟ್ಟಲ್ಲದ ಪಟ್ಟಿ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ನೊಂದಿಗೆ ಈ ರಕ್ಷಣಾತ್ಮಕ ಪುನರಾವರ್ತನೆಯು ಕ್ರಮೇಣ ಅನಿರ್ದಿಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಪಟ್ಟಿಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಕೋರ್ಕರ್ಶನ್ ಅನಂತ ವಸ್ತುವನ್ನು ಉತ್ಪಾದಿಸುವ ಅಗತ್ಯವಿಲ್ಲ; ಕೋರ್ಕರ್ಸಿವ್ ಕ್ಯೂ ಈ ವಿದ್ಯಮಾನಕ್ಕೆ ವಿಶೇಷವಾಗಿ ಉತ್ತಮ ಉದಾಹರಣೆಯಾಗಿದೆ. ಈ ಕೆಳಗಿನ ವ್ಯಾಖ್ಯಾನವು ರೇಖೀಯ ಸಮಯದಲ್ಲಿ (ಈಗಾಗಲೇ ಮೇಲೆ ತಿಳಿಸಲಾದ ಚಪ್ಪಟೆಯನ್ನು ಒಳಗೊಂಡಂತೆ) ಬೈನರಿ ಮರದ ಅಗಲ-ಮೊದಲ ತಿರುವುಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆಃ ಡೇಟಾ ಟ್ರೀ a b = ಲೀಫ್ a | ಬ್ರಾಂಚ್ b (ಟ್ರೀ a b) (ಟ್ರೀ a b) bftrav: ಟ್ರೀ a b-> [ಟ್ರೀ a b] bftrav ಟ್ರೀ = ಟ್ರೀಃ ts ಅಲ್ಲಿ ts = ಜೆನ್ 1 (ಟ್ರೀಃ ts) ಜೆನ್ 0 p = [] ಜೆನ್ ಲೆನ್ (ಲೀಫ್ p) = ಜೆನ್ (ಲೆನ್-1) p ಜೆನ್ ಲೆನ್ (ಬ್ರಾಂಚ್ r: p) = l: r: ಜೆನ್ (ಲೆನ್ + 1) p------------------------------------------------------------ ಈ ಪಟ್ಟಿಯು ಇನ್ಪುಟ್ ಕ್ಯೂ ಮತ್ತು ಫಲಿತಾಂಶ ಎರಡರಲ್ಲೂ ಎರಡು ಉದ್ದೇಶಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ (ಜೆನ್ ಲೆನ್ ಪಿ ಅದರ ಔಟ್ಪುಟ್ ಅನ್ನು ಅದರ ಇನ್ಪುಟ್ ಬ್ಯಾಕ್-ಪಾಯಿಂಟರ್, ಪಿ, ಪಟ್ಟಿಯ ಉದ್ದಕ್ಕೂ ಉತ್ಪಾದಿಸುತ್ತದೆ). ಆರಂಭಿಕ ಮರವು ಸೀಮಿತವಾಗಿದ್ದರೆ ಮಾತ್ರ ಇದು ಸೀಮಿತವಾಗಿರುತ್ತದೆ. ಮುಕ್ತಾಯವನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸರತಿಯ ಉದ್ದವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಕು; ಈ ವ್ಯಾಖ್ಯಾನವನ್ನು ಅನಂತ ಮರಗಳಿಗೆ ಮಾತ್ರ ಅನ್ವಯಿಸಿದರೆ ಇದನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ತಪ್ಪಿಸಬಹುದು. ಈ ಹಾಸ್ಕೆಲ್ ಸಂಕೇತವು ಸ್ವಯಂ-ಉಲ್ಲೇಖಿತ ದತ್ತಾಂಶ ರಚನೆಯನ್ನು ಬಳಸುತ್ತದೆ, ಆದರೆ ಇದು ಮೂಲಭೂತವಾಗಿ ಸೋಮಾರಿಯಾದ ಮೌಲ್ಯಮಾಪನವನ್ನು ಅವಲಂಬಿಸಿಲ್ಲ. ಇದನ್ನು ನೇರವಾಗಿ ಉದಾಹರಣೆಗೆ ಅನುವಾದಿಸಬಹುದು. ಪ್ರೋಲಾಗ್ ಒಂದು ಸೋಮಾರಿಯಾದ ಭಾಷೆಯಲ್ಲ. ಮೇಲಿನಿಂದ ಕೆಳಕ್ಕೆ ಇರುವ ರೀತಿಯಲ್ಲಿ ಪಟ್ಟಿಯನ್ನು (ಕ್ಯೂ ಆಗಿ ಬಳಸುವ) ನಿರ್ಮಿಸುವ ಸಾಮರ್ಥ್ಯವು ಅತ್ಯಗತ್ಯವಾಗಿದೆ. ಅದಕ್ಕಾಗಿ, ಪ್ರೋಲಾಗ್ ಟೈಲ್ ರಿಕರ್ಶನ್ ಮಾಡ್ಯುಲೋ ಕಾನ್ಸ್ ಅನ್ನು ಹೊಂದಿದೆ (ಅಂದರೆ. ತೆರೆದ ಪಟ್ಟಿಗಳು). ಇದು ಸ್ಕೀಮ್, ಸಿ, ಇತ್ಯಾದಿಗಳಲ್ಲಿ ಅನುಕರಣಾರ್ಹವಾಗಿದೆ. ಬದಲಾಯಿಸಬಹುದಾದ ಬಾಲ ಸೆಂಟಿನೆಲ್ ಪಾಯಿಂಟರಿನೊಂದಿಗೆ ಲಿಂಕ್ ಮಾಡಲಾದ ಪಟ್ಟಿಗಳನ್ನು ಬಳಸುವುದುಃ bftrav (ಟ್ರೀ, [Tree|TS]):-bfgen (1, [Tree|TS], TS). bfgen (0, _, []):-!. ಸರತಿಯಲ್ಲಿರುವ% 0 ನಮೂದುಗಳು-- bfgen (N, [leef (_) |P], TS) ಪಟ್ಟಿಯನ್ನು ನಿಲ್ಲಿಸಿ ಮುಚ್ಚಿಃ-N2 ಎಂದರೆ N-1, bfgen (N2, P, TS). bfgen (N, [ಶಾಖೆ (_, L, R) |P], [L, R|TS]):-N2 ಎಂದರೆ N + 1, bfgen (N2, P, TS). %%---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - ಫಂಕ್ಷನ್ ಲೇಬಲ್ ಬೈನರಿ ಟ್ರೀನಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ನೋಡ್ಗೆ ಅಗಲವಾದ ಮೊದಲ ಶೈಲಿಯಲ್ಲಿ ಭೇಟಿ ನೀಡುತ್ತದೆ, ಪ್ರತಿ ಲೇಬಲ್ ಅನ್ನು ಪೂರ್ಣಾಂಕದೊಂದಿಗೆ ಬದಲಾಯಿಸುತ್ತದೆ, ನಂತರದ ಪ್ರತಿಯೊಂದು ಪೂರ್ಣಾಂಕವು ಕೊನೆಯದಕ್ಕಿಂತ 1 ರಿಂದ ದೊಡ್ಡದಾಗಿದೆ. ಈ ಪರಿಹಾರವು ಸ್ವಯಂ-ಉಲ್ಲೇಖಿತ ದತ್ತಾಂಶ ರಚನೆಯನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ಅವಳಿ ಮರವು ಸೀಮಿತವಾಗಿರಬಹುದು ಅಥವಾ ಅನಂತವಾಗಿರಬಹುದು. ಲೇಬಲ್ಃಃ ಟ್ರೀ a b-> ಟ್ರೀ int int ಲೇಬಲ್ t = tn ಅಲ್ಲಿ (tn, ns) = ಗೋ t (1: ns) ಹೋಗಿಃಃ ಟ್ರೀ a b-> [int]-> (ಟ್ರೀ int int, [int]) ಗೋ (ಲೀಫ್ _) (i: a) = (ಲೀಫ್ i, i + 1: a) ಗೋ (ಬ್ರಾಂಚ್ _ lr) (i: a) = (ಬ್ರಾಂಚ್ i ln rn, i + 1: c) ಎಲ್ಲಿ (ln, b) = ಗೋ l a (rn, c) = ಗೋ r b ಅಥವಾ ಪ್ರೋಲಾಗ್ನಲ್ಲಿ, ಹೋಲಿಕೆಗಾಗಿ, ಲೇಬಲ್ (ಟ್ರೀ, Tn):-ಲೇಬಲ್ (ಟ್ರೀ, [1|Ns], Tn, Ns ಲೇಬಲ್ (ಎಲೆ (_), [I|A], ಎಲೆ (I), [I + 1|A]). ಲೇಬಲ್ (ಶಾಖೆ (_, L, R), [I|A], ಶಾಖೆ (I, Ln, Rn), [I + 1|C]):-ಲೇಬಲ್ (L, A, Ln, B), ಲೇಬಲ್ (R, B, Rn, C). ಅಪೋಮಾರ್ಫಿಸಮ್ (ಅನಾಮಾರ್ಪಿಸಮ್ನಂತಹವು, ತೆರೆದುಕೊಳ್ಳುವಂತಹವು) ಎಂಬುದು ಪ್ಯಾರಾಮಾರ್ಫಿಸಮ್ (ಮಡಿಕೆಗಳಂತಹ ಕ್ಯಾಟಾಮಾರ್ಫಿಸಮ್ನಂತಹವು) ಪುನರಾವರ್ತನೆಯ ಒಂದು ರೂಪವಾಗಿರುವ ರೀತಿಯಲ್ಲಿಯೇ ಕೋರ್ಕರ್ಶನ್ನ ಒಂದು ರೂಪವಾಗಿದೆ. CoQ ಪ್ರೂಫ್ ಸಹಾಯಕವು ಕೋಫಿಕ್ಸ್ಪಾಯಿಂಟ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಕೋರ್ ಕರ್ಷನ್ ಮತ್ತು ಕೋಯಿನ್ಡಕ್ಷನ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ವೃತ್ತಾಕಾರದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಇತಿಹಾಸದ ಕೊರೆಕರ್ಶನ್, ಕನಿಷ್ಠ, ಜಾನ್ ಹ್ಯೂಸ್ ಮತ್ತು ಫಿಲಿಪ್ ವಾಡ್ಲರ್ ಅವರಿಗೆ ಮನ್ನಣೆ ನೀಡುತ್ತದೆ; ಹೆಚ್ಚು ಸಾಮಾನ್ಯ ರೂಪಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಯಿತು. ಮೂಲ ಪ್ರೇರಣೆಗಳಲ್ಲಿ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಕ್ರಮಾವಳಿಗಳನ್ನು ತಯಾರಿಸುವುದು (ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಹು ಪಾಸ್ಗಳ ಬದಲು ಡೇಟಾವನ್ನು ದಾಟಲು ಅನುವು ಮಾಡಿಕೊಡುವುದು) ಮತ್ತು ದ್ವಿಗುಣವಾಗಿ ಜೋಡಿಸಲಾದ ಪಟ್ಟಿಗಳು ಮತ್ತು ಸಾಲುಗಳಂತಹ ಶಾಸ್ತ್ರೀಯ ದತ್ತಾಂಶ ರಚನೆಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕ ಭಾಷೆಗಳಲ್ಲಿ ಅನುಷ್ಠಾನಗೊಳಿಸುವುದು ಸೇರಿತ್ತು. ಬಿಸಿಮ್ಯುಲೇಶನ್ ಕೊಯಿನ್ಡಕ್ಷನ್ ರಿಕರ್ಶನ್ ಅನಾಮಾರ್ಪಿಸಂ ಟಿಪ್ಪಣಿಗಳು ಉಲ್ಲೇಖಗಳು ಸೈದ್ಧಾಂತಿಕ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನ ಸ್ವಯಂ-ಉಲ್ಲೇಖ ಲೇಖನಗಳು ಉದಾಹರಣೆಗೆ ಹ್ಯಾಸ್ಕೆಲ್ ಕೋಡ್ ಲೇಖನಗಳು ಉದಾಹರಣೆಗೆ ಪೈಥಾನ್ (ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ) ಕೋಡ್ ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ವರ್ಗ ಸಿದ್ಧಾಂತ ರಿಕರ್ಶನ್