# Recursive program to replace all occurrences of pi with 3.14 in a given string

Given string str of size N. The task is to write a recursive function to replace all occurrences of pi with 3.14 in the given string and print the modified string.

Examples:

Input : str = “pippppiiiipi”
Output : 3.14ppp3.14iii3.14

Input : str = “pip”
Output : 3.14p

Input : str = “xpix”
Output : x3.14x

We have discussed an iterative function here
Approach :

• If there is only one character in a string or the string is empty break the recursive call
• Else keep the first character of the string with yourself and pass the rest of the string to recursion.
• If the first character is not ‘p’ then just put that character in front of the answer which came from recursion
• Else if the first character is ‘p’ and the first character of the part passed to recursion is ‘i’ then replace “pi” with “3.14”

Below is the implementation of the above approach:

## C++

 `// A recursive C++ program to replace` `// all pi in a given string with 3.14` `#include ` `using` `namespace` `std;`   `// Recursive Function to replace all` `// occurrences of pi in a given` `// with 3.14` `void` `replacePiHelper(``char` `str[], ``int` `start)` `{`   `    ``// Base condition` `    ``// if the string is empty` `    ``// or of length one` `    ``if` `(str[start] == ``'\0'` `|| str[start + 1] == ``'\0'``) {` `        ``return``;` `    ``}`   `    ``// Getting the answer from` `    ``// recursion for the smaller` `    ``// problem` `    ``replacePiHelper(str, start + 1);`   `    ``// Small calculation part` `    ``// if the first character is 'p'` `    ``// and the first character of the part` `    ``// passed to recursion is 'i' then replace` `    ``// "pi" with "3.14"` `    ``if` `(str[start] == ``'p'` `&& str[start + 1] == ``'i'``) {`   `        ``// Shifting the characters to` `        ``// right side to put 3.14 in` `        ``// the character array` `        ``for` `(``int` `i = ``strlen``(str); i >= start + 2; i--) {` `            ``str[i + 2] = str[i];` `        ``}`   `        ``// Replacing with "3.14"` `        ``str[start] = ``'3'``;` `        ``str[start + 1] = ``'.'``;` `        ``str[start + 2] = ``'1'``;` `        ``str[start + 3] = ``'4'``;` `    ``}` `}`   `// Function to replace pi with 3.14` `void` `replacePi(``char` `str[])` `{` `    ``replacePiHelper(str, 0);` `}`   `// Driver code` `int` `main()` `{` `    ``char` `str[] = ``"pippppiiiipi"``;`   `    ``// Function call` `    ``replacePi(str);`   `    ``cout << str;`   `    ``return` `0;` `}`

## Java

 `// A recursive Java program to replace` `// all pi in a given string with 3.14`   `class` `GFG {`   `    ``// Recursive Function to replace all` `    ``// occurrences of pi in a given` `    ``// with 3.14` `    ``public` `String replacePi(String str)` `    ``{` `        ``// base condition` `        ``// if the string is empty` `        ``// or of length one` `        ``if` `(str.length() <= ``1``) {` `            ``return` `str;` `        ``}`   `        ``// if the first character is 'p'` `        ``// and the first character of the part` `        ``// passed to recursion is 'i' then replace` `        ``//"pi" with "3.14"` `        ``if` `(str.charAt(``0``) == ``'p'` `&& str.length() >= ``2` `            ``&& str.charAt(``1``) == ``'i'``) {` `            ``return` `"3.14"` `+ replacePi(str.substring(``2``, str.length()));` `        ``}`   `        ``// if the first character is not 'p'` `        ``// then just put that character in` `        ``// front of the answer which came` `        ``// from recursion` `        ``return` `str.charAt(``0``) + replacePi(str.substring(``1``, str.length()));` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``GFG g = ``new` `GFG();` `        ``String str = ``"pippppiiiipi"``;` `        ``System.out.println(g.replacePi(str));` `    ``}` `}`

## Python3

 `# A recursive Python3 program to replace` `# all pi in a given string with 3.14`   `# Recursive Function to replace all` `# occurrences of pi in a given` `# with 3.14` `def` `replacePieHelper(string, start):`   `    ``# Base condition` `    ``# if the string is empty` `    ``# or of length one` `    ``if` `len``(string) < ``2` `or` `start ``=``=` `len``(string):` `        ``return` `string`   `    ``# Getting the answer from` `    ``# recursion for the smaller` `    ``# problem` `    ``replacePieHelper(string, start ``+` `1``)`   `    ``# Small calculation part` `    ``# if the first character is 'p'` `    ``# and the first character of the part` `    ``# passed to recursion is 'i' then replace` `    ``# "pi" with "3.14"` `    ``if``(string[start] ``=``=` `'p'` `and` `       ``string[start ``+` `1``] ``=``=` `'i'``):`   `        ``# Replacing with "3.14"` `        ``string[start:start ``+` `2``] ``=` `[``'3'``, ``'.'``, ``'1'``, ``'4'``]`   `# Function to replace pi with 3.14` `def` `replacePi(string):` `    ``replacePieHelper(string, ``0``)`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``string ``=` `"pippppiiiipi"`   `    ``string ``=` `list``(string)`   `    ``# Function call` `    ``replacePi(string)`   `    ``string ``=` `''.join(string)` `    ``print``(string)`   `# This code is contributed by` `# sanjeev2552`

