 # Tips on how to make this a recursive function

``````def check(text1,text2):
if text1 =="":
return True
if text2 in text1:
return True
else:
return False

def main():
text2=str(raw_input("Enter the text2: "))
text1= str(raw_input("Enter the text1: "))
print(check(text1,text2))

main()
``````

can you give me tips on how to make this recursive function? I have to go by each index like text1 n and compares the another text2 of index n keeps going tell it stops. text1=tion text2=automation the function i have doesn’t go on by one but actually just checks if its has same words in each one text1 in text2. In the recursive function it checks each index than returns true if text1=tion is there in another word text2= automation. Tips will be useful for me.

It would be great if you can articulate exactly what you’re trying to accomplish and why you want to use recursion accomplish this. Also, if you’re using a different language than JavaScript, you should specify it since this website is focused on learning JavaScript.

I’m guessing you’re trying to build a function that checks to see if text2 contains a substring of text1. Why bother with recursion when you can use the function text2.contains(text1); in JavaScript es6? Other languages have similar functions.

Im using python language. I know its no need for a recursion for this. But I’m practicing thats why.

Here is a good example of recursion in Python:

``````def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n-1)
``````

Your example is not a good use case for recursion.

I know that. I was trying to make like that recursion function. but did not work

So this might not be the ideal exercise as the recursive solution is a little involved. I’ll just put a possible solution here - it could be a lot more concise, but I’ve tried to make it a bit more verbose so you can see each condition. You need to be really careful to explicitly handle every possible case, else you can very easily get into infinite recursion situations.

It’s easy enough to write a recursive function if `text1` is a single character.

So for a function `check(char, text)` where `char` is a single character and `text` is the string you’re going to recurse over:

1. if the length both the character and the text are 0, return True (exit as soon as possible if this is the case, this is a sanity check to stop the function erroring if `""` and `""` get passed as arguments).
2. If the character is found in `text`, return True.
3. If the length of text is 0, return False (it is important that this comes after the two conditions above).
4. Otherwise run the function again with the first character from `text` dropped.
``````def check(char, text):
if len(char) == 0 and len(text) == 0:
return True
if  len(text) == 0:
return False
if char == text:
return True
else:
return check(char, text[1:])

check("o", "hello")
``````

You can step through this here.

But you want to check if a set of characters appears in the text. So we need to change the conditions slightly.

1. If the length of text1 is greater than text2, it isn’t possible for text1 to be in text2, so return False (this replaces the len(text) == 0 check in the first function).
2. If the length both the character and the text are 0, return True.
3. If text1 == text2, need to check that text1 == text2 and so on, so we’ll split that out into another function.
i. if that returns True, return True in the main function.
ii. if it doesn’t, run the main function again with the first character in `text2` dropped.
``````def check(text1, text2):
if len(text1) > len(text2):
return False
if len(text1) == 0 and len(text2) == 0:
return True
if text1 == text1:
subcheck = substring_check(text1, text2)
if subcheck:
return True
else:
return check(text1, text2[1:])

def substring_check(str1, str2):
if (len(str1) == 0):
return True
if (str1 != str2):
return False
else:
return substring_check(str1[1:], str2[1:])

check("llo", "hello")
``````

Step through the code here

Apologies if there are any typing mistakes there, but hopefully that should be somewhat helpful.

Would you say a functional language like Haskell would be better for recursion then?

You don’t have a choice, there aren’t any loops. ML-based functional languages (Haskell, ML, OCaml, F# etc), Erlang-VM based languages (Erlang, Elixir, etc), Lisps (like Scheme), logic languages (like Prolog), none of those have looping constructs. Declarative languages, of which they are all types of, don’t have or need loops, they use recursion instead.

Python is imperative, and has awesome built in stuff for doing what recursion is used for in the above languages, so not necessary; it explicitly does not optimise for recursion, so it’s best avoided.

1 Like

I guess @zuzutahan was just practicing the theory as Python is an easy language to learn. 1 Like

Yeah I should have emphasised that - it may well be best avoided overall/unecessary when building real things in Python, but Python is a v good language to actually learn in so it’s a good way to investigate how recursion works; it might not be performant but it’s much easier to read the code than most of those other languages

(edit: edited my OP to take out the mentions of it not being the best lang for recursion)

1 Like