வாசகர்களுக்கு அத்தியாயம் 12இல் வெண்ணிலா கபடி குழு சினிமாவில் இடம்பெற்றிருந்த பரோட்டா உண்ணும் போட்டிக்கு நிரல் எழுதச்சொல்லிக் கேட்டிருந்தது நினைவிருக்கலாம். முதலில் அதைப் பார்த்துவிடுவோம். போட்டியின் விதிகள் உங்களுக்கு நினைவிருக்கிறதா?
1) ஒருவர் 50 பரோட்டாக்கள் சாப்பிட வேண்டும்.
2) அப்படிச் சாப்பிட்டால் 100 ரூபாய் சன்மானம், கூடவே சாப்பிடும் பரோட்டாக்களுக்கு காசுத்தர தேவையில்லை.
3) 50க்கு கீழே சாப்பிடும் ஒருவர் தோற்றவராக அறிவிக்கப்பட்டு, அவரிடமிருந்து சாப்பிட்ட பரோட்டாவுக்கு உண்டான காசையும், கூடவே 100 ரூபாயையும் கடைக்காரர் பெற்றுக்கொள்வார்.
4) 50 பரோட்டாக்களையும் ஒருவர் அதிகபட்சம் 3 தவணைகளில் சாப்பிட்டாக வேண்டும். உதாரணத்துக்கு (20+15+15) என்றால், முதலில் 20 பரோட்டாக்கள், பிறகு 15 பரோட்டாக்கள், நிறைவாக 15 பரோட்டாக்கள் என்கிற அடிப்படையில் மூன்று தவணைகளாகப் பிரித்துப் பரிமாறப்படும்.
நிரல்:
விளக்கம்:
நிரலின் முதல் 5 வரிகள் எளிமையானவைதான். ஒரு பரோட்டாவின் விலை, மொத்த பரோட்டாவின் எண்ணிக்கை, அதிகபட்ச தவணை, போட்டியாளர் சாப்பிட்ட மொத்த பரோட்டாக்களின் எண்ணிக்கை, ஒரு வேளை தோற்றுவிட்டால் செலுத்தவேண்டிய தொகை ஆகியவற்றுக்கான அடையாளங்காட்டிகளை உருவாக்கியிருக்கிறோம்.
நிரலின் உயிர் எப்போதும் போல for loopல் தான் உள்ளது. 3 தவணைகளில் சாப்பிட்டாக வேண்டுமென்ற விதி இருப்பதனால், அதற்கு ஏற்றார்போல for loop வடிவமைக்கப்பட்டு இருக்கிறது. அதன் தொடக்கம் 1 முடிவு 4, அதனால் அதிகபட்சம் 3 முறை இயங்கும்.
ஒவ்வொரு தவணையிலும் போட்டியாளருக்குப் பரிமாறப்படும் எண்ணிக்கையைக் கேட்டுப்பெற்று அதை parottas_servedல் சேமித்து வைக்கிறோம். வென்றுவிட்டால் பிரச்சனையில்லை, ஒருவேளைத் தோற்றால் செலுத்தவேண்டிய தொகையை ஒவ்வொரு தவணையிலும் கணக்கிடப்பட்டு அதன் கூட்டுத்தொகை total_costல் இருக்கும். மூன்று அல்லது அதற்கும் குறைவான தவணைகளில் போட்டியாளர் சாப்பிட்ட பரோட்டாக்களின் எண்ணிக்கையைக் குறிக்க, total_parottas பயன்படுத்தப்பட்டு இருக்கிறது.
அதன் 50ற்கு நிகரானதாக இருந்தால், உடனடியாக for loop தனது இயக்கத்தை நிறுத்திக்கொள்ளும்.
அவ்வளவுதான், இனி அடையாளங்காட்டிகள் கொண்டிருக்கும் மதிப்புகளின் அடிப்படையில் போட்டியின் முடிவுகளை அறிவிக்க வேண்டியதுதான். வென்றவருக்கு வாழ்த்துச்சொல்லி 100 ரூபாயைக் கொடுத்து அனுப்புகிறோம், தோற்றவரிடம் சாப்பிட்ட பரோட்டாவுக்கான காசையும், கூடவே 100 ரூபாயையும் வாங்கிக்கொண்டு மகிழ்ச்சியாக வழியனுப்பி வைக்கிறோம்.
இப்படியொரு நிரலை எழுதுவது அவசியம் தானா? ஆம், ஏனென்றால் ஒரு நிரலாக்கக் கருத்தை இப்படியும் கற்கலாம்.
வெளியீடு 1:
வெளியீடு 2:
0
அத்தியாயம் 11ல் பார்த்த Nested if உங்களுக்கு நினைவிருக்கலாம். அதே போன்று ஒரு loopற்குள் மற்றொன்று என்கிற அடிப்படையில் நாம் for loopஐயும் பயன்படுத்தலாம்.
என்ன காரணத்திற்காக இப்படியொரு ஏற்பாடு?
நிரலில் பயன்படுத்தப்படும் தரவுகள் வரிசைகள் மற்றும் நெடுவரிசைகள்(rows and columns) அடிப்படையில் சேமிக்கப்படவேண்டிய நிர்ப்பந்தம் ஏற்படும் போதலாம் இந்த வாய்ப்பினை பயன்படுத்திக்கொள்ளலாம். வரிசையைக் குறிக்க ஒரு for loop, நெடுவரிசையைக் குறிக்க மற்றொன்று.
நிரல் 2:
வெளியீடு:
விளக்கம்:
வெளி for loopஐ குறிக்க i, கூட்டுக்கு உள்ளே இயங்கும் for loopஐ குறிக்க j. இவ்விரண்டுமே தலா மூன்று முறை இயங்கும் வகையில் வடிவமைக்கப்பட்டு உள்ளன. மிக முக்கியமாக இங்கே கவனிக்கப்பட வேண்டியது என்னவென்றால் i ஒருமுறை இயங்கினால், j மூன்றுமுறை இயங்கும்.
உதாரணத்துக்கு முதல் செய்கையில் iயின் மதிப்பு 1, நிபந்தனை பலித்து உள்ளே செல்கிறது. இப்போது j தனது மூன்று செய்கைகளையும் முழுவதுமாக முடித்தபிறகே நிரல் iயிற்கு திரும்பும்.
மதிப்புகளைப் பயன்படுத்தி இன்னும் சிறப்பாக புரிந்துகொள்வோம்.
i, செய்கை 1:
j, செய்கை 1: -> i *j -> 1*1 -> 1
j, செய்கை 2: -> i *j -> 1*2 -> 1 2
j, செய்கை 3: -> i *j -> 1*3 -> 1 2 3
ஒரு வரிசை வெற்றிகரமாகத் திரையில் அச்சிடப்பட்டு இருக்கிறது. இப்போது இரண்டாவது வரிசைக்கான செயல்பாடு ஆரம்பிக்கிறது.
i, செய்கை 2:
j, செய்கை 1: -> i *j -> 2*1 -> 2
j, செய்கை 2: -> i *j -> 2*2 -> 2 4
j, செய்கை 3: -> i *j -> 2*3 -> 2 4 6
இப்போது நிரலின் வெளிப்பாடு(தற்காலிகமாக) என்று இருக்கும்.
1 2 3
2 4 6
இப்போது கடைசி வரிசையை அச்சிடுவோம்.
i, செய்கை 3:
j, செய்கை 1: -> i *j -> 3*1 -> 3
j, செய்கை 2: -> i *j -> 3*2 -> 3 6
j, செய்கை 3: -> i *j -> 3*3 -> 3 6 9
நிரலின் முழுமையான வெளிப்பாடு கிடைத்துவிட்டது.
1 2 3
2 4 6
3 6 9
Nested for loopல் நீங்கள் நினைவில் வைத்துக்கொள்ள வேண்டியவை
1) வெளி for loopன் ஒரு செய்கைக்கு இணையாக, உள் for loop தனது அனைத்து செய்கைகளையும் முடித்துக்கொடுக்கும்.
iயின் மதிப்பு 1ஆக மட்டும் இருக்கையில், jயின் மதிப்பு 1,2,3 ஆக இருந்ததைக் கவனித்திருக்கலாம்.
2) எங்கெல்லாம் அணி(Matrix) போன்ற அமைப்புக்குள் தரவுகளைச் சேமிக்கவேண்டிய அவசியம் வருகிறதோ, அங்கெல்லாம் Nested for இருக்கும்.
ஒரு மதிப்புக்கும், மற்றொன்றிற்கும் இடைவெளி வேண்டும் என்பதற்காக i*jவைத் தொடர்ந்து end=” ” என்பதைப் பயன்படுத்தியிருக்கிறோம். மேலும் ஒரு வரிசையை அச்சிட்டதும் அடுத்த வரிசைக்கு நிரல் செல்வதற்காக ஏற்பாடு செய்யப்பட்டது தான் print().
இனி Dry Run அடிப்படையில் பரிசோதனை செய்து பார்ப்பதற்காக இரண்டு நிரல்கள்.
நிரல் 3:
நிரல் 4:
0
*
* * *
*
மேலே நான் போட்டிருக்கும் கோலத்திற்கு ஒரு நிரல் எழுதுங்களேன் பார்ப்போம்.
(தொடரும்)
