ஆமவடை

ஏற்கணவே பதிவு செய்த  இடத்தில் இருந்து தொடருவோம்:

ஆமவடை

படம் 1: ஆமவடை

Corollary 2 of  Theorem 3: ஒரே சொல்லில் எழுத்து இரடிக்கப்பட்டால் அந்த சொல் டோரசில் ஒரு சுழலுடன் [loop] கொண்டபடி அமையும்.

Lemma 2:  படுக்கவசமாகவும், நிமிர்ந்துவசமாகவும் அமைகப்பட்ட சொர்கள் மொழியில் இல்லாதவை.

Corollary 3 or Theorem 3: டோரசில் படுக்கவசமாகவும், நிமிர்ந்துவசமாகவும் பாதைகள்/எழுத்துக்கள் இல்லாதவை.

Theorem 4: ஒரு அகராதியில் உள்ள சொர்கள் அனைத்தையும் டோரசில் பிரதிபலித்தால் அந்த குறுக்கிடும் இடங்களின் [intersecting points] ஒன்று அல்லது மெர்பட்ட சொற்களை] எண்ணிக்கை அளவை மிக குறைவாக்கும் வண்ணம் அமைக்க முடியாது. அதாவது ஒரு அகராதியின் சொற்கள் அனைத்து எவ்வித அமைப்பில் உள்ள டோரசானாலும் சரி அதன் குறுக்கிடும் இடங்களின் எண்ணிக்கை மாராது. இது ஒரு மாறிலி [invariant].

Corollary 1 of Theorem 4: மேர்கண்ட டோரசில் [அதன் ஒரு பிரதிபலிப்பில் – ‘அ,ஆ,இ,ஈ, … ,ஒ,ஓ,ஔ‘ என்றும் ‘கசடதபரயரலவழள – ….’  என்றும் வரிசையிலோ, அல்லது வேறு பரிமாணங்களில்  அடுக்கியிருந்தால்] ஒவ்வொரு அகராதிக்கும் ஒரு சிரப்பான குறுக்கிடும் இடங்களின் எண்ணிக்கை கிடைக்கும். இந்த எண் அகராதியின் கையொப்பம் [signature] என்றும் சொல்லாம்.

Theorem 5: டோரசில் உள்ள ஓவ்வொரு அகராதி சொல்லும் ஒரு பாதை என்று கொள்ளலாம். சொல்லின் தொடக்க எழுத்து  பாதையின் தொடக்கத்தையும், சொல்லின் கடைசி எழுத்து பாதையின் முடிவையும் குறிக்கும்; பாதை திசைகொண்ட பாதையாக இருக்கும் – ஒரு அம்பு தொடக்கத்தில் இருந்து முடிவின் திசையில் வழி காட்டும். ஆகையால் அகராதியில் இல்லாத பாதைகள் பிழையாக எழுதப்பட்ட  அகராதி சொற்களுக்கு சமம், அல்லது அகராதியில் இல்லாத புதிய சொற்களுக்கு சமம்.

வாதம் [ஆதாரத்தின் தொடக்கமாக கருத்ப்படலாம்]:  டோரசில்ஒவ்வொரு சொல்லும் [அதன் பாதையும்] அகராதியில் உள்ள சொற்களாகவே இருக்கவேண்டும். Coding-theory / error correction codes theory படி இவ்வகை சரியான எழுத்துக்கள் உள்ள பாதைகள், சரியான சொற்களாகவும், தவான சொற்கள் [இல்லாத சொற்கள்] பிழையானவை என்வும் அமையும். இவ்வாரான சொற்கள் சரியானவையையின் சொற்பிழை எனவும் கருதப்பாடும்.

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

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

படம் 2: Trie மரம் என்ற தரவமைப்பு. இதில் ‘to’, ‘tea’, ‘ted’, ‘ten’, ‘A’, ‘in’, மற்றும் ‘inn’ ஆகிய சொற்கள் இடம் பெற்றுள்ளன.

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

-முத்து.

அல்கோரிதம் – அடுக்குகளை தலைகீழ் படுத்துவது எப்படி ?

Move 1,2,3 disks from peg #1 to peg #2, with peg #3 as intermediate. Move disk 4 from peg #1 to peg #4. Then move all disks from peg #2 to peg #3 using peg #1 as intermediate.

இந்த வாரம் அமெரிக்காவில் “long weekend” அதாவது மூன்று-நாள் வார விடுமுறை – காரணம் மே மதம் நான்காம் திங்கள் “Memorial day” என்கிற “அமெரிக்க போர்வீரர் நினைவு தினம்”. இதனை ஒட்டி சராசரி குடும்பங்கள் நாடெங்கும் உல்லாச பயணம், சுற்றுலா என்று செல்வது அமெரிக்க பண்பாடு. இந்த ஆண்டு எங்கள் வீட்டில் விருந்தினரை வரவேற்கிறோம் – பயணம் என்பது இந்த ஆண்டு எங்கள் விருந்திரனுக்கு மட்டுமே! சரி அப்போது ஒரு புதிய தரவமைப்பு பற்றி ஒரு blog post போடுவோம் என்று எழுத ஆரம்பித்தது இங்கே.

அடுக்கு (Stack) என்பது ஒரு மிக அடிப்படை கணினி நிரலாக்க கோட்பாடு. ஒரு அடுக்கு தரவமைப்பில் செய்யக்கூடிய நடவடிக்கைகள் ஆனது : மேல் நுழை (push), மேல் நீக்கு (pop) என்பது.

