අද Algo පාඩමෙන් කතා කරන්න යන්නේ Queue සම්බන්ධව. මේකෙදි Queue එකක් කියලා අර්ථ දක්වන්න තියෙන්නෙත් සාමාන්‍ය ජීවිතේදි අපි අත්දකින Queue එකම තමයි. ඒ කියන්නේ පේලියක් කියන එක. අපි මුලින්ම බලමු Queue එකක තියෙන ලක්ෂණ මොනවද කියලා.

FIFO?

FIFO කියන එකෙන් අදහස් වෙන්නේ First In First Out කියන එක. ඒ කියන්නේ අපි සාමාන්‍ය ජීවිතේදි දකින පේලි වලත් වෙන්නේ ඉස්සරලාම පේලියට එකතු වුණ කෙනා තමයි මුලින්ම පේලියෙන් එළියට යන්නේ. හැබැයි මතකද අපි කලින් ලිපියෙ Stacks ගැන කියන වෙලාවෙදි LIFO එකක් ගැන කිවුවා. ඒක බැලුවෙ නැත්නම් මෙතනින් බලන්න. ඒකෙදි අපි කලේ මේකෙ විරුද්ධ වැඩේ.

Basic Operations

Queue එකක තියෙන මූලිකම මෙහෙයුම් කිහිපය තමයි මේ පහලින් තියෙන්නේ.

1. Enqueue
2. Dequeue
3. Peek
4. isFull
5. isEmplty

මේ Method ටිකත් අපි කලින් කතා කරපු Stack එකට ගොඩක් සමානයි.

Peek : 

Data එකක් එළියට ගන්නේ නැතිව මුලින්ම(Front) තියෙන Data එක බලන Method එක.

Algorithm:

begin procedure peek

   return queue[front]
   
end procedure

Implementation ( C )

int peek() {
   return queue[front];
}

isFull : 

Queue එක සම්පූර්ණයෙන්ම පිරිලාද නැද්ද Check කරන Method එක. මේකෙදි අපි කරන්නේ Queue එකේ Rear Point එක Queue එකේ Max Size එකට සමාන වුණොත් True Return කරනවා.

Algorithm:

begin procedure isfull

   if rear equals to MAXSIZE
      return true
   else
      return false
   endif
   
end procedure

Implementation ( C )

bool isfull() {
   if(rear == MAXSIZE - 1)
      return true;
   else
      return false;
}

isEmpty : 

Queue එක හිස් වෙලා තියනවද කියලා Check කරන Method එක. Queue එකක් Empty ද නැද්ද කියලා බලන්නේ Front එකේ Value එක Queue එකේ තියෙන්න පුළුවන් අඩුම අගයට එහෙම නැත්නම් 0ට වඩා අඩුයිද කියලා Check කරන එක.

Algorithm:

begin procedure isempty

   if front is less than MIN  OR front is greater than rear
      return true
   else
      return false
   endif
   
end procedure

Implementation ( C )

bool isempty() {
   if(front < 0 || front > rear) 
      return true;
   else
      return false;
}

Enqueue : 

Queue එකට Data Insert කරන Method එක. මේකෙදි අපි පියවර කිහිපයක් අනුගමනය කරනවා Data එකක් Queue එක ඇතුලට දාන්න කලින් අපි එකින් එක පියවර විස්තර ඇතිව බලමු.

පළමු පියවර : Queue එක දැනට Full ද කියලා Check කරන එක. ඒ කියන්නේ Queue එක Full වෙලා තිබුණොත් අපිට තවත් Data Insert කරන්න බෑනෙ. ඒක මේ Check එකෙන් පස්සේ Full වෙලා තිබුණොත් නතර කරනවා

දෙවන පියවර : Queue එක Full වෙලා තිබුණේ නැත්නම් අපි Rear Point එක 1කින් වැඩි කරනවා. ඒ කියන්නේ Next Empty Space එකට.

තුන්වන පියවර : දැන් Rear Point එක තියෙන තැනට අපිට අවශ්‍ය Data එක Insert කරනවා.

Algorithm:

procedure enqueue(data)      
   if queue is full
      return overflow
   endif
   
   rear ← rear + 1
   
   queue[rear] ← data
   
   return true
   
