# Program to construct a DFA which accepts the language L = {a^{N} | N ≥ 1}

**Prerequisite:** Finite Automata

Given a string **S** of size **N**, the task is to design a Deterministic Finite Automata (DFA) for accepting the language **L = {a ^{N} | N ≥ 1}**. The regular language

**L**is {a, aa, aaa, aaaaaaa…, }. If the given string follows the given language

**L**, then print

**“Accepted”**. Otherwise, print

**“Not Accepted”**.

**Examples:**

Input:S = “aaabbb”Output:Not AcceptedExplanation:String must only contain a.

Input:S = “aa”Output:Accepted

**Approach:** The idea by which the automata lead to acceptance of string is stated below in steps:

- The automata will accept all the strings containing only the character
**‘a’**. If the user tried to input any character other than ‘a’, the machine will reject it. - Let the state
**q0**is the**initial**state represent the set of all strings of length**0**, state**q1**is the**final**state represent the set of all strings from**1**to**N**. - State
**q1**contains a self-loop of a which indicates that it can be repeated as required. - The
**a’s**in a given string, if the count of**a**is the same as**N**then it will be accepted. Otherwise, the string will be rejected.

__DFA State Transition Diagram__:

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to check whether the string` `// S satisfy the given DFA or not` `void` `isAcceptedDFA(string s, ` `int` `N)` `{` ` ` `// Stores the count of characters` ` ` `int` `count = 0;` ` ` `// Iterate over the range [0, N]` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `// Count and check every` ` ` `// element for 'a'` ` ` `if` `(s[i] == ` `'a'` `)` ` ` `count++;` ` ` `}` ` ` `// If string matches with DFA` ` ` `if` `(count == N && count != 0) {` ` ` `cout << ` `"Accepted"` `;` ` ` `}` ` ` `// If not matches` ` ` `else` `{` ` ` `cout << ` `"Not Accepted"` `;` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `string S = ` `"aaaaa"` `;` ` ` `// Function Call` ` ` `isAcceptedDFA(S, S.size());` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `class` `GFG` `{` `// Function to check whether the String` `// S satisfy the given DFA or not` `static` `void` `isAcceptedDFA(String s, ` `int` `N)` `{` ` ` `// Stores the count of characters` ` ` `int` `count = ` `0` `;` ` ` `// Iterate over the range [0, N]` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++)` ` ` `{` ` ` `// Count and check every` ` ` `// element for 'a'` ` ` `if` `(s.charAt(i) == ` `'a'` `)` ` ` `count++;` ` ` `}` ` ` `// If String matches with DFA` ` ` `if` `(count == N && count != ` `0` `)` ` ` `{` ` ` `System.out.print(` `"Accepted"` `);` ` ` `}` ` ` `// If not matches` ` ` `else` ` ` `{` ` ` `System.out.print(` `"Not Accepted"` `);` ` ` `}` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `String S = ` `"aaaaa"` `;` ` ` `// Function Call` ` ` `isAcceptedDFA(S, S.length());` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# Python3 program for the above approach` `# Function to check whether the string` `# S satisfy the given DFA or not` `def` `isAcceptedDFA(s, N):` ` ` ` ` `# Stores the count of characters` ` ` `count ` `=` `0` ` ` `# Iterate over the range [0, N]` ` ` `for` `i ` `in` `range` `(N):` ` ` `# Count and check every` ` ` `# element for 'a'` ` ` `if` `(s[i] ` `=` `=` `'a'` `):` ` ` `count ` `+` `=` `1` ` ` `# If string matches with DFA` ` ` `if` `(count ` `=` `=` `N ` `and` `count !` `=` `0` `):` ` ` `print` `(` `"Accepted"` `)` ` ` `# If not matches` ` ` `else` `:` ` ` `print` `(` `"Not Accepted"` `)` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `S ` `=` `"aaaaa"` ` ` `# Function Call` ` ` `isAcceptedDFA(S, ` `len` `(S))` `# This code is contributed by mohit kumar 29` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG` `{` `// Function to check whether the String` `// S satisfy the given DFA or not` `static` `void` `isAcceptedDFA(String s, ` `int` `N)` `{` ` ` ` ` `// Stores the count of characters` ` ` `int` `count = 0;` ` ` `// Iterate over the range [0, N]` ` ` `for` `(` `int` `i = 0; i < N; i++)` ` ` `{` ` ` `// Count and check every` ` ` `// element for 'a'` ` ` `if` `(s[i] == ` `'a'` `)` ` ` `count++;` ` ` `}` ` ` `// If String matches with DFA` ` ` `if` `(count == N && count != 0)` ` ` `{` ` ` `Console.Write(` `"Accepted"` `);` ` ` `}` ` ` `// If not matches` ` ` `else` ` ` `{` ` ` `Console.Write(` `"Not Accepted"` `);` ` ` `}` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` `String S = ` `"aaaaa"` `;` ` ` `// Function Call` ` ` `isAcceptedDFA(S, S.Length);` `}` `}` `// This code is contributed by 29AjayKumar` |

## Javascript

`<script>` ` ` `// JavaScript program for the above approach` ` ` `// Function to check whether the String` ` ` `// S satisfy the given DFA or not` ` ` `function` `isAcceptedDFA(s, N) {` ` ` `// Stores the count of characters` ` ` `var` `count = 0;` ` ` `// Iterate over the range [0, N]` ` ` `for` `(` `var` `i = 0; i < N; i++) {` ` ` `// Count and check every` ` ` `// element for 'a'` ` ` `if` `(s[i] === ` `"a"` `) count++;` ` ` `}` ` ` `// If String matches with DFA` ` ` `if` `(count === N && count !== 0) {` ` ` `document.write(` `"Accepted"` `);` ` ` `}` ` ` `// If not matches` ` ` `else` `{` ` ` `document.write(` `"Not Accepted"` `);` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `var` `S = ` `"aaaaa"` `;` ` ` `// Function Call` ` ` `isAcceptedDFA(S, S.length);` ` ` `</script>` |

**Output:**

Accepted

**Time Complexity:** O(N)**Auxiliary Space:** O(1)