ஒரு அடுக்கை இப்படி (கீழ் கண்டபடி) உருவாக்கலாம்:

எ = அடுக்கு()
மேல்_நுழை( எ, "அ" )
மேல்_நுழை( எ, "ஆ" )

இது கணினியில் ஒரு அடுக்கு போலவே உருவெடுக்கும்,

    
   --> [ ஆ ]
       [ அ ]
      --------
அடுக்கு "எ" என்பதில் இரண்டு உருப்படிகள் உள்ளது; 
இதில் "மேல்" உருப்படி "ஆ" என்ற மதிப்பாகும்.

மேலும் இந்த அடுக்கில் மற்ற உயிரெழுத்துக்களை முழுதாக சேர்க்கலாம்:

மேல்_நுழை( எ, "இ" )
மேல்_நுழை( எ, "ஈ" )
மேல்_நுழை( எ, "உ")
மேல்_நுழை( எ, "ஊ")
மேல்_நுழை( எ, "எ")
மேல்_நுழை( எ, "ஏ")
மேல்_நுழை( எ, "ஐ")
மேல்_நுழை( எ, "ஒ")
மேல்_நுழை( எ, "ஓ")
மேல்_நுழை( எ, "ஔ")

கணினியில் இதன் தோற்றம் இப்படி இருக்கும்,

   --> [ ஔ ]
       [ ஓ ]
       [ ஒ ]
       [ ஐ ]
       [ ஏ ]
       [ எ ]
       [ ஊ ]
       [ உ ]
       [ ஈ ]
       [ இ ]
       [ ஆ ]
       [ அ ]
அடுக்கு "எ" என்பதில் பன்னிரண்டு உருப்படிகள் உள்ளது; 
இதில் "மேல்" உருப்படி "ஔ" என்ற மதிப்பாகும்.

நம்ம இங்கே ஆயுத எழுத்து “ஃ” என்பதை சேர்க்கவில்லை; உங்களுக்கு வேண்டுமானால் நீங்கள் சேர்த்து கொள்ளலாம்.

அடுக்கின் வரிசை மாற்றுவது எப்படி ?

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

மேல்_எடு( எ )
# தற்போது குவிப்பு 'எ' வில் 11 உருப்படிகள் மட்டும் இருக்கும்.
# ஏற்கெனவே உள்ள மேல் உருப்படி 'ஓ' அழிக்கப்பட்டது.
# புதிய மேல் உருப்படி 'ஓ' என்று ஆனது.

இப்போது இந்த அடுக்கின் நிலை,

 -->   [ ஓ ]
       [ ஒ ]
       [ ஐ ]
       [ ஏ ]
       [ எ ]
       [ ஊ ]
       [ உ ]
       [ ஈ ]
       [ இ ]
       [ ஆ ]
       [ அ ]
அடுக்கு : எ 

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

ஏ  = அடுக்கு()
மேல்_நுழை( ஏ, "ஔ")
@( நீளம்( எ ) > 0 ) வரை 
    மதிப்பு = மேல்_எடு( எ )
    மேல்_நுழை( ஏ, மதிப்பு )    
முடி

தற்போது அடுக்கு ‘எ’-வின் நிலை காலியானது:

 -->[ ]
அடுக்கு : எ 

ஆனால் அடுக்கு ‘ஏ’-வின் நிலையோ – வரிசை மாற்றப்பட்டது!

-->[ அ ]
   [ ஆ ]
   [ இ ]
   [ ஈ ]
   [ உ ]
   [ ஊ ]
   [ எ ]
   [ ஏ ]
   [ ஐ ]
   [ ஒ ]
   [ ஓ ]
   [ ஔ ]
அடுக்கு : ஏ 

இந்த நிரல் துண்டு Python மொழியில் இப்படி எழுதலாம்,

# (C) 2017 Ezhil Language Foundation
# This code is shared under public domain
# Ref: https://ezhillang.wordpress.com
import tamil
import pprint

class Stack:
    def __init__(self):
        self.store = list()

    def top(self):
        return self.store(-1)

    def __len__(self):
        return self.store.__len__()

    def push(self,val):
        self.store.insert(-1,val)

    def pop(self):
        val = self.store.pop()
        return val

    def display(self):
        pprint.pprint(list(zip(range(self.__len__()-1,0,-1),self.store)))
        
a = Stack()
for letter in tamil.utf8.uyir_letters:
    a.push(letter)
a.display()

rev_a = Stack()

while len(a) > 0:
    val = a.pop()
    rev_a.push(val)

print("Original stack => ")
a.display()
print("Reversed stack => ")
rev_a.display()

இதன் வெளியீடோ கீழே உள்ளபடி:

[(11, 'ஆ'),
 (10, 'இ'),
 (9, 'ஈ'),
 (8, 'உ'),
 (7, 'ஊ'),
 (6, 'எ'),
 (5, 'ஏ'),
 (4, 'ஐ'),
 (3, 'ஒ'),
 (2, 'ஓ'),
 (1, 'ஔ')]
Original stack => 
[]
Reversed stack => 
[(11, 'ஔ'),
 (10, 'ஓ'),
 (9, 'ஒ'),
 (8, 'ஐ'),
 (7, 'ஏ'),
 (6, 'எ'),
 (5, 'ஊ'),
 (4, 'உ'),
 (3, 'ஈ'),
 (2, 'இ'),
 (1, 'ஆ')]