தமிழில் நிரல் எழுத – எழில் தமிழ் நிரலாக்க மொழி

அத்தியாயம் 1 : தமிழில் நிரல் எழுது தொகு

தமிழில் கணினி மென்பொருள் நிரல் (Computer Software Program) எழுதக் கற்றுக்கொள்ளவேண்டும் என்கின்ற ஆர்வத்துடன் இந்த "எழில்" தளத்துக்கு வருக. எழில், ஒரு தமிழ் நிரலாக்க மொழி; தமிழ் மாணவர்களுக்கு இது முதல் முறை கணிப்பொறி நிரல் எழுதுவதற்கு உதவும்.

எழில் (Ezhil), தமிழில் எழுதும்வகையில் உருவாக்கப்பட்டுள்ள நிரலாக்க மொழியாகும். இதில் தமிழ் கலைச் சொற்களைக் கொண்டே நிரல்கள் எழுத முடியும். இது இலவசமாகக் கிடைக்கக்கூடிய ஒரு நிரல் மொழியாகும். இம்மொழி இன்னோர் பிரபல மொழியாகிய பைத்தானு(Python)டன் ஒத்து இயங்கும்படி உருவாக்கப்பட்டுள்ளது. பைத்தானின் நிரலகங்களைப் பயன்படுத்தி இயங்கும் இந்த மொழியில், ஆங்கிலத்திலும் நிரல்களை எழுதமுடியும். தற்சமயம் சோதனை அடிப்படையில் வெளியிடப்பட்டுள்ள இந்த மொழி, விரைவில் முழுச் செயல்பாட்டுக்கு வரும் என எதிர்பார்க்கப்படுகிறது ^[1].

மேற்கோள் - ஆசிரியர் குறிப்பு தொகு

"தமிழில் நிரல் எழுது" (2013), முத்து அண்ணாமலை, என். சொக்கன், எழுதிய நூல் மூலத்தை கொண்டு இந்த விக்கீ நூல் உருவாக்கப்பட்டது.

அனைவருக்கும் வணக்கம். தமிழில் கணினி மென்பொருள் நிரல் (Computer Software Program) எழுதக் கற்றுக்கொள்ளவேண்டும் என்கின்ற ஆர்வத்துடன் இந்த "எழில்" தளத்துக்கு வந்திருக்கின்றீர்கள். உங்களுக்கு எங்கள் வாழ்த்துகள்! "எழில்"பற்றி மேலும் அறியுமுன்னர், நிரல் என்றால் என்ன, அதைக்கொண்டு நாம் என்ன செய்யமுடியும் என்று ஒரு சுருக்கமான அறிமுகத்தைத் தெரிந்துகொள்வது நல்லது.

ஆங்கிலத்தில் ‘கம்ப்யூட்டர்’ எனப்படும் கணினி ஓர் அற்புதமான சாதனம். ஆனால், அதற்குச் சுய அறிவு என்று எதுவும் கிடையாது. மனிதர்களாகிய நாம் சொல்வதைத் திரும்பச் செய்யும், அவ்வளவுதான்.

உங்கள் வீட்டில் ஒரு நாய்க்குட்டி இருப்பதாக வைத்துக்கொள்ளுங்கள். அதனிடம் ‘உட்கார்’ என்று சொன்னால் அது உட்காருகின்றது, ‘நில்’ என்று சொன்னால் அது நிற்கின்றது.

இங்கே ‘உட்கார்’, ‘நில்’ என்ற சொற்களை நாம் ‘கட்டளை’ என்று அழைக்கிறோம். நீங்கள் இடுகின்ற கட்டளைக்கு ஏற்ப அது செயல்படுகின்றது. அவ்வளவுதான்.

கணினியும் அப்படிதான், நீங்கள் தரும் கட்டளைக்கு ஏற்ப அது இயங்கும்.

ஒரே பிரச்னை, ‘உட்கார்’, ‘நில்’ போன்ற கட்டளைகள் அதற்குப் புரியாது. தெலுங்கு தெரிந்த ஒருவரிடம் நீங்கள் தமிழைத் தவிர்த்துத் தெலுங்கில் பேசுவதுபோல, கணினிக்குத் தெரிந்த மொழியில் பேசினால்தான் அதற்குப் புரியும்!

கணினிக்கு என்னென்ன மொழிகள் தெரியும்?

ஆங்கிலத்தில் இதற்கு ஏராளமான மொழிகள் உள்ளன. உலகெங்கும் லட்சக்கணக்கானோர் இதனைப் பயன்படுத்திக் கணினிக்குக் கட்டளையிடுகிறார்கள், கணினியும் அதன்படி செயல்படுகின்றது.

இந்தக் கட்டளைகளின் தொகுப்புதான், சாஃப்ட்வேர் ப்ரொக்ராம், அல்லது, மென்பொருள் நிரல்.

இப்போது, ஆங்கிலம் அறியாதவர்களும் கணினி நிரல் எழுதக் கற்கவேண்டும் என்ற எண்ணத்துடன், தமிழில் "எழில்" என்ற இந்த மொழி அறிமுகப்படுத்தப்படுகின்றது.

என்ன சொல்கிறீர்கள்? தமிழ் என்பதே ஒரு மொழிதானே, அப்படிப் பார்த்தால் "எழில்" என்பது இன்னொரு மொழியாகத்தானே இருக்கவேண்டும்?

உண்மைதான், தமிழ் என்கின்ற, உங்களுக்கு ஏற்கெனவே நன்றாகத் தெரிந்த மொழியில் உள்ள அதே சொற்களைப் பயன்படுத்தி உருவாக்கப்பட்ட இன்னொரு மொழிதான் "எழில்". இதை நீங்கள் காகிதத்திலும் எழுதலாம், கணினியிலும் எழுதலாம். அதன்மூலம் கணினியை உங்கள் விருப்பம்போல் இயக்கலாம்.

இந்தச் சிறு கையேட்டில், "எழில்" மொழியைப் பயன்படுத்துவதற்கான நுட்பங்களை உங்களுக்குச் சொல்லித்தரப்போகின்றோம். ஒவ்வொரு படியாக முன்னேறி, மிக விரைவில் "எழில்"மூலம் நினைத்ததையெல்லாம் செய்யத் தெரிந்துகொள்ளப்போகின்றீர்கள், கணினி உங்களுடைய அடிமையாகக் கை கட்டி நிற்கப்போகின்றது.

"எழில்" மொழியைக் கொண்டு நாம் என்னவெல்லாம் செய்யலாம்?

ஏராளமாகச் செய்யலாம். மொத்தத்தையும் இங்கே சொல்வது சாத்தியமில்லை, அவற்றை நீங்களே பயன்படுத்தித் தெரிந்துகொள்வதுதான் நன்றாக இருக்கும். என்றாலும், ஒரு சிறிய பட்டியல் இங்கே:

நீங்கள் விரும்பும் விஷயங்களைத் திரையில் அச்சிடலாம்
எளிய, சிக்கலான கணக்குகளைப் போடலாம்
தர்க்க அடிப்படையிலான (Logical) தீர்மாணங்களை எடுக்கலாம்
படம் வரையலாம்
ஒரே செயலை நூறு முறை, ஆயிரம் முறை, கோடி முறை திரும்பத் திரும்பச் செய்யலாம்
முக்கியமாக, இதன்மூலம் கற்றுக்கொண்ட விஷயங்களை அடிப்படையாக வைத்து, மற்ற கணினி மொழிகள், இதைவிடப் பெரிய, பயனுள்ளவற்றைத் தெரிந்துகொள்ளலாம்

உலகெங்கும் கணினி நிரல் எழுதத் தெரிந்தவர்களுக்கு நல்ல வேலை வாய்ப்புகள் உள்ளன. ஆனால் அதைவிடப் பெரிய விஷயம், நிரல் எழுதப் பழகுவதன்மூலம் உங்களுக்குத் தர்க்கரீதியிலான சிந்தனை நன்கு வளரும், அது உங்களது படிப்பிலும், மற்ற செயல்பாடுகளிலும் பிரதிபலிக்கும்.

வாருங்கள், "எழில்" உலகத்தினுள் செல்வோம். அது ஒரு பரவசமான பயணம்!

அதற்குமுன்னால், "எழில்" மொழிபற்றிய சில அடிப்படை விஷயங்களைத் தெரிந்துகொண்டுவிடுவது நல்லது.

எழில் என்பது, தமிழில் உருவாக்கப்பட்ட கணினி நிரல் மொழி. மிகவும் எளிமையானது, திறமூல(Open Source) அடிப்படையில் வெளியிடப்படுவது.

இதன் நோக்கம், தமிழைத் தாய்மொழியாகக் கொண்ட மாணவர்கள் சுலபமாகக் கணினி நிரல் எழுதக் கற்பிப்பது. இதைக் கொண்டு அவர்கள் தர்க்கரீதியில் சிந்திப்பது, கணக்குகள் போடுவது, கணினியியலை கற்பது போன்றவற்றை ஆங்கிலத்தின் துணை இன்றியே அறியமுடியும்.

எழில் நிரல் மொழியில், தமிழ்ச் சொற்களும், இலக்கணமும் மிக எளிமையாக அமைக்கப்பட்டுள்ளன. அதேசமயம் மற்ற நவீன கணினி நிரல் மொழிகளில் (ஆங்கிலம் அடிப்படையிலானவை) உள்ள எல்லா வசதிகளும் இதிலும் உள்ளன.

பயனுள்ள இந்த எழில் கணினி நிரல் மொழி, இலவசமாகவே வழங்கப்படுகிறது. 2007ம் ஆண்டுமுதல் உருவாகிவரும் இந்த மொழி, 2009ம் ஆண்டு முறைப்படி வெளியானது.

எழில் மொழியில் நிரல் எழுதுவதற்கான வழிமுறைகள், கிட்டத்தட்ட BASIC கணினி மொழியைப்போலவே அமைந்திருக்கும். நீங்கள் எழுதும் நிரல்கள் ஒன்றபின் ஒன்றாக வரிசையாக இயக்கப்படும். அல்லது, Functions எனப்படும் ‘நிரல் பாக’ங்களை நீங்கள் பயன்படுத்தலாம்.

இந்த மொழியில் எண்கள், எழுத்துச் சரங்கள், தர்க்கக் குறியீடுகள், பட்டியல்கள் போன்ற வகைகள் உள்ளன. நீங்கள் பயன்படுத்தும் மாறி(Variable)களைத் தனியே அறிவிக்க(Declaration)த் தேவையில்லை. அவைகளை நேரடியாக நிரலில் பயன்படுத்தத் தொடங்கலாம்.

அதேசமயம், ஒரு வகை மாறியை இன்னொரு வகை மாறியாக மாற்றுவது என்றால், அதற்கு உரியக் குறிச்சொற்களைப் பயன்படுத்தவேண்டும்.

எழில் மொழியின் நோக்கங்கள்:

கல்வி : ஒன்றாம் வகுப்பு முதல் 12ம் வகுப்புவரை பயிலும் மாணவர்கள் இதனைப் பயன்படுத்தி அடிப்படைக் கணினியியல், நிரல் எழுதுதல்பற்றி அறியலாம்
இயல்பானது : எழில் மொழியின் இலக்கணம், தமிழின் எழுத்து இலக்கணத்தை ஒட்டியே அமைக்கப்பட்டுள்ளது. ஆகவே, தமிழில் பேசுகின்ற, எழுதுகின்ற எவரும் இதனைச் சுலபமாக அறிந்துகொண்டு பின்பற்றலாம்

இதில் உள்ள வசதிகள்:

கணிதமும் தர்க்கரீதியிலான குறியீடுகளும் உள்ளன
முந்நூற்றைம்பதுக்கும் மேற்பட்ட நிரல் பாகங்கள் இதில் ஏற்கெனவே சேர்க்கப்பட்டுள்ளன
இவைதவிர, நீங்களே புதிய நிரல் பாகங்களை எழுதிச் சேர்க்கலாம்
Notepad++ , Emacs ஆகியவற்றை பயன்படுத்துகின்றவர்கள், தங்களது நிரல்களுக்கு ஏற்ற வண்ணக் குறியீடுகளை அமைத்துக்கொள்ளும் வசதி இந்த எழில் மொழியில் உண்டு

குறிச்சொற்கள்:

எழில் மொழியில் நிரல் எழுதுவதற்கென ஏராளமான குறிச் சொற்கள் உள்ளன. இவற்றை நாம் அடுத்தடுத்த அத்தியாயங்களில் விளக்கமாகப் பார்க்கவிருக்கிறோம்.

இப்போதைக்கு, எழில் மொழியில் உள்ள முக்கியமான குறிச் சொற்களின் பட்டியலையும், அதற்கு இணையான ஆங்கிலச் சொற்களையும் இங்கே பார்த்துவிடுவோம்:

ஆக : for
நிறுத்து : break
தொடர் : continue
பின்கொடு : return
ஆனால் : if
இல்லைஆனால் : elseif
இல்லை : else
தேர்ந்தெடு : select
தேர்வு : case
ஏதேனில் : otherwise
வரை: while
செய் : do
முடியேனில் : until
பதிப்பி : print
நிரல்பாகம் : function
முடி : end

