மேம்பட்ட தரவு கட்டமைப்புகளின் தொடர்ச்சியாக இந்த வாரம் அணி(Array) குறித்துப் பார்க்கவிருக்கிறோம். மேல்நிலை வகுப்பு கணித பாடங்களில் மேட்ரிக்ஸ் (Matrix) குறித்துப் படித்திருப்போம், அதை நிரலில் அணி த.கட்டமைப்பைக் கொண்டு உருவாக்கமுடியும். மேலும் அணிகளுக்கு என்றே பைத்தான் ஒரு முழுமையான தொகுப்பை நிரலாளருக்கு வழங்குகிறது. ஆனால் எடுத்தவுடனேயே அப்படிப் பயன்படுத்திப் பழகிவிட்டால், ஒரு தரவு கட்டமைப்பு எப்படி தரவுகளைச் சேமிக்கிறது? தேவைப்படும் குறிப்பிட்ட தரவை பெற என்ன நுட்பத்தைப் பயன்படுத்துகிறது? ஒரு த.கட்டமைப்புக்கும் மற்றொன்றுக்கும் என்ன வேறுபாடு? சூழலுக்கு ஏற்ப சரியான தரவு கட்டமைப்புகளைத் தேர்ந்தெடுப்பது எப்படி போன்ற கேள்விகளுக்கு விடை தெரியாமல் போய்விடும்.
நிரலாளரின் பணியை எளிமையாக்கத் தொகுப்புகளை வழங்குவது பைத்தானின் பெரிய மனது, இருப்பினும் அதன் அடிப்படைகளை நிரல் எழுதித் தெரிந்து வைத்துக்கொள்ளும் பண்பு ஒரு நிரலாளராக நம்மை என்றும் காக்கும்.
முந்தைய அத்தியாயங்களில் செய்ததைப் போலவே பட்டியல் தரவு வகையைக் கொண்டே அணிகளை உருவாக்க இருக்கிறோம்.
அணியை எவ்வாறு புரிந்துகொள்வது? அல்லது நிரலில் எப்போதெல்லாம் அணியின் தேவை ஏற்படும்?
1) தரவுகள் வரிசையாகச் சேமிக்கப்பட வேண்டியிருந்தால்
2) தரவுகள் அனைத்தும் ஒரே வகையைச் சார்ந்ததாக இருக்கும் பட்சத்தில்
3) தரவுகள் நிலையான அளவை மட்டும் கொண்டிருந்தால்
மேற்சொன்ன அனைத்தும் மிகச் சரியாக மேட்ரிக்சுக்குப் பொருந்தும் இல்லையா? எனவே அதை எடுத்துக்காட்டாக எடுத்துக்கொண்டு அணியைப் புரிந்துகொள்ள முயல்வோம்.
நிரல் 1: அன்றாட வெப்பநிலையை ஒற்றைப் பரிமாண அணியில் சேகரித்தல்
அணியை ஒற்றை மற்றும் பல்பரிமாணமாக உருவாக்கிப் பயன்படுத்தலாம். வெப்பநிலைகளைப் பட்டியலில் சேமித்து வைத்திருக்கிறோம். புரிந்துகொள்வதற்கு வசதியாக இந்நிரலை மூன்றாகப் பிரித்துக்கொள்ளலாம்
1) சேமித்த வெப்பநிலைகளை for loopஐ கொண்டு அச்சிடுவது
2) வெப்பநிலைகளின் சராசரியைக் கண்டறிவது, அதன் கூட்டுத்தொகையைக் கணக்கிட்டு அதை மொத்த வெப்பநிலைகளின் எண்ணிக்கையைக்கொண்டு வகுக்கும்பொழுது நமக்கு அதன் சராசரி கிடைக்கிறது.
3) நிறைவாக அதிகபட்ச, குறைந்தபட்ச வெப்பநிலைகளை
பைத்தான் வழங்கும் max(), min() மு.வ.செயல்பாடுகளைக் கொண்டு கண்டறியலாம்.
வெளியீடு:
நிரல் 2: இரண்டு அணிகளைக் கூட்டுதல்
[1, 2],
[3, 4]
[5, 6],
[7, 8]
மேலிருக்கும் இரண்டு அணிகளையும் கூட்டி புதிதாக ஒரு மூன்றாம் அணியை உருவாக்கப் போகிறோம். கணிதத்தில் செய்ததை அப்படியே நிரலில் செய்கிறோம், அவ்வளவுதான்.
இவ்விரண்டு அணிகளையும் குறிக்க matrix_A, matrix_B எனும் அடையாளங்காட்டிகள் உருவாக்கப்படுகின்றன. அவற்றை matrix_addition() என்ற செயல்பாட்டுக்கு அளவுருக்களாக அனுப்பிவைக்கிறோம். அவற்றைப் பெற்றுக்கொண்ட செயல்பாடு அவற்றின் அளவு இணையாக இருக்கிறதா என்பதைப் பரிசோதிக்கிறது. அப்படி இருக்கும்பட்சத்தில் மட்டும்தான் அணிகளின் கூட்டுத்தொகையைக் கண்டறிய முடியும்.
இரண்டு அணிகளையும் கையாள வேண்டியிருப்பதால் உட்பொதிவுள்ள(nested) for loop தேவைப்படுகிறது. எப்படி கூட்டுத்தொகை கணக்கிடப்படுகின்றன என்பதைப் பட்டியலின் நேர் குறியீட்டு எண் உதவியோடு பார்ப்போம்.
[0][0]: 1 + 5 = 6
[0][1]: 2 + 6 = 8
[1][0]: 3 + 7 = 10
[1][1]: 4 + 8 = 12
மூன்றாம் அணி உருவாகிவிட்டது. அதை result=[] என்ற பட்டியலில் சேமித்து அச்சிடுகிறோம்.
வெளியீடு:
நிரல் 3: மேட்ரிக்சின் மூலைவிட்ட(diagonals) மதிப்புகளைக் கண்டறிதல்
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
இதன் மூலைவிட்ட மதிப்புகள் என்ன?
1+5+9 = 10.
கணிதத்தில் தான் எப்படி என்று நமக்கு ஏற்கனவே தெரியுமே, நிரலில் எப்படி என்கிறீர்களா? அதே டைலர், அதே வாடகை தான். பட்டியலில் மூலைவிட்ட மதிப்புகள் சேமிக்கப்பட்டிருக்கும் நேர் குறியீட்டு எண்களை மட்டும் பிரித்து எழுதுங்கள், நிரல் தயார்!.
[0, 0]
[1, 1]
[2, 2]
இந்த குறியீட்டு எண்களில் சேமிக்கப்பட்டு இருக்கும் மதிப்புகளின் கூட்டுத்தொகை என்னவென்று கணக்கிட்டால் கதை முடிந்தது.
[0][0] = 1
[1][1] = 5
[2][2] = 9
1+5+9=15
வெளியீடு:
நிரல் 4: இரண்டு அணிகளைப் பெருக்குதல்
[2, 3],
[4, 1]
[5, 7]
[6, 8]
இவ்விரண்டு அணிகளையும் பெருக்கி அதன் முடிவுகளை வைத்து மூன்றாவது ஒரு அணியை உருவாக்குகிறோம்.
நேர் குறியீட்டு எண்ணை வைத்து முதலில் மதிப்புகளை கண்டறிவோம், பிறகு அதை அப்படியே நிரலுக்குப் பொருத்திப் பார்த்தால் வேலை முடிந்தது.
Iteration 1 (i=0, j=0):
k = 0: result[0][0] += matrix_A[0][0] * matrix_B[0][0] => 0 + 2 * 5 = 10
k = 1: result[0][0] += matrix_A[0][1] * matrix_B[1][0] => 10 + 3 * 6 = 28
Iteration 2 (i=0, j=1):
k = 0: result[0][1] += matrix_A[0][0] * matrix_B[0][1] => 0 + 2 * 7 = 14
k = 1: result[0][1] += matrix_A[0][1] * matrix_B[1][1] => 14 + 3 * 8 = 38
Iteration 3 (i=1, j=0):
k = 0: result[1][0] += matrix_A[1][0] * matrix_B[0][0] => 0 + 4 * 5 = 20
k = 1: result[1][0] += matrix_A[1][1] * matrix_B[1][0] => 20 + 1 * 6 = 26
Iteration 4 (i=1, j=1):
k = 0: result[1][1] += matrix_A[1][0] * matrix_B[0][1] => 0 + 4 * 7 = 28
k = 1: result[1][1] += matrix_A[1][1] * matrix_B[1][1] => 28 + 1 * 8 = 36
i,j மற்றும் kவுக்கு என்று மூன்று for loopகளை மட்டும் உங்களால் உருவாக்க முடிந்தால், நிரல் சுடச்சுட தயார்.
வெளியீடு:
(தொடரும்)
