Hopcroft–Karp Algorithm for Maximum Matching | Set 2 (Implementation)

Recursive Implementation of atoi()

Last Updated : 19 Sep, 2023

The atoi() function takes a string (which represents an integer) as an argument and returns its value. We have discussed iterative implementation of atoi(). How to compute recursively?

Approach:

The idea is to separate the last digit, recursively compute the result for the remaining n-1 digits, multiply the result by 10 and add the obtained value to the last digit.

Below is the implementation of the idea.

C++

// Recursive C program to compute atoi()
#include <cctype>
#include <cstring>
#include <iostream>
 
using namespace std;
 
// Recursive function to compute atoi()
int myAtoiRecursive(char* str, int n)
{
    // If str is NULL or str contains non-numeric
    // characters then return 0 as the number is not
    // valid
    int count = 0, check;
    // loop to count the no. of alphabets in str
    for (int i = 0; i <= strlen(str); ++i) {
 
        // check if str[i] is an alphabet
        check = isalpha(str[i]);
 
        // increment count if str[i] is an alphabet
        if (check)
            ++count;
    }
    if (count != 0) {
        return 0;
    }
   
    // Base case (Only one digit)
    if (n == 1)
        return *str - '0';
 
    // If more than 1 digits, recur for (n-1), multiply
    // result with 10 and add last digit
    return (10 * myAtoiRecursive(str, n - 1) + str[n - 1]
            - '0');
}
 
// Driver Program
int main(void)
{
    char str[] = "112";
    int n = strlen(str);
    printf("%d", myAtoiRecursive(str, n));
    return 0;
}

Java

// Recursive Java program to compute atoi()
class GFG{
 
// Recursive function to compute atoi()
static int myAtoiRecursive(String str, int n)
{
    // If str is NULL or str contains non-numeric
    // characters then return 0 as the number is not
    // valid
    if (str == "" || !str.matches("^\\d*$")) {
        return 0;
    }
    // Base case (Only one digit)
    if (n == 1)
    {
        return str.charAt(0) - '0';
    }
     
    // If more than 1 digits, recur for (n-1), 
    // multiply result with 10 and add last digit
    return (10 * myAtoiRecursive(str, n - 1) + 
                      str.charAt(n - 1) - '0');
}
 
// Driver code
public static void main(String[] s)
{
    String str = "112";
    int n = str.length();
     
    System.out.println(myAtoiRecursive(str, n));
}
}

Python3

# Python3 program to compute atoi()
 
# Recursive function to compute atoi()
def myAtoiRecursive(string, num):
    # If str is NULL or str contains non-numeric
    # characters then return 0 as the number is not
    # valid
    if string.isalpha() :
         return 0;
       
    if(len(string) == 0):
         return 0;
    # base case, we've hit the end of the string,
    # we just return the last value
    if len(string) == 1:
        return int(string) + (num * 10)
         
    # add the next string item into our num value
    num = int(string[0:1]) + (num * 10)
     
    # recurse through the rest of the string
    # and add each letter to num
    return myAtoiRecursive(string[1:], num)
 
# Driver Code    
string = "112"
 
print(myAtoiRecursive(string, 0))

C#

// Recursive C# program to compute atoi()
using System;
using System.Text.RegularExpressions;
class GFG{
 
// Recursive function to compute atoi()
static int myAtoiRecursive(string str, int n)
{
    // If str is NULL or str contains non-numeric
    // characters then return 0 as the number is not
    // valid
    if (Regex.IsMatch(str, "^[a-zA-Z]*$")){
      return 0;
    }
    // Base case (Only one digit)
    if (n == 1)
    {
        return str[0] - '0';
    }
     
    // If more than 1 digits, recur for (n-1), 
    // multiply result with 10 and add last digit
    return (10 * myAtoiRecursive(str, n - 1) + 
                                  str[n - 1] - '0');
}
 
// Driver code
public static void Main()
{
    string str = "112";
    int n = str.Length;
     
    Console.Write(myAtoiRecursive(str, n));
}
}

Javascript

