Reverse word in python

Since everyone else’s covered the case where the punctuation moves, I’ll cover the one where you don’t want the punctuation to move.

import re
def reverse_words(sentence):
    return re.sub(r'[a-zA-Z]+', lambda x : x.group()[::-1], sentence)

Breaking this down.

re is python’s regex module, and re.sub is the function in that module that handles substitutions. It has three required parameters.

The first is the regex you’re matching by. In this case, I’m using r'w+'. The r denotes a raw string, [a-zA-Z] matches all letters, and + means «at least one».

The second is either a string to substitute in, or a function that takes in a re.MatchObject and outputs a string. I’m using a lambda (or nameless) function that simply outputs the matched string, reversed.

The third is the string you want to do a find in a replace in.

So «What is my name?» -> «tahW si ym eman?»

Addendum:

I considered a regex of r'w+' initially, because better unicode support (if the right flags are given), but w also includes numbers and underscores. Matching - might also be desired behavior: the regexes would be r'[a-zA-Z-]+' (note trailing hyphen) and r'[w-]+' but then you’d probably want to not match double-dashes (ie --) so more regex modifications might be needed.

The built-in reversed outputs a reversed object, which you have to cast back to string, so I generally prefer the [::-1] option.

We are given a string and we need to reverse words of a given string

Examples:

Input : str =" geeks quiz practice code"
Output : str = code practice quiz geeks  
Input : str = "my name is laxmi"
output : str= laxmi is name my 

reverse the words in the given string program 

code practice quiz geeks

Time Complexity: O(n), where n is the length of the string
Auxiliary Space: O(n), where n is the length of the string

We are given a string and we need to reverse words of a given string? Examples:

Input : str = geeks quiz practice code
Output : str = code practice quiz geeks

This problem has an existing solution please refer Reverse words in a given String link. We will solve this problem in python. Given below are the steps to be followed to solve this problem.

• Separate each word in a given string using split() method of string data type in python.
• Reverse the word separated list.
• Print words of the list, in string form after joining each word with space using ” “.join() method in python.

Implementation:

code practice quiz geeks

Time Complexity: O(n), where n is the length of the string
Auxiliary Space: O(n), where n is the length of the string

This solution use the same procedure but have different methods to reverse the words in string with the help backward iteration and regular expression module. Following are the steps of our approach:

• Find all the words in string with the help of re.findall() function. 
• Iterate over the list in backward manner. 
• Join the words in a string with the help of join() function.

code practice quiz geeks

Another approach to reverse the words in a given string is to use a stack. A stack is a data structure that supports push and pop operations. You can use a stack to reverse the words in a string by pushing the words onto the stack one by one and then popping them off the stack to form the reversed string.

Here is an example of how you can use a stack to reverse the words in a given string in Python:

code practice quiz geeks

Method: 

1. The input string is split into a list of words using the split() method. By default, split() splits the string on whitespace characters (spaces, tabs, and newlines), so each word is separated into its own element of the list.

2. An empty string variable called reversed_string is initialized.

3. A for loop is used to iterate over the indices of the words list in reverse order. The loop starts from the index of the last word in the list (i.e., len(words)-1) and goes backwards to the first word (i.e., index 0). For each index, the corresponding word is appended to reversed_string, followed by a space character.

4. Finally, the extra space character at the end of reversed_string is removed using the strip() method, and the resulting string is returned.

code practice quiz geeks

time complexity: O(n)  

auxiliary space: O(n)

This approach has a time complexity of O(n) and a space complexity of O(n), where n is the length of the string.

Reverse Words in a String Using Two-Pointer Approach

1. Reverse the entire string.
2. Reverse each word in the reversed string.

Steps:

1. Start by taking the input string as s.
2. Reverse the entire string s using a two-pointer approach.
3. Initialize two pointers, start and end, both pointing to the first character of the reversed string respectively.
4. Traverse the string s and when a space is encountered, reverse the word between start and end pointers using a similar two-pointer approach.
5. Update the start pointer to the next character after the space and the end pointer to the same position as the start pointer.
6. Repeat steps 4 and 5 until the end of the string is reached.
7. Return the reversed string.

code practice quiz geeks

Time Complexity: O(N), where N is the length of the input string.

Auxiliary Space: O(1), the algorithm uses constant space to perform the reverse operation in place.