## C#

 `// A recursive C# program to replace` `// all pi in a given string with 3.14`   `using` `System;` `class` `gfg {` `    ``// Recursive Function to replace all` `    ``// occurrences of pi in a given` `    ``// with 3.14` `    ``public` `String replacePi(String str)` `    ``{` `        ``// base condition` `        ``// if the string is empty` `        ``// or of length one` `        ``if` `(str.Length <= 1) {` `            ``return` `str;` `        ``}`   `        ``// if the first character is 'p'` `        ``// and the first character of the part` `        ``// passed to recursion is 'i' then replace` `        ``//"pi" with "3.14"` `        ``if` `(str[0] == ``'p'` `&& str.Length >= 2` `            ``&& str[1] == ``'i'``) {` `            ``return` `"3.14"` `+ replacePi(str.Substring(2, str.Length - 2));` `        ``}`   `        ``// if the first character is not 'p'` `        ``// then just put that character in` `        ``// front of the answer which came` `        ``// from recursion` `        ``return` `str[0] + replacePi(str.Substring(1, str.Length - 1));` `    ``}` `}`   `// Driver Code` `class` `geek {` `    ``public` `static` `int` `Main()` `    ``{` `        ``gfg g = ``new` `gfg();` `        ``string` `input = ``"pippppiiiipi"``;` `        ``Console.WriteLine(g.replacePi(input));` `        ``return` `0;` `    ``}` `}`

## Javascript

 ``

Output

`3.14ppp3.14iii3.14`

Time complexity: O(N) where N is length of given string

Auxiliary space: O(N) for call stack

Another Approach:

A simple recursive approach to replace all pi in a given function with “3.14”. Firstly function is declared we don’t need any helper function.

• Base case if the string is empty or the length of the string is 1 return the string.
• If the 0th and 1st element of the string is p and we have to handle them for the rest we have to call recursion it will give the result.
• If not then we have to call recursion from 1st to all elements then add recursion result to 1st element and return it.

Below is the implementation of the above approach:

## C++

 `// C++ program for above approach` `#include ` `using` `namespace` `std;`   `// A simple recursive approach` `// to replace all pi in a given` `// function with "3.14". Firstly` `// function is declared we don't` `// need any helper function one` `// function is enough` `string replacePi(string s)` `{`   `    ``// Base case if s is empty` `    ``// or length of s is 1` `    ``// return the s` `    ``if` `(s.length() == 0 || s.length() == 1)` `        ``return` `s;`   `    ``// If the 0th and 1st element` `    ``// of s are p and i we have to` `    ``// handle them for rest we have` `    ``// to call recursion it will` `    ``// give the result` `    ``if` `(s[0] == ``'p'` `&& s[1] == ``'i'``) {`   `        ``// Smalloutput is a variable` `        ``// used to store recursion result` `        ``string smallOutput = replacePi(s.substr(2));`   `        ``// And we have to add the recursion` `        ``// result with the first part we` `        ``// handled and return the answer` `        ``return` `"3.14"` `+ smallOutput;` `    ``}` `    ``else` `{` `        ``// If 1st & 2nd element aren't "p" & "i", then keep` `        ``// 1st index as it is & call recursion for rest of` `        ``// the string.` `        ``return` `s[0] + replacePi(s.substr(1));` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``string s = ``"pipppiiipi"``;`   `    ``// Function call` `    ``string result = replacePi(s);`   `    ``cout << result << endl;`   `    ``return` `0;` `}`   `// This code is contributed by divyeshrabadiya07`