அத்தியாயம் 2 : எழில் ஒரு அறிமுகம் தொகு

இப்போது, "எழில்" மொழியைக் கொண்டு தமிழிலேயே கணினி நிரல், அதாவது Software Program எப்படி எழுதுவது என்று கற்றுக்கொள்வோம்.

அதற்குமுன்னால், நீங்கள் ஏற்கெனவே "எழில்" மொழியைப் பயன்படுத்துவதற்கான மென்பொருளை (Software) இணையத்திலிருந்து பதிவிறக்கம் செய்துவிட்டீர்கள் (Downloaded), உங்கள் கணினியில் அதை நிறுவிவிட்டீர்கள் (Installed) என நம்புகின்றேன். ஒருவேளை நீங்கள் அதைச் செய்யவில்லை என்றால், உடனடியாக http://ezhillang.org/ என்ற இணைய தளத்துக்குச் செல்லுங்கள், அங்கே தரப்பட்டுள்ள உதவிக் குறிப்புகளின் அடிப்படையில் உங்கள் கணினியை "எழில்" மயமாக்குங்கள்!

அடுத்து, நாம் நிரல் எழுதத் தொடங்கவேண்டும். ஆனால், எங்கே?

இதற்கு நாம் Interpreter என்ற பகுதியைத் தொடங்கவேண்டும். அதாவது, உங்களது நிரலை வாசித்து, அதைச் செயல்படுத்தி விடைகளைத் திரையில் காட்டுகின்ற பகுதி. நம் வசதிக்காக, இதனை "நிரல் மேசை" என அழைப்போம்!

உங்களது எழில் கணினித் திரையில் "ez" என்று தட்டச்சு செய்யுங்கள். விசைப்பலகையில் உள்ள "Enter" விசையைத் தட்டுங்கள்.

உடனே, உங்கள் திரையில் Interpreter, அதாவது நிரல் மேசை தோன்றும். இதில்தான் நாம் நம்முடைய நிரல்களை எழுதப்போகின்றோம்***

இப்போது, ஒரு மிக எளிய நிரல் எழுதுவோம். இதன் பெயர், ‘வணக்கம்’.

அதாவது, உங்கள் கணினி உங்களுக்கு வணக்கம் சொல்லப்போகின்றது. அதற்கு நீங்கள் பிறப்பிக்கவேண்டிய கட்டளை இது:

#*************************************
பதிப்பி "வணக்கம் தமிழ்நாடு!"
#*************************************

இந்தக் கட்டளையை நீங்கள் தட்டச்சு செய்து, "Enter" என்ற விசையைத் தட்டுங்கள்.

மறுவிநாடி, உங்கள் திரையில் "வணக்கம் தமிழகம்!" என்ற எழுத்துகள் தோன்றும்.

வாழ்த்துக்கள்! நீங்கள் உங்களுடைய முதல் நிரலை எழுதிவிட்டீர்கள்!

இது மிக எளிமையான நிரல்தான். இன்னும் சிக்கலான, பயனுள்ள பல செயல்களைச் செய்யக்கூடிய நிரல்களை அடுத்தடுத்து எழுதப்போகின்றீர்கள்.

அதற்குமுன்னால், நாம் தொடங்கிய நிரல் மேசையை எப்படி மூடிவைப்பது என்று தெரிந்துகொள்ளவேண்டும். அதற்கு நீங்கள் பயன்படுத்தவேண்டிய கட்டளைச் சொல் exit()

இதைத் தட்டச்சு செய்து "Enter" பொத்தானை அழுத்தியதும், நிரல் மேசைத் திரை காணாமல் போய்விடும்.

பிறகு, நமக்கு வேண்டியபோது ez என்று தட்டச்சு செய்து மீண்டும் "Enter" பொத்தானை அழுத்தினால் போதும், மீண்டும் நிரல் மேசை தோன்றும், அடுத்த நிரலை எழுதத் தொடங்கலாம்.

இப்படி ஒவ்வொருமுறையும் நிரல் மேசையைத் தொடங்கி, மீண்டும் மூடிவைப்பது சிரமமாக இருந்தால், இன்னோர் எளிய வழி இருக்கிறது, நீங்கள் வழக்கமாக இணையத்தை அணுகப் பயன்படுத்தும் Internet Browser-ல் ‘எழில்’ மொழி நிரல்களை எழுதலாம். இதோ இப்படி:

முதலில், முன்புபோலவே நிரல் மேசையைத் தொடங்கிக்கொள்ளுங்கள்
அதில் இப்படி தட்டச்சு செய்யுங்கள்: python ezhil/EZWeb.py
சில விநாடிகள் கழித்து, உங்கள் திரையில் ‘Server Starts - localhost:8080’ என்ற செய்தி தோன்றிடும்
இப்போது, உங்கள் கணினியில் ’எழில்’ மொழி நிறுவப்பட்டிருக்கும் இடத்துக்கு (Folder) செல்லுங்கள், அங்கே ‘Web' என்ற பகுதியைத் திறந்துகொள்ளுங்கள்
அதற்குள் ‘ezhil_on_the_web.html' என்ற கோப்பு இருக்கும், அதனைத் திறக்கவும்.
அவ்வளவுதான், இனிமேல் நீங்கள் உங்கள் Internet Browserன் திரையிலேயே ‘எழில்’ நிரல்களை எழுதலாம், இயக்கலாம், விடையைப் பார்க்கலாம்!

ஒரு விஷயம், Browserமூலம் இயங்கும் இந்த “எழில்” வடிவத்தில் சில குறிப்பிட்ட வசதிகள் இல்லை, உதாரணமாக, கணினியைப் பயன்படுத்துகின்றவரிடம் ஓர் எண்ணையோ, எழுத்தையோ கோரிப் பெறமுடியாது, படம் வரையமுடியாது.

ஆகவே, இந்தப் புத்தகத்தில் உள்ள சில நிரல்களை நீங்கள் அதில் இயக்கமுடியாமல் போகலாம், அப்போது, நாம் முன்பு பார்த்துள்ள நிரல் மேசையைப் பயன்படுத்திக்கொள்ளுங்கள்.

இப்போது, "எழில்" மொழியைப் பயன்படுத்திச் சில எளிய கணக்குகளைப் போடுவோம்.

முதலில், நாம் ஏற்கெனவே பார்த்த முறைப்படி உங்கள் நிரல் மேசையைத் திறந்துகொள்ளுங்கள். அதில் கீழே உள்ள வரியைத் தட்டச்சு செய்து "Enter" பொத்தானை அழுத்துங்கள்

#*************************************
பதிப்பி 10+15
#*************************************

இப்போது உங்கள் திரையில் 25 என்ற எண் தோன்றும். அதாவது, 10, 15 ஆகியவற்றின் கூட்டுத் தொகை.

இதேபோல், நாம் கழித்தல், பெருக்கல், வகுத்தல் ஆகியவற்றையும் செய்யலாம். இப்படி:

#*************************************
பதிப்பி 30-5
பதிப்பி 5*5
பதிப்பி 25/5
#*************************************

இன்னும் கொஞ்சம் பெரிய கணக்கு, இருபத்தைந்தின் இரண்டடுக்கு , அதாவது 25 * 25 எப்படிக் கணக்கிடுவீர்கள்? இதோ, இப்படிதான்:

#*************************************
பதிப்பி 25^2
#*************************************

இந்தக் கணக்குகளை நாம் தனித்தனியே போடவேண்டும் என்று அவசியம் இல்லை, பலவற்றைத் தொகுத்து ஒரே வரியில்கூட எழுதலாம். இப்படி:

#*************************************
பதிப்பி (((5+(25^2))/6)^2)
#*************************************

இங்கே நீங்கள் அடைப்புக்குறிக்குள் தந்துள்ள வரிசைப்படி "எழில்" ஒவ்வொரு கணக்காகப் போடும், நிறைவாக சரியான விடையைச் சொல்லிவிடும்.

உங்களுடைய கணக்கு வகுப்பில் "பை" என்ற முக்கியமான எண்ணைப்பற்றிப் படித்திருப்பீர்கள். 3.14 என்று தொடங்கும் அந்தப் பயனுள்ள எண்ணை உங்களது "எழில்" கணக்குகளில் பயன்படுத்தவேண்டுமானால், இப்படி எழுதவேண்டும்:

#*************************************
பதிப்பி  pi()
#*************************************

இதேபோல், Sin, Cos, Tan, Log போன்றவற்றையும் "எழில்" கணக்குகளில் கொண்டுவரலாம். இப்படி:

#*************************************
radian = pi()/180
பதிப்பி sin(30*radian)
பதிப்பி tan(60*radian)
பதிப்பி log(100*radian)
#*************************************

ஆனால், இவையெல்லாம் நாமே தட்டச்சு செய்கிற கணக்குகள். கொஞ்சம் வித்தியாசமாக, நாம் கேட்கிற கணக்குகளைக் கணினியே போட்டுப் பதில் தரும்படி மாற்றமுடியாதா?

நிச்சயமாகச் செய்யலாம், அதுதான் நம்முடைய அடுத்த பணி!

இதுவரை, நாம் தட்டச்சு செய்த விஷயங்களை "எழில்" மொழி அப்படியே நிறைவேற்றிக்கொண்டிருந்தது. இப்போது, அது கேட்கும் கேள்விக்கு நாம் பதில் சொல்லப்போகிறோம்.

இதற்கு நாம் "உள்ளீடு" என்ற கட்டளையைப் பயன்படுத்தவேண்டும். இதுபோல:

#*************************************
முதல்எண் = உள்ளீடு("ஓர் எண்ணைச் சொல்லுங்கள்: ")
#*************************************

இந்தக் கட்டளையை நிறைவேற்றினால், உங்கள் கணினித் திரையில் "ஓர் எண்ணைச் சொல்லுங்கள்: " என்ற எழுத்துகள் தோன்றும். நீங்கள் ஏதாவது ஓர் எண்ணைத் தட்டச்சு செய்து "Enter" பொத்தானை அழுத்தவேண்டும்.

உடனே, நீங்கள் தட்டச்சு செய்த எண் கணினியால் பெறப்பட்டு, "முதல்எண்" என்ற பெயரில் சேமிக்கப்பட்டுவிடும்.

இப்போது, இரண்டாவதாக இன்னோர் எண்ணையும் உள்ளீடு செய்வோம். இப்படி:

#*************************************
இரண்டாம்எண் = உள்ளீடு("இன்னோர் எண்ணைச் சொல்லுங்கள்: ")
#*************************************

இந்தக் கட்டளை நிறைவேறியதும், நீங்கள் இன்னோர் எண்ணைத் தட்டச்சு செய்யவேண்டும். அது "இரண்டாம்எண்" என்ற பெயரில் சேமிக்கப்பட்டுவிடும்.

இப்போது, இந்த இரண்டு எண்களையும் கூட்டி, "மூன்றாம்எண்" என்ற பெயரில் சேமிப்போம். இது உங்களுக்கு ஏற்கெனவே நன்றாகத் தெரிந்த விஷயம்தானே:

#*************************************
மூன்றாம்எண் = முதல்எண் + இரண்டாம்எண்
#*************************************

நிறைவாக, இந்த விடையை அச்சிடுவோம், இதோ இப்படி:

#*************************************
பதிப்பி "நீங்கள் தந்த எண்களின் கூட்டுத் தொகை: " மூன்றாம்எண்
#*************************************

அவ்வளவுதான். இப்போது, இந்த நிரலை இயக்கிப் பார்ப்போம்.

See : simple_add.n
#*************************************
ஓர் எண்ணைச் சொல்லுங்கள்: 6
இன்னோர் எண்ணைச் சொல்லுங்கள்: 7
நீங்கள் தந்த எண்களின் கூட்டுத் தொகை: , 13
#*************************************
ஓர் எண்ணைச் சொல்லுங்கள்: 10
இன்னோர் எண்ணைச் சொல்லுங்கள்: 5
நீங்கள் தந்த எண்களின் கூட்டுத் தொகை: 15
#*************************************

அருமை! "எழில்" மொழியைப் பயன்படுத்தி ஓர் உபயோகமான நிரல் எழுதிவிட்டீர்கள்!

இப்போது, உங்களுக்கு ஒரு பயிற்சி.

ஒரு கடையில் ஏராளமான நபர்கள் வந்து காய்கறி, பழம், ரொட்டி வாங்கிச் செல்கின்றார்கள். இவற்றின் விலைகளை நீங்கள் தனித்தனியே பெற்று, மொத்தக் கூட்டுத் தொகை எவ்வளவு என்று சொல்லவேண்டும். பின்னர், அவர்கள் தரும் தொகை எவ்வளவு என்று பார்த்து, மீதி சில்லறை எவ்வளவு என்றும் சொல்லவேண்டும்.

இதுவரை நீங்கள் கற்றுக்கொண்ட விஷயங்களை வைத்து அதற்கு ஒரு நிரல் எழுதுங்கள் பார்க்கலாம்!

விடை:

#*************************************
காய்கறி = உள்ளீடு("காய்கறி வாங்கிய தொகை எவ்வளவு? ")
பழம் = உள்ளீடு("பழம் வாங்கிய தொகை எவ்வளவு? ")
ரொட்டி = உள்ளீடு("ரொட்டி வாங்கிய தொகை எவ்வளவு? ")

மொத்தத்தொகை = காய்கறி + பழம் + ரொட்டி

பதிப்பி "நீங்கள் தரவேண்டிய ரூபாய் " மொத்தத்தொகை

தரும்தொகை = உள்ளீடு("நீங்கள் தரும் தொகை எவ்வளவு? ")

மீதித்தொகை = தரும்தொகை - மொத்தத்தொகை

பதிப்பி "நன்றி. மீதி சில்லறையைப் பெற்றுக்கொள்ளுங்கள்: ரூபாய் " மீதித்தொகை
#*************************************

அத்தியாயம் 3 : எழில் கணினியுடன் ஒரு உரையாடல் தொகு

சென்ற அத்தியாயத்தில் "எழில்" மொழியைப் பயன்படுத்தி எண்களோடு விளையாடினோம், இப்போது எழுத்துகள், சொற்கள், சொற்றொடர்களுடன் விளையாடப் பழகுவோம்.

"க" என்பது ஒரு தனி எழுத்து, "ல்" என்பது இன்னொரு தனி எழுத்து, அவை சேர்ந்து "கல்" என்ற சொல் உருவாகின்றது. இப்படிப் பல சொற்கள் சேர்ந்து ஒரு சொற்றொடராகும், இப்படி: "கல்லும் மண்ணும் சேர்ந்து கட்டிய வீடு."

இவை அனைத்தையும் நாம் "சரங்கள்" என்று அழைக்கலாம். ஒரு சரம் என்பது தனி எழுத்தாகவோ, சொற்களாகவோ, சொற்றொடராகவோ இருக்கலாம்.

உதாரணமாக, "நீ" என்பது ஒரு சரம், "நீர்" என்பது இன்னொரு சரம், "நீர் தருகிறேன்" என்பது இன்னொரு சரம். இப்படி சொல்லிக்கொண்டே போகலாம்.

எழில் மொழியில், இந்தச் சரங்களை வைத்து என்னவெல்லாம் செய்யமுடியும்?

முதலில், ஒரு சரத்தின் நீளத்தைக் கண்டுபிடிப்போம். அதற்கு ஓர் எளிய நிரல் எழுதுவோம்.

#*************************************
அ = உள்ளீடு("உங்களுக்குப் பிடித்த ஏதாவது ஓர் எழுத்துச் சரத்தைத் தாருங்கள்: ")

பதிப்பி "நீங்கள் தந்த சரம்: " அ
பதிப்பி "அந்தச் சரத்தின் நீளம்: " நீளம்(அ)
#*************************************

இந்த நிரலை மேலோட்டமாகப் படித்தாலே உங்களுக்கு நன்றாகப் புரியும். நீங்கள் தரப்போகும் கணினியை "எழில்" மொழி வாங்கி, "அ" என்ற பெயரில் சேமிக்கிறது, பின்னர் அதன் நீளத்தைக் கணக்கிட்டு அச்சிடுகிறது.

இப்போது, நாம் எழுதிய நிரலை இயக்கிப் பார்ப்போம்:

#*************************************
உங்களுக்குப் பிடித்த ஏதாவது ஓர் எழுத்துச் சரத்தைத் தாருங்கள்: என் பெயர் எழில்
நீங்கள் தந்த சரம்: என் பெயர் எழில்
அந்தச் சரத்தின் நீளம்: 10
#*************************************

அடுத்து, இரண்டு எழுத்துச் சரங்களை ஒட்டவைப்பது எப்படி என்று பார்க்கலாம்.

இதற்கு, நீங்கள் எண்களைக் கூட்டுவதற்குப் பயன்படுத்திய "+" என்ற கூட்டலகுறியீட்டைப் பயன்படுத்தலாம். இதோ இப்படி: ்

#*************************************
அ = "தமிழ்"
ஆ = "அமுது"
இ = அ + ஆ

பதிப்பி அ
பதிப்பி ஆ
பதிப்பி இ
#*************************************

இந்த நிரல், "தமிழ்" , "அமுது" ஆகிய இரு எழுத்துச் சரங்களை ஒட்டவைத்துக் காண்பிக்கிறது. அதனை இயக்கினால், "தமிழ்அமுது" என்று அச்சிடும்.

இப்போது, உங்களுக்கு ஒரு பயிற்சி, "தமிழ்அமுது" என்ற சொல் பார்ப்பதற்கு நன்றாக இல்லையே, இந்த நிரலைக் கொஞ்சம் மாற்றி, இரு சொற்களுக்கும் நடுவில் ஓர் இடைவெளி விட்டு "தமிழ் அமுது" என்று அச்சிடும்படி செய்யுங்கள், பார்க்கலாம்!

விடை:

#*************************************
அ = "தமிழ்"
ஆ = " "
இ = "அமுது"
ஈ = அ + ஆ + இ

பதிப்பி ஈ
#*************************************

அடுத்த பயிற்சி. இதுவரை நீங்கள் கற்றுக்கொண்ட செய்திகளையெல்லாம் வைத்து, கீழே தரப்பட்டுள்ள தேவைக்கேற்ப ஒரு நிரல் எழுதுங்கள்:

உங்கள் கணினி இரண்டு எழுத்துச் சரங்களைக் கேட்டுப் பெறவேண்டும்
அந்த இரண்டையும் ஒட்டவைத்து மூன்றாவதாக ஒரு சரத்தை உருவாக்கவேண்டும்
இந்த மூன்றாவது சரத்தின் நீளத்தைத் திரையில் அச்சிடவேண்டும்

விடை:

#*************************************
முதல்சரம் = உள்ளீடு("ஒரு சொல்லைக்கூறுங்கள்: ")
இரண்டாம்சரம் = உள்ளீடு("இன்னொருசொல்லைக்குறுங்கள்: ")

மூன்றாம்சரம் = முதல்சரம் + இரண்டாம்சரம்

சரநீளம் = நீளம்(மூன்றாம்சரம்)

பதிப்பி "நீங்கள் தந்த இரு சரங்களில் உள்ள மொத்த எழுத்துகள் " சரநீளம்
#*************************************

அடுத்து, ஒரு ஜாலியான விளையாட்டு, ஒரு சரத்துக்குள் நாம் விரும்புகின்ற எழுத்துகள் எங்கே இருக்கின்றன என்று கொஞ்சம் தேடிக் கண்டுபிடிக்கலாமா?

இதற்கு, "சரம்_கண்டுபிடி" என்ற கட்டளை வார்த்தையைப் பயன்படுத்தவேண்டும். இதோ இப்படி:

#*************************************
முக்கனிகள் = "மா, பலா, வாழை"

பதிப்பி "முக்கனிகள் : " முக்கனிகள்
பதிப்பி சரம்_கண்டுபிடி(முக்கனிகள், "வாழை")
பதிப்பி சரம்_கண்டுபிடி(முக்கனிகள், "தேங்காய்")
#*************************************

மா, பலா, வாழை என்ற முக்கனிகளில், வாழை உள்ளது, ஆகவே, வாழையைத் தேடும்போது பூஜ்ஜியத்துக்கு மேற்பட்ட ஓர் எண் விடையாகக் கிடைக்கும்.

ஆனால், அந்த முக்கனிகளின் பட்டியலில் தேங்காய் இல்லை. ஆகவே, அதனைத் தேடும்போது பூஜ்ஜியத்தைவிடக் குறைவான (-1) விடை உங்களுக்குக் கிடைக்கும். இதுவே "சரம்_கண்டுபிடி" கட்டளையின் பயன்.

அடுத்து, முக்கனிகளைக் கொஞ்சம் மாற்றம் செய்வோமா? எனக்கு வாழை பிடிக்காது, அதற்குப் பதிலாகக் கொய்யாவைச் சேர்த்து விளையாடுவோம். இதோ இப்படி:

#*************************************
முக்கனிகள் = "மா, பலா, வாழை"

பதிப்பி "பழைய முக்கனிகள் : " முக்கனிகள்

முக்கனிகள் = சரம்_இடமாற்று(முக்கனிகள், "வாழை", "கொய்யா")

பதிப்பி "புதிய முக்கனிகள் : " முக்கனிகள்
#*************************************

இங்கே "சரம்_இடமாற்று" என்ற கட்டளை "வாழை"யைத் தூக்கி எறிந்துவிட்டு, அந்த இடத்தில் "கொய்யா"வை உள்ளே நுழைத்துவிட்டது. இதனை இயக்கினால், கீழ்க்காணும் விடை கிடைக்கும்:

*************************************
பழைய முக்கனிகள் : மா, பலா, வாழை
புதிய முக்கனிகள் : மா, பலா, கொய்யா
*************************************

இப்படி ஒவ்வொரு பழமாகப் பார்த்துப் பார்த்து மாற்றிக்கொண்டிருப்பது சிரமம். இதையே இன்னும் சுலபமாகச் செய்ய ஏதேனும் வழி உண்டா?

அதற்கு நீங்கள் "பட்டியல்" என்ற கட்டளையைப் பயன்படுத்தவேண்டும்.

வகுப்பில் உங்கள் ஆசிரியர் சொல்லும் செய்திகளை ஒன்றன்கீழ் ஒன்றாகப் பட்டியல் இடுகின்றீர்கள் அல்லவா? அதுபோல, பழங்களை வரிசையாக அடுக்கிவைக்கப் பட்டியலைப் பயன்படுத்தலாம்.

முதலில், ஒரு காலிப் பட்டியலைத் தயாரிப்போம். இதோ, இப்படி:

#*************************************
பழங்கள் = பட்டியல்()
#*************************************

அடுத்து, இந்தப் பட்டியலில் பழங்களைச் சேர்ப்போம், அதற்கு "பின்இணை" என்ற கட்டளையைப் பயன்படுத்தவேண்டும்:

#*************************************
பின்இணை(பழங்கள், "மா")
பின்இணை(பழங்கள், "பலா")
பின்இணை(பழங்கள், "வாழை")
பின்இணை(பழங்கள், "கொய்யா")
பின்இணை(பழங்கள், "ஆப்பிள்")
#*************************************

ஆக, இப்போது நம் பட்டியலில் ஐந்து பழங்கள் உள்ளன. அவற்றுக்குத் தனித்தனியே எண்கள் தருவோமா?

ஒரு செய்தி, பட்டியலின் எண்கள் 1, 2, 3 என அமையாது, பூஜ்ஜியத்திலிருந்து தொடங்கும், அதாவது, 0, 1, 2... இப்படி.

0 மா
1 பலா
2 வாழை
3 கொய்யா
4 ஆப்பிள்

இப்போது, நாம் ஒரு குறிப்பிட்ட பழத்தை அச்சிடவேண்டுமென்றால், "எடு" என்ற கட்டளையைப் பயன்படுத்தவேண்டும். உதாரணமாக, இந்த வரியைப் பாருங்கள்:

#*************************************
எடு(பழங்கள், 1)
#*************************************

இந்த நிரல் இயங்கினால், "பலா" என்று அச்சிடும். காரணம், அந்தப் பட்டியலில் 1 என்ற எண்ணுக்கு நேராக அந்தப் பழம்தான் பதிவாகியுள்ளது.

அடுத்தபடியாக, இந்தப் பட்டியலில் உள்ள பழங்களை அகர வரிசைப்படி அடுக்குவோமா? அதற்கு நாம் "வரிசைப்படுத்து" என்ற கட்டளையைப் பயன்படுத்தவேண்டும். இதோ, இப்படி:

#*************************************
வரிசைப்படுத்து(பழங்கள்)
#*************************************

இந்தக் கட்டளை, பழங்களை அகர வரிசைப்படி மாற்றும். அதாவது, முதலில் ஆப்பிள், அடுத்து கொய்யா, பலா, மா, அதன்பிறகு வாழை.

இப்போது, முன்பு நாம் இயக்கிய பழைய கட்டளையை மீண்டும் இயக்குவோம்:

#*************************************
எடு(பழங்கள், 1)
#*************************************

ஆனால் விடை, பலா இல்லை, கொய்யா! காரணம், நாம் பழங்களை அகர வரிசைப்படி அடுக்கியதுதான்!

இப்போது, உங்களுக்கு ஒரு பயிற்சி, மூன்று நண்பர்களுடைய பெயரைப் ஒரு பட்டியலில் சேர்த்து, அகர வரிசைப்படி அவர்கள் ஒவ்வொருவருக்கும் வணக்கம் சொல்லி அச்சிடுங்கள். உதாரணமாக, வணக்கம் கணேஷ், வணக்கம் ரமேஷ்... இப்படி.

விடை:

#*************************************
நண்பர்கள் = பட்டியல்()

பின்இணை(நண்பர்கள், "கணேஷ்")
பின்இணை(நண்பர்கள், "ரமேஷ்")
பின்இணை(நண்பர்கள், "மகேஷ்")

வரிசைப்படுத்து(நண்பர்கள்)

