என்கணித இயக்கிகளில் +, * ஆகிய இரண்டையும் பட்டியல் செயல்பாடுகளுக்காகப் பயன்படுத்தலாம், மற்றவை எதுவும் பொருந்தாது. + என்பதும் கூட கூட்டல் என்கிற அடிப்படையில் பயன்படுத்த இயலாது, பட்டியலை பொருத்தவரையில் + என்றால் இணைத்தல், * என்றால் பிரதி செய்கை.
மேற்கண்ட நிரலில் l1, l2 என்ற இரண்டு பட்டியலை உருவாக்கியிருக்கிறோம். l1+l2 என்ற நிரல்வரி l1 என்ற பட்டியலோடு l2வை இணைக்கவும் என்பதைக் குறிக்கிறது. அதாவது இணைத்தல் தான், கூட்டல் அல்ல.
இது எப்படி சாத்தியம்?
ஒரே இயக்கி தான், ஆனால் அது புழங்கும் தரவுகளின் அடிப்படையில் தனது செயல்பாடுகளை மாற்றிக்கொள்கிறது. எண்கள் என்றால் + என்பது கூட்டல் கழித்தல், அதுவே பட்டியல் என்றால் இணைத்தல் மட்டும் தான்.
*க்கான உதாரணத்தைப் பாருங்கள்.
இதில் l3*2 என்ற நிரல்வரி, பட்டியலில் உள்ள உறுப்புகளை 2 முறை பிரதியெடுத்து ஒரே பட்டியலாக்குகிறது. *க்கை தொடர்ந்து வரும் எண்ணின் அடிப்படையில் பிரதி எடுக்கப்படுகிறது.
குறிப்பு: + இயக்கி பட்டியல்களோடு மட்டுமே இயங்கும், 2 அல்லது அதற்கும் மேற்பட்ட பட்டியல்களோடு விளையாடலாம். அதேபோல, * இயக்கிக்குத் தான் சரியாக இயங்க ஒரு பட்டியல் மற்றும் ஒரு முழு எண் கட்டாயம் தேவை. இவற்றில் ஏதாவது இல்லாமல் போனால் பிழை அல்லது நாம் எதிர்பார்க்கும் முடிவுகள் கிடைக்காமல் போகும்.
0
பட்டியலை ஒப்பிடுவது எப்படி?
இரண்டு பட்டியல் தனித்தனியே இருக்கிறது என்று வைத்துக்கொள்வோம். அவற்றில் சிறியது பெரியது கண்டறிய முடியுமா?
மேற்கண்ட நிரல் எப்படி True என்ற பதிலைத் தருகிறது?
பட்டியலின் ஒவ்வொரு உறுப்பாக எடுத்து அதை ஒப்பிட்டுப் பார்க்க வேண்டியதுதான்.
2>1 -> இல்லை
3>2 -> இல்லை
7>9 -> ஆம்
அவ்வளவுதான். ஏதாவதொரு ஒப்பீடு “ஆம்” என்று வந்தால்கூட போதும் முடிவும் ஆம் தான். சரி இப்போது இந்த நிரல் ஏன் False என்று வருகிறது யோசியுங்கள்.
0
ஒரு பட்டியலுக்குள் இன்னொரு பட்டியல் சத்தியமா?
ஏன் இல்லை?
மேற்கண்ட நிரலில் உள்ளது போல, ஒரு பட்டியலுக்குள் நீங்கள் எத்தனை பட்டியலை வேண்டுமானாலும் உருவாக்கிக் கொள்ளலாம், அப்படி உருவாக்கப்படுபவை முதன்மை பட்டியலின் ஒரு உறுப்பாகவே தொடரும். அதன் காரணமாகவே பட்டியலின் நீளம் 5 என்று காட்டுகிறது.
0
நிரல்: ஒரு பட்டியலின் பெரிய, சிறிய எண்களைக் கண்டறிதல்.
விளக்கம்:
list1 என்ற அடையாளங்காட்டியில் மொத்தம் 9 உறுப்புகள் உள்ளன, அவற்றிலிருந்து பெரியதைக் கண்டறிந்து சேமிக்க max_element, சிறியதைக் கண்டறிந்து சேமிக்க min_element ஆகிய இரண்டு அடையாளங்காட்டிகளை உருவாக்கிக்கொள்கிறோம்.
இப்போதைக்கு நம் வசதிக்காகப் பட்டியலின் முதல் உறுப்பையே பெரிய, சிறிய எண்ணாக அனுமானித்துக் கொள்கிறோம்.
for loopஐ பயன்படுத்தி பட்டியலின் ஒவ்வொரு எண்ணாகப் பயணித்து அது முதல் உறுப்பை விட பெரியதாக இருக்கிறதா என்று நிரல் ஒப்பிட்டுப் பார்க்கிறது, ஆம் என்றால் max_elementன் மதிப்பு பெரிய எண்ணின் மதிப்பைக்கொண்டு புதுப்பிக்கப்படுகிறது. ஒருவேளை ஒப்பீட்டில் இல்லை என்று வந்தால் min_elementன் மதிப்பு புதுப்பிக்கப்படும். பட்டியலின் கடைசி உறுப்பு ஒப்பிடப்படும் வரை இச்செய்கை தொடரும்.
இறுதியில் பெரிய எண் max_elementலும், சிறிய எண் min_elementலும் சேமிக்கப்பட்டு இருக்கும்.
நிரல்: பட்டியலில் ஒன்றுக்கும் மேற்பட்ட முறை இடம்பெற்றிருக்கும் நகல் எண்களை நீக்குதல்
விளக்கம்:
தனித்துவமான எண்களைச் சேமிக்க unique_list=[] என்றொரு பட்டியலை உருவாக்குகிறோம். முதன்மை பட்டியலிலிருந்து ஒவ்வொரு உறுப்பாக எடுத்து அது unique_listல் ஏற்கனவே இடம்பெறாமல் இருக்கிறதா என்பதைச் சோதனை செய்து பார்க்கிறோம். முடிவு ஆம் என்று வந்தால் மட்டும், அந்த உறுப்பை unique_listல் சேர்க்கிறோம்.
இறுதியாக unique_listஐ அச்சிட்டுப் பார்த்தால், போலிகள் நீக்கப்பட்டு அசல் எண்கள் மட்டுமே இடம்பெற்றிருக்கும்.
நிரல்: இரண்டு பட்டியல்களிலும் உள்ள பொதுவான எண்களைக் கண்டறிதல்
விளக்கம்:
2 பட்டியல்களைக் குறிக்க list 1, list 2 என்ற அடையாளங்காட்டிகள். பொதுவான எண்களை மட்டும் சேமிக்க மற்றொரு பட்டியல், common_elements=[].
list 1ன் ஒவ்வொரு உறுப்பாக எடுத்து, அது list 2ல் இடம்பெற்று common_elementsல் இடம்பெறாமல் இருந்தால், குறிப்பிட்ட அந்த உறுப்பை common_elementsல் இணைக்கிறோம்.
இறுதியில் common_elementஐ அச்சிட்டுப் பார்த்தால், 2 பட்டியல்களிலும் உள்ள பொதுவான எண்கள் இடம்பெற்றிருக்கும்.
0
பட்டியல் இந்த அத்தியாயத்தோடு நிறைவடைகிறது. அடுத்தவாரம் மற்றுமொரு தரவு கட்டமைப்போடு சந்திப்போம்.
(தொடரும்)