This article is contributed by Shashank Mishra (Gullu). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Knowing how to reverse a Python string is a common thing you might have to do as a Python developer. It could also help you in coding interviews.

Python does not provide a built-in function to reverse the characters in a string. To reverse a string in Python you can use the slice operator with the syntax [::-1]. You can also use the reversed() function together with the string join() function.

Let’s go through different ways to return a Python string in reverse order.

Let’s immediately learn a simple method to reverse a string.

I want to give you the solution to the problem first, then we will understand how this solution exactly works.

Open the Python shell and define a Python string:

>>> word = "Python"

To reverse a string in Python you can use slicing with the following syntax: [::-1].

>>> print(word)
Python
>>> print(word[::-1])
nohtyP 

Fantastic! Nice and concise!

As you can see in the second print statement the reversed string is returned.

If you want to make this code reusable you can create a function that given a string returns the reversed string.

>>> def reverse_word(word):
...     return word[::-1]
... 
>>> print(reverse_word("Python"))
nohtyP 

In the next section, we will learn how the expression [::-1] works.

What is the Meaning of [::-1] in Python?

You might be wondering, what does the syntax [::-1] mean?

This is the Python slice operator that in its basic form allows to select a substring from a string.

For example, let’s say you want to select the first three characters of our word, you can use the following slicing expression.

>>> print(word[0:3])
Pyt

The substring starts at the character with index 0 (the first character) and ends at the character with index 3 – 1 so 2.

If we omit the first zero in the slice expression the output is the same:

>>> print(word[:3])
Pyt 

But, the slicing syntax we have used before is slightly different:

[::-1]

This expression uses the extended syntax for the slice operator.

[begin:end:step]

By default, the value of step is 1. Also if you don’t specify any value for begin the Python interpreter will start from the beginning of the string.

And, if you don’t specify a value for end Python will go until the end of the string.

Let’s see what happens if we don’t specify a value for begin and end and we set the step to 1:

>>> print(word)
Python
>>> print(word[::1])
Python 

Python goes through every character of the string from the beginning to the end using a step equal to 1.

The only difference in the expression we have seen before to reverse a string is that we have used a step equal to -1.

When you specify a step equal to -1 in a slicing expression the Python interpreter goes through the characters of the string backward. This explains the output returned by the expression [::-1].

>>> print(word[::-1])
nohtyP 

How Do You Reverse a String with a Python While Loop?

We can obtain the same output returned by the slice operator but using a while loop.

This is not something you would necessarily use if you had to reverse a string in a real application considering that it requires more lines of code compared to slicing.

At the same time knowing how to reverse a string in Python with a while loop helps you develop the way you think when you look for a solution to a coding problem.

Here is what we want to do…

Start from the end of our input string and go backward one character at a time using a while loop.

Every character is added to the new string reversed_word which is initially an empty string and at the end contains the original string but reversed.

def reversed_word(word):
    reversed_word = ''
    index = len(word) - 1

    while index >= 0:
        reversed_word += word[index]
        index -= 1

    return reversed_word

As you can see we start at the index len(word) -1, the last character of our string. Then we go back, at every iteration of the while loop, as long as the index is greater than or equal to zero.

Remember that len(word) is the length of the string.

Note: writing index -= 1 is the same as index = index – 1. So it’s just a more concise way to decrement the index by 1.

Let’s test this program by calling our function:

print(reversed_word("Python"))

[output]
nohtyP 

It works fine!

What Does the Python reversed() Function Do?

Python also provides a built-in function called reversed().

What does it do? Can we use it to reverse the characters in a string?

According to the official Python documentation, the reversed() function returns a reverse iterator.

But, how can it help?

>>> print(reversed("Greece"))
<reversed object at 0x7ff8e0172610> 

Here is what we get if we cast the reverse iterator to a list.

>>> print(list(reversed("Greece")))
['e', 'c', 'e', 'e', 'r', 'G'] 

We get back a Python list in which every element is a character of the initial string but in reversed order. To obtain the reversed string we also have to use the string join() function.

>>> print(''.join(reversed("Greece")))
eceerG 

We are using an empty separator character to concatenate the characters returned by the reverse iterator.

We could also cast the iterator to a list before passing it to the join function and the result would be the same.

