Skip to content
geeksforgeeks
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • Tutorials
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
  • Practice
    • Build your AI Agent
    • GfG 160
    • Problem of the Day
    • Practice Coding Problems
    • GfG SDE Sheet
  • Contests
    • Accenture Hackathon (Ending Soon!)
    • GfG Weekly [Rated Contest]
    • Job-A-Thon Hiring Challenge
    • All Contests and Events
  • Aptitude
  • Engineering Mathematics
  • Discrete Mathematics
  • Operating System
  • DBMS
  • Computer Networks
  • Digital Logic and Design
  • C Programming
  • Data Structures
  • Algorithms
  • Theory of Computation
  • Compiler Design
  • Computer Org and Architecture
Open In App
Next Article:
Introduction to Theory of Computation
Next article icon

Automata Tutorial

Last Updated : 30 Jan, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

Automata Theory is a branch of the Theory of Computation. It deals with the study of abstract machines and their capacities for computation. An abstract machine is called the automata. It includes the design and analysis of automata, which are mathematical models that can perform computations on strings of symbols according to a set of rules.

Why we study Theory of Computation?

  • Regular Expressions (RE) : Used for pattern matching in Linux/Unix command prompt, programming languages and XML/DTD to describe structure.
  • Finite Automata in Modeling Systems : Used in designing and checking models and electronic circuits that operate based on certain rules.
  • Context-Free Grammars (CFG) : Used in Compiler / Programming Language design to describe syntax and natural language processing to describe structure.
  • Mathematical Models : Mathematical understanding of computing devices by mathematically modeling them.
  • Building Block for Quantam Computing: Turing Machines (we study in this subject) are considered a fundamental building block for understanding quantum computation models.
  • Optimizing Algorithm Efficiency : Helps classify problems based (e.g., P, NP, NP-complete, and NP-hard), proving that some problems have no efficient solutions.
  • Understanding Computability : Study of which problems can be solved using algorithms, essentially defining the boundaries of what a computer can calculate.. Problems like the "Halting Problem" which are demonstrably impossible to solve with a general algorithm.

Please refer Why we Study Theory of Computation? for details.

Automata – Introduction

  1. Introduction
  2. Chomsky Hierarchy
  3. Applications of various Automata

Regular Expression and Finite Automata

  1. Finite Automata Introduction
  2. Arden’s Theorem
  3. L-graphs and what they represent
  4. Hypothesis (language regularity) and algorithm (L-graph to NFA)
  5. Regular Expressions, Regular Grammar and Regular Languages
  6. How to identify if a language is regular or not
  7. Designing Finite Automata from Regular Expressions
  8. Star Height of Regular Expression and Regular Language
  9. Generating regular expression from finite automata
  10. Designing Deterministic Finite Automata (Set 2)
  11. NFA to DFA Conversion
  12. Program to Implement NFA with epsilon move to DFA Conversion
  13. Minimization of DFA
  14. Kleene’s Theorem Part-1
  15. MEALY and MOORE Machines
  16. Difference between Mealy machine and Moore machine
  17. Problems on Finite Automata
  18. Operations on DFA

>> Quiz on Regular Languages and Finite Automata

CFG (Context Free Grammar)

  1. Relationship between grammar and language
  2. Simplifying Context Free Grammars
  3. Closure Properties of Context Free Languages(CFL)
  4. Union & Intersection of Regular languages with CFL
  5. Converting Context Free Grammar to Chomsky Normal Form
  6. Converting Context Free Grammar to Greibach Normal Form
  7. Pumping Lemma
  8. Check if the language is Context Free or Not
  9. Ambiguity in Context Free Grammar
  10. Operator grammar and precedence parser
  11. Context-sensitive Grammar (CSG) and Language (CSL)

PDA (Pushdown Automata)

  1. Pushdown Automata
  2. Pushdown Automata Acceptance by Final State
  3. Detailed Study of PushDown Automata
  4. Problems on Pushdown Automata

>> Quiz on Context Free Languages and Pushdown Automata

Turing Machine

  1. Turing Machine
  2. Halting Problem
  3. Theory of Computation | Applications of various Automata
  4. Turing Machine as Comparator
  5. Problems on Turing Machine

>> Quiz on Turing Machines and Recursively Enumerable Sets