<script>
    // Recursive Javascript program to compute atoi()
     
    // Recursive function to compute atoi()
    function myAtoiRecursive(str, n)
    {
        // If str is NULL or str contains non-numeric
        // characters then return 0 as the number is not
        // valid 
         if (str.match(/^[A-Za-z]+$/)) {
         return 0;
         }
        // Base case (Only one digit)
        if (n == 1)
        {
            return str[0].charCodeAt() - '0'.charCodeAt();
        }
 
        // If more than 1 digits, recur for (n-1),
        // multiply result with 10 and add last digit
        return (10 * myAtoiRecursive(str, n - 1) + str[n - 1].charCodeAt() - '0'.charCodeAt());
    }
     
    let str = "112";
    let n = str.length;
      
    document.write(myAtoiRecursive(str, n));
 
 
</script>

Output

Time complexity: O(n),
Auxiliary Space: O(n)

Hopcroft–Karp Algorithm for Maximum Matching | Set 2 (Implementation)

N

Narendra Kangralkar

Improve

Article Tags :

Practice Tags :

Similar Reads

Implementation of Binomial Heap

In previous article, we have discussed about the concepts related to Binomial heap. Examples Binomial Heap: 12------------10--------------------20 / \ / | \ 15 50 70 50 40 | / | | 30 80 85 65 | 100A Binomial Heap with 13 nodes. It is a collection of 3 Binomial Trees of orders 0, 2 and 3 from left to

Implementation of Restoring Division Algorithm for unsigned integer

In the previous article, we have already discussed the Restoring Division Algorithm. In this article, we will discuss the implementation of this algorithm. Restoring Division Algorithm is used to divide two unsigned integers. This algorithm is used in Computer Organization and Architecture. This alg

String to Integer - Write your own atoi()

Given a string s, the task is to convert it into integer format without utilizing any built-in functions. Refer the below steps to know about atoi() function. Examples: Input: s = "-123"Output: -123 Input: s = " -"Output: 0Explanation: No digits are present, therefore 0. Input: s = " 123123123131113

Implementation of Non-Restoring Division Algorithm for Unsigned Integer

In the previous article, we have already discussed the Non-Restoring Division Algorithm. In this article, we will discuss the implementation of this algorithm. Non-restoring division algorithm is used to divide two unsigned integers. The other form of this algorithm is Restoring Division. This algor

Implement Stack using Array

Stack is a linear data structure which follows LIFO principle. To implement a stack using an array, initialize an array and treat its end as the stackâ€™s top. Implement push (add to end), pop (remove from end), and peek (check end) operations, handling cases for an empty or full stack. Step-by-step a

Recursive Program to find Factorial of a large number

Given a large number N, the task is to find the factorial of N using recursion. Factorial of a non-negative integer is the multiplication of all integers smaller than or equal to n. For example factorial of 6 is 6*5*4*3*2*1 which is 720. Examples: Input : N = 100Output : 9332621544394415268169923885

Implementing Atbash Cipher

Definition: Atbash cipher is a substitution cipher with just one specific key where all the letters are reversed that is A to Z and Z to A. It was originally used to encode the Hebrew alphabets but it can be modified to encode any alphabet. Relationship to Affine: Atbash cipher can be thought of as

Recursive Program to print multiplication table of a number

Given a number N, the task is to print its multiplication table using recursion. Examples Input: N = 5 Output: 5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 5 * 6 = 30 5 * 7 = 35 5 * 8 = 40 5 * 9 = 45 5 * 10 = 50 Input: N = 8 Output: 8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 *

Implementation of XOR Linked List in Python

Prerequisite: XOR Linked List An ordinary Doubly Linked List requires space for two address fields to store the addresses of previous and next nodes. A memory-efficient version of Doubly Linked List can be created using only one space for the address field with every node. This memory efficient Doub

Evaluation of Prefix Expressions

Prefix and Postfix expressions can be evaluated faster than an infix expression. This is because we don't need to process any brackets or follow operator precedence rule. In postfix and prefix expressions which ever operator comes before will be evaluated first, irrespective of its priority. Also, t