>>> print(''.join(list(reversed("Greece"))))
eceerG 

We have seen how to reverse a string in Python using just one line of code.

In one of the final sections of this tutorial, we will analyze which approach is the most performant.

Reverse String in Python Using Recursion

In this section, we will create a Python function that uses recursion to reverse a word / string.

This is a more complex implementation you will probably never use, but understanding it can add something to your Python developer knowledge.

def reverse_string_recursively(word):
    if len(word) == 0:
        return word
    else:
        return reverse_string_recursively(word[1:]) + word[0]

Let’s break down this code to understand how it works.

Call the function as shown below:

print(reverse_string_recursively('Hello'))

The first time it’s executed, the return statement in the else branch is equal to:

reverse_string_recursively('ello') + 'H'

This expression is equal to:

reverse_string_recursively('llo') + 'e' + 'H'

And this continues until the string passed to the function is empty:

reverse_string_recursively('lo') + 'l' + 'e' + 'H'
reverse_string_recursively('o') + 'l' + 'l' + 'e' + 'H'
reverse_string_recursively('') + 'o' + 'l' + 'l' + 'e' + 'H'

When the length of the string passed to the function is zero the function returns the string itself (see the logic in the if branch), so the final result is:

'' + 'o' + 'l' + 'l' + 'e' + 'H'

Here is what you get if you execute the expression above in the Python shell:

>>> '' + 'o' + 'l' + 'l' + 'e' + 'H'
'olleH'

The + sign is the Python string concatenation operator.

How to Reverse a Unicode String

Unicode is a standard used to represent characters in any language (and not only, with Unicode you can even represent emojis).

You might want to use Unicode if you have to handle strings in languages other than English.

For example, the following word means ‘Good morning’ in Greek:

Καλημερα

Let’s print each letter by using their Unicode representation:

>>> print('U0000039A')
Κ
>>> print('U000003B1')
α
>>> print('U000003BB')
λ
>>> print('U000003B7')
η
>>> print('U000003BC')
μ
>>> print('U000003B5')
ε
>>> print('U000003C1')
ρ
>>> print('U000003B1')
α  

And now let’s print the full word still using the Unicode representation for each character:

>>> word = 'U0000039AU000003B1U000003BBU000003B7U000003BCU000003B5U000003C1U000003B1'
>>> print(word)
Καλημερα 

We can reverse the string by using the first approach we have covered in this tutorial (the slice operator).

>>> print(word[::-1])
αρεμηλαΚ 

Performance Comparison of Approaches to Reverse a Python String

Let’s confirm which one of the approaches to reverse the characters of a string is the fastest.

To measure the performance of each implementation we will use Python’s timeit module.

Reverse a string using the slice operator

import timeit 

testfunction = '''
def reversed_word():
    return 'hello'[::-1]
'''

print(timeit.timeit(testfunction))

[output]
0.054680042 

Reverse a string using a while loop

import timeit 

testfunction = '''
def reversed_word():
    word = 'hello'
    reversed_word = ''
    index = len(word) - 1

    while index >= 0:
        reversed_word += word[index]
        index = index - 1

    return reversed_word
''' 

print(timeit.timeit(testfunction))

[output]
0.063328583  

Reverse a string using the join() and reversed() functions

import timeit 

testfunction = '''
def reversed_word():
    word = 'hello'
    return ''.join(reversed(word))
''' 

print(timeit.timeit(testfunction))

[output]
0.062542167 

Reverse a string using the join(), list() and reversed() functions

import timeit 

testfunction = '''
def reversed_word():
    word = 'hello'
    return ''.join(list(reversed(word)))
''' 

print(timeit.timeit(testfunction))

[output]
0.059792666999999994  

The fastest implementation is the one using the slice operator.

Conclusion

In this tutorial, we have seen multiple ways to reverse a Python string.

The most performant way to reverse a string uses slicing but it’s also possible to use the reversed() function together with the join() and list() functions.

Implementing your own function to reverse a string using a loop doesn’t really make sense considering that it wouldn’t be as performant as the slice operator and it would require more lines of code.

Bonus read: Are you getting started with Python? Have a look at this tutorial that will give you a comprehensive overview of what it means to start coding in Python.

When you’re using Python strings often in your code, you may face the need to work with them in reverse order. Python includes a few handy tools and techniques that can help you out in these situations. With them, you’ll be able to build reversed copies of existing strings quickly and efficiently.

Knowing about these tools and techniques for reversing strings in Python will help you improve your proficiency as a Python developer.

In this tutorial, you’ll learn how to:

• Quickly build reversed strings through slicing
• Create reversed copies of existing strings using reversed() and .join()
• Use iteration and recursion to reverse existing strings manually
• Perform reverse iteration over your strings
• Sort your strings in reverse order using sorted()

To make the most out of this tutorial, you should know the basics of strings, for and while loops, and recursion.

a_string[start:stop:step]

>>> letters = "AaBbCcDd"

>>> # Get all characters relying on default offsets
>>> letters[::]
'AaBbCcDd'
>>> letters[:]
'AaBbCcDd'

>>> # Get every other character from 0 to the end
>>> letters[::2]
'ABCD'

>>> # Get every other character from 1 to the end
>>> letters[1::2]
'abcd'

>>> letters = "ABCDEF"

>>> letters[::-1]
'FEDCBA'

>>> letters
'ABCDEF'

>>> letters = "ABCDEF"

>>> letters[slice(None, None, -1)]
'FEDCBA'

>>> greeting = reversed("Hello, World!")

>>> next(greeting)
'!'
>>> next(greeting)
'd'
>>> next(greeting)
'l'

>>> "".join(reversed("Hello, World!"))
'!dlroW ,olleH'

>>> def reversed_string(text):
...     result = ""
...     for char in text:
...         result = char + result
...     return result
...

>>> reversed_string("Hello, World!")
'!dlroW ,olleH'

>>> def reversed_string(text):
...     result = ""
...     index = len(text) - 1
...     while index >= 0:
...         result += text[index]
...         index -= 1
...     return result
...

>>> reversed_string("Hello, World!")
'!dlroW ,olleH'

>>> def reversed_string(text):
...     if len(text) == 1:
...         return text
...     return reversed_string(text[1:]) + text[:1]
...

>>> reversed_string("Hello, World!")
'!dlroW ,olleH'

>>> very_long_greeting = "Hello, World!" * 1_000

>>> reversed_string(very_long_greeting)
Traceback (most recent call last):
    ...
RecursionError: maximum recursion depth exceeded while calling a Python object

>>> from functools import reduce

>>> def reversed_string(text):
...     return reduce(lambda a, b: b + a, text)
...

>>> reversed_string("Hello, World!")
'!dlroW ,olleH'

>>> greeting = "Hello, World!"

>>> for char in reversed(greeting):
...     print(char)
...
!
d
l
r
o
W

,
o
l
l
e
H

>>> reversed(greeting)
<reversed object at 0x7f17aa89e070>

>>> greeting = "Hello, World!"

>>> for char in greeting[::-1]:
...     print(char)
...
!
d
l
r
o
W

,
o
l
l
e
H

>>> greeting[::-1]
'!dlroW ,olleH'

>>> from collections import UserString

>>> class ReversibleString(UserString):
...     def reverse(self):
...         self.data = self.data[::-1]
...

>>> text = ReversibleString("Hello, World!")
>>> text
'Hello, World!'

>>> # Reverse the string in place
>>> text.reverse()
>>> text
'!dlroW ,olleH'

>>> text = ReversibleString("Hello, World!")

>>> # Support reverse iteration out of the box
>>> for char in reversed(text):
...     print(char)
...
!
d
l
r
o
W

,
o
l
l
e
H

>>> text
"Hello, World!"

>>> vowels = "eauoi"

>>> # Sort in ascending order
>>> sorted(vowels)
['a', 'e', 'i', 'o', 'u']

>>> # Sort in descending order
>>> sorted(vowels, reverse=True)
['u', 'o', 'i', 'e', 'a']

>>> vowels = "eauoi"

>>> "".join(sorted(vowels, reverse=True))
'uoiea'

>>> for vowel in sorted(vowels, reverse=True):
...     print(vowel)
...
...
u
o
i
e
a

In this tutorial, we will learn how to reverse words of a string given by the user in python. Before getting on to the actual code, let us learn some string methods.

split() method

As the name suggests, the split() method basically splits the string into a list. You can condition it based on separator and maximum splits you want it to do. Default separator is a white space and default maximum split value is -1 (i.e. all the times).  You can split at ‘,’, ‘:’, ‘#’, etc.

Syntax:

string.split(separator, max_split)

Example:

string = "codespeedy is the best"

print(string.split())

Output:

['codespeedy', 'is', 'the', 'best']

reverse() method

There are various ways to reverse a string like reversed() function, using [::-1] to print in the reversed order or using the reverse() method. Each one has it’s own usage, advantages and disadvantages. In this tutorial, we have used reverse() method which will directly reverse and modify the original list.

Syntax:

list.reverse()

Example:

list = ['1', '2', '3', '4']

print(list.reverse())

Output:

['4','3','2','1']

join() method

join() method simply concatenate iterable-object like the elements of list, tuple, string, etc. This function returns a string with all the elements joined by string separator.

Syntax:

string.join(element)

Example:

list = ['1', '2', '3', '4']

separator = '-'

print(separator.join(list))

Output:

1-2-3-4

Reversing words of a string in Python

Problem statement: Write a python program to reverse words of a given string.

Steps/Algorithm:

1. Take the string input from user.
2. Split the string using split() function.
3. Use the reverse() method to reverse all the words that have been split from the string.
4. Finally, join and print them using the join() function.

Code/Program:

x = input("Enter any string: ")
#take input from user

a = x.split()
#use split method to split at whitespaces

a.reverse()
#reverse all the elements of the string 

print(' '.join(a))
#concatenate them into a string

Run the program online
Output:

Enter any string: codespeedy is the best
best the is codespeedy

NOTE: There may be other possible ways to solve this problem.

Also read:

• How to reverse the elements in a list in Python by its index

In this python tutorial, you will learn about the python program to reverse a string.

There are 8 methods to reverse the string in Python, which are shown below.

• Using the slicing method
• Using the reversed() function
• Using For loop
• Using the Recursion
• Using join() and list comprehension method
• Using the reduce() function
• Using the stack
• Using the list comprehension
• Using the while loop

Let us all 8 methods to reverse a string in Python using examples. And we will start with the first method of using slicing.

Method-1: Python program to reverse a string using the slicing method

This method uses the slicing of Python strings to reverse the string by starting from the last character and returning every character to the first one with a step of -1.

# Function to reverse a string
def reverse_string(string):
    # Returns the reversed string by slicing from the end to the beginning
    return string[::-1]

# Testing the function with the input string "United Kingdom"
print("Reverse of the string is : ", reverse_string("United Kingdom"))

The above code defines a function called reverse_string which takes a string as an argument and returns the reverse of the input string using string slicing. The function is then called and the reverse of the string “United Kingdom” is printed to the console.

Read: How to Check if a String contains a Substring in Python

Method-2: Python program to reverse a string using the reversed() function

The reversed() function returns a reverse iterator, so we can convert it into a string using the join() method. This method is easy to use and more efficient than some other methods.

# Function to reverse a string
def reverse_string(string):
    # Return the reversed string using the reversed() function and join() method
    return "".join(reversed(string))

# Print the reversed string
print("Reverse of the string is : ", reverse_string("USA"))

The above code defines a function reverse_string which takes a string as an argument and returns the reversed version of the string.

The function uses the reversed function and the join method to reverse the string. The code then calls the reverse_string function with the argument “USA” and prints the returned value, which is the reverse of the string “USA”.

Output: Reverse of the string is :  ASU

Read: Python string formatting

Method-3: Python program to reverse a string using For loop

In this method, we use a for loop to iterate over the characters in the string and build a new string by adding each character to the beginning of an empty string.

# Function to reverse a string
def reverse_string(string):
    # Initialize an empty string
    result = ""
    # Loop through each character in the string and add it to the beginning of the result string
    for char in string:
        result = char + result
    # Return the reversed string
    return result

# Call the function with a string "Canada" as an argument
print("Reverse of the string is : ", reverse_string("Canada"))

The above code defines a function reverse_string which takes a string as input and returns the reverse of that string by concatenating each character from the end to the start of the string into a new result string.

• The function is then called with the string “Canada” and the resulting reverse string is printed.

Outptut: Reverse of the string is :  adanaC

Read: Python compare strings

Method-4: Python program to reverse a string using the Recursion

This method uses recursion to reverse the string. The base case of the recursion is an empty string, and for each recursive call, the first character is added to the end of the reverse of the rest of the string.

# Function to reverse a string using recursion
def reverse_string(string):
    # Base case: If the length of the string is 0, return the string
    if len(string) == 0:
        return string
    else:
        # Recursive step: Return the last character of the string + the reverse of the rest of the string
        return reverse_string(string[1:]) + string[0]

# Testing the reverse_string function with the input "New York"
print("Reverse of the string is : ", reverse_string("New York"))

Output: Reverse of the string is :  kroY weN

Read: Python find number in String

Method-5: Python program to reverse a string using join() and list comprehension method

This method uses the join() method to concatenate the characters in the string in reverse order, generated through a generator expression that iterates over the string in reverse order.

# Function to reverse a string using list comprehension
def reverse_string(string):
    return "".join(string[i] for i in range(len(string)-1, -1, -1))

# Reverse the string "Brazil" and print the result
print("Reverse of the string is : ", reverse_string("Brazil"))

The above code defines a function reverse_string that takes a string as an argument. The function returns a reversed version of the string using the built-in join method.

• The join method concatenates the elements of the string, which are obtained using the list comprehension that iterates through the string in reverse order (i.e., from the last index to the first index).

Output: Reverse of the string is :  lizarB

Read: Find first number in string in Python

Method-6: Python program to reverse a string using the reduce() function

This method uses the reduce() function from the functools module to apply a binary function to the elements of the string in reverse order, creating a single cumulative value.

# Function to reverse a string using reduce method
from functools import reduce

def reverse_string(string):
    # Using reduce to concatenate the characters in the string in reverse order
    return reduce(lambda x, y: y + x, string)

# Testing the reverse_string function
print("Reverse of the string is : ", reverse_string("Australia"))

The above code is a python script that reverses a string using the reduce() method from the functools library. The script defines a function called reverse_string which takes a string as an argument.

• The function returns the reversed string by using the reduce() method with a lambda function as an argument.

Output: Reverse of the string is :  ailartsuA

Read: Remove non-ASCII characters Python

Method-7: Python program to reverse a string using the stack

This method uses a stack data structure to reverse the string. The stack is created by pushing each character in the string onto it and then popping the characters off the stack to build the reversed string.

# Function to reverse a string using a stack
def reverse_string(string):
    # Create a stack of characters from the input string
    stack = [char for char in string]
    # Initialize an empty string to store the result
    result = ""
    # Pop characters from the stack and add them to the result until the stack is empty
    while stack:
        result += stack.pop()
    # Return the reversed string
    return result

# Test the function by passing a sample string
print("Reverse of the string is : ", reverse_string("Washington"))

The above code defines a function reverse_string that takes in a string as an argument and returns its reverse.

• The function uses a stack data structure to store the characters of the string and then pops the elements from the stack to get the reverse string.
• Finally, the reversed string is returned and printed.

Output: Reverse of the string is :  notgnihsaW

Read: How to trim a string in Python

Method-8: Python program to reverse a string using the while loop

A while loop is used to iterate over the indices of the string in reverse order (from the last character to the first character).

# Function to reverse a string
def reverse_string(string):
    # Initializing an empty string to store the reverse
    result = ""
    # Finding the length of the string
    length = len(string)
    # Iterating through the string in reverse order
    while length > 0:
        # Decreasing the length by 1
        length -= 1
        # Adding the character to the result string
        result += string[length]
    # Returning the reverse string
    return result

# Printing the reverse of the string
print("Reverse of the string is : ", reverse_string("Amazon"))

The above code defines a function reverse_string which takes a string as an argument and returns its reverse by concatenating the characters in reverse order.

• The reverse string is calculated using a loop that starts from the end of the input string and goes till the start.
• For each iteration, the character at the current index is added to the result string.

Output: Reverse of the string is :  nozamA

You may also like to read the following Python tutorials.

• How to concatenate strings in python
• Python remove substring from a String
• Python string uppercase() method with examples

In this Python tutorial, we have learned about the Python program to reverse a string using the following methods:

• Using the slicing method
• Using the reversed() function
• Using For loop
• Using the Recursion
• Using join() and list comprehension method
• Using the reduce() function
• Using the stack
• Using the list comprehension
• Using the while loop