Schwartzian transform
ಕಂಪ್ಯೂಟರ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ, ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವು ವಸ್ತುಗಳ ಪಟ್ಟಿಯನ್ನು ವಿಂಗಡಿಸುವ ದಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸಲು ಬಳಸುವ ತಂತ್ರವಾಗಿದೆ. ಈ ನುಡಿಗಟ್ಟು ಹೋಲಿಕೆ-ಆಧಾರಿತ ವಿಂಗಡಣೆಗೆ ಸೂಕ್ತವಾಗಿದೆ, ಆದೇಶವು ವಾಸ್ತವವಾಗಿ ಅಂಶಗಳ ಒಂದು ನಿರ್ದಿಷ್ಟ ಆಸ್ತಿಯ (ಕೀ) ಕ್ರಮವನ್ನು ಆಧರಿಸಿದೆ, ಅಲ್ಲಿ ಆ ಆಸ್ತಿಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು ತೀವ್ರವಾದ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದ್ದು ಅದನ್ನು ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯ ಬಾರಿ ನಿರ್ವಹಿಸಬೇಕು. ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವು ಹೆಸರಿಸಲಾದ ತಾತ್ಕಾಲಿಕ ವ್ಯೂಹಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ ಎಂಬುದು ಗಮನಾರ್ಹವಾಗಿದೆ. ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವು ಅಲಂಕರಣ-ವಿಂಗಡಣೆ-ಅಲಂಕರಣ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಲಿಸ್ಪ್ ಭಾಷಾವೈಶಿಷ್ಟ್ಯದ ಒಂದು ಆವೃತ್ತಿಯಾಗಿದೆ, ಇದು ವಿಂಗಡಣಾ ಕೀಲಿಗಳನ್ನು ತಾತ್ಕಾಲಿಕವಾಗಿ ಇನ್ಪುಟ್ ವಸ್ತುಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವ ಮೂಲಕ ಮರು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಹೋಲುತ್ತದೆ, ಇದು ನಿರ್ದಿಷ್ಟ ಇನ್ಪುಟ್ ಮೌಲ್ಯಕ್ಕೆ ಅನುಗುಣವಾದ ಕೀಲಿಯ ಲೆಕ್ಕಾಚಾರವನ್ನು ಪುನರಾವರ್ತಿಸುವುದನ್ನು ತಪ್ಪಿಸುತ್ತದೆ. ಹೋಲಿಸಿದರೆ, ಈ ನುಡಿಗಟ್ಟು ಪ್ರತಿ ಇನ್ಪುಟ್ ಐಟಂನ ಕೀಲಿಯನ್ನು ನಿಖರವಾಗಿ ಒಮ್ಮೆ ಲೆಕ್ಕ ಹಾಕಲಾಗುತ್ತದೆ ಎಂದು ಭರವಸೆ ನೀಡುತ್ತದೆ, ಇದು ಇನ್ಪುಟ್ ಡೇಟಾವು ನಕಲಿ ವಸ್ತುಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ಕೆಲವು ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಕಾರಣವಾಗಬಹುದು. 1994ರಲ್ಲಿ ಪರ್ಲ್ 5 ಬಿಡುಗಡೆಯಾದ ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ಇದನ್ನು ಮೊದಲ ಬಾರಿಗೆ ಪರ್ಲ್ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಿದ ರಾಂಡಲ್ ಎಲ್. ಶ್ವಾರ್ಟ್ಜ್ ಅವರ ಹೆಸರನ್ನು ಈ ಭಾಷಾವೈಶಿಷ್ಟ್ಯಕ್ಕೆ ಇಡಲಾಗಿದೆ. "ಶ್ವಾರ್ಟ್ಜಿಯನ್ ಟ್ರಾನ್ಸ್ಫಾರ್ಮ್" ಎಂಬ ಪದವು ಹಲವಾರು ವರ್ಷಗಳ ಕಾಲ ಪರ್ಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ಗೆ ಮಾತ್ರ ಅನ್ವಯಿಸುತ್ತಿತ್ತು, ಆದರೆ ನಂತರ ಅದನ್ನು ಪೈಥಾನ್ನಂತಹ ಇತರ ಭಾಷೆಗಳ ಕೆಲವು ಬಳಕೆದಾರರು ಆ ಭಾಷೆಗಳಲ್ಲಿನ ಇದೇ ರೀತಿಯ ಭಾಷಾವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಉಲ್ಲೇಖಿಸಲು ಅಳವಡಿಸಿಕೊಂಡರು. ಆದಾಗ್ಯೂ, ಈ ಅಲ್ಗಾರಿದಮ್ ಈಗಾಗಲೇ ಇತರ ಭಾಷೆಗಳಲ್ಲಿ ಬಳಕೆಯಲ್ಲಿತ್ತು (ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ಹೆಸರಿನ ಅಡಿಯಲ್ಲಿ) ಇದನ್ನು ಪರ್ಲ್ ಸಮುದಾಯದಲ್ಲಿ ಶ್ವಾರ್ಟ್ಜ್ ಆ ನಿರ್ದಿಷ್ಟ ಭಾಷಾವೈಶಿಷ್ಟ್ಯದ ರೂಪದಲ್ಲಿ ಜನಪ್ರಿಯಗೊಳಿಸುವ ಮೊದಲು. "ಶ್ವಾರ್ಟ್ಜಿಯನ್ ಟ್ರಾನ್ಸ್ಫಾರ್ಮ್" ಎಂಬ ಪದವು ಒಂದು ನಿರ್ದಿಷ್ಟ ನುಡಿಗಟ್ಟನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಅಲ್ಗಾರಿದಮ್ ಅಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಪದದ ಉದ್ದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಪದಗಳ ಪಟ್ಟಿಯನ್ನು ("ಆ", "ಎ", "ಆ") ವಿಂಗಡಿಸಲುಃ ಮೊದಲು ಪಟ್ಟಿಯನ್ನು ನಿರ್ಮಿಸಿ (["ಆ", "4], [" ಎ ", 1], [" ಆ ", 2]), ನಂತರ ಅದನ್ನು ಪಡೆಯುವ ಸಂಖ್ಯಾ ಮೌಲ್ಯಗಳ ಪ್ರಕಾರ ವಿಂಗಡಿಸಿ ([" ಎ ", 1], [" ಆ ", 2], [" ಆ ", 4]), ನಂತರ ಸಂಖ್ಯೆಗಳನ್ನು ತೆಗೆದುಹಾಕಿ ಮತ್ತು ನೀವು ಪಡೆಯುತ್ತೀರಿ (" ಎ "," ಆ "," ಆ "). ಅದು ಸಾಮಾನ್ಯವಾಗಿ ಅಲ್ಗಾರಿದಮ್ ಆಗಿತ್ತು, ಆದ್ದರಿಂದ ಇದನ್ನು ರೂಪಾಂತರವೆಂದು ಪರಿಗಣಿಸಲಾಗುವುದಿಲ್ಲ. ಇದನ್ನು ನಿಜವಾದ ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವನ್ನಾಗಿ ಮಾಡಲು, ಇದನ್ನು ಪರ್ಲ್ನಲ್ಲಿ ಈ ರೀತಿ ಮಾಡಲಾಗುತ್ತದೆಃ @sorted = ನಕ್ಷೆ {$_-> [0]] ವಿಂಗಡಣೆ {$a-> [1] <= $b-> [1] ಅಥವಾ $a-> [0] cmp $b-> [0]} #ಸಂಖ್ಯಾತ್ಮಕ ಹೋಲಿಕೆಯನ್ನು ಬಳಸಿ, ಮೂಲ ನಕ್ಷೆಯಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ವಿಂಗಡಣೆಗೆ ಹಿಂತಿರುಗಿ, #ಸ್ಟ್ರಿಂಗ್ನ ಉದ್ದವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿ @unsorted; ಪರ್ಲ್ ಭಾಷಾವೈಶಿಷ್ಟ್ಯ ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರದ ಸಾಮಾನ್ಯ ರೂಪವೆಂದರೆಃ @sorted = ನಕ್ಷೆ {$_-> [0] ವಿಂಗಡಣೆ {$a-> [1] cmp ಬಲದಿಂದ ಎಡಕ್ಕೆ ಓದುವುದು (ಅಥವಾ ಕೆಳಗಿನಿಂದ ಮೇಲಕ್ಕೆ): ಮೂಲ ಪಟ್ಟಿ @unsorted ಅನ್ನು ನಕ್ಷೆಯ ಕಾರ್ಯಾಚರಣೆಗೆ ನೀಡಲಾಗುತ್ತದೆ, ಅದು ಪ್ರತಿ ವಸ್ತುವನ್ನು ಅದರ ವಿಂಗಡಣೆ ಕ್ರಮವನ್ನು ನಿರ್ಧರಿಸುವ ಲೆಕ್ಕಾಚಾರದ ಮೌಲ್ಯವನ್ನು ಒಳಗೊಂಡಿರುವ (ಅನಾಮಧೇಯ 2-ಅಂಶದ ಉಲ್ಲೇಖ) ಶ್ರೇಣಿಯಲ್ಲಿ ಸುತ್ತುತ್ತದೆ (ವಸ್ತುವಿನ ಪಟ್ಟಿಯು [ವಸ್ತುವಿನ, ಮೌಲ್ಯದ] ಪಟ್ಟಿಯಾಗುತ್ತದೆ); ನಂತರ ನಕ್ಷೆಯಿಂದ ತಯಾರಿಸಿದ ಪಟ್ಟಿಗಳ ಪಟ್ಟಿಯನ್ನು ವಿಂಗಡಿಸಲಾಗುತ್ತದೆ, ಇದು ಹಿಂದೆ ಲೆಕ್ಕ ಹಾಕಿದ ಮೌಲ್ಯಗಳ ಪ್ರಕಾರ ಅದನ್ನು ವಿಂಗಡಿಸುತ್ತದೆ (ವಸ್ತುವಿನ, ಮೌಲ್ಯದ ಪಟ್ಟಿ); ಅಂತಿಮವಾಗಿ, ಮತ್ತೊಂದು ನಕ್ಷೆಯ ಕಾರ್ಯಾಚರಣೆಯು ವಿಂಗಡಿಸಲು ಬಳಸುವ ಮೌಲ್ಯಗಳನ್ನು (ಅನಾಮಧೇಯ ಶ್ರೇಣಿಯಿಂದ) ಬಿಚ್ಚುತ್ತದೆ, ಮೂಲ ಪಟ್ಟಿಯ ವಸ್ತುಗಳನ್ನು ವಿಂಗಡಿಸಿದ ಕ್ರಮದಲ್ಲಿ (ವಸ್ತುವಿನ, ಮೌಲ್ಯದ ಪಟ್ಟಿ) ಉತ್ಪಾದಿಸುತ್ತದೆ. ಅನಾಮಧೇಯ ಸರಣಿಗಳ ಬಳಕೆಯು ವಿಂಗಡಣೆ ಮಾಡಿದ ತಕ್ಷಣ ಪರ್ಲ್ ಕಸ ಸಂಗ್ರಾಹಕರು ಮೆಮೊರಿಯನ್ನು ಮರುಪಡೆಯುವುದನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ. ಎಫಿಷಿಯೆನ್ಸಿ ಅನಾಲಿಸಿಸ್ ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವಿಲ್ಲದೆ, ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿನ ವಿಂಗಡಣೆಯನ್ನು ಪರ್ಲ್ನಲ್ಲಿ ಈ ರೀತಿ ಬರೆಯಲಾಗುತ್ತದೆಃ @sorted = ಸಾರ್ಟಿಂಗ್ {ಫೂ ($a) cmp ಫೂ ($b)} @unsorted; ಇದು ಕೋಡ್ಗೆ ಚಿಕ್ಕದಾಗಿದ್ದರೂ, ಕೀ ಫಂಕ್ಷನ್ (ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ ಕರೆಯಲ್ಪಡುತ್ತದೆ) ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ದುಬಾರಿಯಾಗಿದ್ದರೆ ಇಲ್ಲಿ ನಿಷ್ಕಪಟ ವಿಧಾನವು ಕಡಿಮೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತದೆ. ಏಕೆಂದರೆ ಪ್ರತಿ ಬಾರಿ ಎರಡು ಅಂಶಗಳನ್ನು ಹೋಲಿಸಬೇಕಾದರೆ ಬ್ರಾಕೆಟ್ಗಳೊಳಗಿನ ಕೋಡ್ ಅನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ. ಒಂದು ಅತ್ಯುತ್ತಮ ಹೋಲಿಕೆ ಪ್ರಕಾರವು ಪ್ರತಿ ಹೋಲಿಕೆಗೆ 2 ಕರೆಗಳೊಂದಿಗೆ ಒ (ಎನ್ ಲಾಗ್ ಎನ್) ಹೋಲಿಕೆಗಳನ್ನು (ಇಲ್ಲಿ ಎನ್ ಪಟ್ಟಿಯ ಉದ್ದವಾಗಿದೆ) ಮಾಡುತ್ತದೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ ಒ (ಎನ್ ಲಾಗ್ ಎನ್) ಕರೆಗಳು ಬರುತ್ತವೆ. ಹೋಲಿಸಿದರೆ, ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು ಪ್ರತಿ ಅಂಶಕ್ಕೆ, ಆರಂಭಿಕ ಹಂತದಲ್ಲಿ, ಒಟ್ಟು n ಕರೆಗಳಿಗೆ ಕೇವಲ 1 ಕರೆಯನ್ನು ಮಾತ್ರ ಮಾಡುತ್ತೇವೆ. ಆದಾಗ್ಯೂ, ಕಾರ್ಯವು ತುಲನಾತ್ಮಕವಾಗಿ ಸರಳವಾಗಿದ್ದರೆ, ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರದ ಹೆಚ್ಚುವರಿ ಓವರ್ಹೆಡ್ ಅನಗತ್ಯವಾಗಿರಬಹುದು. ಉದಾಹರಣೆಗೆ, ಕಡತಗಳ ಪಟ್ಟಿಯನ್ನು ಅವುಗಳ ಮಾರ್ಪಾಡು ಸಮಯಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ವಿಂಗಡಿಸಲು, ನಿಷ್ಕಪಟ ವಿಧಾನವು ಈ ಕೆಳಗಿನಂತಿರಬಹುದುಃ ಕಾರ್ಯ ನೈವ್ಕಂಪೇರ್ (ಕಡತ a, ಕಡತ b) {ರಿಟರ್ನ್ ಮಾರ್ಪಾಡು ಟೈಮ್ (a) <ಮಾರ್ಪಾಡು ಟೈಮ್ (b)}// ಆ ವಿಂಗಡಣೆ (ಪಟ್ಟಿ, ಹೋಲಿಕೆಪ್ರೆಡಿಕೇಟ್) ಎರಡು ಅಂಶಗಳನ್ನು ಹೋಲಿಸಲು// ಹೋಲಿಕೆಪ್ರೆಡಿಕೇಟ್ ಬಳಸಿ ಕೊಟ್ಟಿರುವ ಪಟ್ಟಿಯನ್ನು ವಿಂಗಡಿಸುತ್ತದೆ ಎಂದು ಭಾವಿಸಿ. ಸಾರ್ಟಿಂಗ್ ಅರೇಃ = ಸಾರ್ಟಿಂಗ್ (ಫೈಲ್ಸ್ ಅರೇ, ನೈವ್ಕಂಪೇರ್) ಪ್ರತಿ ಕಡತಕ್ಕೆ ಮಾರ್ಪಾಡು ಸಮಯಗಳು ಇಲ್ಲದಿದ್ದರೆ, ಈ ವಿಧಾನವು ಪ್ರತಿ ಬಾರಿಯೂ ಕಡತವನ್ನು ವಿಂಗಡಣೆಯಲ್ಲಿ ಹೋಲಿಸಿದಾಗ ಅವುಗಳನ್ನು ಮರು-ಗಣನೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ. ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವನ್ನು ಬಳಸಿಕೊಂಡು, ಮಾರ್ಪಾಡು ಸಮಯವನ್ನು ಪ್ರತಿ ಕಡತಕ್ಕೆ ಒಮ್ಮೆ ಮಾತ್ರ ಲೆಕ್ಕ ಹಾಕಲಾಗುತ್ತದೆ. ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವು ಮೇಲೆ ವಿವರಿಸಿದ ಕ್ರಿಯಾತ್ಮಕ ಭಾಷಾವೈಶಿಷ್ಟ್ಯವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇದು ತಾತ್ಕಾಲಿಕ ವ್ಯೂಹಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ. ಅದೇ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಉತ್ತಮವಾಗಿ ವಿವರಿಸಲು ಕಾರ್ಯವಿಧಾನವಾಗಿ ಬರೆಯಬಹುದು, ಆದರೆ ಇದಕ್ಕೆ ತಾತ್ಕಾಲಿಕ ಸರಣಿಗಳನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ಇದು ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವಲ್ಲ. ಈ ಕೆಳಗಿನ ಸ್ಯೂಡೋ-ಕೋಡ್ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಈ ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆಃ ಫೈಲ್ಗಳಲ್ಲಿನ ಪ್ರತಿ ಫೈಲ್ಗೆ, ರೂಪಾಂತರಗೊಂಡ ಅರೇ ಕಾರ್ಯದ ಕೊನೆಯಲ್ಲಿ ಅರೇ ಇನ್ಸರ್ಟ್ ಅರೇ (ಫೈಲ್, ಮಾರ್ಪಾಡು ಸಮಯ (ಫೈಲ್)) ಸಿಂಪಲ್ಅರೇ ಹೋಲಿಕೆ (ಅರೇ a, ಅರೇ b) {ರಿಟರ್ನ್ a [2] <b [2]} ರೂಪಾಂತರಗೊಂಡ ಅರೇಃ = ವಿಂಗಡಿಸಲಾದ ಅರೇ ಇತಿಹಾಸದ ಕೊನೆಯಲ್ಲಿ ರೂಪಾಂತರಗೊಂಡ ಅರೇ ಇನ್ಸರ್ಟ್ ಫೈಲ್ [1] ನಲ್ಲಿರುವ ಪ್ರತಿ ಫೈಲ್ಗೆ ವಿಂಗಡಿಸಲಾಗಿದೆ. ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರದ ಮೊದಲ ಆನ್ಲೈನ್ ನೋಟವು ಡಿಸೆಂಬರ್ 16,1994 ರಂದು ರಾಂಡಲ್ ಶ್ವಾರ್ಟ್ಜ್ ಅವರು comp.unix.shell ಯೂಸ್ನೆಟ್ ನ್ಯೂಸ್ ಗ್ರೂಪ್ನಲ್ಲಿರುವ ಥ್ರೆಡ್ಗೆ ಪೋಸ್ಟ್ ಮಾಡಿದ್ದು, ಇದನ್ನು comp.lang.perl ಗೆ ಕ್ರಾಸ್ ಪೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ. (ಪರ್ಲ್ ಟೈಮ್ಲೈನ್ನ ಪ್ರಸ್ತುತ ಆವೃತ್ತಿಯು ತಪ್ಪಾಗಿದೆ ಮತ್ತು 1995ರ ನಂತರದ ದಿನಾಂಕವನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ.) ಸಾಲುಗಳ ಪಟ್ಟಿಯನ್ನು ಅವುಗಳ "ಕೊನೆಯ" ಪದದಿಂದ ಹೇಗೆ ವಿಂಗಡಿಸುವುದು ಎಂಬ ಪ್ರಶ್ನೆಯೊಂದಿಗೆ ಥ್ರೆಡ್ ಪ್ರಾರಂಭವಾಯಿತುಃ ಅಡ್ಜನ್ಃ ಜೋಶುವಾ ಎನ್ಜಿ ಅಡ್ಕ್ಟೆಕ್ಃ ಕಾಲಾಪ್ ತಿಮೋತಿ ಕ್ವಾಂಗ್ ಅಡ್ಮ್ಗ್ಃ ಮಹಾಲಿಂಗಮ್ ಗೋಬಿಯರಮಾನನ್ ಅಡ್ಮ್ಲ್ನ್ಃ ಮಾರ್ಥಾ ಎಲ್. ನಂಗಲಾಮ ಶ್ವಾರ್ಟ್ಜ್ ಹೀಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಿದರುಃ #!/ಯುಎಸ್ಆರ್/ಬಿನ್/ಪರ್ಲ್ಗೆ 5 ಅಗತ್ಯವಿದೆ; #ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳು, ಹೊಸ ದೋಷಗಳು! ಮುದ್ರಣ ನಕ್ಷೆ {$_-> [0]} ವಿಂಗಡನೆ {$a-> [1] cmp $b-> [1]] ನಕ್ಷೆ {[$_,/(\S +) $/]} <>; ಈ ಸಂಕೇತವು ಈ ಫಲಿತಾಂಶವನ್ನು ನೀಡುತ್ತದೆಃ ಅಡ್ಮ್ಗ್ಃ ಮಹಾಲಿಂಗಮ್ ಗೋಬಿಯರಮಾನನ್ ಆಡ್ಕಟ್ಕ್ಃ ಕಾಲಾಪ್ ತಿಮೋತಿ ಕ್ವಾಂಗ್ ಆಡ್ಕಟ್ಃ ಮಾರ್ಥಾ ಎಲ್. ನಂಗಲಾಮ ಅಡ್ನ್ಃ ಜೋಶುವಾ ಎನ್ಜಿ ಶ್ವಾರ್ಟ್ಜ್ ಅವರು ಪೋಸ್ಟ್ನಲ್ಲಿ "ಪರ್ಲ್ನಲ್ಲಿ ಲಿಸ್ಪ್ನೊಂದಿಗೆ ಮಾತನಾಡುತ್ತಿದ್ದಾರೆ" ಎಂದು ಬರೆದಿದ್ದಾರೆ, ಇದು ಭಾಷಾವೈಶಿಷ್ಟ್ಯದ ಲಿಸ್ಪ್ ಮೂಲವನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ. "ಶ್ವಾರ್ಟ್ಜಿಯನ್ ಟ್ರಾನ್ಸ್ಫಾರ್ಮ್" ಎಂಬ ಪದವನ್ನು ಟಾಮ್ ಕ್ರಿಶ್ಚಿಯನ್ಸನ್ ಅವರು ಮುಂದಿನ ಉತ್ತರದಲ್ಲಿ ಸೃಷ್ಟಿಸಿದರು. ಕ್ರಿಸ್ಟಿಯಾನ್ಸೆನ್ ಅವರ ನಂತರದ ಪೋಸ್ಟ್ಗಳು ಅವರು ರಚನೆಗೆ ಹೆಸರಿಡುವ ಉದ್ದೇಶವನ್ನು ಹೊಂದಿರಲಿಲ್ಲ, ಆದರೆ ಕೇವಲ ಮೂಲ ಪೋಸ್ಟ್ನಿಂದ ಅದನ್ನು ಉಲ್ಲೇಖಿಸುವ ಉದ್ದೇಶವನ್ನು ಹೊಂದಿದ್ದರು ಎಂದು ಸ್ಪಷ್ಟಪಡಿಸಿದರುಃ ಅಂತಿಮವಾಗಿ ಅದನ್ನು "ದಿ ಬ್ಲ್ಯಾಕ್ ಟ್ರಾನ್ಸ್ಫಾರ್ಮ್" ಎಂದು ಹೆಸರಿಸುವ ಅವರ ಪ್ರಯತ್ನವು ಹಿಡಿತ ಸಾಧಿಸಲಿಲ್ಲ (ಇಲ್ಲಿ "ಬ್ಲ್ಯಾಕ್" ಎಂಬುದು "ಶ್ವಾರ್ [ಟಿ] ಝಡ್" ಮೇಲಿನ ಶ್ಲೇಷವಾಗಿದೆ, ಅಂದರೆ ಜರ್ಮನ್ ಭಾಷೆಯಲ್ಲಿ ಕಪ್ಪು ಎಂದರ್ಥ). ಇತರ ಭಾಷೆಗಳೊಂದಿಗೆ ಹೋಲಿಕೆ ಕೆಲವು ಇತರ ಭಾಷೆಗಳು ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರದಂತೆಯೇ ಅದೇ ಆಪ್ಟಿಮೈಸೇಶನ್ಗೆ ಅನುಕೂಲಕರ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತವೆಃ ಪೈಥಾನ್ 2.4 ಮತ್ತು ಅದಕ್ಕಿಂತ ಹೆಚ್ಚಿನದರಲ್ಲಿ, ಕಾರ್ಯ ಮತ್ತು ಸ್ಥಳದಲ್ಲಿನ ವಿಧಾನ ಎರಡೂ ಬಳಕೆದಾರರಿಗೆ "ಪ್ರಮುಖ ಕಾರ್ಯ" ವನ್ನು ಒದಗಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುವ ನಿಯತಾಂಕವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ (ಮೇಲಿನ ಉದಾಹರಣೆಗಳಲ್ಲಿರುವಂತೆ). ಪೈಥಾನ್ 3 ಮತ್ತು ಅದಕ್ಕಿಂತ ಹೆಚ್ಚಿನದರಲ್ಲಿ, ಕೀ ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸುವುದು ಕಸ್ಟಮ್ ವಿಂಗಡಣಾ ಕ್ರಮವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಏಕೈಕ ಮಾರ್ಗವಾಗಿದೆ (ಈ ಹಿಂದೆ ಬೆಂಬಲಿತವಾದ ನಿಯತಾಂಕವು ಬಳಕೆದಾರರಿಗೆ "ಹೋಲಿಕೆ ಕಾರ್ಯ" ವನ್ನು ಒದಗಿಸಲು ಅವಕಾಶ ಮಾಡಿಕೊಟ್ಟಿತು). ಪೈಥಾನ್ 2.4ಕ್ಕಿಂತ ಮೊದಲು, ಅಭಿವರ್ಧಕರು ಲಿಸ್ಪ್-ಮೂಲದ ಡೆಕರೇಟ್-ಸಾರ್ಟ್-ಅನ್ಡೆಕೊರೇಟ್ (ಡಿ. ಎಸ್. ಯು) ಭಾಷಾವೈಶಿಷ್ಟ್ಯವನ್ನು ಬಳಸುತ್ತಿದ್ದರು, ಸಾಮಾನ್ಯವಾಗಿ ವಸ್ತುಗಳನ್ನು (ಸಾರ್ಟ್ಕಿ, ಆಬ್ಜೆಕ್ಟ್) ಟುಪಲ್ನಲ್ಲಿ ಸುತ್ತುವ ಮೂಲಕ. ರೂಬಿ 1.8.6 ಮತ್ತು ಅದಕ್ಕಿಂತ ಹೆಚ್ಚಿನದರಲ್ಲಿ, ಅಮೂರ್ತ ವರ್ಗವು (s ಅನ್ನು ಒಳಗೊಂಡಿರುವ) ಒಂದು ವಿಧಾನವನ್ನು ಹೊಂದಿದೆ, ಇದು "ಕೀ ಫಂಕ್ಷನ್" ಅನ್ನು (ಮೇಲಿನ ಉದಾಹರಣೆಗಳಲ್ಲಿರುವಂತೆ) ಕೋಡ್ ಬ್ಲಾಕ್ ಆಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಡಿ 2 ಮತ್ತು ಅದಕ್ಕಿಂತ ಹೆಚ್ಚಿನದರಲ್ಲಿ, ಕಾರ್ಯವು ಲಭ್ಯವಿದೆ. ಇದಕ್ಕೆ ಕಡಿಮೆ ತಾತ್ಕಾಲಿಕ ದತ್ತಾಂಶದ ಅಗತ್ಯವಿರಬಹುದು ಮತ್ತು ಇದು ಪರ್ಲ್ ನುಡಿಗಟ್ಟು ಅಥವಾ ಪೈಥಾನ್ ಮತ್ತು ಲಿಸ್ಪ್ನಲ್ಲಿರುವ ಅಲಂಕಾರ-ವಿಂಗಡಣೆ-ಅಲಂಕರಿಸದ ನುಡಿಗಟ್ಟಿಗಿಂತ ವೇಗವಾಗಿರಬಹುದು. ಏಕೆಂದರೆ ವಿಂಗಡಣೆಯನ್ನು ಸ್ಥಳದಲ್ಲೇ ಮಾಡಲಾಗುತ್ತದೆ, ಮತ್ತು ಕನಿಷ್ಠ ಹೆಚ್ಚುವರಿ ದತ್ತಾಂಶವನ್ನು (ರೂಪಾಂತರಗೊಂಡ ಅಂಶಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು) ಮಾತ್ರ ರಚಿಸಲಾಗುತ್ತದೆ. ರಾಕೆಟ್ನ ಕೋರ್ ಸಾರ್ಟ್ ಕಾರ್ಯವು ಕೀಲಿಯನ್ನು ಹೊರತೆಗೆಯುವ ಕಾರ್ಯದೊಂದಿಗೆ #: ಕೀವರ್ಡ್ ವಾದವನ್ನು ಮತ್ತು ಹೆಚ್ಚುವರಿ #: ಕ್ಯಾಶ್-ಕೀಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ವಿಂಗಡಿಸುವ ಸಮಯದಲ್ಲಿ ಪರಿಣಾಮವಾಗಿ ಬರುವ ಮೌಲ್ಯಗಳನ್ನು ಕ್ಯಾಶ್ ಮಾಡುವಂತೆ ವಿನಂತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಪಟ್ಟಿಯನ್ನು ಬದಲಾಯಿಸುವ ಒಂದು ಅನುಕೂಲಕರ ಮಾರ್ಗವೆಂದರೆ. ಪಿಎಚ್ಪಿ 5.3 ಮತ್ತು ಅದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ರೂಪಾಂತರವನ್ನು, ಉದಾಹರಣೆಗೆ, ಬಳಸುವ ಮೂಲಕ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. PHP.function ಸ್ಪೇಸ್ ಬಾಲ್ಸ್ _ ಸಾರ್ಟ್ (ಅರೇ & $a) ನಲ್ಲಿನ ಅಸ್ಥಿರ ವಿಂಗಡಣಾ ಕ್ರಮಾವಳಿಗಳ ಮಿತಿಗಳ ಸುತ್ತ ಕೆಲಸ ಮಾಡಲುಃ ಅನೂರ್ಜಿತ {ಅರೇ _ ವಾಕ್ ($a, ಫಂಕ್ಷನ್ (& $v, $k) {$v = ಅರೇ ($v, $k);}); ಅಸ್ಸಾರ್ಟ್ ($a); ಅರೇ _ ವಾಕ್ ($a, ಫಂಕ್ಷನ್ (& $v, $$) {$v = $v [0];} ಎಲಿಕ್ಸಿರ್ನಲ್ಲಿ, ಮತ್ತು ವಿಧಾನಗಳು ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಯಾವುದೇ ಮಾಡ್ಯೂಲ್ಗೆ ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಕೆದಾರರಿಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ. ರಾಕುವಿನಲ್ಲಿ, ಹುಡ್ ಅಡಿಯಲ್ಲಿ ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವನ್ನು ನಿರ್ವಹಿಸಲು ಕೇವಲ 1 ವಾದವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಕಂಪರೇಟರ್ ಲ್ಯಾಂಬ್ಡಾವನ್ನು ಸರಬರಾಜು ಮಾಡಬೇಕಾಗುತ್ತದೆಃ @a.sort ({$a.Str}) #ಅಥವಾ ಚಿಕ್ಕದುಃ @a.sort (*. Str) ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯದ ಮೇಲೆ ವಿಂಗಡಿಸುತ್ತದೆ, @a.sort ({$a.Str cmp $^ b.Str}) ಪ್ರತಿ ಹೋಲಿಕೆಗೆ ಸ್ವಲ್ಪ ಮೊದಲು ಅಂಶಗಳನ್ನು ಹೋಲಿಸಲು ಪರಿವರ್ತಿಸುತ್ತದೆ. ರಸ್ಟ್ನಲ್ಲಿ, ಸ್ವಲ್ಪ ಗೊಂದಲಮಯವಾಗಿ, ವಿಧಾನವು ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವನ್ನು * ಮಾಡುವುದಿಲ್ಲ * ಏಕೆಂದರೆ ಇದು ಕೀಲಿಗಾಗಿ ಹೆಚ್ಚುವರಿ ಸಂಗ್ರಹಣೆಯನ್ನು ನಿಯೋಜಿಸುವುದಿಲ್ಲ, ಇದು ಪ್ರತಿ ಹೋಲಿಕೆಗೆ ಪ್ರತಿ ಮೌಲ್ಯಕ್ಕೆ ಪ್ರಮುಖ ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತದೆ. ಈ ವಿಧಾನವು ಪ್ರತಿ ಅಂಶಕ್ಕೆ ಒಮ್ಮೆ ಕೀಲಿಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ. ಉಲ್ಲೇಖಗಳು ಬಾಹ್ಯ ಕೊಂಡಿಗಳು ರಾಂಡಲ್ ಎಲ್. ಶ್ವಾರ್ಟ್ಜ್ ಮಾರ್ಕ್-ಜಾಸನ್ ಡೊಮಿನಸ್ ಅವರ ಶ್ವಾರ್ಟ್ಜಿಯನ್ ಟ್ರಾನ್ಸ್ಫಾರ್ಮ್ನೊಂದಿಗೆ ವಿಂಗಡಿಸುವುದು ಶ್ವಾರ್ಟ್ಜಿಯನ್ ಟ್ರಾನ್ಸ್ಫಾರ್ಮ್ http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52234 ಪೈಥಾನ್ ಸಾಫ್ಟ್ವೇರ್ ಫೌಂಡೇಶನ್ (2005) ಅನ್ನು ವಿವರಿಸುತ್ತದೆ. 1. 5. 2 ನಾನು ಒಂದು ಸಂಕೀರ್ಣವಾದ ವಿಂಗಡಣೆ ಮಾಡಲು ಬಯಸುತ್ತೇನೆಃ ನೀವು ಪೈಥಾನ್ನಲ್ಲಿ ಶ್ವಾರ್ಟ್ಜಿಯನ್ ರೂಪಾಂತರವನ್ನು ಮಾಡಬಹುದೇ? ಪಡೆಯಲಾಗಿದೆ ಜೂನ್ 22,2005. ಮೆಮೊಯಿಜ್ ಪರ್ಲ್ ಮಾಡ್ಯೂಲ್-ದುಬಾರಿ ಕಾರ್ಯಗಳನ್ನು ಅವುಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಕ್ಯಾಶಿಂಗ್ ಮಾಡುವ ಮೂಲಕ ವೇಗವಾಗಿ ಮಾಡುತ್ತದೆ. ಕ್ರಮಾವಳಿಗಳನ್ನು ವಿಂಗಡಿಸುವುದು ಉದಾಹರಣೆಗೆ ಪರ್ಲ್ ಕೋಡ್ ಇರುವ ಲೇಖನಗಳು ಉದಾಹರಣೆಗೆ ರಾಕೆಟ್ ಕೋಡ್ ಪರ್ಲ್ ಇರುವ ಲೇಖನಗಳು