அ = "வணக்கம் "

பதிப்பி அ + எடு(நண்பர்கள், 0)
பதிப்பி அ + எடு(நண்பர்கள், 1)
பதிப்பி அ + எடு(நண்பர்கள், 2)
#*************************************

அத்தியாயம் 4 : எழில் நிபந்தனைகள் தொகு

இதுவரை, நாம் எழுதிய நிரல் வகைகள் அனைத்தும், நேர் கோட்டில் செல்பவை. அதாவது, ஒரு வரிக்குப்பிறகு அடுத்த வரி, பின்னர் இன்னொரு வரி... இப்படி.

அவ்வாறில்லாமல், சில காரணிகளுக்கேற்ப ஒரே நிரலை வெவ்வேறுவிதமாக மாற்றி இயங்கச் செய்ய முடியுமா?

தாராளமாகச் செய்யலாம், இதற்கு நாம் தர்க்கக் குறியீடுகளைப் பயன்படுத்தவேண்டும்.

உதாரணமாக, நீங்கள் வீட்டுப்பாடம் எழுதி முடித்தால், விளையாடச் செல்லலாம் என்று உங்கள் தாய் கூறுகிறார். இதனைத் தர்க்கக் குறியீடுகளின்படி எப்படி எழுதுவது?

வீட்டுப்பாடம் எழுதி முடித்துவிட்டாயா?
ஆம் எனில் ... விளையாடலாம்
இல்லை எனில் ... விளையாடக்கூடாது

இதே செய்தியை "எழில்" மொழியில் ஒரு நிரலாக எழுதிப் பார்ப்போமா? இதோ, இப்படி:

#*************************************
அ = உள்ளீடு("வீட்டுப்பாடம் எழுதிவிட்டாயா? ")

@(அ == "ஆமாம்") ஆனால்
	பதிப்பி "விளையாடச் செல்லலாம்"
இல்லை
	பதிப்பி "வீட்டுப்பாடம் எழுதியபிறகுதான் விளையாடவேண்டும்!"
முடி
#*************************************

இங்கே நாம் பயன்படுத்தியிருக்கும் தர்க்கக் குறியீடு, இப்படி அமைகிறது:

முதலில் "@" என்ற சிறப்பு எழுத்து
அடுத்து, அடைப்புக்குறிக்குள் நாம் ஒப்பிடவிரும்பும் செய்தி (அ = "ஆமாம்")
அடுத்து, "ஆனால்" என்கிற சொல்
அடுத்த வரியில், அந்த ஒப்பீடு உண்மை எனில், நாம் செய்ய விரும்பும் செயல், இங்கே நாம் ஒன்று அல்லது அதற்கு மேற்பட்ட செயல்களை வெவ்வேறு வரிகளில் தரலாம்
அடுத்து "இல்லை" என்கிற சொல்
அடுத்த வரியில், அந்த ஒப்பீடு பொய் எனில், நாம் செய்ய விரும்பும் செயல், இங்கேயும் நாம் ஒன்று அல்லது அதற்கு மேற்பட்ட செயல்களை வெவ்வேறு வரிகளில் தரலாம்
நிறைவாக "முடி" என்கிற சொல், நாம் செய்யும் தர்க்கரீதியிலான பணிகளை நிறைவு செய்கின்றது

இதைப் புரிந்துகொள்வதற்கு, இன்னோர் எளிய உதாரணம் பார்ப்போம்:

#*************************************
வயது = உள்ளீடு("உங்கள் வயது என்ன? ")

@(வயது > 18) ஆனால்
	பதிப்பி "நீங்கள் தேர்தலில் வாக்களிக்கலாம்"
	பதிப்பி "நீங்கள் வாகனம் ஓட்டலாம்"
இல்லை
	பதிப்பி "நீங்கள் தேர்தலில் வாக்களிக்க இயலாது"
	பதிப்பி "நீங்கள் வாகனம் ஓட்ட இயலாது"
முடி
#*************************************

இதையே கொஞ்சம் விரிவுபடுத்தி, ஒரு சிறிய விநாடி வினா நிகழ்ச்சி நடத்துவோமா?

#*************************************
பதிப்பி "இந்தியாவின் தலைநகரம் எது?"
பதிப்பி "அ. சென்னை"
பதிப்பி "ஆ. மதுரை"
பதிப்பி "இ. டெல்லி"
பதிப்பி "ஈ. மும்பை"

சரியானவிடை = "இ"
உங்கள்விடை = உள்ளீடு("உங்களுடைய பதில் என்ன? ")

@(சரியானவிடை == உங்கள்விடை) ஆனால்
	பதிப்பி "வாழ்த்துகள். உங்களுக்கு 10 மதிப்பெண்கள்!"
இல்லை
	பதிப்பி "தவறான விடை. மீண்டும் முயற்சி செய்யுங்கள்!"
முடி
#*************************************

சில நேரங்களில், ஒரு தர்க்க ஒப்பீட்டுக்குள் இன்னொரு தர்க்க ஒப்பீடும் வரலாம், அப்போது @, ஆனால், இல்லை, முடி ஆகிய நான்கு சொற்களையும் முழுமையாக, அடுத்தடுத்து வரும் ஒரே தொகுப்பாக (Block) ஒன்றுக்குள் இன்னொன்றை அமைத்துப் பயன்படுத்தவேண்டும். கிட்டத்தட்ட உங்கள் கணிதப் பாடத்தில் வரும் அடைப்புக்குறிகளைப்போல என்று வைத்துக்கொள்ளுங்களேன்!

உதாரணமாக, இந்த நிரலைப் பாருங்கள்:

#*************************************
அ = உள்ளீடு("ஓர் எண்ணைச் சொல்லுங்கள் ")
ஆ = உள்ளீடு("இன்னோர் எண்ணைச் சொல்லுங்கள் ")

@(அ == ஆ) ஆனால்
	பதிப்பி "இரு எண்களும் சமம்!"
இல்லை
	@(அ > ஆ) ஆனால்
		பதிப்பி "முதல் எண் பெரியது!"	
	இல்லை
		பதிப்பி "இரண்டாம் எண் பெரியது!"
	முடி
முடி
#*************************************

இதுவரை நாம் பார்த்த நிரல்களோடு ஒப்பிடுகையில், இது கொஞ்சம் பெரியதாக உள்ளது. பின்னர் இன்னொருநாள் வேறொருவரோ (அல்லது நாமேகூட) இதனைப் படித்தால் நமக்குப் புரியுமோ, புரியாதோ!

ஆகவே, நிரல் எழுதும்போதே, அதற்கான விளக்கங்களையும் ஆங்காங்கே எழுதிவிடுவது நல்லது. இதற்கு நீங்கள் "##" என்ற சின்னத்தைப் பயன்படுத்தவேண்டும். இதோ இப்படி:

#*************************************
## இந்த நிரலை எழுதியவர்: சந்திரசேகரன்

## முதல் எண்ணை உள்ளிடுதல்

அ = உள்ளீடு("ஓர் எண்ணைச் சொல்லுங்கள் ")

## இரண்டாவது எண்ணை உள்ளிடுதல்

ஆ = உள்ளீடு("இன்னோர் எண்ணைச் சொல்லுங்கள் ")

## உள்ளிட்டப்பட்ட இரு எண்களும் சமமா என்று ஒப்பிட்டுப் பார்த்தல்

@(அ == ஆ) ஆனால்
	பதிப்பி "இரு எண்களும் சமம்!"
இல்லை

## அவற்றில் ஏதேனும் ஒன்று பெரியதா என்று ஒப்பிட்டுப் பார்த்தல்

	@(அ > ஆ) ஆனால்
		பதிப்பி "முதல் எண் பெரியது!"	
	இல்லை
		பதிப்பி "இரண்டாம் எண் பெரியது!"
	முடி
முடி
#*************************************

இப்போது, உங்களுக்கு ஒரு பயிற்சி. கீழ்க்காணும் தேவைக்கேற்ப "எழில்" மொழியில் ஒரு நிரல் எழுதுங்கள், ஆங்காங்கே உரிய விளக்கங்களுடன் அது அமையவேண்டும்:

இன்று என்ன கிழமை என்று கேட்டுத் தெரிந்துகொள்ளவேண்டும்
அது சனி அல்லது ஞாயிறு எனில், விடுமுறை நாளை அனுபவிக்குமாறு வாழ்த்தவேண்டும்

விடை:

#*************************************
## இந்த நிரலை எழுதியவர்: கவிதா

## கிழமை உள்ளிடப்படுகிறது

கிழமை = உள்ளீடு("இன்று என்ன கிழமை?")

## இது சனிக்கிழமையா?

@(கிழமை == "சனி") ஆனால்
	பதிப்பி "மகிழ்ச்சி, விடுமுறை நாளை அனுபவியுங்கள்!"
இல்லை
## இது ஞாயிற்றுக்கிழமையா?

	@(கிழமை == "ஞாயிறு") ஆனால்
		பதிப்பி "மகிழ்ச்சி, விடுமுறை நாளை அனுபவியுங்கள்!"
	இல்லை
		பதிப்பி "நன்றி, இந்த நாள் இனிய நாளாகட்டும்!"
	முடி
முடி
#*************************************

அத்தியாயம் 5 : எழில் மடக்கு கட்டளைகள் தொகு

கணினியின் மிகப் பெரிய பலங்களில் ஒன்று, சில செயல்களைத் திரும்பத் திரும்பச் செய்வது.

ஆங்கிலத்தில் இதனை Loop என்பார்கள். தமிழில் ’வளையம்’ என்று சொல்லலாம். அதாவது, ஒரு வளையத்தின்மீது ஊர்ந்து செல்லும் எறும்பைப் போல், சுற்றிச் சுற்றி வருவது.

ஆனால், அப்படி நிரந்தரமாகச் சுற்றிக்கொண்டே இருக்கமுடியாதல்லவா? ஒருகட்டத்தில் அதிலிருந்து வெளியே வரவேண்டும். அதற்கு ஒரு நிபந்தனை(Condition)யைத் தரவேண்டும்.

ஓர் உதாரணத்தோடு பார்ப்போம். எழில் மொழியில் ‘வரை’ என்ற குறிச்சொல்லைப் பயன்படுத்தி (ஆங்கிலத்தில் "While") ஓர் எளிய நிரல் எழுதுவோம்.

#*************************************
அ = 0

@(அ < 5) வரை

	பதிப்பி "வணக்கம்!"
	அ = அ + 1

முடி
#*************************************

இந்த நிரலை வரி வரியாகப் படித்துப் புரிந்துகொள்வோம்:

	1. முதலில் "அ" என்ற மாறியில் 0 என்ற எண்ணைச் சேமிக்கிறோம்
	2. அடுத்து, அந்த "அ" என்ற மாறியில் உள்ள எண் ஐந்தைவிடக் குறைவா என்று பார்க்கிறோம் (ஆம்!)
	3. ஆம் எனில், நாம் இரண்டு வேலைகளைச் செய்கிறோம்:

		4. திரையில் வணக்கம் என்று அச்சிடுகிறோம்
		5. "அ" என்ற மாறியுடன் ஒன்றைக் கூட்டுகிறோம். அதாவது அ = 0 + 1 = 1

	6. மறுபடி, "அ" என்ற மாறியில் உள்ள எண் ஐந்தைவிடக் குறைவா என்று பார்க்கிறோம் (ஆம்!)
	7. மறுபடி, திரையில் "வணக்கம்" என்று அச்சிடுகிறோம், "அ" என்ற எண்ணுடன் ஒன்றைக் கூட்டுகிறோம் அ = 1 + 1 = 2
	8. இப்படியே 6, 7 இரண்டையும் திரும்பத் திரும்ப செய்கிறோம், "அ" என்ற எண்ணில் 3, 4, 5 என்ற எண்கள் பதிவாகின்றன
	9. இப்போது "அ" என்ற மாறியில் பதிவாகியிருக்கும் எண் ஐந்தைவிடக் குறைவாக இல்லை, ஆகவே நிரலை அத்துடன் நிறைவு செய்துவிடுகிறோம்

இப்போது கணக்குப் போட்டுச் சொல்லுங்கள், "வணக்கம்" என்ற சொல் எத்தனைமுறை அச்சாகியிருக்கிறது?

ஐந்து முறை, இல்லையா?

அதுதான் "வரை" என்ற குறிச்சொல்லின் வேலை. நாம் குறிப்பிடும் நிபந்தனை (அ < 5) உண்மையாக உள்ளவரை, அதே வேலையைத் திரும்பத் திரும்பச் செய்துகொண்டிருக்கும்.

கிட்டத்தட்ட இதேபோல், "செய்", "முடியேனில்" என்ற இரண்டு குறிச்சொற்கள் இருக்கின்றன. ஆங்கிலத்தில் இவற்றை "Do Until Statement" என்று அழைப்பார்கள்.

இதற்கு ஓர் உதாரணம் இதோ:

#*************************************
அ = 0

செய்

	பதிப்பி "வணக்கம்!"
	அ = அ + 1

முடியேனில் @(அ < 5)
#*************************************