end procedure

Implementation ( C )

int enqueue(int data)      
   if(isfull())
      return 0;
   
   rear = rear + 1;
   queue[rear] = data;
   
   return 1;
end procedure

Dequeue : 

Queue එකෙන් Data එළියට ගන්න Method එක. මේක කරන්නත් අපි උඩදි කතා කරා වගේ පියවර කිහිපයක් යන්න ඕන.

පළමු පියවර : Queue එක Empty ද කියලා Check කරන්න ඕන. මොකද අපිට Empty Queue එකකින් Data එකක් එළියට ගන්න බෑ.

දෙවන පියවර : Queue එක Empty වෙලා තිබුණොත් Underflow Error එකක් Display කරනවා. නැත්නම් Front Pointer එක ඊළඟ Element එකට Point කරනවා.

Algorithm:

procedure dequeue
   if queue is empty
      return underflow
   end if

   data = queue[front]
   front ← front + 1
   
   return true
end procedure

Implementation ( C )

int dequeue() {

   if(isempty())
      return 0;

   int data = queue[front];
   front = front + 1;

   return data;
}

දැන් අපි මේ එකින් එක බලපු Methods ටික එකතු කරලා සම්පූර්ණ Queue එකක Implementation එක බලමු.

Language : C

typedef void * queue_data_type;
struct queue_item {
	queue_data_type contents;
	struct queue_item* next;
};
struct queue_root {
	struct queue_item* head;
	struct queue_item* tail;
};

void init_queue(struct queue_root* queue){
	queue->head = queue->tail = NULL;
}

void push_queue(struct queue_root* queue, int size, queue_data_type contents){
	struct queue_item *item = malloc(sizeof(item));
	item->contents = contents;
	item->next = NULL;
	if (queue->head == NULL){
		queue->head = queue->tail = item;
	} else {
		queue->tail = queue->tail->next = item;
	}
}

queue_data_type pop_queue(struct queue_root* queue){
	queue_data_type popped;
	if (queue->head == NULL){
		return NULL; // causes a compile warning.  Just check for ==NULL when popping.
	} else {
		popped = queue->head->contents;
		struct queue_item* next = queue->head->next;
		free(queue->head);
		queue->head = next;
		if (queue->head == NULL)
			queue->tail = NULL;
	}
	return popped;
}

void process_queue(struct queue_root* queue, void (*func)(queue_data_type)){
	if (queue == NULL)
		return;
	struct queue_item* current = queue->head;
	while (current != NULL){
		next = current->next
		func(current->contents);
		current = next;
	}
}

හරි එහෙනම් මොනවා හරි ප්‍රශ්ණයක් තිබුණොත් Comment එකක් දාන්න.

The post Queue Abstract Data Type (With Implementation) appeared first on The SIGMA.

Stacks

මුලින්ම මේ පාඩම් මාලාව හැඳින්වීමේදි අපි කතා කරා මොනවද මේ Data Structures කියන්නේ සහ ඇයි අපිට මේ දේවලි ඕන වෙන්නේ කියලා. ඒ ලිපිය බැලුවේ නැත්නම් මෙතනින් බලන්න.

හරි අපි අද කතා කරන්න යන්නේ අපේ පළවෙනි Data Type එක ගැන. stacks කියන්නේ එක්තරා විදියක Operations කිහිපයකට සීමා වෙලා තියෙන Data Type එකක්. ඒ කියන්නේ stack එක්ක අපිට කරන්න පුළුවන් වෙන්නේ Data ඇතුලට දාන එක, අන්තිමට දැම්ම Data එක ආපහු ගන්න එක හා අන්තිමට දැම්ම Data එක මොකද්ද කියලා බලන එක විතරයි. ඒකයි මේක ගොඩක්ම සරලම මට්ටමේ Data Type එකක් වෙන්නේ. මේ Data Type එකට Array එකකදි වගේ ඕන තැනකට Data දාන්නත් ඕන තැනකින් Data එළියට ගන්නත් බෑ. මේ Data Type එකට Data ගන්න සහ දාන්න පුළුවන් වෙන්නේ LIFO (Last In First out) කියන Method එකට අනුව. ඒ කියන්නේ ඔයාට මේ Data Type එකෙන් Data එකක් එළියට ගන්න ඕන නම් ගන්න පුළුවන් වෙන්නේ අන්තිමට ඇතුලට දැම්ම Data එක. තේරුනේ නැහැනේ? හරි අපි තව ටිකක් විස්තර ඇතිව බලමු.