## Java

 `// Java program for above approach` `class` `GFG {`   `    ``// A simple recursive approach` `    ``// to replace all pi in a given` `    ``// function with "3.14". Firstly` `    ``// function is declared we don't` `    ``// need any helper function one` `    ``// function is enough` `    ``public` `static` `String replacePi(String s)` `    ``{`   `        ``// Base case if s is empty` `        ``// or length of s is 1` `        ``// return the s` `        ``if` `(s.length() == ``0` `|| s.length() == ``1``)` `            ``return` `s;`   `        ``// If the 0th and 1st element` `        ``// of s are p and i we have to` `        ``// handle them for rest we have` `        ``// to call recursion it will` `        ``// give the result` `        ``if` `(s.charAt(``0``) == ``'p'` `&& s.charAt(``1``) == ``'i'``) {`   `            ``// Smalloutput is a variable` `            ``// used to store recursion result` `            ``String smallOutput = replacePi(s.substring(``2``));`   `            ``// And we have to add the recursion` `            ``// result with the first part we` `            ``// handled and return the answer` `            ``return` `"3.14"` `+ smallOutput;` `        ``}` `        ``else` `{`   `            ``// If not then we have to call` `            ``// recursion from 1st to all elements` `            ``// then add recursion result to` `            ``// 1st element and return it` `            ``String smallOutput = replacePi(s.substring(``1``));` `            ``return` `s.charAt(``0``) + smallOutput;` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String s = ``"pipppiiipi"``;`   `        ``// Function call` `        ``String result = replacePi(s);` `        ``System.out.println(result);` `    ``}` `}`   `// This code is contributed by divyesh072019`

## Python

 `# Python program for above approach`   `# A simple recursive approach` `# to replace all` `# pi in a given function with "3.14"` `# Firstly function is declared we don't` `# need any helper function one` `# function is enough`     `def` `replacePi(string):`   `    ``# Base case if string is empty` `    ``# or length of string is 1` `    ``# return the string` `    ``if` `len``(string) ``=``=` `0` `or` `                     ``len``(string) ``=``=` `1``:` `        ``return` `string` `    `  `    ``# If the 0th and 1st element ` `    ``# of string are p ` `    ``# and i we have to handle them` `    ``# for rest we have to call ` `    ``# recursion it will give the result` `    ``if` `string[``0``] ``=``=` `'p'` `and` `string[``1``] ``=``=` `'i'``:` `      `  `        ``# Smalloutput is a variable ` `        ``# used to store recursion result` `        ``smallOutput ``=` `replacePi(string[``2``:])    ` `        `  `        ``# And we have to add the recursion ` `        ``# result with the first part we ` `          ``# handled and return the answer` `        ``return` `"3.14"` `+` `smallOutput             ` `    ``else``:` `        `  `        ``# If not then we have to call ` `        ``# recursion from 1st to all elements` `        ``# then add recursion result to ` `        ``# 1st element and return it` `        ``smallOutput ``=` `replacePi(string[``1``:])` `        ``return` `string[``0``] ``+` `smallOutput` `      `  `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `  ``string ``=` `"pipppiiipi"`   `  ``# Function call` `  ``result ``=` `replacePi(string)` `  ``print` `result`

## C#

 `// C# program for above approach` `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `class` `GFG {`   `    ``// A simple recursive approach` `    ``// to replace all pi in a given` `    ``// function with "3.14". Firstly` `    ``// function is declared we don't` `    ``// need any helper function one` `    ``// function is enough` `    ``static` `string` `replacePi(``string` `s)` `    ``{`   `        ``// Base case if s is empty` `        ``// or length of s is 1` `        ``// return the s` `        ``if` `(s.Length == 0 || s.Length == 1)` `            ``return` `s;`   `        ``// If the 0th and 1st element` `        ``// of s are p and i we have to` `        ``// handle them for rest we have` `        ``// to call recursion it will` `        ``// give the result` `        ``if` `(s[0] == ``'p'` `&& s[1] == ``'i'``) {`   `            ``// Smalloutput is a variable` `            ``// used to store recursion result` `            ``string` `smallOutput = replacePi(s.Substring(2));`   `            ``// And we have to add the recursion` `            ``// result with the first part we` `            ``// handled and return the answer` `            ``return` `"3.14"` `+ smallOutput;` `        ``}` `        ``else` `{`   `            ``// If not then we have to call` `            ``// recursion from 1st to all elements` `            ``// then add recursion result to` `            ``// 1st element and return it` `            ``string` `smallOutput = replacePi(s.Substring(1));` `            ``return` `s[0] + smallOutput;` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``string` `s = ``"pipppiiipi"``;`   `        ``// Function call` `        ``string` `result = replacePi(s);` `        ``Console.Write(result);` `    ``}` `}`   `// This code is contributed by rutvik_56`

## Javascript

 ``

Output

```3.14pp3.14ii3.14
```

Time complexity: O(N), where N is the length of the given string
Auxiliary space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next