இந்த நிரலும் முந்தைய நிரலைப்போன்றுதான் உள்ளது. ஆனால், இதனை எழுதி இயக்கிப் பார்த்தால் ஒரு மிகப் பெரிய வித்தியாசம் தெரியவரும், இங்கே "வணக்கம்" என்ற சொல் ஐந்து முறை அல்ல, ஆறு முறை அச்சாகும்.

ஏன் தெரியுமா?

"வரை" என்ற குறிச்சொல்லைப் பயன்படுத்தும்போது, உங்கள் கணினி "அ < 5" என்ற நிபந்தனையை முதலில் பரிசோதித்துவிட்டு, அதன்பிறகுதான் நாம் சொல்வதை அச்சிடும். ஆகவே, அ = 5 என்று ஆனதும், உடனடியாக அச்சிடுவதை நிறுத்திவிடும்.

ஆனால் "செய்", "முடியேனில்" ஆகிய குறிச்சொற்கள் அப்படியல்ல, இவற்றைப் பயன்படுத்தினால் உங்கள் கணினி முதலில் அச்சிட்டுவிட்டு, அதன்பிறகுதான் "அ < 5" என்ற நிபந்தனையைப் பரிசோதிக்கும். ஆகவே, அ = 5 என்று ஆனபிறகும், கூடுதலாக இன்னொருமுறை (அதாவது, 6வது முறையாக) "வணக்கம்" என்று அச்சிட்டுவிட்டுதான் நிற்கும்.

இதனால், நீங்கள் நிரல் எழுதும்போது எப்போது "வரை" பயன்படுத்தவேண்டும், எப்போது "செய்", "முடியேனில்" கூட்டணியைப் பயன்படுத்தவேண்டும் என்று யோசித்துத் தீர்மானிக்கவேண்டும். தவறுகளைத் தவிர்க்கவேண்டும்.

இப்போது, உங்களுக்கு ஒரு பயிற்சி:

திரையில் ஓர் எண்ணைக் கேட்கவேண்டும்
அந்த எண் ஐம்பதாகவோ, அல்லது அதைவிடக் குறைவான ஓர் எண்ணாகவோ இருந்தால், அதற்குப் பதில் மற்றொரு எண்ணைக் கேட்கவேண்டும்
ஐம்பதைவிடப் பெரிய ஓர் எண் வரும்வரை தொடர்ந்து கேட்டுக்கொண்டே இருக்கவேண்டும்

விடை:

#*************************************
அ = உள்ளீடு ("ஏதாவது ஓர் எண்ணைத் தாருங்கள் ")

@(அ <= 50) வரை

	அ = உள்ளீடு("இந்த எண் வேண்டாம். இன்னோர் எண்ணைத் தாருங்கள் ")

முடி

பதிப்பி "நன்றி!"
#*************************************

அடுத்து, நாம் "தேர்ந்தெடு" என்ற குறிச்சொல்லைக் கற்றுக்கொள்ளப்போகிறோம். ஆங்கிலத்தில் இதனை Case Statement என்று அழைப்பார்கள்.

இதை ஓர் உதாரணத்துடன் பார்த்தால் புரியும். உங்கள் வகுப்பில் உள்ள ஒவ்வொருவரின் பெயரைக் கேட்டு, அவர் ஆணாக இருந்தால் "செல்வன்" என்றும், பெண்ணாக இருந்தால் "செல்வி" என்றும் அடைமொழியோடு அழைத்து வணக்கம் சொல்லவேண்டும். அதற்கு ஒரு நிரல் எழுதுவோம்.

#*************************************
பெயர் = உள்ளீடு ("உங்கள் பெயர் என்ன? ")
பாலினம் = உள்ளீடு ("நீங்கள் ஆணா? பெண்ணா? ")

@(பாலினம்) தேர்ந்தெடு

தேர்வு @("ஆண்")
	
	பதிப்பி "வணக்கம் செல்வன். ", பெயர்
	நேருத்து

தேர்வு @("பெண்")
	
	பதிப்பி "வணக்கம் செல்வி. ", பெயர்
	நேருத்து

முடி
#*************************************

எளிமையான நிரல்தான். இல்லையா?

முதலில் உங்கள் நண்பருடைய பெயரையும் பாலினத்தையும் கேட்டுக்கொள்கிறோம்
பின்னர் பாலினத்தை அடிப்படையாக வைத்து, ஒவ்வொரு தேர்வாகப் பார்க்கிறோம்
ஆண் எனில் "வணக்கம் செல்வன். " என்று சொல்லி அவருடைய பெயரை அச்சிடுகிறோம், அதோடு நிரலை நிறுத்திவிடுகிறோம், இதற்கு "நேருத்து" என்ற குறிச்சொல் பயன்படுகிறது
ஒருவேளை அப்படி நிறுத்தாமல் நிரலை மேலும் தொடரவேண்டும் என்றால், அதற்குத் "தொடர்" என்ற குறிச்சொல்லைப் பயன்படுத்தலாம்
உங்கள் நண்பர் பெண் எனில் "வணக்கம் செல்வி. " என்று சொல்லி அவர் பெயரை அச்சிடுகிறோம், அதோடு நிரலை நிறுத்திவிடுகிறோம்
நிறைவாக "முடி" என்ற குறிச்சொல்லைப் பயன்படுத்தி வளையத்தை நிறைவு செய்கிறோம்.

இப்படி இரண்டு, மூன்று "தேர்வு"கள்மட்டும் இருந்தால், எளிதாக நிரல் எழுதிவிடலாம், நிறைய "தேர்வு"கள் இருந்துவிட்டால், ஒவ்வொன்றாக யோசித்து எழுதுவது சிரமமாயிற்றே.

பிரச்னையில்லை, அதற்காக "ஏதேனில்" என்ற குறிச்சொல் உள்ளது, அதற்குமேலே தரப்பட்டுள்ள எந்தத் "தேர்வு"ம் பொருந்தாவிட்டால், இங்கே உள்ள நிரல் வரிகள் நிறைவேற்றப்படும். உதாரணமாக:

#*************************************
ஊர் = உள்ளீடு ("உங்கள் ஊர் என்ன? ")

@(ஊர்) தேர்ந்தெடு

தேர்வு @("சென்னை")

	பதிப்பி "சென்னையில் உள்ள மெரீனா கடற்கரை அழகானது!"
	நேருத்து

தேர்வு @("கோவை")

	பதிப்பி "கோவையின் தமிழ் மிக இனிமையானது!"
	நேருத்து

தேர்வு @("மதுரை")

	பதிப்பி "சிறந்த கோயில்கள் நிறைந்தது மதுரை!"
	நேருத்து

ஏதேனில்

	பதிப்பி "உங்கள் ஊர்பற்றி அறிந்ததில் மிக்க மகிழ்ச்சி!"
	நேருத்து
முடி
#*************************************

அவ்வளவுதான், எல்லா ஊர்களையும் பட்டியல் போடாமல், "ஏதேனில்" என்ற குறிச்சொல்லைப் பயன்படுத்திவிட்டோம். சென்னை, கோவை, மதுரைதவிர மற்ற அனைத்து ஊர்களுக்கும் இந்த வரிதான் அச்சிடும்.

உங்கள் வீட்டுச் சமையலறையில் சிறிய, பெரிய தட்டுகள் இருந்தால், ஒரு தட்டை இன்னொன்றுக்குள் பொருத்தலாம் அல்லவா? அதுபோல, எழில் கணினி மொழியில் இந்த வளையங்களை ஒன்றுக்குள் ஒன்று என அமைக்கலாம். அதனைப் ‘பின்னல் வளையம்’ (Nested Loop) என்பார்கள்.

ஆனால் ஒன்று, பின்னல் வளையம் என்பது, ஒரு தட்டுக்குள் இன்னொன்றை வைப்பதுபோல், உள்ளே இருக்கும் வளையம் கச்சிதமாக வெளி வளையத்துக்குள் பொருந்தவேண்டும். இல்லாவிட்டால், உங்கள் நிரல் வேலை செய்யாது.

பின்னல் வளையங்களை எப்படி அமைப்பது என்பதற்கு உதாரணமாக இந்த நிரலைப் பாருங்கள்:

#*************************************
அ = 1

@(அ <= 10) வரை
	
	ஆ = 1
	
	@(ஆ <= 10) வரை
	
		இ = அ * ஆ
	
		ஈ = str(அ) + " * " + str(ஆ) + " = " + str(இ)

		பதிப்பி ஈ

		ஆ = ஆ + 1

	முடி

	அ = அ + 1

முடி
#*************************************

இந்த நிரல் 1 * 1 = 1 என்பதில் தொடங்கி 10 * 10 = 100 என்பதுவரையிலான பெருக்கல் வாய்ப்பாட்டை உங்களுடைய திரையில் அச்சிடும்.

இங்கே "அ" என்ற மாறியை அடிப்படையாகக் கொண்ட வளையம் வெளியே உள்ளது, "ஆ" என்ற இன்னொரு மாறியை அடிப்படையாகக் கொண்ட வளையம் உள்ளே இருக்கின்றது, அது முடிந்தபிறகுதான் வெளிவளையமும் முடிகின்றது என்பதைக் கவனித்துப் பாருங்கள்.

இப்போது, உங்களுக்கு ஒரு பயிற்சி:

* நீங்கள் ஒன்றிலிருந்து நூறுக்குள் ஓர் எண்ணைத் தீர்மாணித்துக்கொள்ளவேண்டும் (இதற்கு நீங்கள் "randint(1,100)" என்ற கட்டளையைப் பயன்படுத்தலாம்) * மற்றவர்களை அதை ஊகிக்கச் செய்யவேண்டும், அவர்களுக்கு உதவியாக, சிறு துப்பு(Clue)கள் தரலாம் * பத்து முயற்சிகளுக்குள் அவர்கள் அந்த எண்ணைச் சரியாக ஊகித்துவிட்டால், அவர்கள் வெற்றி பெற்றார்கள் என அறிவிக்கவேண்டும்

விடை:

#*************************************
எண் = randint(1,100)

வாய்ப்பு = 0

@(வாய்ப்பு < 10 ) வரை

   ஊகித்தஎண் = உள்ளீடு ("ஒன்றிலிருந்து நூறுக்குள் உள்ள ஏதோ ஓர் எண்ணை நான் மனத்தில் நினைத்துள்ளேன். அது என்ன என்று உங்களால் ஊகிக்கமுடியுமா? ")

  வாய்ப்பு = வாய்ப்பு + 1

   @( எண் == ஊகித்தஎண் ) ஆனால்
      பதிப்பி "வாழ்த்துக்கள்! சரியான பதில்!"
      exit(0)
   முடி

   @( எண் < ஊகித்தஎண் ) ஆனால்
      பதிப்பி "நீங்கள் சொல்லும் எண் தவறு, நான் நினைத்த எண்ணைவிட அது பெரியது!"
   இல்லை
      பதிப்பி "நீங்கள் சொல்லும் எண் தவறு, நான் நினைத்த எண்ணைவிட அது சிறியது"
  முடி
  
  பதிப்பி "கவலை வேண்டாம், இன்னும் ", (10 - வாய்ப்புகள்), " வாய்ப்புகள் உள்ளன. நீங்கள் நிச்சயம் வெல்லலாம், மீண்டும் முயற்சி செய்யுங்கள்!"

முடி

பதிப்பி "மன்னிக்கவும், நீங்கள் பத்து வாய்ப்புகளுக்குள் சரியான எண்ணைக் கண்டுபிடிக்கவில்லை!"
#*************************************

அடுத்து, ’ஒவ்வொன்றாக’ என்கிற ஒரு குறிச்சொல்லைப் பார்க்கவிருக்கிறோம். ஆங்கிலத்தில் இதனை 'For Each Loop' என்று அழைப்பார்கள்.

உதாரணமாக, ஒன்று முதல் ஆறு வரை உள்ள எண்களை அச்சிடவேண்டும் என்றால், அதை இப்படிச் செய்யலாம்:

#*************************************
எண்கள் = [1, 2, 3, 4, 5, 6]

@(எண்கள் இல் இவ்வெண்) ஒவ்வொன்றாக
	பதிப்பி இவ்வெண்
முடி
#*************************************

இங்கே நாம் ‘எண்கள்’ என்ற பட்டியலில் ஆறு எண்களை வைத்துள்ளோம். பின்னர் அவற்றை ஒவ்வொன்றாக எடுத்து ‘இவ்வெண்’ என்ற பெயரில் சேமிக்கின்றோம், பின் அதனை அச்சிடுகின்றோம்.

ஒருவேளை, ஆறுக்குப் பதில் நூறு எண்கள் இருந்தால்? அத்துனை நீளமாக எழுதுவது சிரமம் ஆயிற்றே!

உண்மைதான். அதற்காகவே ‘எழில்’ மொழியில் ‘ஆக’ என்ற குறிச்சொல் உள்ளது. இதனைப் பயன்படுத்தினால், ஒவ்வொன்றாக எழுதாமல், அதனை ஒரு கணக்காகச் செய்துவிடலாம், இப்படி:

#*************************************
@(எண் = 1, எண் <= 100, எண் = எண் + 1) ஆக

	பதிப்பி எண்

முடி
#*************************************

மிக எளிய நிரல்தான். ஒவ்வொரு வரியாகப் படித்தால் தெளிவாகப் புரிந்துவிடும்:

முதலில் ‘எண்’ என்ற பெயரில் 1 என்ற எண்ணைச் சேமிக்கிறோம்
பிறகு, ‘எண் <= 100’ என்று நிபந்தனை விதிக்கிறோம்
நிறைவாக, எண்ணை ஒவ்வொன்றாக அதிகரிக்கிறோம்
ஆக, ’எண்’ என்பது 1, 2, 3, 4, 5, 6 ... என படிப்படியாக அதிகரிக்கும், திரையில் அச்சிடப்படும்
அந்த ’எண்’ 101ஆக மாறியதும், ‘எண் <= 100’ என்ற நிபந்தனை தவறாகிவிடுகின்றது, ஆகவே, அதற்குமேல் அச்சிடுவதை நிறுத்திவிடுகின்றோம்

இப்போது, உங்களுக்கு ஒரு பயிற்சி:

ஒன்று முதல் ஆயிரம் வரை உள்ள எண்களில் ஒற்றைப்படை எண்களைமட்டும் திரையில் அச்சிடவேண்டும்
அடுத்தபடியாக, ஆயிரத்திலிருந்து ஒன்றுவரை உள்ள எண்களில் இரட்டைப்படை எண்களைமட்டும் திரையில் அச்சிடவேண்டும்
இதற்கு நீங்கள் "%" என்ற குறியீட்டைப் பயன்படுத்தலாம், அது இரு எண்களை வகுத்து, அதன்பிறகு மீதமுள்ள எண்ணைமட்டும் தரும்.

விடை:

#*************************************
பதிப்பி "ஒற்றைப்படை எண்கள்"
@(எண்=1, எண் <=1000, எண் = எண் + 1) ஆக

	மீதம் = எண் % 2
	@(மீதம் == 1) ஆனால்
		# ஒற்றைப்படை எண்
		பதிப்பி எண்
	முடி
முடி

பதிப்பி "இரட்டைப்படை எண்கள்"
@(எண்=1000, எண் >= 1, எண் = எண் - 1) ஆக

	மீதம் = எண் % 2
	@(மீதம் == 0) ஆனால்
		#இரட்டைப்படை எண்
		பதிப்பி எண்
	முடி

முடி
#*************************************

அத்தியாயம் 6 : எழில் வழி கணினி திரையில் வரைபடங்கள் தொகு

இதுவரை எழில் மொழியைக் கொண்டு நிறைய செய்திகளை ‘எழுதி’ப் பார்த்துவிட்டோம், ஒரு மாறுதலுக்காக, கொஞ்சம் ‘வரைந்து’ பார்ப்போமா?

வேடிக்கை இல்லை, நிஜமாகவே, ‘எழில்’ மொழியைக் கொண்டு படங்கள் வரையமுடியும். அடிப்படையான கோடு, வட்டம் போன்றவற்றில் தொடங்கி, கொஞ்சம் மெனக்கெட்டால் முழுமையான ஓவியங்களைக்கூட வரையமுடியும். அதைதான் இந்த அத்தியாயத்தில் கற்றுக்கொள்ளப்போகிறோம்!

இதற்கு நாம் பல புதிய "எழில்" குறிச்சொற்களைப் பயன்படுத்தவேண்டியிருக்கும். அவற்றில் சிலவற்றை முதலில் பட்டியல் போட்டுவிடுவோம்:

முன்னாடி
வலது
இடது
பின்னாடி
எழுதுகோல்மேலே
எழுதுகோல்கீழே

இந்தப் பெயர்களைப் பார்த்தாலே, அவை என்ன செய்யும் என்பது உங்களுக்கு ஓரளவு புரியும். அவற்றைப் பயன்படுத்தி நிரல் எழுதத் தொடங்குமுன், ‘எழுதுகோல்’ என்றால் என்ன?

சாதாரணமாக நாம் ஒரு காகிதத்தில் படம் வரையும்போது, எழுதுகோல் என்பது பேனா, அல்லது பென்சில். அதைக் காகிதத்தின்மீது வைத்துப் பல திசைகளில் இழுக்கிறோம். அப்படியே படம் உருவாகிறது.

கணினியிலும் அதுபோல் ஓர் எழுதுகோல் இருப்பதாகக் கற்பனை செய்துகொள்ளுங்கள், உங்களுடைய "எழில்" நிரல்மூலமாக, அந்த எழுதுகோலைப் பல திசைகளில் நகர்த்துகின்றீர்கள், படம் வரைகின்றீர்கள்.

உதாரணமாக, ஓர் எளிய பயிற்சி. கோடு ஒன்றை வரையப் பழகுவோம்.

காகிதத்தில் கோடு வரைவது சுலபம். எழுதுகோலை ஓர் இடத்தில் வைத்து, அங்கிருந்து வலதுபக்கமாகக் கொஞ்சம் நகர்த்தினால் கோடு உருவாகிவிடும். அவ்வளவுதான்.

கணினியிலும் அதையே செய்யலாம். இதோ இப்படி:

#*************************************
முன்னாடி(50)
#*************************************

அவ்வளவுதான், திரையின் மையத்தில் உள்ள எழுதுகோல், 50 புள்ளிகள் வலதுபக்கமாக நகரும். கோடு உருவாகிவிடும்.

அதே கோட்டை மேலிருந்து கீழாக வரைவதென்றால்? இதோ இப்படி:

#*************************************
வலது(90)
முன்னாடி(50)
#*************************************

இங்கே நாம் எழுதுகோலை வலதுபக்கமாக 90 பாகைகள் திருப்புகிறோம் (அதாவது கீழ்நோக்கி), பின்னர் 50 புள்ளிகள் முன்னே நகர்கிறோம் (அதாவது, கீழே), இதனால் மேலிருந்து கீழே ஒரு கோடு உருவாகிவிடுகிறது. மிகச் சுலபம்!

இதையே இன்னும் கொஞ்சம் நீட்டி, ஒரு முழுச் சதுரம் வரைவோமா?

#*************************************
முன்னாடி(50)
வலது(90)
முன்னாடி(50)
வலது(90)
முன்னாடி(50)
வலது(90)
முன்னாடி(50)
வலது(90)
#*************************************

இந்தச் சதுரம் அழகாக இருக்கிறது, பக்கத்திலேயே இன்னொரு பெரிய சதுரம் வரையவேண்டும். எப்படி?

அதற்கு நாம் "எழுதுகோல்மேலே" மற்றும் "எழுதுகோல்கீழே" என்ற கட்டளைகளைப் பயன்படுத்தவேண்டும். இதன்மூலம் உங்கள் திரையில் எழுதுகோல் நகரும், ஆனால் படம் வரையாது, இதோ இப்படி:

#*************************************
எழுதுகோல்மேலே()
முன்னாடி(200)
எழுதுகோல்கீழே()

முன்னாடி(100)
வலது(90)
முன்னாடி(100)
வலது(90)
முன்னாடி(100)
வலது(90)
முன்னாடி(100)
#*************************************

இப்போது, இந்த நிரல் முழுவதையும் இயக்கிப் பார்த்தால், உங்கள் திரையில் இரண்டு சதுரங்களைக் காணலாம்.

சதுரம் வரைவதற்காக இவ்வளவு தூரம் சிரமப்படாமல், எளிதாக ஒரு "வரை" குறிச்சொல்லைப் பயன்படுத்தியும் வரையலாம், இதோ இப்படி:

#*************************************
அ = 0

@(அ < 4) வரை

	முன்னாடி(50)
	வலது(90)
	அ = அ + 1

முடி
#*************************************

இந்தப் படம் அழகாக இருக்கிறது. அடுத்து, நான் இதை அழித்துவிட்டு இன்னொரு படத்தை வரைவதற்கு விரும்புகிறேன். அது எப்படி?

அதற்கு நீங்கள் turtle_reset என்ற கட்டளையைப் பயன்படுத்தவேண்டும். இதோ இப்படி:

#*************************************
turtle_reset()
#*************************************

அடுத்து பல வண்ணங்களில் இன்னும் பெரிய படங்களை வரைவதற்குப் பழகுவோம். இதற்கு நீங்கள் பயன்படுத்தவேண்டிய குறிச்சொல், turtle_color.

உதாரணமாக, ஒரு சிவப்புச் சதுரம் வரையலாமா? இதோ இப்படி:

#*************************************
அ = 0

turtle_color("red")

@(அ < 4) வரை

	முன்னாடி(50)
	வலது(90)
	அ = அ + 1

முடி
#*************************************

முன்பு பார்த்த அதே நிரல்தான், கூடுதலாக, turtle_color என்ற குறிச்சொல்லைத் தந்து, சிவப்பு நிறத்தில் வரையும்படி கணினிக்குச் சொல்கிறோம். அவ்வளவுதான் வித்தியாசம்.

அடுத்து, சிவப்பு நிறத்தில் ஒரு வட்டம் வரையலாமா? அதற்கு நாம் கூடுதலாகப் பயன்படுத்தவேண்டிய குறிச்சொற்கள் இரண்டு: turtle_fill & turtle_circle

#*************************************
turtle_color("red")
turtle_fill(True)
turtle_circle(100)
#*************************************

ஒருவேளை நீங்கள் அரைவட்டம் வரைய விரும்பினால், turtle_circle என்ற குறிச்சொல்லுடன், 180 பாகை என்கிற எண்ணையும் சேர்த்துக் கொடுங்கள்:

#*************************************
turtle_circle(100, 180)
#*************************************

அப்படியானால், கால்வட்டத்துக்கு என்ன செய்வீர்கள்?

#*************************************
turtle_circle(100, 90)
#*************************************

மிக எளிமைதான். இல்லையா?

அடுத்து, கொஞ்சம் சிரமமான ஒரு வடிவத்தை வரைவோம்: பச்சை நிற நட்சத்திரம்!

இந்த நிரல் பார்ப்பதற்குச் சற்று சிரமமாக இருக்கும், ஆனால், காகிதத்தில் நட்சத்திரம் வரைந்து, உங்கள் பேனா எந்தத் திசையில் எவ்வளவு தூரம் நகர்கிறது என்று ஒருமுறை கவனித்தால் தெளிவாகப் புரிந்துவிடும்:

#*************************************
turtle_color("green")
வலது(36)
முன்னாடி(100)
வலது(144)
முன்னாடி(100)
வலது(144)
முன்னாடி(100)
வலது(144)
முன்னாடி(100)
வலது(144)
முன்னாடி(100)
#*************************************

இதுவரை நீங்கள் கற்றுக்கொண்ட செய்திகளைப் பயன்படுத்தி, ஒரே செயலைப் பலமுறை செய்யும் கணினியின் திறமையையும் ஒருங்கிணைத்தால், ஏராளமான புதுப்புது விஷயங்களை நீங்கள் வரைந்து பார்த்துக் கலக்கமுடியும்.

இதை நிரூபிக்கும்வண்ணம், உங்களுக்கு இப்போது ஒரு பயிற்சி. "யின் யாங்" என்ற பிரபலமான சின்னத்தைப்பற்றிக் கேள்விப்பட்டிருப்பீர்கள். தெரியாது என்றால், இணையத்தில் தேடுங்கள், "எழில்" மொழியில் அதனை வரைந்து பாருங்கள்

விடை:

#*************************************

    turtle_color("black")
    turtle_fill(True)
    turtle_circle(100, 180)
    turtle_circle(200, 180)
     இடது(180)
    turtle_circle( -100 , 180 )
    turtle_color("white")
    turtle_fill(True)
    turtle_color("black")
     இடது(90)
     எழுதுகோல்மேலே()
     முன்னாடி(200*0.375)
     வலது(90)
     எழுதுகோல்கீழே()
    turtle_circle(200*0.125)
     இடது(90)
    turtle_fill(False)
     எழுதுகோல்மேலே()
     பின்னாடி(200*0.375)
     எழுதுகோல்கீழே()
     இடது(90)

#*************************************

அத்தியாயம் 7 : எழில் வழி நிரல் பாகம் செயல்பாடுக்ள் தொகு

இதுவரை எழில் மொழியைப் பயன்படுத்திப் பல்வேறு உபயோகமான நிரல்களை எழுதினோம், அவற்றைப் பயன்படுத்திப் புரிந்துகொண்டோம்.

அடுத்தகட்டமாக, பொதுப் பயன்பாட்டுக்குரிய சில முக்கியமான நிரல்களை எழுதப் பழகுவோம். இவற்றை நீங்கள் ஒருமுறை எழுதிவிட்டால் போதும், பிறகு வேண்டியபோதெல்லாம் அழைத்துப் பயன்படுத்தலாம்.

உதாரணமாக, உங்கள் வீட்டில் ஊறுகாய் இருக்கிறது, அதை ஒருமுறை தயாரித்து வைத்துவிடுகிறீர்கள், பிறகு எப்போது அதைச் சாப்பிட விரும்பினாலும் ஜாடியைத் திறந்து எடுத்துப் போட்டுக்கொள்கிறோம், ஒவ்வொருமுறையும் ஊறுகாயைப் புதிதாகச் சமைக்கவேண்டியதில்லை.