FIFO කියන්නේ මොකක්ද?

සරලවම විස්තර කරන්න උදාහරණ කිහිපයක් කියන්නම්.

හිතන්න මේ වගේ පොත් ගොඩක් හදන්න වුනොත් ඔයාට පොත් ටික අරගෙන පිළිවෙලට පොත් එකින් එක අරගෙන ගොඩ ගහන්න වෙනවනේ. දැන් හිතන්න ඔයා ආපහු ඔය පිලිවෙලට හදපු පොත් ගොඩින් එකින් එක පොත් ආපහු ගන්නවා කියලා. ඒ කියන්නේ ඔයාට මුලින්ම ගන්න වෙන්නේ අන්තිමට තිබ්බ පොත. ඔයා මුලින්ම තිබ්බ පොත ආපහු ගන්න වෙන්නේ අන්තිමට. Stack එකත් මෙන්න මේ උදාහරණයට සමානයි. පොත් කියන්නේ හරියට ඔයාගෙ Stack එක ඇතුලේ තියෙන එක එක Data වගේ. පොත් ගොඩගහනවා වගේ ඔයා මේ Stack එකට Data දාන්න යන්නේ.

තවත් උදාහරණයක් තමයි හැමෝම වගේ දැකලා ඇති පුටු මේ විදියට එක උඩ එක අහුරලා තියෙන විදිය. හැමෝම මේක ප්‍රායෝගික ජීවිතේදි කරලත් ඇතිනේ. මේකෙදිත් වෙන්නේ උඩදි කිවුව පොත් උදාහරණෙ වුන කතාවම තමයි. අන්තිමට දැම්ම පුටුව තමයි ආපහු ගද්දී මුලින්ම ගන්න වෙන්නේ.

Stack Operations

මේ ලිපියේ මුලදිත් මම සඳහන් කරා Stack එකක තියෙන මූලිකම Operations ගැන. දැන් හදන්නේ ඒවා ගැන විස්තරාත්මකව කතා කරගෙන යන්න.

1. Push
2. Pop
3. Peek

1.PUSH

මේ Method එකෙදි කරන්නේ Stack එකට Data දාන එක. ඒ කියන්නේ Data දාන්නේ Stack එකේ Top එකට. ඒක වෙන්නේ කොහොමද කියලා උඩ උදාහරණත් එක්ක ඔයාලට තේරෙනවා ඇති කියලා හිතනවා. Stack එකකට Data Insert කරන්න තියෙන එකම Method එක PUSH කරන එක.

2.PULL

මේ Method එක යොදාගෙන තමයි Stack එකේ උඩම තියෙන Data එක ආපහු එළියට ගන්න. ඒකෙදි වෙන්නේ Stack එකෙන් අයින් වෙලා Data එක එළියට එන එක.

3.PEEK

මේකෙදි කරන්නේ Stack එකෙන් Data එක එළියට ගන්නේ නැතුව උඩම තියෙන Data එක මොකද්ද කියලා බලන ඒක. මේකෙදි Stack එකෙන් Data එක අයින් වෙන්නේ නෑ. නිකත් උඩ තියෙන්නේ මොකද්ද කියලා බලන එක විතරයි.

Implementation

Python:

class Stack(object):

    def __init__(self):
        self._list = []

    def push(self, item):
        self._list.append(item)

    def pop(self):
        try:
            return self._list.pop()
        except IndexError:
            raise IndexError('pop from empty stack')
    def peek(self):
        try:
            print(_list[len(_list-1)])
        except IndexError:
            raise IndexError('empty stack')