Decidability

  1. Decidable and undecidable problems
  2. Decidability
  3. Undecidability and Reducibility
  4. NP-Completeness | Set 1 (Introduction)
  5. Proof that Hamiltonian Path is NP-Complete
  6. Proof that vertex cover is NP complete
  7. Computable and non-computable problems

>> Quiz on Undecidability

Quick Links

  • Last Minute Notes(LMNs)
  • ‘Quizzes’ on Theory Of Computation !
  • Recent Articles on Theory Of Computation

Next Article
Introduction to Theory of Computation
author
kartik
Improve
Article Tags :
  • GATE CS
  • GateCS2023

Similar Reads

  • Automata Tutorial
    Automata Theory is a branch of the Theory of Computation. It deals with the study of abstract machines and their capacities for computation. An abstract machine is called the automata. It includes the design and analysis of automata, which are mathematical models that can perform computations on str
    3 min read

    • Automata _ Introduction

    • Introduction to Theory of Computation
      Automata theory, also known as the Theory of Computation, is a field within computer science and mathematics that focuses on studying abstract machines to understand the capabilities and limitations of computation by analyzing mathematical models of how machines can perform calculations. Why we stud
      7 min read
    • Chomsky Hierarchy in Theory of Computation
      According to Chomsky hierarchy, grammar is divided into 4 types as follows: Type 0 is known as unrestricted grammar.Type 1 is known as context-sensitive grammar.Type 2 is known as a context-free grammar.Type 3 Regular Grammar.Type 0: Unrestricted Grammar: Type-0 grammars include all formal grammar.
      2 min read
    • Applications of various Automata
      Automata are used to design and analyze the behavior of computational systems. Each type of automaton has specific capabilities and limitations, making it suitable for various practical applications. Automata theory is not only fundamental to the design of programming languages and compilers but als
      4 min read

    Regular Expression and Finite Automata

    • Introduction of Finite Automata
      Finite automata are abstract machines used to recognize patterns in input sequences, forming the basis for understanding regular languages in computer science. They consist of states, transitions, and input symbols, processing each symbol step-by-step. If the machine ends in an accepting state after
      4 min read
    • Arden's Theorem in Theory of Computation
      Arden's Theorem is a fundamental result in the Theory of Computation used to solve regular expressions from a given linear equation. It is particularly useful when converting finite automata into regular expressions Statement of Arden's TheoremLet P and Q be two regular expressions. If P does not co
      5 min read
    • Solving Automata Using Arden's Theorem
      Arden's Theorem states that, if P & Q are two regular expressions over  “∑”, and if P does not contain “∈”, then the following equation R given by R = Q + RP has a unique solution ; R = QP*  For certain examples provided below, it’s fairly simple to derive them.  But for the following example, i
      7 min read
    • L-graphs and what they represent in TOC
      In Theory of Computation (TOC), Finite Automata (DFA/NFA) are mathematical models used to recognize Regular Languages. However, not all programming languages can be represented using Finite Automata because they require more computational power than what FA can provide. Languages like C, Pascal, Has
      4 min read
    • Hypothesis (language regularity) and algorithm (L-graph to NFA) in TOC
      Prerequisite - Finite automata, L-graphs and what they represent L-graphs can generate context sensitive languages, but it’s much harder to program a context sensitive language over programming a regular one. This is why I’ve came up with a hypothesis about what kind of L-graphs can generate a regul
      7 min read
    • Regular Expressions, Regular Grammar and Regular Languages
      To work with formal languages and string patterns, it is essential to understand regular expressions, regular grammar, and regular languages. These concepts form the foundation of automata theory, compiler design, and text processing. Regular ExpressionsRegular expressions are symbolic notations use
      7 min read
    • How to identify if a language is regular or not
      Prerequisite - Regular Expressions, Regular Grammar and Regular Languages, Pumping Lemma There is a well established theorem to identify if a language is regular or not, based on Pigeon Hole Principle, called as Pumping Lemma. But pumping lemma is a negativity test, i.e. if a language doesn't satisf
      8 min read
    • Designing Finite Automata from Regular Expression (Set 1)
      In this article, we will see some popular regular expressions and how we can convert them to finite automata. Even number of a's : The regular expression for even number of a's is (b|ab*ab*)*. We can construct a finite automata as shown in Figure 1. The above automata will accept all strings which h
      3 min read
    • Star Height of Regular Expression and Regular Language
      The star height relates to the field of theoretical computation (TOC). It is used to indicate the structural complexity of regular expressions and regular languages. In this context, complexity refers to the maximum nesting depth of Kleene stars present in a regular expression. A regular language ma
      3 min read
    • Generating regular expression from Finite Automata
      Prerequisite - Introduction of FA, Regular expressions, grammar and language, Designing FA from Regular Expression There are two methods to convert FA to the regular expression: 1. State Elimination Method:Step 1 - If the start state is an accepting state or has transitions in, add a new non-accepti
      3 min read
    • Code Implementation of Deterministic Finite Automata (Set 1)
      In this article, we will learn about designing of Deterministic Finite Automata (DFA) and it's code implementation. Problem-1: Construction of a DFA for the set of string over {a, b} such that length of the string |w|=2 i.e, length of the string is exactly 2. Explanation - The desired language will
      8 min read
    • Program for Deterministic Finite Automata (Set 2)
      In this article, we will learn about designing of Deterministic Finite Automata (DFA) and it's code implementation. Problem-1: Construction of a DFA for the set of string over {a, b} such that length of the string |w| is divisible by 2 i.e, |w| mod 2 = 0. Explanation - The desired language will be l
      7 min read
    • DFA for Strings not ending with "THE"
      Problem - Accept Strings that not ending with substring "THE". Check if a given string is ending with "the" or not. The different forms of "the" which are avoided in the end of the string are: "THE", "ThE", "THe", "tHE", "thE", "The", "tHe" and "the" All those strings that are ending with any of the
      12 min read
    • DFA of a string with at least two 0’s and at least two 1’s
      Problem - Draw deterministic finite automata (DFA) of a string with at least two 0’s and at least two 1’s. The first thing that come to mind after reading this question us that we count the number of 1's and 0's. Thereafter if they both are at least 2 the string is accepted else not accepted. But we
      3 min read
    • DFA for accepting the language L = { anbm | n+m=even }
      Design a deterministic finite automata(DFA) for accepting the language L =[Tex] {a^n b^{m} | m+n=even} [/Tex] For creating DFA for language, L = { a^n b^m ; n+m=even } use elementary mathematics, which says- even + even = even and odd + odd = even. Examples:Input: a a b b // n = 2, m = 2, 2 + 2 = 4
      15+ min read
    • DFA machines accepting odd number of 0’s or/and even number of 1’s
      Prerequisite - Designing finite automata Problem - Construct a DFA machine over input alphabet [Tex]\sum_[/Tex]= {0, 1}, that accepts: Odd number of 0’s or even number of 1’s Odd number of 0’s and even number of 1’s Either odd number of 0’s or even number of 1’s but not the both together Solution -
      3 min read
    • DFA of a string in which 2nd symbol from RHS is 'a'
      Draw deterministic finite automata (DFA) of the language containing the set of all strings over {a, b} in which 2nd symbol from RHS is 'a'. The strings in which 2nd last symbol is "a" are: aa, ab, aab, aaa, aabbaa, bbbab etc Input/Output INPUT : baba OUTPUT: NOT ACCEPTED INPUT: aaab OUTPUT: ACCEPTED
      10 min read
    • Union process in DFA
      Prerequisite - Designing finite automata To perform the union operation on two deterministic finite automata (DFAs), the following steps can be taken: Create a new DFA with a new set of states, consisting of all the states from both original DFAs.Define the initial state of the new DFA to be the tup
      5 min read
    • Concatenation process in DFA
      Prerequisite - Designing finite automata Designing a DFA for the set of string over {a, b} such that string of the language start with "a" and end with "b". There two desired language will be formed: L1 = {a, aab, aabab, .......} L2 = {b, bbab, bbabab, .......} In L1, starting element is "a" and in
      2 min read
    • DFA in LEX code which accepts even number of zeros and even number of ones
      Lex is a computer program that generates lexical analyzers, which is commonly used with the YACC parser generator. Lex, originally written by Mike Lesk and Eric Schmidt and described in 1975, is the standard lexical analyzer generator on many Unix systems, and an equivalent tool is specified as part
      6 min read
    • Conversion from NFA to DFA
      An NFA can have zero, one or more than one move from a given state on a given input symbol. An NFA can also have NULL moves (moves without input symbol). On the other hand, DFA has one and only one move from a given state on a given input symbol. Steps for converting NFA to DFA:Step 1: Convert the g
      5 min read
    • Minimization of DFA
      DFA minimization stands for converting a given DFA to its equivalent DFA with minimum number of states. DFA minimization is also called as Optimization of DFA and uses partitioning algorithm.Minimization of DFA Suppose there is a DFA D < Q, Δ, q0, Δ, F > which recognizes a language L. Then the
      7 min read
    • Reversing Deterministic Finite Automata
      Prerequisite – Designing finite automata Reversal: We define the reversed language [Tex]L^R \text{ of } L [/Tex] to be the language [Tex]L^R = \{ w^R \mid w \in L \} [/Tex], where [Tex]w^R := a_n a_{n-1} \dots a_1 a_0 \text{ for } w = a_0 a_1 \dots a_{n-1} a_n [/Tex] Steps to Reversal:  Draw the sta
      4 min read
    • Complementation process in DFA
      Prerequisite – Design a Finite automata Suppose we have a DFA that is defined by ( Q, [Tex]\Sigma  [/Tex], [Tex]\delta  [/Tex], q0, F ) and it accepts the language L1. Then, the DFA which accepts the language L2 where L2 = ̅L1', will be defined as below:   ( Q, [Tex]\Sigma[/Tex], [Tex]\delta[/Tex],
      2 min read
    • Kleene's Theorem in TOC | Part-1
      A language is said to be regular if it can be represented by using Finite Automata or if a Regular Expression can be generated for it. This definition leads us to the general definition that; For every Regular Expression corresponding to the language, a Finite Automata can be generated. For certain
      4 min read
    • Mealy and Moore Machines in TOC
      Moore and Mealy Machines are Transducers that help in producing outputs based on the input of the current state or previous state. In this article we are going to discuss Moore Machines and Mealy Machines, the difference between these two machinesas well as Conversion from Moore to Mealy and Convers
      3 min read
    • Difference Between Mealy Machine and Moore Machine
      In theory of computation and automata, there are two machines: Mealy Machine and Moore Machine which is used to show the model and behavior of circuits and diagrams of a computer. Both of them have transition functions and the nature of taking output on same input is different for both. In this arti
      4 min read

    CFG

    • Relationship between grammar and language in Theory of Computation
      In the Theory of Computation, grammar and language are fundamental concepts used to define and describe computational problems. A grammar is a set of production rules that generate a language, while a language is a collection of strings that conform to these rules. Understanding their relationship i
      4 min read
    • Simplifying Context Free Grammars
      A Context-Free Grammar (CFG) is a formal grammar that consists of a set of production rules used to generate strings in a language. However, many grammars contain redundant rules, unreachable symbols, or unnecessary complexities. Simplifying a CFG helps in reducing its size while preserving the gene
      6 min read
    • Closure Properties of Context Free Languages
      Context-Free Languages (CFLs) are an essential class of languages in the field of automata theory and formal languages. They are generated by context-free grammars (CFGs) and are recognized by pushdown automata (PDAs). Understanding the closure properties of CFLs helps in determining which operation
      11 min read
    • Union and Intersection of Regular languages with CFL
      Context-Free Languages (CFLs) are an essential class of languages in the field of automata theory and formal languages. They are generated by context-free grammars (CFGs) and are recognized by pushdown automata (PDAs). Understanding the closure properties of CFLs helps in determining which operation
      3 min read
    • Converting Context Free Grammar to Chomsky Normal Form
      Chomsky Normal Form (CNF) is a way to simplify context-free grammars (CFGs) so that all production rules follow specific patterns. In CNF, each rule either produces two non-terminal symbols, or a single terminal symbol, or, in some cases, the empty string. Converting a CFG to CNF is an important ste
      5 min read
    • Converting Context Free Grammar to Greibach Normal Form
      Context-free grammar (CFG) and Greibach Normal Form (GNF) are fundamental concepts in formal language theory, particularly in the field of compiler design and automata theory. This article delves into what CFG and GNF are, provides examples, and outlines the steps to convert a CFG into GNF. What is
      6 min read
    • Pumping Lemma in Theory of Computation
      There are two Pumping Lemmas, which are defined for 1. Regular Languages, and 2. Context - Free Languages Pumping Lemma for Regular Languages For any regular language L, there exists an integer n, such that for all x ? L with |x| ? n, there exists u, v, w ? ?*, such that x = uvw, and (1) |uv| ? n (2
      4 min read
    • Check if the language is Context Free or Not
      Identifying regular languages is straightforward, but determining if a language is context-free can be tricky. Since the Pumping Lemma requires mathematical proof, it is time-consuming. Instead, observational techniques help quickly determine whether a language is context-free. Pumping Lemma for Con
      4 min read
    • Ambiguity in Context free Grammar and Languages
      Context-Free Grammars (CFGs) are essential in formal language theory and play a crucial role in programming language design, compiler construction, and automata theory. One key challenge in CFGs is ambiguity, which can lead to multiple derivations for the same string. Understanding Derivation in Con
      3 min read
    • Operator grammar and precedence parser in TOC
      A grammar that is used to define mathematical operators is called an operator grammar or operator precedence grammar. Such grammars have the restriction that no production has either an empty right-hand side (null productions) or two adjacent non-terminals in its right-hand side. Examples - This is
      6 min read
    • Context-sensitive Grammar (CSG) and Language (CSL)
      Context-Sensitive Grammar - A Context-sensitive grammar is an Unrestricted grammar in which all the productions are of form - Where α and β are strings of non-terminals and terminals. Context-sensitive grammars are more powerful than context-free grammars because there are some languages that can be
      2 min read

    PDA (Pushdown Automata)

    • Introduction of Pushdown Automata
      We have already discussed finite automata. But finite automata can be used to accept only regular languages. Pushdown Automata is a finite automata with extra memory called stack which helps Pushdown automata to recognize Context Free Languages. This article describes pushdown automata in detail. Pu
      5 min read
    • Pushdown Automata Acceptance by Final State
      We have discussed Pushdown Automata (PDA) and its acceptance by empty stack article. Now, in this article, we will discuss how PDA can accept a CFL based on the final state. Given a PDA P as: P = (Q, Σ, Γ, δ, q0, Z, F) The language accepted by P is the set of all strings consuming which PDA can move
      4 min read
    • Construct Pushdown Automata for given languages
      Prerequisite - Pushdown Automata, Pushdown Automata Acceptance by Final State A push down automata is similar to deterministic finite automata except that it has a few more properties than a DFA.The data structure used for implementing a PDA is stack. A PDA has an output associated with every input.
      4 min read
    • Construct Pushdown Automata for all length palindrome
      A Pushdown Automaton (PDA) is like an epsilon Non deterministic Finite Automata (NFA) with infinite stack. PDA is a way to implement context free languages. Hence, it is important to learn, how to draw PDA. Here, take the example of odd length palindrome: Que-1: Construct a PDA for language L = {wcw
      6 min read
    • Detailed Study of PushDown Automata
      According to the Chomsky Hierarchy, the requirement of a certain type of grammar to generate a language is often clubbed with a suitable machine that can be used to accept the same language. When the grammar is simple, the language becomes more complex, hence we require a more powerful machine to un
      3 min read
    • NPDA for accepting the language L = {anbm cn | m,n>=1}
      Before attempting this problem, you should have a working knowledge of Pushdown Automata concepts. ProblemThe problem can be solved if you have prior knowledge about NPDA. Design a non deterministic PDA for accepting the language L = {an bm cn | m, n >= 1}, i.e., L = { abc, abbc, abbbc, aabbcc, a
      2 min read
    • NPDA for accepting the language L = {an bn cm | m,n>=1}
      Prerequisite: Basic Knowledge of Pushdown Automata. ProblemDesign a non deterministic PDA for accepting the language L = {anbncm | m, n>=1}, i.e., L = { abc, abcc, abccc, aabbc, aaabbbcc, aaaabbbbccccc, ...... } In each of the string, the number of a's is equal to number of b's and the number of
      2 min read
    • NPDA for accepting the language L = {anbn | n>=1}
      Prerequisite: Basic knowledge of pushdown automata. Problem :Design a non deterministic PDA for accepting the language L = {an bn | n>=1}, i.e., L = {ab, aabb, aaabbb, aaaabbbb, ......} In each of the string, the number of a's are followed by equal number of b's. ExplanationHere, we need to maint
      2 min read
    • NPDA for accepting the language L = {amb2m| m>=1}
      ProblemDesign a non deterministic PDA for accepting the language L = {am ,b2m | m>=1} L = {abb, aabbbb, aaabbbbbb, aaaabbbbbbbb, ......} In each of the string, the number of a's are followed by double number of b's. Explanation - Here, we need to maintain the order of a’s and b’s. That is, all th
      2 min read
    • NPDA for accepting the language L = {am bn cp dq | m+n=p+q ; m,n,p,q>=1}
      Prerequisite - Pushdown automata, Pushdown automata acceptance by final state Problem - Design a non deterministic PDA for accepting the language L = {[Tex]a^m[/Tex] [Tex]b^n[/Tex] [Tex]c^p[/Tex] [Tex]d^q[/Tex] | m + n = p + q : m, n, p, q>=1}, i.e., L = {abcd, abbcdd, abbccd, abbbccdd, ......} I
      2 min read
    • Construct Pushdown automata for L = {0n1m2m3n | m,n ≥ 0}
      Prerequisite - Pushdown automata, Pushdown automata acceptance by final state Pushdown automata (PDA) plays a significant role in compiler design. Therefore there is a need to have a good hands on PDA. Our aim is to construct a PDA for L = {0n1m2m3n | m,n ≥ 0} Examples - Input : 00011112222333 Outpu
      3 min read
    • Construct Pushdown automata for L = {0n1m2n+m | m, n ≥ 0}
      Prerequisite : PDA plays a very important role in task of compiler designing. Therefore, there is a need to have good practice on PDA. ProblemConstruct a PDA which accepts a string of the form { 0 n 1 m 2 m+n | m , n >=0 } ExamplesInput: 00001111 ( case 1 )Output: Accepted Input: 111222 (case 2)O
      2 min read
    • NPDA for accepting the language L = {ambncm+n | m,n ≥ 1}
      The problem below require basic knowledge of Pushdown Automata. Problem Design a non deterministic PDA for accepting the language L = {am bn cm+n | m,n ≥ 1} for eg. , L = {abcc, aabccc, abbbcccc, aaabbccccc, ......} In each of the string, the total sum of the number of 'a’ and 'b' is equal to the nu
      2 min read
    • NPDA for accepting the language L = {amb(m+n)cn| m,n ≥ 1}
      A solid understanding of pushdown automata and their input acceptance via final states is essential before proceeding with this topic. Problem Design a non deterministic PDA for accepting the language L = {am b(m+n) cn | m,n ≥ 1}.The strings of given language will be: L = {abbc, abbbcc, abbbcc, aabb
      3 min read
    • NPDA for accepting the language L = {a2mb3m|m>=1}
      Before learning this, you should know about pushdown automata and how they accept inputs using final states. Problem Design a non deterministic PDA for accepting the language L = {a2mb3m| m ≥ 1}, i.e., L = {aabbb, aaaabbbbbb, aaaaaabbbbbbbbb, aaaaaaaabbbbbbbbbbbb, ......} In each of the string, for
      2 min read
    • NPDA for accepting the language L = {amb2m+1 | m ≥ 1}
      ProblemDesign a non deterministic PDA for accepting the language L = { am b2m+1 | m ≥ 1} or L = { am b b2m | m ≥ 1}, i.e., L = {abbb, aabbbbb, aaabbbbbbb, aaaabbbbbbbbb, ......} In each of the string, the number of 'b' is one more than the twice of the number of 'a'. ExplanationHere, we need to main
      2 min read
    • NPDA for accepting the language L = {aibjckdl | i==k or j==l,i>=1,j>=1}
      Prerequisite - Pushdown automata, Pushdown automata acceptance by final state Problem - Design a non deterministic PDA for accepting the language L = {[Tex]a^i[/Tex] [Tex]b^j[/Tex] [Tex]c^k[/Tex] [Tex]d^l[/Tex] : i==k or j==l, i>=1, j>=1}, i.e., L = {abcd, aabccd, aaabcccd, abbcdd, aabbccdd, a
      3 min read
    • Construct Pushdown automata for L = {a2mc4ndnbm | m,n ≥ 0}
      Pushdown Automata plays a very important role in task of compiler designing. That is why there is a need to have a good practice on PDA. Our objective is to construct a PDA for L = {a2mc4ndn bm | m,n ≥ 0} Example: Input: aaccccdbOutput: AcceptedInput: aaaaccccccccddbbOutput: AcceptedInput: acccddbOu
      3 min read
    • NPDA for L = {0i1j2k | i==j or j==k ; i , j , k >= 1}
      Prerequisite - Pushdown automata, Pushdown automata acceptance by final state The language L = {0i1j2k | i==j or j==k ; i , j , k >= 1} tells that every string of ‘0’, ‘1’ and ‘2’ have certain number of 0’s, then certain number of 1’s and then certain number of 2’s. The condition is that count of
      2 min read
    • NPDA for accepting the language L = {anb2n| n>=1} U {anbn| n>=1}
      To understand this question, you should first be familiar with pushdown automata and their final state acceptance mechanism. ProblemDesign a non deterministic PDA for accepting the language L = {an b2n : n>=1} U {an bn : n>=1}, i.e., L = {abb, aabbbb, aaabbbbbb, aaaabbbbbbbb, ......} U {ab, aa
      2 min read
    • NPDA for the language L ={wЄ{a,b}* | w contains equal no. of a's and b's}
      A solid understanding of pushdown automata fundamentals is essential for this question. ProblemDesign a non deterministic PDA for accepting the language L ={wЄ{a,b}* | w contains equal no. of a's and b's}, i.e., L = {ab, aabb, abba, aababb, bbabaa, baaababb, .......} The number of a's and b's are sa
      3 min read

    Turing Machine

    • Recursive and Recursive Enumerable Languages in TOC
      Recursive Enumerable (RE) or Type -0 Language RE languages or type-0 languages are generated by type-0 grammars. An RE language can be accepted or recognized by Turing machine which means it will enter into final state for the strings of language and may or may not enter into rejecting state for the
      5 min read
    • Turing Machine in TOC
      Turing Machines (TM) play a crucial role in the Theory of Computation (TOC). They are abstract computational devices used to explore the limits of what can be computed. Turing Machines help prove that certain languages and problems have no algorithmic solution. Their simplicity makes them an effecti
      7 min read
    • Turing Machine for addition
      Prerequisite - Turing Machine A number is represented in binary format in different finite automata. For example, 5 is represented as 101. However, in the case of addition using a Turing machine, unary format is followed. In unary format, a number is represented by either all ones or all zeroes. For
      3 min read
    • Turing machine for subtraction | Set 1
      Prerequisite - Turing Machine Problem-1: Draw a Turing machine which subtract two numbers. Example: Steps: Step-1. If 0 found convert 0 into X and go right then convert all 0's into 0's and go right.Step-2. Then convert C into C and go right then convert all X into X and go right.Step-3. Then conver
      2 min read
    • Turing machine for multiplication
      Prerequisite - Turing Machine Problem: Draw a turing machine which multiply two numbers. Example: Steps: Step-1. First ignore 0's, C and go to right & then if B found convert it into C and go to left. Step-2. Then ignore 0's and go left & then convert C into C and go right. Step-3. Then conv
      2 min read
    • Turing machine for copying data
      Prerequisite - Turing Machine Problem - Draw a Turing machine which copy data. Example - Steps: Step-1. First convert all 0's, 1's into 0's, 1's and go right then B into C and go left Step-2. Then convert all 0's, 1's into 0's, 1's and go left then Step-3. If 1 convert it into X and go right convert
      2 min read
    • Construct a Turing Machine for language L = {0n1n2n | n≥1}
      Prerequisite - Turing Machine The language L = {0n1n2n | n≥1} represents a kind of language where we use only 3 character, i.e., 0, 1 and 2. In the beginning language has some number of 0's followed by equal number of 1's and then followed by equal number of 2's. Any such string which falls in this
      3 min read
    • Construct a Turing Machine for language L = {wwr | w ∈ {0, 1}}
      The language L = {wwres | w ∈ {0, 1}} represents a kind of language where you use only 2 character, i.e., 0 and 1. The first part of language can be any string of 0 and 1. The second part is the reverse of the first part. Combining both these parts a string will be formed. Any such string that falls
      5 min read
    • Construct a Turing Machine for language L = {ww | w ∈ {0,1}}
      Prerequisite - Turing Machine The language L = {ww | w ∈ {0, 1}} tells that every string of 0's and 1's which is followed by itself falls under this language. The logic for solving this problem can be divided into 2 parts: Finding the mid point of the string After we have found the mid point we matc
      7 min read
    • Construct Turing machine for L = {an bm a(n+m) | n,m≥1}
      L = {an bm a(n+m) | n,m≥1} represents a kind of language where we use only 2 character, i.e., a and b. The first part of language can be any number of "a" (at least 1). The second part be any number of "b" (at least 1). The third part of language is a number of "a" whose count is sum of count of a's
      3 min read
    • Construct a Turing machine for L = {aibjck | i*j = k; i, j, k ≥ 1}
      Prerequisite – Turing Machine In a given language, L = {aibjck | i*j = k; i, j, k ≥ 1}, where every string of 'a', 'b' and 'c' has a certain number of a's, then a certain number of b's and then a certain number of c's. The condition is that each of these 3 symbols should occur at least once. 'a' and
      2 min read
    • Turing machine for 1's and 2’s complement
      Problem-1:Draw a Turing machine to find 1's complement of a binary number. 1’s complement of a binary number is another binary number obtained by toggling all bits in it, i.e., transforming the 0 bit to 1 and the 1 bit to 0. Example: Approach:Scanning input string from left to rightConverting 1's in
      3 min read
    • Recursive and Recursive Enumerable Languages in TOC
      Recursive Enumerable (RE) or Type -0 Language RE languages or type-0 languages are generated by type-0 grammars. An RE language can be accepted or recognized by Turing machine which means it will enter into final state for the strings of language and may or may not enter into rejecting state for the
      5 min read
    • Turing Machine for subtraction | Set 2
      Prerequisite – Turing Machine, Turing machine for subtraction | Set 1 A number is represented in binary format in different finite automatas like 5 is represented as (101) but in case of subtraction Turing Machine unary format is followed . In unary format a number is represented by either all ones
      2 min read
    • Halting Problem in Theory of Computation
      The halting problem is a fundamental issue in theory and computation. The problem is to determine whether a computer program will halt or run forever. Definition: The Halting Problem asks whether a given program or algorithm will eventually halt (terminate) or continue running indefinitely for a par
      4 min read
    • Turing Machine as Comparator
      Prerequisite – Turing MachineProblem : Draw a turing machine which compare two numbers. Using unary format to represent the number. For example, 4 is represented by 4 = 1 1 1 1 or 0 0 0 0 Lets use one's for representation. Example: Approach: Comparing two numbers by comparing number of '1's.Comparin
      3 min read

    Decidability

    • Decidable and Undecidable Problems in Theory of Computation
      In the Theory of Computation, problems can be classified into decidable and undecidable categories based on whether they can be solved using an algorithm. A decidable problem is one for which a solution can be found in a finite amount of time, meaning there exists an algorithm that can always provid
      6 min read
    • Undecidability and Reducibility in TOC
      Decidable Problems A problem is decidable if we can construct a Turing machine which will halt in finite amount of time for every input and give answer as ‘yes’ or ‘no’. A decidable problem has an algorithm to determine the answer for a given input. Examples Equivalence of two regular languages: Giv
      5 min read
    • Computable and non-computable problems in TOC
      Computable Problems - You are familiar with many problems (or functions) that are computable (or decidable), meaning there exists some algorithm that computes an answer (or output) to any instance of the problem (or for any input to the function) in a finite number of simple steps. A simple example
      6 min read

    TOC Interview preparation

    • Last Minute Notes - Theory of Computation
      The Theory of Computation (TOC) is a critical subject in the GATE Computer Science syllabus. It involves concepts like Finite Automata, Regular Expressions, Context-Free Grammars, and Turing Machines, which form the foundation of understanding computational problems and algorithms. This article prov
      13 min read

    TOC Quiz and PYQ's in TOC

    • Theory of Computation - GATE CSE Previous Year Questions
      The Theory of Computation(TOC) subject has high importance in GATE CSE exam because: large number of questions nearly 6-8% of the total papersignificant weightage (6-8 marks) across multiple years Below is the table for previous four year mark distribution of TOC in GATE CS: Year Approx. Marks from
      2 min read
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences