Program to construct a DFA which accepts the language having all 'a' before all 'b' Last Updated : 23 Jul, 2025 Comments Improve Suggest changes Like Article Like Report Given a string S, the task is to design a Deterministic Finite Automata (DFA) for accepting the language L = {aNbM | N ≥ 0, M ≥ 0, N+M ≥ 1}. , i.e., a regular language L such that all 'a' occur before the first occurrence of 'b' {a, ab, aab, bb..., }. If the given string follows the given language L, then print “Accepted”. Otherwise, print “Not Accepted”. Examples Input: S = "aabbb"Output: AcceptedExplanation: All the 'a' come before 'b' s. Input: S = "ba"Output: Not AcceptedExplanation: 'b' comes before 'a'. Input: S = "aaa"Output: AcceptedExplanation: Note that 'b' does not need to occur in S Input: S = "b"Output: AcceptedExplanation: Note that 'a' does not need to occur in S Approach: The problem can be accepted only when the following cases are met: All the characters can be 'a'.All the characters can be 'b'.All the 'b' come occur after all the 'a'.There is at least one character in the string. This can be better visualized with the help of the state transition diagram of the DFA State Transition Diagram: State Transition Diagram of the above DFA Below is the implementation of the above approach: C++ // C++ Program to implement // the above approach #include <bits/stdc++.h> using namespace std; // Function for state zero Q0 int startStateQ0(char s) { int state; if (s == 'a') state = 1; else if (s == 'b') state = 2; else state = -1; return state; } // Function for first state Q1 int firstStateQ1(char s) { int state; if (s == 'a') state = 1; else if (s == 'b') state = 2; else state = -1; return state; } // Function for second state Q2 int secondStateQ2(char s) { int state; if (s == 'b') state = 2; else if (s == 'a') state = 3; else state = -1; return state; } // Function for third state Q3 int thirdStateQ3(char s) { int state = 3; return state; } // Function to check // if the string is accepted or not int isAcceptedString(string String) { int l = String.length(); // dfa tells the number associated // with the present dfa = state int state = 0; for (int i = 0; i < l; i++) { if (state == 0) state = startStateQ0(String[i]); else if (state == 1) state = firstStateQ1(String[i]); else if (state == 2) state = secondStateQ2(String[i]); else if (state == 3) state = thirdStateQ3(String[i]); else return 0; } if (state == 1 || state == 2) return 1; else return 0; } int main() { string String = "ba"; if (isAcceptedString(String)) cout << "ACCEPTED"; else cout << "NOT ACCEPTED"; } // This code is contributed by Samim Hossain Mondal. Java // Java Program to implement // the above approach import java.util.*; public class GFG { // Function for state zero Q0 static int startStateQ0(char s) { int state; if (s == 'a') state = 1; else if (s == 'b') state = 2; else state = -1; return state; } // Function for first state Q1 static int firstStateQ1(char s) { int state; if (s == 'a') state = 1; else if (s == 'b') state = 2; else state = -1; return state; } // Function for second state Q2 static int secondStateQ2(char s) { int state; if (s == 'b') state = 2; else if (s == 'a') state = 3; else state = -1; return state; } // Function for third state Q3 static int thirdStateQ3(char s) { int state = 3; return state; } // Function to check // if the string is accepted or not static int isAcceptedString(String Str) { int l = Str.length(); // dfa tells the number associated // with the present dfa = state int state = 0; for (int i = 0; i < l; i++) { if (state == 0) state = startStateQ0(Str.charAt(i)); else if (state == 1) state = firstStateQ1(Str.charAt(i)); else if (state == 2) state = secondStateQ2(Str.charAt(i)); else if (state == 3) state = thirdStateQ3(Str.charAt(i)); else return 0; } if (state == 1 || state == 2) return 1; else return 0; } public static void main(String args[]) { String Str = "ba"; if (isAcceptedString(Str) != 0) System.out.println("ACCEPTED"); else System.out.println("NOT ACCEPTED"); } } // This code is contributed by Samim Hossain Mondal. Python3 # Function for state zero Q0 def startStateQ0(s): if (s == 'a'): state = 1 elif (s == 'b'): state = 2 else: state = -1 return state # Function for first state Q1 def firstStateQ1(s): if (s == 'a'): state = 1 elif (s == 'b'): state = 2 else: state = -1 return state # Function for second state Q2 def secondStateQ2(s): if (s == 'b'): state = 2 elif (s == 'a'): state = 3 else: state = -1 return state # Function for third state Q3 def thirdStateQ3(s): state = 3 return state #Function to check #if the string is accepted or not def isAcceptedString(String): l = len(String) # dfa tells the number associated # with the present dfa = state state = 0 for i in range(l): if (state == 0): state = startStateQ0(String[i]) elif (state == 1): state = firstStateQ1(String[i]) elif (state == 2): state = secondStateQ2(String[i]) elif (state == 3): state = thirdStateQ3(String[i]) else: return 0 if(state == 1 or state == 2): return 1 else: return 0 # Driver code if __name__ == "__main__": String = "ba" if (isAcceptedString(String)): print("ACCEPTED") else: print("NOT ACCEPTED") C# // C# Program to implement // the above approach using System; class GFG { // Function for state zero Q0 static int startStateQ0(char s) { int state; if (s == 'a') state = 1; else if (s == 'b') state = 2; else state = -1; return state; } // Function for first state Q1 static int firstStateQ1(char s) { int state; if (s == 'a') state = 1; else if (s == 'b') state = 2; else state = -1; return state; } // Function for second state Q2 static int secondStateQ2(char s) { int state; if (s == 'b') state = 2; else if (s == 'a') state = 3; else state = -1; return state; } // Function for third state Q3 static int thirdStateQ3(char s) { int state = 3; return state; } // Function to check // if the string is accepted or not static int isAcceptedString(string Str) { int l = Str.Length; // dfa tells the number associated // with the present dfa = state int state = 0; for (int i = 0; i < l; i++) { if (state == 0) state = startStateQ0(Str[i]); else if (state == 1) state = firstStateQ1(Str[i]); else if (state == 2) state = secondStateQ2(Str[i]); else if (state == 3) state = thirdStateQ3(Str[i]); else return 0; } if (state == 1 || state == 2) return 1; else return 0; } public static void Main() { string Str = "ba"; if (isAcceptedString(Str) != 0) Console.Write("ACCEPTED"); else Console.Write("NOT ACCEPTED"); } } // This code is contributed by ukasp. JavaScript <script> // JavaScript Program to implement // the above approach // Function for state zero Q0 function startStateQ0(s) { if (s == 'a') state = 1 else if (s == 'b') state = 2 else state = -1 return state } // Function for first state Q1 function firstStateQ1(s) { if (s == 'a') state = 1 else if (s == 'b') state = 2 else state = -1 return state } // Function for second state Q2 function secondStateQ2(s) { if (s == 'b') state = 2 else if (s == 'a') state = 3 else state = -1 return state } // Function for third state Q3 function thirdStateQ3(s) { state = 3 return state } // Function to check // if the string is accepted or not function isAcceptedString(String) { l = String.length; // dfa tells the number associated // with the present dfa = state state = 0 for (let i = 0; i < l; i++) { if (state == 0) state = startStateQ0(String[i]) else if (state == 1) state = firstStateQ1(String[i]) else if (state == 2) state = secondStateQ2(String[i]) else if (state == 3) state = thirdStateQ3(String[i]) else return 0 } if (state == 1 || state == 2) return 1 else return 0 } let String = "ba" if (isAcceptedString(String)) document.write("ACCEPTED") else document.write("NOT ACCEPTED") // This code is contributed by Potta Lokesh </script> OutputNOT ACCEPTED Time Complexity: O(N) where N is the length of the stringAuxiliary Space: O(1) Comment More infoAdvertise with us Next Article Introduction to Theory of Computation A ashutosh deshwal Follow Improve Article Tags : Theory of Computation binary-string DFA 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 _ IntroductionIntroduction to Theory of ComputationAutomata 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 study 7 min read Chomsky Hierarchy in Theory of ComputationAccording 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 AutomataAutomata 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 AutomataIntroduction of Finite AutomataFinite 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 ComputationA Regular Expression (RE) is a way to describe patterns of strings using symbols and operators like union, concatenation, and star. A Deterministic Finite Automaton (DFA) is a machine that reads input strings and decides if they match the pattern by moving through a set of defined states without any 6 min read Solving Automata Using Arden's TheoremArden'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, it' 6 min read L-graphs and what they represent in TOCIn 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 TOCPrerequisite - 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 LanguagesTo 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 used 7 min read How to identify if a language is regular or notPrerequisite - 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)A regular expression is a simple way to describe patterns in text, like “any number of a's†(a*) or “either a or b†(a|b). A finite automaton is a basic machine that reads a string one letter at a time and decides if it matches a given pattern. Converting a regular expression to a finite automaton m 4 min read Star Height of Regular Expression and Regular LanguageThe 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 may 3 min read Generating regular expression from Finite AutomataFinite Automata and Regular Expressions are two ways to represent patterns in strings within formal language theory. While Finite Automata use states and transitions, Regular Expressions provide a compact symbolic notation. Converting a Finite Automaton into a Regular Expression helps to understand 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 be 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 li 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’sProblem - 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 }ProblemDesign a deterministic finite automata(DFA) for accepting the language L = {an bm | n+m = even}Examples:Input: a a b b , n = 2, m = 2 2 + 2 = 4 (even)Output: ACCEPTEDInput: a a a b b b b ,n = 3, m = 43 + 4 = 7 (odd) Output: NOT ACCEPTEDInput: a a a b b b , n = 3, m = 33 + 3 = 6 (even)Output: 14 min read DFA machines accepting odd number of 0’s or/and even number of 1’sPrerequisite - Designing finite automata Problem - Construct a DFA machine over input alphabet \sum_= {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 - Let first d 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 DFAIn theory of computation, union of two Deterministic Finite Automata (DFAs) is an operation used to construct a new DFA that recognizes union of languages accepted by the original automata. For example, two DFAs each recognizing a language L1​ and L2​ respectively, their union DFA will accept any st 4 min read Concatenation Process in DFAIn the context of Deterministic Finite Automata (DFA), concatenation refers to the process of combining two regular languages (or strings) together to form a new language.DFA is a model used to recognize patterns or decide if a string belongs to a particular language.Concatenation is simply taking t 3 min read DFA in LEX code which accepts even number of zeros and even number of onesLex 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 DFAAn 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 DFADFA 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 AutomataPrerequisite – Designing finite automata Reversal: We define the reversed language L^R \text{ of } L  to be the language L^R = \{ w^R \mid w \in L \} , where 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 Steps to Reversal: Draw the states as it is.Add a new single accep 4 min read Complementation process in DFAPrerequisite – Design a Finite automata Suppose we have a DFA that is defined by ( Q, \Sigma  , \delta  , 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, \Sigma, \delta, q0, Q-F )The complement of a DFA can be obtai 2 min read Kleene's Theorem in TOC | Part-1A 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 TOCMoore 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 MachineIn 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 CFGRelationship between grammar and language in Theory of ComputationIn 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 GrammarsA 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 LanguagesContext-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 CFLContext-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 FormChomsky 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 FormContext-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 C 6 min read Pumping Lemma in Theory of ComputationThere 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 NotIdentifying 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 Cont 4 min read Ambiguity in Context free Grammar and LanguagesContext-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 Cont 3 min read Operator grammar and precedence parser in TOCA 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 AutomataWe 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.Pus 5 min read Pushdown Automata Acceptance by Final StateWe 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 languagesPrerequisite - 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 palindromeA Pushdown Automata (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 AutomataAccording 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, aaa 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 c 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 maintai 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 the 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 = {a^m b^n c^p d^q | m + n = p + q : m, n, p, q>=1}, i.e., L = {abcd, abbcdd, abbccd, abbbccdd, ......} In each of the string, the total number of 'a 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: AcceptedInput: 111222 (case 2)Ou 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 numb 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, aabbb 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 e 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 mainta 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 = {a^i b^j c^k d^l : i==k or j==l, i>=1, j>=1}, i.e., L = {abcd, aabccd, aaabcccd, abbcdd, aabbccdd, aabbbccddd, ......} In each string, the numbe 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: acccddbOut 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, aabb 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 same 3 min read Turing MachineRecursive and Recursive Enumerable Languages in TOCRecursive and Recursive Enumerable Languages in TOC are two important classes of languages which are linked with Turing Machine. A recursive language is one where a Turing Machine always halts and decides whether a string belongs to the language or not. A recursively enumerable language is one where 6 min read Turing Machine in TOCTuring 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 additionPrerequisite - 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 1Prerequisite - 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 multiplicationPrerequisite - 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 dataPrerequisite - 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}Problem : L = { anbma(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 o 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 complementProblem-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:1's ComplementApproach:Scanning input string from left to rightConv 3 min read Recursive and Recursive Enumerable Languages in TOCRecursive and Recursive Enumerable Languages in TOC are two important classes of languages which are linked with Turing Machine. A recursive language is one where a Turing Machine always halts and decides whether a string belongs to the language or not. A recursively enumerable language is one where 6 min read Turing Machine for subtraction | Set 2Prerequisite – 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 ComputationThe 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 part 4 min read Turing Machine as ComparatorPrerequisite – 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 DecidabilityDecidable and Undecidable Problems in Theory of ComputationIn 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 TOCDecidable 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 TOCIn the Theory of Computation, problems are classified as computable or non-computable based on whether they can be solved by an algorithm. Computable problems have a clear, step-by-step procedure that always lead to a correct solution while non-computable problems cannot be solved by any algorithm, 6 min read TOC Interview preparationLast Minute Notes - Theory of ComputationThe 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 provi 13 min read TOC Quiz and PYQ's in TOCTheory of Computation - GATE CSE Previous Year QuestionsThe 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:YearApprox. Marks from TOC 2 min read Like