def main():
    st = Stack()
    # Push and print
    for i in range(10):
        st.push(i)
        print("Pushed ", i)
    st.push('Hello World')

    # Pop
    print(st.pop())

    # Exceptions
    while True:  # Empty the stack
        try:
            st.pop()
        except Exception as e:
            print('Exception: {0}'.format(e))
            break


if __name__ == '__main__':
    main()

C:

#include 
#include 

typedef struct stack {
	void *data;
	struct stack *next;
} Stack;

Stack *new_stack_node(void *data) {
	Stack *new_node = (Stack*) malloc(sizeof(Stack));
	if (new_node == NULL) {
		return NULL;
	}
	new_node -> data = data;
	new_node -> next = NULL;
	return new_node;
}

int push(Stack **stack, void *data) {
	Stack *new_node = new_stack_node(data);
	if (new_node == NULL) {
		return 0;
	}
	new_node -> next = *stack;
	*stack = new_node;
	return 1;
}

void *pop(Stack **stack) {
	if (*stack == NULL) {
		return NULL;
	}
	Stack *temp = *stack;
	*stack = (*stack) -> next;
	temp -> next = NULL;
	void *data = temp -> data;
	free(temp);
	return data;
}

int main() {
	int a = 5;
	float b = 6.0;
	char c[] = "Hello World!";
	Stack *st = NULL;
	push(&st, (void*) (&a));
	push(&st, (void*) (&b));
	push(&st, (void*) (c));
	char *c_popped = (char*) pop(&st);
	float b_popped = *((float*) pop(&st));
	int a_popped = *((int*) pop(&st));
	printf("%d %f %s\n", a_popped, b_popped, c_popped);
	if (pop(&st) == NULL) {
		printf("Unable to pop from empty stack\n");
	}
	return 0;
}

තවත් Languages වලින් බලන්න මෙතනින් යන්න.

දැන් අපි මේ ලියපු Stack එක භාවිතා කරලා විසදන්න පුළුවන් ගැටළු මොනවද කියලා පොඩ්ඩක් බලමු.

1. Parenthesis 

මේ ප්‍රශ්ණය තමයි අපි මොකක් හරි String එකක් දුන්නහම ඒ දුන්න String එක ඇතුලේ තියන වරහන් Balance වෙලා තියෙනවද කියලා බලන එක. උදාහරණයක් විදියට (3*[5+2]) මේ කොටසේ වරහන් Balance වෙලා තියෙන්නේ කියලා පේනවනේ. හැබැයි මේ වගේ එකක් ගන්න. (5+(5]} මේක Balance වෙලා නෑ. අන්න ඒ දේ හඳුන ගන්න අපි කොහොමද මේ stack එක යොදා ගන්නේ.

විසඳුම:

• අපි කරන්නේ අපිට Open Bracket({[() එකක් හම්බෙන හැම වෙලාවකම ඒක අපි Stack එකක් ඇතුලට දාගන්නවා.
• Close Bracket එකක් හම්බුණොත් අපි Stack එකෙන් එක පාරක් POP කරලා හම්බෙන Open Bracket එක අපේ Close Bracket එකට සමානයිද කියලා Check කරනවා. සමාන වුණොත් තවත් මේ විදියට ඉස්සරහට Check කරගෙන යනවා. නැත්නම් Program එක Close කරනවා ගැලපෙන්නේ නෑ කියලා.
• Bracket හැර හම්බෙන අනිත් හැම Character එකක්ම අපි නොසලකා හරිනවා.

වැඩේ තේරුණේ නෑ වගේ නම් ආපහු මේ Image එක දිහා බලන්න.

Implementation:

class Stack():
    def __init__(self):
        self.items=[]

    def isEmpty(self):
        return self.items==[]

    def push(self,item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def peek(self):
        return self.items[len(self.items)-1]

    def size(self):
        return len(self.items)

x=str(input("Enter the Statement"))
s1=Stack()

u=0
d=0
for k in x:
    if k=='[' or k=='(' or k=='{':
        s1.push(k)
        d+=1

    elif k==']' or k==')' or k=='}':
        a=s1.pop()
        print(a,k)
        if (a=='(' and k==')') or (a=='[' and k==']') or (a=='{' and k=='}'):
            u+=1
            
        else:
            print("Not a Parantheses")

if u==d:
    print("This is a Parantheses")

2. Palindrome

මේ ප්‍රශ්ණෙ තමයි මුල ඉඳලා අගට කියෙවුවත් අග ඉඳලා මුලට කියෙවුවත් සමාන විදියට ශබ්ද වෙන වචන හොයන එක. උදාහරණයක් විදියට MADAM වගේ.

විසඳුම:

මේ ප්‍රශ්නෙ විසඳන්න අපි කරන්නේ මේ වගේ වැඩක්. අපිට දෙන String එක Stack එකකට දාගෙන ඒකෙන් POP කරගෙන තවත් Stack එකක් හදා ගන්නවා. ඒ කියන්නේ මේකෙදි Stacks දෙකක් යොදා ගන්න වෙනවා.  ඊට පස්සේ පළවෙනි Stack එකට ආපහු අර String එක දාගෙන මේ Stack දෙකෙන් POP කර කර බලනවා හැම element එකක්ම සමාන වෙනවද කියලා. POP කරන හැම සැරේකම Elements සමාන වෙනවා කියන්නේ මේක Palindrome එකක් වෙනවා.

Implementation: 

මේකෙ Implementation එක මම කරලා තියෙන්නේ Stack Class එකටමයි. එහෙම නැතුව වෙනම කරන්නත් පුළුවන් අවුලක් නැතුව.

class Stack(object):
    def __init__(self,items):
        self.items=[]
        for e in items:
            self.push(e)

    def push(self,item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def __repr__(self):
        return str(self.items)  

    def isPalindrome(self):
        tr=Stack([])
        t=Stack(self.items)
        while t.items:
            tr.push(t.pop())
        t=Stack(self.items)    
        while t.items and tr.items:
            c1=t.pop()
            c2=tr.pop()
            print c1,c2
            if c1!=c2: return False
        return True    

තවත් මේ Stack එක භාවිතා කරලා විසඳන්න පුළුවන් ප්‍රශ්ණ තියෙනවා Post Fix Expressions වගේ ගැටළු. ඒවාට පුළුවන්නම් උත්සාහ කරලා බලන්න. Code එකේ මොනවා හරි ප්‍රශ්ණයක් තිබුණොත් Comment කරන්න උදව් කරන්නම්…

ඊළඟ පාඩම QUEUES.  

The post Stack Abstract Data Type (With Implementation) appeared first on The SIGMA.

What is String Match?

String Match is a useful activity in our day today lives. If you want to search something that you don’t know you just google the word or set of words that describes what you want to know. And in the studies if you want to find a phrase in a book you search for it one page by page. The manual efficient String Search Algorithm is  the dictionary. Dictionary has ordered every word in ascending order of the alphabet. If you want to find a word from the dictionary you can move to the exact page very fast.

But Just imaging if you have a book with 1000 pages and just text paragraphs and you want to find a word. You will have to read the entire book to find what you search for. But how computer find a string so quickly from a thousands of words. I’m going to explain some algorithms works inside the computer from this set of posts. These are the algorithms:

1. Naive Search Algorithms
2. Boyer – moore Algorithm
3. Robin – karp Algorithm

1. Naive Search Algorithm

Native Search algorithms is kind of idiot algorithm that use in computers to search words. I call it idiot because the run time is very high. However this is the simplest algorithm for implementation

#include <stdio.h>
#include <memory.h>

void bruteForce(char text[],char pattern[]);

int main() {
char text[]="abbcabab";
char pattern[]="ab";
bruteForce(text,pattern);
}

void bruteForce(char text[],char pattern[]){

int maxShift= strlen(text)- strlen(pattern);
for (int i=0;i<maxShift;i++){
int count_of_match=0;
for (int j=0;j< strlen(pattern);j++) {
if (text[i + j] == pattern[j]) {
count_of_match++;
}
}
if (count_of_match== strlen(pattern)){
printf("%s%d\n","pattern matched at index ",i);
}
}
}

For this kind of search It will take O(mn) kind of complexity for find a single word. It’s heavily use the system resources because it compares character by character again and again. Therefore we have some other algorithm to make it Faster.

 2. Boyer Moore Algorithm

This is a kind of fast algorithm when comparing with naive search. Because this can shift the pattern fast and find the index where the pattern exactly positioned.

You can more refer about this algorithm from here :  https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm

In this algorithm the most considered thing is bad characteristic table.  First we go thorough all characters in the text and make and array with key as the index and the value as the index character  last occurred index of the pattern. If the selected character is not occurred in the pattern we put -1 as the value . This is the reprocessing part of the algorithm. Once this table is generated you can search for a string with O(n) complexity.

Ok let’s go for the Implementation.

#include <stdio.h>
#include <string.h>

int findchar(char pat[], char letter);
int boyer_moore(char txt[], char pat[]);
void setTable(char text[],char pattern[]);
int index_table[256];

int main(){
char text[] = "ratcatbatnatfat";
char pattern[] = "cat";
int shift= boyer_moore(text,pattern);
if (shift!=-1){
printf("%s%d\n","Match Found at index",shift);
}else{
printf("%s\n", "Not found a Match");
}
return 0;
// findchar(pattern,'c');
}

int boyer_moore (char txt[], char pat[]){
setTable(txt,pat);
int i,j,n=strlen(txt),m=strlen(pat),lastch;
i=m-1;
j=m-1;
while (i<n){
if (txt[i]==pat[j]){
// printf("%c%s%d\n",txt[i]," i= ",i);
if (j==0){
//printf("%s%d\n"," ",i);
return i;
}else{
j--;
i--;
}
}else{
lastch=index_table[(int)txt[i]];
// printf("%s%c%d","Last char of ",txt[i],lastch );
if(lastch==-1){
i+=m;
}else{
i+=(j-lastch);
}
// printf("%s%d\n"," i= ",i);
j=m-1;
}
}
return -1;
}

int findchar(char pat[], char letter){
int pat_size= strlen(pat)-1;
for (int i=0; i<pat_size+1; i++){
// printf("%c%s%c\n", pat[pat_size-i]," > ",letter);
if (pat[pat_size-i]==letter){
// printf("%s%c%d","letter ",letter,(pat_size-i));
return (pat_size-i);
}
}
return -1;
}

void setTable(char text[],char pattern[]){
for (int i=0;i<strlen(text);i++) {
int current= findchar(pattern,text[i]);
index_table[(int)text[i]]=current;
}
// for (int i=0;i<256;i++){
// printf("%d\n",index_table[i] );
// }
}

I’m not going to explain whole code. But If you don’t understand what kind of method that I have used simply just put a comment about your problem. Then I would like to move in to the rabin karp algorithm.

3.  Rabin Karp Algorithm

Rabin karp is kind of method that based on some calculation. Actually humans can’t go with this process because we are poor in calculations. But a computer can do it very fast. So in this method we use a Hashing method to compare two strings. Hash is generated by a mathematical formula. I will paste the Implementation and reference link for find more information about this algorithm.

Reference : https://en.wikipedia.org/wiki/Rabin%E2%80%93Karp_algorithm

#include <stdio.h>
#include <string.h>

#define d 256

int rabincarp_search(char pattern[], char text[], int q){
int m = strlen(pattern);
int n= strlen(text);
int i,j,t=0,p=0,h=1;

for (i=0; i<m-1; i++){
h=(h*d)%q;
}

for (i=0; i<m ; i++){
p=(p*d + pattern[i])%q;
t=(t*d + text[i])%q;
}

for (i=0; i<=n-m; i++){
if (p==t){
for (j=0; j<m; j++){
if (text[i+j]!=pattern[j]){
break;
}
}
if(j==m){
printf("%s%d\n", "Pattern has found in index ",i);
}
}
if (i<n-m){
t=(d*(t-text[i]*h) + text[i+m])%q;
if (t < 0)
t = (t + q);
}
}
return 0;
}

int main(){
char text[]="carratcappatnat";
char pattern[]="rat";
int q=101;
int shift=rabincarp_search(pattern,text,q);
return shift;
}

This will little weird if you don’t try it yourself. Just try and post your questions here. I will be there to help you. Thank You.

The post String Matching Algorithms appeared first on The SIGMA.