All Assignments

How to Convert CFG to PDA

noreply@blogger.com (Unknown) — Tue, 22 Sep 2009 15:09:00 +0000

Sample here :

http://www.cse.msu.edu/~torng/Classes/Archives/cps360.98spring/Examples/CFGtoPDA/tsld001.htm

watch: alan turings documentary

Fibonacci in C#

noreply@blogger.com (Unknown) — Sun, 20 Sep 2009 13:42:00 +0000

It is a pattern when you add the 2 previous numbers together and to get the next number. And so on.

1. 1. 1. 2. 3. 5. 8. 13. 21. 34. 55. 89. 144. And so on.


int a = 0;
int b = 1;
int c = 0;
int n = 46; //to the N'th fibonacci No.

Console.WriteLine("Which Fibonacci Number do you want?");

n = Convert.ToInt16(Console.ReadLine());

if (n != 1)
{
        for (int i = 1; i <= n; i++)
        {
                c = a + b;
                a = b;
                b = c;
        }
        Console.WriteLine("the {0}th Fibonacci number is {1}", n, a);
}
else
{
        Console.WriteLine("the {0}st Fibonacci number is 1", n);
}
Console.ReadKey();

Fibonacci in C++

noreply@blogger.com (Unknown) — Sun, 20 Sep 2009 13:41:00 +0000

It is a pattern when you add the 2 previous numbers together and to get the next number. And so on.

1. 1. 1. 2. 3. 5. 8. 13. 21. 34. 55. 89. 144. And so on.


#include < iostream. h >
using namespace std;
int main()
{
        int number[30] = {1, 1, 0};
        int total;
        for(int i = 2; i < 30; i++)
        {
                number[i] = number[i - 1] + number[i - 2];
                cout << number[i] << endl;
        }
        return 0;
}

Fibonacci in C

noreply@blogger.com (Unknown) — Sun, 20 Sep 2009 13:40:00 +0000

It is a pattern when you add the 2 previous numbers together and to get the next number. And so on.

1. 1. 1. 2. 3. 5. 8. 13. 21. 34. 55. 89. 144. And so on.

#include < stdio.h >

int main()
{
        int i, x;
        int a = 0;
        int b = 1;

        printf("%i\n%i\n", a, b);
        for(i = 2; i < 100; i++)
        {
                x = a;
                a = b;
                b = x + b;
                printf("%i\n", b);
        }

        return 0;
}

Fibonacci in Basic

noreply@blogger.com (Unknown) — Sun, 20 Sep 2009 13:40:00 +0000

It is a pattern when you add the 2 previous numbers together and to get the next number. And so on.

1. 1. 1. 2. 3. 5. 8. 13. 21. 34. 55. 89. 144. And so on.
BASIC
fib0=0

fib1=1

FOR cnt= 1 TO n

fib2=fib1+fib0

PRINT fib2

fib0=fib1

fib1=fib2

NEXT cnt

/* fib2 is the sum of the two preceeding terms.*/

Hex to Oct Vice Versa Converter Using c#

noreply@blogger.com (Unknown) — Thu, 30 Jul 2009 10:42:00 +0000


/*First u must create a Ui*/


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
  public partial class Form1 : Form
  {
      public Form1()
      {
        InitializeComponent();
      }

      private void button1_Click(object sender, EventArgs e)
      {
       int x, flag = 0;
       for (x = 0; x <> 97 && textBox1.Text[x]
 <> 64 && textBox1.Text[x] < flag =" 1;" 
flag ="=" text = "" val =" 0," power =" 
(textBox1.TextLength" str = "" str2 = "" i =" 0;"
 num =" val;" rem =" num" num =" num" rem ="=" 
rem ="=" rem ="=" rem ="=" rem ="=" rem ="=" i =" 
str.Length">= 0; i--)
              {
                  str2 += str[i];
              }
              if (textBox1.Text == "0")
                  textBox2.Text = "0";

              textBox2.Text = textBox2.Text + str2;
          }
          else
          {
MessageBox.Show("Value should not have digits like 8, 9 or any alphabet!");
              textBox1.Text = "";
          }

      }

      private void button2_Click(object sender, EventArgs e)
      {
          textBox4.Text = "";
          int val = 0, power = (textBox3.TextLength - 1), i;
          int num, rem;
          String str = "", str2 = "";


     for (i = 0; i < num =" val;" rem =" (int)num" num =" 
(int)num" i =" str.Length">= 0; i--)
          {
              str2 += str[i];
          }

    textBox4.Text = textBox4.Text + str2;  
      }

   private void Form1_Load(object sender, EventArgs e)
      {

      }
  }
}

Fibonacci in Assembly Language

noreply@blogger.com (Unknown) — Wed, 29 Jul 2009 04:44:00 +0000

It is a pattern when you add the 2 previous numbers together and to get the next number. And so on.

1. 1. 1. 2. 3. 5. 8. 13. 21. 34. 55. 89. 144. And so on.


ASSEMBLY
.data
fibonacci DWORD 100 dup (0)
.code
mov edx,offset fibonacci
mov eax,1
mov ebx,1
mov ecx,49
@@:
mov DWORD PTR [edx],eax
mov DWORD PTR [edx+4],ebx
add eax,ebx
add ebx,eax
add edx,8
sub ecx,1
jnz @B

Octal to Binary number converter

noreply@blogger.com (Unknown) — Tue, 30 Jun 2009 10:14:00 +0000


#include < iostream.h >
void main ()
{
 const int converts = 10;

  for (int ctr = 1;ctr <= converts; ctr++)
  {
 int dec = 0, mult = 1, prod = 0, rem, oct, px, chk;
 bool isoctal = true;
 
 cout << "Enter a valid Octal Number: ";
 cin >> oct;
 
 px = oct;

 while (px > 0)
 {
  chk = px % 10;
  if (chk >= 8)
  {
   isoctal = false;
   cout << "Invalid Octal Number\n\n";
   break;
  }
  px = px / 10;
 }

 if (isoctal)
 {
 while (oct > 0)
 {
  rem = oct % 10;
  prod = rem * mult;
  dec = dec + prod;
  mult = mult * 8;
  oct = oct / 10;
 }

 mult = 1;

 while (dec > 0)
 {
  rem = dec % 2;
  prod = rem * mult;
  oct = oct + prod;
  mult = mult * 10;
  dec = dec / 2;
 }

 cout << "The Binary equivalent is: " << oct << "\n\n";
 }
 
  }
}

source: http://www.planetsourcecode.com/

Pumping lemma for regular languages

noreply@blogger.com (Unknown) — Tue, 30 Jun 2009 09:06:00 +0000

In the theory of formal languages, the pumping lemma for regular languages describes an essential property of all regular languages. Informally, it says that all sufficiently long words in a regular language may be pumped - that is, have a middle section of the word repeated an arbitrary number of times - to produce a new word which also lies within the same language.

The pumping lemma was first articulated by Y. Bar-Hillel, M. Perles, E. Shamir in 1961.It is useful for disproving the regularity of a specific language in question. It is one of a few pumping lemmas, each with a similar purpose.

Formal statement

Let L be a regular language. Then there exists an integer p ≥ 1 depending only on L such that every string w in L of length at least p (p is called the "pumping length") can be written as w = xyz (i.e., w can be divided into three substrings), satisfying the following conditions:

1. |y| ≥ 1
2. |xy| ≤ p
3. for all i ≥ 0, xyiz ∈ L

y is the substring that can be pumped (removed or repeated any number of times, and the resulting string is always in L). (1) means the loop y to be pumped must be of length at least one; (2) means the loop must occur within the first p characters. There is no restriction on x and z.

Informal statement and explanation

The pumping lemma describes an essential property of regular languages. It says that a word w of the language L with length of at least m, (where m is a constant, called the pumping length, depending only on the language L) may be split into three substrings, w = xyz, such that the middle portion, y (which must not be empty), can be repeated an arbitrary number of times (including zero times, which removes it) yielding a string that is still in L. This process of repetition is known as "pumping". Moreover, the pumping lemma guarantees that the length of xy will be at most m, imposing a limit on the ways in which w may be split. Note that finite languages satisfy the pumping lemma trivially by having m equal to the maximum string length in L plus one.

Use of lemma

The pumping lemma is often used to prove that a particular language is non-regular: a proof by contradiction (of the language's regularity) may consist of exhibiting a word (of the required length) in the language which lacks the property outlined in the pumping lemma.

For example the language L = {anbn : n ≥ 0} over the alphabet Σ = {a, b} can be shown to be non-regular as follows. Let w, x, y, z, p, and i be as stated in the pumping lemma above. Let w in L be given by w = apbp. By the pumping lemma, there must be some decomposition w = xyz with |xy| ≤ p, |y| ≥ 1 such that xyiz in L for every i ≥ 0. If we let |xy|=p and |z|=p, then xy is the first half of w, consisting of p consecutive instances of the letter a. Because |y| ≥ 1, it contains at least one instance of the letter a and xy2z has more instances of the letter a than the letter b. Therefore xy2z is not in L (note that any value of i ≠ 1 will give us a contradiction). We have reached a contradiction because, in this case, the pumped word does not belong to the language L. Therefore, the assumption that L is regular must be incorrect. Hence L is not regular.

The proof that the language of balanced (i.e., properly nested) parentheses is not regular follows the same idea. Given p, there is a string of balanced parentheses that begins with more than p left parentheses, so that y will consist entirely of left parentheses. By repeating y, we can produce a string that does not contain the same number of left and right parentheses, and so they cannot be balanced.
source: wikipidea

Decimal to Binary, Octal and HEX converter

noreply@blogger.com (Unknown) — Thu, 25 Jun 2009 13:41:00 +0000

to be exact here :

http://www.c.happycodings.com/Beginners_Lab_Assignments/code18.html


#include< stdio.h >
#include< conio.h >
#define MAX 79
#define ESC 27
void main()
{
   char res,r;
   int i,k=0,y;
   long j=0,l=0,o=0;
   textcolor(15);
   for(i=0;i<5000;i++)
      cprintf(" ");
   while(1)
   {
      clrscr();
      printf("Enter Any Number To Be Converted : ");
      scanf("%ld",&j);
      l=j;
      o=l;
      k=0;
      if(j>2145555550)
      {
         textcolor(4);
         gotoxy(15,5);
         cprintf("The Number Is Greater Than Range");
         textcolor(15);
         getch();
         goto end;
      }
      else
      {
         gotoxy(1,6);
         printf("Binary Equivalent:-");
         y=MAX;
         while(j>0)
         {
            k=j%2;
            j=j/2;
            gotoxy(y,6);
            y--;
            printf("%d",k);
         }
         gotoxy(1,8);
         printf("Hexadecimal Equivalent:- ");
         y=MAX;
         while(l>0)
         {
            k=l%16;
            l=l/16;
            gotoxy(y,8);
            y--;
            if(k<=9)
            {
               printf("%d",k);
            }
            if(k==10)
            {
               printf("A");
            }
            if(k==11)
            {
               printf("B");
            }
            if(k==12)
            {
               printf("C");
            }
            if(k==13)
            {
               printf("D");
            }
            if(k==14)
            {
               printf("E");
            }
            if(k==15)
            {
               printf("F");
            }
         }
         gotoxy(1,10);
         printf("Octal Equivalent:- ");
         y=MAX;
         while(o>0)
         {
            k=o%8;
            o=o/8;
            gotoxy(y,10);
            y--;
            printf("%d",k);
         }
      }
      gotoxy(15,25);
      printf("Press Any Key To Continue , ESC To Exit");
      res=getch();
      if(res==ESC)
      {
         break;
      }
   }
   end:
   textcolor(7);
   for(i=0;i<5000;i++)
      cprintf(" ");
   clrscr();
}

Regular Languages

noreply@blogger.com (Unknown) — Wed, 24 Jun 2009 05:16:00 +0000

1. L((a+b)*a)= L(a+b)*
= {a,b}*
= {e,a,b,aa,ab,ba,bb,...}
L((a+b)*a)={a,b}*,{a}
={a,aa,ba,aaa,aba,...}
{w є {a,b}* / w ends in a}
_______________________________________

2 . L(a*b*) = L(a*) L(b*)
L(a*) = {e, a, aa, aaa, aaaa, …}
L(b*) = {e, b, bb, bbb, bbbb, …}
L(a*) L(b*) = {e, a, aa, aaa, aaaa, …}
= {e, b, bb, bbb, bbbb, …}
other option:
if
L(a*b*) = L(a*)L(b*)
L(a*) = {e,a,aa,aaa,....}
L(b*) = {e,b,bb,bbb,....}

then
L(a*)L(b*)={ee,eb,ebb,ebbb,.....,ae,ab,abb,....}
daun sort nimo lexicographic.

therefore ang first five kay:
L(a*)L(b*)={e,a,b,aa,ab}

_______________________________________

3.L(00 + 11) = L(00) U L(11)
= {00, 11}
_______________________________________

4.L(1(0+1)0) = L(1) L(0+1) L(0)
= 1 (L(0)UL(1)) 0
= 1 {0,1} 0
= {100, 110}
_______________________________________

5.L((0+1)* 10(0+1)*) = L((0+1)*) L (10)+ L((0+1)*)
=L(0+1)* L(10) L(0+1)*
=L(0) U L(1)* L(10) (L(0) U L(1))*
=({0} U {1})* {10} ({0} U {1})*
={0,1}* {10} {0,1}*
={e,0,1,...} {10} {e,0,1,...}
={e.10.e,e.10.0,e.10.1,...,0.10.e,0.10.0,0.10.1,...,1.10.e,1.10.0,1.10.1,...}
={10,100,101,010,110,...}
={10,010,100,101,110,...}
_______________________________________
main credits to: NR

Automata

noreply@blogger.com (Unknown) — Thu, 18 Jun 2009 12:13:00 +0000

1. Who is the Father of Computer Science?
Alan Turing, the Father of Computer Science

Not only is Alan Turing the father of all modern computer science, he also was the single individual most responsible for breaking the Enigma code during World War II, and he laid the foundation for artificial intelligence by posing the Turing Test in 1950.

Unfortunately, Alan Turing was also terribly persecuted for the "crime" of being a homosexual. He was arrested in 1952 for having sex with another man. It pains me greatly to read about the degrading and inhumane treatment one of our greatest scientific minds was subjected to. Alan Turing ultimately committed suicide not long afterwards at the age of 42.

The "nobel prize of computing" was founded in Turing's name in 1966. Reading the list of Turing Award recipients is humbling indeed, a reminder of not only how far we've come, but how far we have to go.

2: Automata/Automation

The Automata word has come out from Automatic,And Automata is a machine language

In theoretical computer science, automata theory is the study of abstract machines and problems which they are able to solve. Automata theory is closely related to formal language theory as the automata are often classified by the class of formal languages they are able to recognize.

An automaton is a mathematical model for a finite state machine (FSM). A FSM is a machine that, given an input of symbols, "jumps", or transitions, through a series of states according to a transition function (which can be expressed as a table). In the common "Mealy" variety of FSMs, this transition function tells the automaton which state to go to next given a current state and a current symbol.

1. To introduce formal concepts of automata, grammars and languages.
2. To introduce ideas of computability and decidability.
3. To illustrate the importance of automata, formal language theory and general models of computation in Computer Science and Artificial Intelligence.

3. Applications of Automata

Cellular automata, for the modelling of physical systems
Weighted automata, for image processing
Learning automata, for artificial intelligence applications
Symmetrical difference NFAs, for random number generation, cryptology and circuit design.
Chart-based automata, for object oriented modelling (ROOM), GUI design and test case generation, embedded system design, control systems.
Automata in pattern matching
Automata in graphics animation
Automata in compiling and NLP
Automata in protocol implementation
Automata in Operations Research (max,+), (min,+)

source:http://www.codinghorror.com
www.wikipedia.com