அதே சமையலறையிலிருந்து இன்னோர் உதாரணம், ஒருவர் ரசம் சமைக்கும்போது, ஒரு குறிப்பிட்ட செய்முறையைப் பின்பற்றுவார். அதன் நடுவே ‘ரசப்பொடியைப் போடவும்’ என்று இருக்கும்.

ரசப்பொடி என்பதை, அவர் இப்போது தயாரிப்பதில்லை, ஏற்கெனவே எப்போதோ தயாரித்துவைத்துவிட்டார், பின்னர் தேவைப்படும்போது சட்டென்று எடுத்துப் பயன்படுத்துகிறார், அதன்பிறகு, செய்முறையில் இருக்கும் மற்ற விஷயங்களைத் தொடர்ந்து செய்கிறார்.

அதுபோல, ஒரு நிரலின் நடுவே, சில விஷயங்கள் நாம் அடிக்கடி செய்கிறவையாக இருக்கும், அவற்றை ஒவ்வொருமுறையும் தனித்தனியே எழுதிக்கொண்டிருக்காமல், ஒருமுறை எழுதிவைத்துவிட்டு, தேவைப்படும்போது அழைத்துப் பயன்படுத்தலாம், பிறகு, நம்முடைய நிரலைத் தொடர்ந்து எழுதலாம்.

உதாரணமாக, இரண்டு எண்களில் எது பெரியது என்று கண்டுபிடிப்பதற்கான எளிய நிரல் ஒன்றை எழுதுவோம்:

#*****************************
எண்1 = உள்ளீடு("ஓர் எண்ணைச் சொல்லுங்கள்: ")
எண்2 = உள்ளீடு("இன்னோர் எண்ணைச் சொல்லுங்கள்: ")

@(எண்1 > எண்2) ஆனால்
	பதிப்பி "நீங்கள் தந்தவற்றுள் பெரிய எண்: ", எண்1
இல்லை
	பதிப்பி "நீங்கள் தந்தவற்றுள் பெரிய எண்: ", எண்2
முடி
#*****************************

மிக எளிய நிரல் இது. கணினிப் பயனாளரிடமிருந்து இரு எண்களைக் கேட்டு வாங்கி, அதில் எது பெரியதோ அதைமட்டும் திரையில் அச்சிடுகிறது.

இந்தப் ‘பெரிய எண்ணைக் கண்டுபிடித்தல்’ என்ற செயல், நம்முடைய பல கணக்குகளில் அடிக்கடி வரும், அப்போதெல்லாம் இந்த நிரலை மீண்டும் மீண்டும் எழுதிக்கொண்டிருக்காமல், ஒருமுறை எழுதிவிட்டுப் பின்னர் அதைப் பலமுறை பயன்படுத்தமுடியுமா என்று பார்ப்போம்.

இதற்கு நாம் ‘நிரல்பாகம்’ என்ற சிறப்புக் குறிச்சொல்லைப் பயன்படுத்தவேண்டும். ஆங்கிலத்தில் இதனை ‘Function' என்று அழைப்பார்கள்.

#*****************************
நிரல்பாகம் பெரியது (எண்1, எண்2)

	@(எண்1 > எண்2) ஆனால்
		பின்கொடு எண்1
	இல்லை
		பின்கொடு எண்2
	முடி

முடி
#*****************************

இங்கே நாம் என்ன செய்திருக்கிறோம்? படிப்படியாக அலசுவோம்:

1. “பெரியது" என்ற பெயரில் ஒரு நிரல்பாகத்தைத் தொடங்கியிருக்கிறோம் 2. இந்த நிரல்பாகத்தை அழைக்க விரும்புவோர் அதற்கு இரண்டு எண்களைத் தரவேண்டும், அவற்றை அடைப்புக் குறியினுள் எழுதியிருக்கின்றோம் 3. இவற்றுள் எண்1 பெரியது என்றால், நிரல்பாகத்தை அழைத்தவருக்கு அதையே விடையாகக் கொடுக்கின்றோம், இல்லாவிட்டால் எண்2ஐ விடையாகத் தருகின்றோம், இதற்குப் ‘பின்கொடு’ என்ற குறிச்சொல் பயன்படுகிறது. ஆங்கிலத்தில் இதனை ‘Return' என்பார்கள்.

இங்கே நாம் நிரல்பாகத்தைமட்டும்தான் எழுதியிருக்கின்றோம். அதனை இன்னும் அழைக்கவில்லை, அதாவது, இந்த நிரலை நாம் இன்னும் பயன்படுத்தவில்லை. ரசப்பொடியை எடுத்துப் போட்டுச் சமைத்தால்தானே ரசம் தயாராகும்?

அதற்கான நிரல் வரி மிக எளிது:

#*****************************
பதிப்பி பெரியது(10, 15)
பதிப்பி பெரியது(12, 8)
#*****************************

அவ்வளவுதான், நமக்கு வேண்டிய இடங்களில் “பெரியது" என்ற சொல்லை எழுதி, அதற்கு வேண்டிய இரண்டு எண்களைக் கொடுத்தவுடன் விடை பளிச்சென்று திரும்பக் கிடைத்துவிடும். பிரமாதம், இல்லையா?

ஆனால், நிரல்பாகத்தின் உண்மையான பயன் இதுவன்று, கொஞ்சம் சிக்கலான கணக்குகளில் அதைப் பயன்படுத்திப் பார்த்தால்தான் இதனுடைய முழு பலமும் நமக்குத் தெரியவரும்.

முதலில், Factorial எனப்படும் தொடர்பெருக்கு எண்ணைக் கணக்கிடுவதற்கு ஒரு நிரல் எழுதுவோம்.

அதற்குமுன்னால், ஓர் எண்ணின் Factorialஐ எப்படிக் கண்டுபிடிப்பது? உங்கள் கணக்குப் பாடத்தைச் சற்றே நினைவுபடுத்திப் பாருங்கள்:

உதாரணமாக, எண் 7 ஐ எடுத்துக்கொள்வோம், இதன் Factorial 7! என்று குறிக்கப்படும்
$7!=$ அதில் தொடங்கி ஒன்று வரையிலான அனைத்து எண்களின் பெருக்குத் தொகை, அதாவது, $7!=7*6*5*4*3*2*1=5040$

அவ்வளவுதான். எளிமையான கணக்கு!

ஆனால், உங்களிடம் யாராவது ’100! எவ்வளவு?’ என்று கேட்டுவிட்டால் என்ன செய்வீர்கள்? 100*99*98... என்று கணக்குப் போடுவதற்கு ரொம்ப நேரமாகுமே!

கவலை வேண்டாம், எழில் மொழியும், அதன் நிரல்பாகமும் உங்கள் துணைக்கு வரும். இதோ இப்படி:

#******************************
நிரல்பாகம் தொடர்பெருக்கு(அ)
	@(அ == 0) ஆனால்
		பின்கொடு 1
	இல்லை
		பின்கொடு அ*தொடர்பெருக்கு(அ-1)
	முடி
முடி

பதிப்பி தொடர்பெருக்கு(7)
பதிப்பி தொடர்பெருக்கு(100)
#*****************************

இந்த நிரல் எப்படி இயங்குகிறது?

முதலில் தொடர்பெருக்கு(7) எனத் தொடங்குகிறோம், அங்கே அது 7 * தொடர்பெருக்கு(6) என மாறுகிறது, பின் 7 * 6 * தொடர்பெருக்கு(5) என மாறுகிறது... இப்படியே தொடர்ந்து $7 * 6 * 5 * 4 * 3 * 2 * 1 = 5040$ என்று கண்டறிந்துவிடுகிறோம்!

இதேபோல், தொடர்பெருக்கு(100)ஐயும் அழைக்கலாம், ஆனால் அதன் விடை மிக மிகப் பெரியது, இந்தப் புத்தகத்தில் எழுதுவது சாத்தியமில்லை!

அடுத்து, இதேபோல் இரு எண்களுக்கு இடையே GCD அல்லது மீபொவ எனப்படுகிற மீப்பெரு பொது வகுத்தி கண்டுபிடிக்க ஒரு நிரல் எழுதுவோம்.

மறுபடியும், உங்கள் கணக்குப் பாடத்தைச் சற்றே நினைவுபடுத்திப் பாருங்கள், GCD என்றால் என்ன?

	* உதாரணமாக, எண்கள் 54, 42 ஆகியவற்றை எடுத்துக்கொள்வோம்
	* இதில் 54 என்பது 1, 2, 3, 6, 9, 18, 27 , 54 ஆகியவற்றால் வகுபடும்
	* ஆனால் 42 என்பது 1, 2, 3, 4, 6, 8, 12, 24 ஆகியவற்றால் வகுபடும்
	* இந்த இரண்டு பட்டியலுக்கும் பொதுவான எண்கள் 1, 2, 3, 6 ஆகியவை
	* இவற்றில் பெரியது 6
	* ஆகவே, 54, 42ன் GCD 6

எளிமையான கணக்குதான். ஆனால் இதைக் கையால் செய்வது சிரமம். திரும்பத் திரும்பப் பலமுறை வகுத்துப் பார்த்துக்கொண்டே இருக்கவேண்டும்.

அதற்குதான் நிரல்பாகம் பயன்படுகிறது, இதோ இப்படி:

#*****************************
நிரல்பாகம் மீபொம(அ, ஆ)
	பெரிது = max(அ, ஆ)
	சிறிது = min(அ, ஆ)
	@(சிறிது == 0) ஆனால்
		பின்கொடு பெரிது
	இல்லை
		பின்கொடு மீபொம(பெரிது - சிறிது, சிறிது)
	முடி
முடி

பதிப்பி "54, 42 இடையிலான மீபொம = ", மீபொம(54, 42)
#*****************************

இந்த நிரல் எப்படி இயங்குகின்றது என நாம் படிப்படியாகப் பார்க்கவேண்டும்:

முதன்முறை:

	மீபொம(54, 42)
	பெரிது = அவற்றில் பெரிய எண் = 54
	சிறிது = அவற்றில் சிறிய எண் = 42
	சிறிது == 0 இல்லை
	ஆகவே, அதே மீபொம நிரல்பாகம் மீண்டும் அழைக்கப்படும், இப்படி: மீபொம(பெரிது - சிறிது, சிறிது), அதாவது, மீபொம(54-42, 42), மீபொம(12, 42)
	
	இப்போது,
	பெரிது = 42
	சிறிது = 12
	சிறிது == 0 இல்லை
	அதே மீபொம நிரல்பாகம் மீண்டும் அழைக்கப்படும், மீபொம(42-12, 12), அதாவது மீபொம(30, 12)

	இப்போது,
	பெரிது = 30
	சிறிது = 12
	சிறிது == 0 இல்லை
	அதே மீபொம நிரல்பாகம் மீண்டும் அழைக்கப்படும், மீபொம(30-12, 12) அதாவது, மீபொம(18, 12)
	
	இப்போது,
	பெரிது = 18
	சிறிது = 12
	சிறிது == 0 இல்லை
	அதே மீபொம நிரல்பாகம் மீண்டும் அழைக்கப்படும், மீபொம(18-12, 12) அதாவது, மீபொம(6, 12)
	
	இப்போது,
	பெரிது = 6
	சிறிது = 12
	சிறிது == 0 இல்லை
	அதே மீபொம நிரல்பாகம் மீண்டும் அழைக்கப்படும், மீபொம(12-6, 6) அதாவது மீபொம(6,6)
	
	இப்போது,
	பெரிது = 6
	சிறிது = 6
	சிறிது ==0 இல்லை
	அதே மீபொம நிரல்பாகம் மீண்டும் அழைக்கப்படும், மீபொம(6-6, 0), அதாவது மீபொம(6, 0)
	
	இப்போது,
	பெரிது = 6
	சிறிது = 0
	சிறிது == 0
	ஆகவே, GCD விடை = பெரிது = 6

அவ்வளவுதான். நாம் கையால் போட்ட அதே கணக்கைக் கணினியால் போட்டுவிட்டோம். நிரல்பாகத்தின் உண்மையான பயன் இப்போது தெரிந்திருக்கும். ஒருமுறை இருமுறை அல்ல, நூறு முறை, ஆயிரம் முறைகூட இதனை நீங்கள் அழைத்துப் பயன்படுத்தலாம்!

இப்போது, உங்களுக்கு ஒரு பயிற்சி:

	* ஒன்று முதல் ஐம்பது வரை உள்ள எண்களில் எவையெல்லாம் பகா எண்கள் (Prime Numbers) என்று கண்டறிந்து, திரையில் அச்சிடுங்கள்
	* பின்னர் அந்த எண்களின் கூட்டுத்தொகையையும் அச்சிடவேண்டும்
	* இந்தக் கூட்டுத்தொகை பகு எண்ணா, பகா எண்ணா என்று கண்டறியவேண்டும்
	* உங்களுக்கு உதவியாக ஒரு குறிப்பு, ஓர் எண் பகா எண்ணா என்று கண்டறிய நீங்கள் floor, fmod என்ற கணிதச் செயல்பாடுகளைப் பயன்படுத்தவேண்டியிருக்கும், இவைபற்றித் தேடிப் படித்துத் தெரிந்துகொள்ளுங்கள், அல்லது, உங்களுடைய புதிய வழிமுறையைக் கண்டறியுங்கள்

விடை:

#*****************************
நிரல்பாகம் பகாஎண்ணா(அ)

	ஆ = 1
	இ = floor(அ/2)
	@(இ >= 2) வரை
		@(fmod(அ, இ) == 0) ஆனால்
			ஆ = 0
			நிறுத்து
		முடி
		இ = இ + 1	
	முடி
	பின்கொடு ஆ
முடி

எல்லை = 50
எண் = 1
கூட்டுத்தொகை = 0

@(எண் <= எல்லை) வரை
	
	விடை = பகாஎண்ணா(எண்)
	@(விடை) ஆனால்
		பதிப்பி எண்
		கூட்டுத்தொகை = கூட்டுத்தொகை + எண்
	முடி
	எண் = எண் + 1

முடி

பதிப்பி "இதுவரை நாம் பார்த்த பகா எண்களின் கூட்டுத்தொகை: ", கூட்டுத்தொகை

கூட்டுத்தொகைவிடை = பகாஎண்ணா(கூட்டுத்தொகை)

@(கூட்டுத்தொகைவிடை) ஆனால்
	பதிப்பி "இந்தக் கூட்டுத்தொகையும் ஒரு பகா எண்தான்"
இல்லை
	பதிப்பி "இந்தக் கூட்டுத்தொகை பகா எண் அல்ல"
முடி
#*****************************

நிரல்பாகம் கணக்கில்மட்டும்தான் உதவுமா? மற்ற இடங்களில் அதனை உபயோகப்படுத்தமுடியாதா?

நன்றாக உபயோகப்படுத்தலாம். உதாரணமாக, படம் வரைவதற்கு!

ஏற்கெனவே ‘எழில்’ பயன்படுத்திப் பல எளிய படங்களை வரைந்திருக்கிறோம், இப்போது, கொஞ்சம் சிக்கலான ஒரு படத்தை வரைவோம், நிரல்பாகம் உதவியுடன்!

இங்கே நாம் வரையப்போவது, ஒரு செடியின் படம் (ஆங்கிலத்தில் Fern என்பார்கள்), இந்தச் செடியில் உள்ள வெவ்வேறு அளவிலான இலைகளையெல்லாம் ஒவ்வொன்றாக வரைந்துகொண்டிருக்காமல், நிரல்பாகத்தின்மூலம் சட்டென்று வரையப்போகிறோம். இதோ, இப்படி:

#*****************************
நிரல்பாகம் சாளரத்தில் ( அ )
    பதிப்பி "Window = ", அ
முடி

நிரல்பாகம் PD()
    பதிப்பி "Pen Down"
முடி

நிரல்பாகம் PU()
    பதிப்பி "Pen Up"
முடி

நிரல்பாகம் FD(அ)
    பதிப்பி "Forward ",அ
முடி

நிரல்பாகம் RT(அ)
    பதிப்பி "Right ", x
முடி

நிரல்பாகம் LT(அ)
    பதிப்பி "Left ",x
முடி

நிரல்பாகம் BK(அ)
    பதிப்பி "Back ",அ
முடி

நிரல்பாகம்  வேம்பு (அளவு, பதிவு)
   @( அளவு < 1 )  ஆனால்
        பின்கொடு 0
   முடி
   
   FD(அளவு)
   RT (70)
   வேம்பு (அளவு * 0.5 ,  -1 * பதிவு )
   LT(70*பதிவு)

   FD(அளவு)
   LT (70)
   வேம்பு (அளவு * 0.5,  1 *பதிவு )
   RT(70*பதிவு)
   
   RT (7*பதிவு)
   வேம்பு ( அளவு - 1, பதிவு )
   LT(7*பதிவு)
   BK(அளவு * 2)
முடி

சாளரத்தில் ( "clearscreen" )
PU()
PD()
சா = 5
BK (150*சா )

வேம்பு (25 , 1)
#*****************************

நாம் இதுவரை எழுதியதிலேயே மிகப் பெரிய நிரல் இதுதான். மேலோட்டமாகப் பார்ப்பதற்குக் கொஞ்சம் சிக்கலாக இருக்கும். ஆனால் உண்மையில், வேம்பு() என்ற நிரல்பாகத்தைக் கொண்டு நாம் எழுதுகோலை முன்னும் பின்னும் வலமும் இடமும் நகர்த்துகிறோம், ஓர் இலையை வரைகிறோம், பின் அடுத்த இலையை வரைகிறோம், இந்த செய்தியை மனத்தில் கொண்டு வாசித்தால், நிரல் தெளிவாகப் புரியும்.

இந்த அத்தியாயத்தில் நாம் பார்த்தவை சில எளிய உதாரணங்கள்மட்டுமே, உண்மையில் நிரல்பாகத்தின் பயன் மிக மிகப் பெரியது, அதன்மூலம் அற்புதமான பல கணக்குகளை நொடியில் செய்துமுடிக்கலாம், வகைவகையான படங்களை வரையலாம், உங்கள் கற்பனைமட்டுமே எல்லை!

அத்தியாயம் 8: எழில் வழி கோப்புகளை கையாளுதல் தொகு

இந்தச் சிறு கையேட்டில், எழில் நிரல் மொழியைக் கொண்டு ஏராளமான விஷயங்களைச் செய்யத் தெரிந்துகொண்டோம். அடுத்து என்ன?

Files எனப்படும் கோப்புகளை நிரல்வழியே கையாள்வதன்மூலம் நாம் மேலும் பல பயனுள்ள நிரல்களை எழுதமுடியும். அவை வெறுமனே கற்கும் நோக்கத்துக்காகமட்டுமில்லாமல், பலருக்கும் உபயோகப்படும்.

உதாரணமாக, "எழில்"மூலமாக, உங்களுடைய கணினியில் ஒரு சிறு கோப்பை உருவாக்கி, அதில் சில விஷயங்களை எழுதிப் பார்ப்போம்

முதலில் புதிய கோப்பு ஒன்றை உருவாக்குவதற்கு, நாம் “கோப்பை_திற" என்கிற சொல்லைப் பயன்படுத்தவேண்டும். இதோ இப்படி:

#*****************************
புதுக்கோப்பு = கோப்பை_திற("weekdays.txt", "w")
#*****************************

இங்கே weekdays.txt என்பது கோப்பின் பெயர், “w" என்பது நாம் அதில் ஏதோ சில விஷயங்களை எழுத(write)ப்போகின்றோம் என்பதைக் குறிக்கும் சொல்.

இப்படி நாம் உருவாக்கிய புதிய கோப்பை, “புதுக்கோப்பு" என்ற பெயரில் சேமித்துவைக்கின்றோம். பின்னர் இந்தப் பெயரைப் பயன்படுத்திப் பல செயல்களைச் செய்யலாம். உதாரணமாக:

#*****************************
அ = "திங்கள்"
ஆ = "செவ்வாய்"
இ = "புதன்"
ஈ = "வியாழன்"
உ = "வெள்ளி"

கோப்பை_எழுது(புதுக்கோப்பு, அ)
கோப்பை_எழுது(புதுக்கோப்பு, ஆ)
கோப்பை_எழுது(புதுக்கோப்பு, இ)
கோப்பை_எழுது(புதுக்கோப்பு, ஈ)
கோப்பை_எழுது(புதுக்கோப்பு, உ)
#*****************************

நிறைவாக, அந்தக் கோப்பை மூடவேண்டும். அதற்குப் பயன்படுத்தவேண்டிய நிரல் வரி:

#*****************************
கோப்பை_மூடு(புதுக்கோப்பு)
#*****************************

அடுத்தபடியாக, நாம் எழுதிய இந்தக் கோப்பில் என்ன இருக்கின்றது என்று படிக்க விரும்புகின்றோம். அதற்கு இந்தக் கட்டளைகளைப் பயன்படுத்தலாம்:

#*****************************
பழையகோப்பு = கோப்பை_திற("weekdays.txt")
வரிகள் = கோப்பை_படி(பழையகோப்பு)
பதிப்பி வரிகள்
கோப்பை_மூடு(பழையகோப்பு)
#*****************************

கவனியுங்கள், இந்தமுறை கோப்பை_திற என்ற கட்டளையில் "w" என்று குறிப்பிடவில்லை, காரணம், நாம் இந்தக் கோப்பில் எதுவும் புதிதாக எழுதப்போவதில்லை, வெறுமனே படிக்கப்போகின்றோம், அவ்வளவுதான்.

இப்போது உங்களுக்கு ஒரு பயிற்சி, இதுவரை நீங்கள் கற்றுக்கொண்ட செய்திகளை வைத்து கீழேத் தரப்பட்டுள்ள தேவைகளுக்கேற்ப ஒரு நிரல் எழுதுங்கள்:

பூஜ்ஜியம் முதல் ஐநூறு வரை உள்ள Fibonacci எண்களைக் கண்டுபிடிக்கவேண்டும்
அவை ஒவ்வொன்றின் வர்க்கங்களை(Square)மட்டும் ஒரு கோப்பில் எழுதவேண்டும்
பின்னர் அவற்றைத் திரையில் அச்சிடவேண்டும்

விடை:

#*****************************
எண்1 = 0
எண்2 = 1
எல்லை = 500

புதுக்கோப்பு = கோப்பை_திற("fibonacci.txt", "w")
கோப்பை_எழுது(புதுக்கோப்பு, எண்1 * எண்1)
கோப்பை_எழுது(புதுக்கோப்பு, எண்2 * எண்2)

எண்3 = எண்1 + எண்2

@(எண்3 <= எல்லை) வரை
	
	கோப்பை_எழுது(புதுக்கோப்பு, எண்3 * எண்3)

	எண்1 = எண்2
	எண்2 = எண்3
	எண்3 = எண்1 + எண்2

முடி

கோப்பை_மூடு(புதுக்கோப்பு)

# அச்சிடுதல்
பழையகோப்பு = கோப்பை_திற("fibonacci.txt")
வரிகள் = கோப்பை_படி(பழையகோப்பு)
பதிப்பி வரிகள்
கோப்பை_மூடு(பழையகோப்பு)
#*****************************

"எழில்" மொழியில் அருமையான பல பயன்பாடுகள் உள்ளன என்பதை விளக்கமாகப் பார்த்துவந்தோம், இதில் நீங்கள் அடிப்படை நிரல்களை எழுதப் பழகியபிறகு, அடுத்தகட்டமாக பைதான்(Python)போன்ற "எழில்"க்கு இணையான, அதேபோன்ற வடிவமைப்பைக் கொண்ட இன்னொரு விரிவான மொழியைக் கற்கலாம்.

அப்போது, நீங்கள் ஒரு முக்கியமான செய்தியை உணர்வீர்கள், "எழில்" , “பைதான்" ஆகிய இரண்டிற்கும் இடையே எழுதும் விதம் (Syntax) மாறுகிறதேதவிர, இவ்விரு மொழிகளிலும் நிரல் எழுதுவதற்கான அடிப்படைச் செயல் (Logical Thought Process) ஒன்றுதான்.

இந்த இரு மொழிகளில்மட்டுமன்று, உலகில் உள்ள அனைத்துக் கணினி நிரல் மொழிகளிலும், எழுதும் விதம்தான் மாறுபடும். சிந்திக்கத் தெரிந்தவர்கள் அதைக் கற்றுக்கொண்டு நிபுணராவது மிக எளிது. பின்னர் புதுப்புது மொழிகள் அறிமுகமானாலும் நாம் சுலபமாக அவற்றைத் தெரிந்துகொண்டு வெற்றி பெறலாம்.

ஆகவே, எந்த மொழியைக் கற்கின்றோம் என்பதை பற்றி அதிகம் கவலைப்படவேண்டாம், நிரல் எழுத்தாளராகச் சிந்திக்கக் கற்றுக்கொண்டால் போதும், அதுவே உங்களைப் பல திசைகளுக்குக் கொண்டுசெல்லும்!

“எழில்" மொழியில் தொடங்கிய உங்கள் பயணம், எல்லாப் பக்கங்களிலும் விரியட்டும், உங்களுக்கு வாழ்த்துகள்!

மேலும் காண்க தொகு

Rosetta code எழில் தமிழ் நிரல்கள்^[2]
Youtube எழில் பற்றிய விடியோ (கானொளி) ^[3]
எழில் EzhilLang Project Website ^[4]

[எழில்_தமிழ்_நிரலாக்க_மொழி-1] ttps://ta.wikipedia.org/s/27xm

[2] ttp://rosettacode.org/wiki/Category:Ezhil

[3] ttps://www.youtube.com/playlist?list=PLo6YZ6ilTE53TrRVSCCkhXGInRB1Kcwx-

[4] ttp://ezhillang.org

[1]

[2]

[3]

[4]