In this tutorial, you'll learn how to use the set timer functions.

How to Set a Timer Function

There are various ways of setting a timer function, such as the setTimeout, setInterval, clearTimeout, and setImmediate functions. You'll learn about each of them in this article.

How to Use setTimeout and setInterval

The setTimeout function executes an expression after a specified delay in milliseconds while the setInterval function executes an expression after a specified interval in milliseconds.

You can use the setTimeout() function when you want to execute code block with a specific delay, but just once.

The setTimeout function is denoted by setTimeout(). Here's an example of how you can use it:

// Execute a function after 3 seconds
⁠ const timeoutId = setTimeout(() => {
    console.log('Timeout executed after 3 seconds');
}, 3000);

The above code block shows how to use the setTimeout syntax to execute a function after 3 seconds. The name of the variable is timeoutId which stores the execution of the setTimeout. The time set is 3000 milliseconds (or 3 seconds).

You can use the setInterval() function when you want to execute a code block repeatedly but at specific intervals – for instance, when animating elements.

The setInterval function is denoted by setInterval(). Here's how you can use it:

// Execute a function every 1 second
const intervalId = setInterval(() => {
    console.log('Interval executed every 1 second');
}, 1000);

The above code block shows how to use the setInterval syntax to execute a function after 1 second. The name of the variable is intervalId which stores the execution of the setInterval. The time is set to 1000 milliseconds (1 second).

How to Use clearTimeout and clearInterval

The clearTimeout function cancels a timeout previously scheduled with  the setTimeout function. clearInterval cancels an interval previously set with ⁠setInterval .

The clearTimeout function is denoted by clearTimeout();. It accepts an argument that stores the setTimeout function.

Here's an example of how it works:

const timeoutId = setTimeout(() => {
    console.log('Timeout executed after 3 seconds');
}, 3000);

clearTimeout(timeoutId);
console.log('Timeout cleared');

The clearTimeout function takes the variable name timeoutID which stores the setTimeout function and clears the function.

The clearInterval function is denoted by clearInterval();. It accepts an argument that stores the setInterval function under the block of the setTimeout function.

Here's an example of how it works:

const intervalId = setInterval(() => {
    console.log('Interval executed every 1 second');
}, 1000);

setTimeout(() => {
    clearInterval(intervalId);
    console.log('Interval cleared. Function will no longer execute.');
}, 5000);

In the above code block, the setTimeout function is introduced. The clearInterval function is passed into the code block, the argument intervalId is passed, and then the function is executed.

Another timer function is setImmediate which executes a function asynchronously as soon as possible after the current code block finishes executing. But it’s not universally supported across all browsers, so it’s rarely used.

Wrapping Up

It's important to know how to use JavaScript timer functions and when to apply them to your code. And remember that the timer is set to milliseconds, so whatever number you use, divide it by 1000 to determine how many seconds it is.

If you have any questions, you can reach out to me on Twitter 💙.

While working with arrays, you'll often need to know their length. The length of an array tells us how many elements are present in the array. You can use this to check if an array is empty and, if not, iterate through the elements in it.

How to Find the Length of an Array

Using the <.length> property

Javascript has a <.length> property that returns the size of an array as a number(integer).

Here's an example of how to use it:

let numbers = [12,13,14,25]
let numberSize = numbers.length
console.log(numberSize)
# Output
# 4

In the above code, a variable with the name numbers stores an array of numbers, while the variable numberSize stores the number of elements present in the array by using the method .length. The number size is then printed using console.log – hence the output 4.

Let's now check to see what the data type of the length property is:

let numbers = [12,13,14,25]
let numberSize = numbers.length
console.log(typeof numberSize)
# Output
# number

In the above code we see that the output is number.

Here's an example of how to access an array element with the length property in a for loop:

let numbers = [12,13,14,25]
for (i = 0; i < numbers.length; i++){
   console.log(numbers[i]);
}
# Output
# 12
# 13
# 14
# 25

Without Using the .length() method

In this method, we will iterate through the elements and count each of the elements present in the array.

Here's how it works:

function arrayLength(arr) {
   let count = 0;
   for (const element of arr) {
     count++;
   }

   return count; 
}
let numbers = [12,13,14,25]
console.log("Length of array:", arrayLength(numbers));
# Output
# Length of array: 4

In the above code, there's a function named arrayLength that accepts the array as input. We created a variable called count that is assigned 0. The count variable will store the count of the number of elements in the array.

To count the elements in the array, we used a for-of loop to check each element in the array.

The code iterates over each element in the array until undefined is encountered. That is, we iterate over each element in the array until we reach the end of the array where there are no more elements to check. Finally we return count as the output.

We pass in the variable <numbers> as the input to the function in order to obtain the length of the array as the returned value.

Conclusion

The most common and straightforward method is to use the length property of the array. But you can also use a longer method by looping through the array. These methods allow you to work with arrays of different sizes and types.

If you have any questions, you can reach out to me on Twitter 💙.

Many projects rely on libraries and other dependencies, and installing each one can be tedious and time-consuming.

This is where a ‘requirements.txt’ file comes into play. requirements.txt is a file that contains a list of packages or libraries needed to work on a project that can all be installed with the file. It provides a consistent environment and makes collaboration easier.

Format of a requirements.txt File

Diagram showing a box containing requirements.txt and another box below it containing the text "package_name == version"

The above image shows a sample of a created requirements.txt file, containing a list of packages and versions of the installation.

Key Terms

I've mentioned a few terms so far that you may not know. Here's what they mean, along with some other important terms you'll come across when working with requirements.txt:

• Dependencies are software components that a program needs to run correctly. They can be libraries, frameworks, or other programs.

• Packages are a way to group together related dependencies. They make it easier to install and manage dependencies.

• Virtual Environments is a directory that contains a copy of the Python interpreter and all of the packages that are required for a particular project.

• Pip: This is a package manager for Python. You can use Pip to install, uninstall, and manage Python packages.

How to Create a requirements.txt File

To create a requirements file, you must set up your virtual environment. If you use Pycharm, there's a virtual environment already setup (.venv). But with Visual Studio code, you have to create the virtual environment yourself.

You can use your terminal or command prompt to create your requirements file. These are the steps to follow when creating the file:

First, open your terminal or command prompt. Then check to see if the file path shown is your working directory. Use the following command to do that:

$ cd folder-name #cd - change directory

In the command above, replace ‘folder-name’ with the directory name you want to access.

Diagram showing set project directory on command line

Next, run this command:

$ pip freeze > requirements.txt

And you'll see that the requirements file gets added

Here's the output:

Diagram showing the newly created requirements file

And here's your newly created requirements.txt file:

Diagram showing lists of packages in requirements file

The image above shows the dependencies you can work with along with their versions.

How to Work with a requirements.txt File

Now that we have the requirements file, you can see that it consists of a long list of different packages.

To work with the packages, you have to install them. You can do this by using the command prompt or terminal.

Type this command:

pip install -r requirements.txt

It will look like this:

Image showing installation of packages present in requirements.txt file

Now that all the dependencies are installed, you can work with requirements.txt.

Example of using requirements.txt

In this example, we will be working with two libraries, beautifulsoup4 and requests, to return some information from a site.

Diagram showing the working libraries for this example in the requirements file

In the image above, we see that the two libraries are present in the requirements.txt file and their version. Now we can work with the libraries because we installed them previously.

• Import the library BeautifulSoup from the package name bs4 (beautifulsoup4) and also import the library requests.

from bs4 import BeautifulSoup
import requests

• To fetch information from the website URL, we use the .get() method to tap into the requests library.

web_data = requests.get("https://www.lithuania.travel/en/category/what-is-lithuania", headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36"})

• Now that we have access to the the URL, the Beautiful Soup library accepts the web_data and returns all HTML contents present in it.

soup = BeautifulSoup(web_data.content, features="html.parser")

• The final result I chose to return is elements with the

  tag in the first position [0].

news_info = soup.findAll("p")[0]
print(news_info.text

Bringing it all together:

from bs4 import BeautifulSoup
import requests
web_data = requests.get("https://www.lithuania.travel/en/category/what-is-lithuania", headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36"})
soup = BeautifulSoup(web_data.content, features="html.parser")
news_info = soup.findAll("p")[0]
print(news_info.text)

And here's the output:

Diagram showing code and result

Benefits of Using a requirements.txt File

• Managing dependencies: By listing the dependencies of your project in a requirements.txt file, you can easily see what packages are required and what versions they need to be.

• Sharing your project with others: If you share your project with others, you can include the requirements.txt file so that they can easily install the required packages. This can save them time and frustration and can help to ensure that everyone is using the same versions of the packages.

Conclusion

In the article, we learned how to create a requirements.txt file and outlined the benefits of using it.

You should also try it out and work on a few projects with it. If you have any questions, you can reach out to me on Twitter 💙.

In computer science, a greedy algorithm is an algorithm that finds a solution to problems in the shortest time possible. It picks the path that seems optimal at the moment without regard for the overall optimization of the solution that would be formed.

Edsger Dijkstra, a computer scientist and mathematician who wanted to calculate a minimum spanning tree, introduced the term "Greedy algorithm". Prim and Kruskal came up with optimization techniques for minimizing cost of graphs.

Many Greedy algorithms were developed to solve graph problems. A graph is a structure made up of edges and vertices.

Diagram of a simple graph

Greedy vs Not Greedy Algorithms

An algorithm is greedy when the path picked is regarded as the best option based on a specific criterion without considering future consequences. But it typically evaluates feasibility before making a final decision. The correctness of the solution depends on the problem and criteria used.

Example: A graph has various weights and you are to determine the maximum value in the tree. You'd start by searching each node and checking its weight to see if it is the largest value.

There are two approaches to solving this problem: greedy approach or not greedy.

Example graph

This graph consists of different weights and we need to find the maximum value. We'll apply the two approaches on the graph to get the solution.

Greedy Approach

In the images below, a graph has different numbers in its vertices and the algorithm is meant to select the vertex with the largest number.

Starting from vertex 6, then it's faced with two decisions – which is bigger, 3 or 4? The algorithm picks 4, and then is faced with another decision – which is bigger, 14 or 11. It selects 14, and the algorithm ends.

On the other hand there is a vertex labeled 20 but it is attached to vertex 3 which greedy does not consider as the best choice. It is important to select appropriate criteria for making each immediate decision.

The sample graph showing the greedy approach

Not Greedy Approach

The “not greedy” approach checks all options before arriving at a final solution, unlike the "greedy approach" which stops once it gets its results.

Starting from vertex 6, then it's faced with two decisions – which is bigger, 3 or 4? The algorithm picks 4, and then is faced with another decision – which is bigger, 14 or 11. It selects 14 and keeps it aside.

Then it runs the process again, starting from vertex 6. It selects the vertex with 3 and checks it. 20 is attached to the vertex 3 and the process stops. Now it compares the two results – 20 and 14. 20 is bigger, so it selects the vertex (3) that carries the largest number and the process ends.

This approach considers many possibilities in finding the better solution.

The sample graph showing the non-greedy approach

Characteristics of a Greedy Algorithm

• The algorithm solves its problem by finding an optimal solution. This solution can be a maximum or minimum value. It makes choices based on the best option available.

• The algorithm is fast and efficient with time complexity of O(n log n) or O(n). Therefore applied in solving large-scale problems.

• The search for optimal solution is done without repetition – the algorithm runs once.

• It is straightforward and easy to implement.

How to Use Greedy Algorithms

Before applying a greedy algorithm to a problem, you need to ask two questions:

• Do you need the best option at the moment from the problem?

• Do you need an optimal solution (either minimum or maximum value)?

If your answer to these questions is "Yes", then a greedy algorithm is a good choice to solve your problem.

Procedure

Let’s assume you have a problem with a set of numbers and you need to find the minimum value.

You start of by defining the constraint, which in this case is finding the minimum value. Then each number will be scanned and checked on each constraint which serves as a condition to be fulfilled. If the condition is true, the number(s) is selected and returned as the final solution.

Here's a flowchart representation of this process:

Flow chart showing the process for solving a problem using greedy algorithms

Greedy Algorithm Examples

Problem 1 : Activity Selection Problem

This problem contains a set of activities or tasks that need to be completed. Each one has a start and finish time. The algorithm finds the maximum number of activities that can be done in a given time without them overlapping.

Approach to the Problem

• We have a list of activities. Each has a start time and finish time.

• First, we sort the activities and start time in ascending order using the finish time of each.

• Then we start by picking the first activity. We create a new list to store the selected activity.

• To choose the next activity, we compare the finish time of the last activity to the start time of the next activity. If the start time of the next activity is greater than the finish time of the last activity, it can be selected. If not we skip this and check the next one.

• This process is repeated until all activities are checked. The final solution is a list containing the activities that can be done.

The table below shows a list of activities as well as starting and finish times.

The first step is to sort the finish time in ascending order and arrange the activities with respect to the result.

After sorting the activities, we select the first activity and store it in the selected activity list. In our example, the first activity is “Homework”.

Moving to the next activity, we check the finish time of “Homework” (5) which was the last activity selected and the starting time of “Term paper” (4). To pick an activity, the starting time of the next activity must be greater than or equal to the finish time. (4) is less than (5), so we skip the activity and move to the next.

The next activity “Presentation” has a starting time of (6) and it is greater than the finish time (5) of “Homework”. So we select it and add it to our list of selected activities.

For the next activity, we do the same checking. Finish time of “Presentation” is (10), starting time of “Volleyball practice ” is (10). We see that the starting time is equal to the finish time which satisfies one of the conditions, so we select it and add it to our list of selected activities.

Continuing to the next activity, the finish time of “Volleyball” practice is (12) and the starting time of “Biology lecture” is (13). We see the starting time is greater than the finish time so we select it.

For our last activity, the starting time for “Hangout” is (7) and the finishing time of our last activity “Biology lecture” is (14), 7 is less than 14, so we cannot select the activity. Since we are at the end of our activity list, the process ends.

Our final result is the list of selected activities that we can do without time overlapping: {Homework, Presentation, Volleyball practice, Biology lecture}.

Code Implementation of the Example

The variable <data> stores the starting times of each activity, the finish time of each activity, and the list of tasks (or activities) to be performed.

The variable <selected_activity> is an empty list that will store the selected activities that can be performed.

<start_position> shows the position the first activity which is index “0”. This will be our starting point.

data = {
  "start_time": [2 , 6 , 4 , 10 , 13 , 7],
  "finish_time": [5 , 10 , 8 , 12 , 14 , 15],
  "activity": ["Homework" , "Presentation" , "Term paper" , "Volleyball practice" , "Biology lecture" , "Hangout"]
}

selected_activity =[]
start_position = 0

Here's a dataframe table showing the original data:

Original Info

   start_time  finish_time             activity
0           2            5             Homework
1           6           10         Presentation
2           4            8           Term paper
3          10           12  Volleyball practice
4          13           14      Biology lecture
5           7           15              Hangout

Then we sort the finish time in ascending order and rearrange the start time and activity in respect to it. We target the variables by using the keys in the dictionary.

tem = 0
for i in range(0 , len(data['finish_time'])):
   for j in range(0 , len(data['finish_time'])):
       if data['finish_time'][i] < data['finish_time'][j]:
           tem = data['activity'][i] , data['finish_time'][i] , data['start_time'][i]
           data['activity'][i] , data['finish_time'][i] , data['start_time'][i] = data['activity'][j] , data['finish_time'][j] , data['start_time'][j]
           data['activity'][j] , data['finish_time'][j] , data['start_time'][j] = tem

In the code above, we intialized <tem> to zero. We are not using the inbuilt method to sort the finish time. We are using two loops to arrange it in ascending order. <i> and <j> represent the indexes and check if values of the <data['finish_time'][i]> is less than <data['finish_time'][j]>.

If the condition is true, <tem> stores the values of the elements in the <i> position and swaps the corresponding element.

Now we print the final result, here's what we get:

print("Start time: " , data['start_time'])
print("Finish time: " , data['finish_time'])
print("Activity: " , data['activity'])

# Results before sorting
# Start time:  [2, 6, 4, 10, 13, 7]
# Finish time:  [5, 10, 8, 12, 14, 15]
# Activity:  ['Homework', 'Presentation', 'Term paper', 'Volleyball practice', 'Biology lecture', 'Hangout']


# Results after sorting
# Start time:  [2, 4, 6, 10, 13, 7]
# Finish time:  [5, 8, 10, 12, 14, 15]
# Activity:  ['Homework', 'Term paper', 'Presentation', 'Volleyball practice', 'Biology lecture', 'Hangout']

And here's a dataframe table showing the sorted data:

Sorted Info with respect to finish_time

   start_time  finish_time             activity
0       2            5             Homework
1       4            8           Term paper
2       6           10         Presentation
3          10           12       Volleyball practice
4          13           14         Biology lecture
5       7           15          Hangout

After sorting the activities, we start by selecting the first activity, which is “Homework”. It has a starting index of “0” so we use the <start_position> to target the activity and append it to the empty list.

selected_activity.append(data['activity'][start_position])

The condition for selecting an activity is that the start time of the next activity selected is greater than the finish time of the previous activity. If the condition is true, the selected activity is added to the <selected_activity> list.

for pos in range(len(data['finish_time'])):
   if data['start_time'][pos] >= data['finish_time'][start_position]:
       selected_activity.append(data['activity'][pos])
       start_position = pos

print(f"The student can work on the following activities: {selected_activity}")

# Results
# The student can work on the following activities: ['Homework', 'Presentation', 'Volleyball practice', 'Biology lecture']

Here's what it looks like all together:

data = {
  "start_time": [2 , 6 , 4 , 10 , 13 , 7],
  "finish_time": [5 , 10 , 8 , 12 , 14 , 15],
  "activity": ["Homework" , "Presentation" , "Term paper" , "Volleyball practice" , "Biology lecture" , "Hangout"]
}

selected_activity =[]
start_position = 0
# sorting the items in ascending order with respect to finish time
tem = 0
for i in range(0 , len(data['finish_time'])):
   for j in range(0 , len(data['finish_time'])):
       if data['finish_time'][i] < data['finish_time'][j]:
           tem = data['activity'][i] , data['finish_time'][i] , data['start_time'][i]
           data['activity'][i] , data['finish_time'][i] , data['start_time'][i] = data['activity'][j] , data['finish_time'][j] , data['start_time'][j]
           data['activity'][j] , data['finish_time'][j] , data['start_time'][j] = tem

# by default, the first activity is inserted in the list of activities to be selected.

selected_activity.append(data['activity'][start_position])
for pos in range(len(data['finish_time'])):
   if data['start_time'][pos] >= data['finish_time'][start_position]:
       selected_activity.append(data['activity'][pos])
       start_position = pos

print(f"The student can work on the following activities: {selected_activity}")
# Results
# The student can work on the following activities: ['Homework', 'Presentation', 'Volleyball practice', 'Biology lecture']

Problem 2: Fractional Knapsack Problem

A knapsack has a maximum weight, and it can only accommodate a certain set of items. These items have a weight and a value.

The aim is to fill the knapsack with the items that have the highest total values and do not exceed the maximum weight capacity.

Approach to the Problem

There are two elements to consider: the knapsack and the items. The knapsack has a maximum weight and carries some items with a high value.

Scenario: In a jewelry store, there are items made of gold, silver, and wood. The costliest item is gold followed by silver and then wood. If a jewerly thief comes to the store, they take gold because they will make the most profit.

The thief has a bag (knapsack) that they can put those items in. But there is a limit to what the thief can carry because these items can get heavy. The idea is to pick the item the makes the highest profit and fits in the bag (knapsack) without exceeding its maximum weight.

• The first step is to find the value to weight ratio of all items to know what fraction each one occupies.

• We then sort these ratios in descending order (from highest to lowest ). This way we can pick the ratios with the highest number first knowing that we will make a profit.

• When we pick the highest ratio, we find the corresponding weight and add it to the knapsack. There are conditions to be checked.

Condition 1: If the item added has a lesser weight than the maximum weight of the knapsack, more items are added until the sum of all the items in the bag are the same as the maximum weight of the knapsack.

Condition 2: If the sum of the items’ weight in the bag is more than the maximum capacity of the knapsack, we find the fraction of the last item added. To find the fraction, we do the following:

• We find the sum of the remaining weights of the items in the knapsack. They must be less than the maximum capacity.

• We find the difference between the maximum capacity of the knapsack and the sum of the remaining weights of the items and divide by the weight of the last item to be added.

Fraction =  (maximum capacity of the knapsack - sum of remaining weights) / weight of last item to be added

To add the weight of the last item to the knapsack, we multiply the fraction by the weight.

Weight_added = weight of last item to be added  * fraction

When we sum up the weights of all the items it will be equal to the knapsack's maximum weight.

Practical Example:

Let's say that the maximum capacity of the knapsack is 17, and there are three items available. The first item is gold, the second item is silver, and third item is wood.

• Weight of gold is 10, the weight of silver is 6, and the weight of wood is 2

• the value (profit) of gold is 40, the value (profit) of silver is 30, and the value (profit) of wood is 6.

• Ratio of gold= value/weight = 40/10 = 4

• Ratio of silver = value/weight=30/6 = 5

• Ratio of wood = value/weight = 6/2 = 3

• Arranging the ratios in descending: 5, 4, 3.

• The largest ratio is 5 and we match it to the corresponding weight “6”. It points to silver.

• We put silver in the knapsack first and compare it to the maximum weight which is 17. 6 is less than 17 so we have to add another item. Going back to the ratios, the second largest is “4” and it corresponds to the weight of “10” which points to gold.

• Now, we put gold in the knapsack, add the weight of the silver and gold, and compare it with the knapsack weight. (6 + 10 = 16). Checking it against the maximum weight, we see that it is less. So we can take another item. We go back to the list of ratios and take the 3rd largest which is “3” and it corresponds to “2” which points to wood.

• When we add wood in the knapsack, the total weight is (6 +10+2 = 18) but that is greater than our maximum weight which is 17. We take out the wood from the knapsack and we are left with gold and silver. The total sum of the two is 16 and the maximum capacity is 17. So we need a weight of 1 to make it equal. Now we apply condition 2 discussed above to find the fraction of wood to fit in the knapsack.

Explanation of filling the remaining space in the backpack with a fractional piece of wood

Now the knapsack is filled.

Code Implementation of the Example

The variable <data> stores the weights of each item and the profits. The variable <maximum_capacity> stores the maximum weight of the knapsack. <selected_wt> is intialized at 0, and it will store the selected weights to be put in the knapsack. Lastly, <max_profit> is intialized as 0, it will store the values of the selected weight.

data = {
    "weight": [10 , 6 , 2],
    "profit":[40 , 30 ,6]
}
max_weight = 17
selected_wt = 0
max_profit = 0

Then we calculate the ratio of the profit to the weight. Ratio = profit/weight:

ratio = [int(data['profit'][i] / data['weight'][i]) for i in range(len(data['profit']))]

Now that we have the ratio, we arrange the elements in descending order, from biggest to smallest. Then the items in weight and profit are arranged according to the positions of the sorted ratio.

for i in range(len(ratio)):
    for j in range(i + 1 , len(ratio)):
        if ratio[i] < ratio[j]:
            ratio[i] , ratio[j] = ratio[j] , ratio[i]
            data['weight'][i] , data['weight'][j] = data['weight'][j] , data['weight'][i]
            data['profit'][i] , data['profit'][j] = data['profit'][j] , data['profit'][i]

After the weight and profit are sorted, we start choosing the items and checking the condition. We loop through the length of ratio to target the index of each item in the list. Note: all items in ratio are arranged from biggest to smallest, so the first item is the maximum value and the last item is the minimum value.

for i in range(len(ratio)):

The first item we select has the highest ratio amongst the rest and it is in index 0. Now that the first weight is selected weight, we check if it is less than maximum weight. If it is, we add items till the total weight is equal to the weight of the knapsack. The second item we select has the second highest ratio amongst the rest and it is in index 1, the arrangement is that order of selection.

For every selected weight, we add it to the selected_wt variable and their corresponding profits to the max_profit variable.

if selected_wt + data['weight'][i] <= max_weight:
          selected_wt += data['weight'][i]
          max_profit += data['profit'][i]

When the sum of the selected weights in the knapsack exceeds the maximum weight, we find the fraction of the weight of the last item added to make the total selected weights be equal to the maximum weight. We do this by finding the difference between the max_weight and the sum of the selected weights divided by the weight of the last item added.

The final profit made from the fraction carried is added to the max_profit variable. Then we return the max_profit as the final result.

      else:
          frac_wt = (max_weight - selected_wt) / data['weight'][i]
          frac_value = data['profit'][i] * frac_wt
          max_profit += frac_value
          selected_wt += (max_weight - selected_wt)
print(max_profit)

Bringing it all together:

data = {
    "weight": [10 , 6 , 2],
    "profit":[40 , 30 ,6]
}
max_weight = 17
selected_wt = 0
max_profit = 0

# finds ratio
ratio = [int(data['profit'][i] / data['weight'][i]) for i in range(len(data['profit']))]

# sort ratio in descending order, rearranges weight and profit in order of the sorted ratio
for i in range(len(ratio)):
    for j in range(i + 1 , len(ratio)):
        if ratio[i] < ratio[j]:
            ratio[i] , ratio[j] = ratio[j] , ratio[i]
            data['weight'][i] , data['weight'][j] = data['weight'][j] , data['weight'][i]
            data['profit'][i] , data['profit'][j] = data['profit'][j] , data['profit'][i]


# checks if selected weight with the highest ratio is less than the maximum weight, if so it adds it to knapsack and stores the profit, select the next item.
# else the sum of the selected weights is more than max weight, finds fraction

for i in range(len(ratio)):
    if selected_wt + data['weight'][i] <= max_weight:
          selected_wt += data['weight'][i]
          max_profit += data['profit'][i]
    else:
          frac_wt = (max_weight - selected_wt) / data['weight'][i]
          frac_value = data['profit'][i] * frac_wt
          max_profit += frac_value
          selected_wt += (max_weight - selected_wt)

print(f"The maximum profit that can be made from each item is: {round(max_profit , 2)} euros")
# Result
# The maximum profit that can be made from each item is: 73.0 euros

Applications of Greedy Algorithms

There are various applications of greedy algorithms. Some of them are:

• [Minimum spanning tree](https://en.wikipedia.org/wiki/Minimum_spanning_tree#:~:text=A%20minimum%20spanning%20tree%20(MST,minimum%20possible%20total%20edge%20weight.) is without any cycles and with the minimum possible total edge weight. This tree is derived from a connected undirected graph with weights.

• Dijkstra’s shortest path is a search algorithm that finds the shortest path between a vertex and other vertices in a weighted graph.

• Travelling salesman problem involves finding the shortest route that visits different places only once and returns to the starting point

• Huffman coding assigns shorter code to frequently occurring symbols and longer code to less occurring symbols. It is used to encode data efficiently.

Advantages of Using a Greedy Algorithm

Greedy algorithms are quite straight forward to implement and easy to understand. They are also very efficient and have a lower complexity time of O(N * logN).

They're useful in solving optimization problems, returning a maximum or minimum value.

Disadvantages/Limitations of Using a Greedy Algorithm

Even though greedy algorithms are straightforward and helpful in optimization problems, they don't offer the best solutions at all times.

Also greedy algos only run once, so they don't check the correctness of the result produced.

Conclusion

Greedy algorithms are a straightforward approach to solving optimization problems, returning a minimum or maximum value.

This article explained some examples of greedy algorithms and the approach to tackling each problem. By understanding how a greedy algorithm problems works you can better understand dynamic programming. If you have any questions feel free to reach out to me on Twitter💙.

In Python, there are different ways of working with strings. These methods are built-in functions that change the results of the string.

For instance, if I want to print out my name with its first letter capitalized, I use the .title() method to capitalize the first letter.

In this article, we will learn how to convert uppercase letters to lowercase letters without using the built-in method.

How to Convert a String to Lowercase using .lower()

Strings can consist of different characters – one of those characters being letters of the alphabet. You can write the English alphabet as uppercase or lowercase letters. When changing a string to lowercase, it only applies to the letters.

In Python, there is a built-in method that can change a string that is in uppercase to lowercase. It also applies to strings that have letters both in uppercase and lowercase. The “.lower() “ method changes the strings to lowercase.

name = "BOB STONE"
print(name.lower()) # >> bob stone
name1 = "Ruby Roundhouse"
print(name1.lower()) # >> ruby roundhouse
name2 = "joHN Wick"
print(name2.lower()) # >> john wick
name3 = "charlieNew"
print(name3.lower()) # >> charlienew

We can see in the above code block that the variables that store each string have uppercase letters. Then with the .lower() method, it converts those letters to lowercase.

Other Ways to Convert a Python String to Lowercase

Apart from the inbuilt method “.lower()”, there are different ways of converting uppercase letters to lowercase letters in Python. In this article, we will look at two different ways.

There are two ways of accessing letters:

• copying them manually into a list or

• making use of Unicode standard

How to Access Letters from a List

The idea is to loop through a list of letters and replace the uppercase letters in a string with lowercase letters.

First, create a variable that stores an input that accepts a string with uppercase letters.

Then, create another variable that stores a list of uppercase letters and lowercase letters.

Last, create the final variable that stores an empty string, which is where the lowercase letters will be stored.

word = str(input("Enter a word: ” ))

alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']

lowercase_letters = ''

In the list above, we see that it has lowercase letters and uppercase letters. There are 26 letters in the English alphabet, but the index in a list starts from 0, so the count of the alphabet is 51 (for both upper and lowercase letters).

We can also see that the lowercase letters are written first (left side), and the uppercase letters are written second (right side). The indexes of the lowercase letters range from 0 - 25, while the indexes of the upper case letters ranges from 26 - 51.

Next, we loop through each character in the string.

for char in word:

<char> is the new variable name that stores all the characters from the <word> variable.

There are two cases of strings we are going to convert. The first case is the strings with only uppercase letters and the second has strings with special symbols, numerals, some lowercase, and some uppercase letters.

CASE I: strings with uppercase only

To convert the uppercase letters to lowercase, we have to find the index of each letter stored by the variable <char> from the list. To find an index we use the ".index()" method:

alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
word = str(input("Enter a word: " ))
for char in word:
    print(alphabet.index(char))

# Results
# Enter a word: GIRL
# 32
# 34
# 43
# 37

In the above code, the indexes of the letters in the "GIRL" are printed.

In the list, the lowercase letters have indexes from 0-25 and uppercase letters have indexes from 26 - 51. When setting the condition ("if" statement) we start checking if the index of the letter is greater than '25' because the first uppercase index starts from '26' .

To get the corresponding lowercase letters, we substract 26 from each uppercase index. When we get the indexes of the lowercase numbers, we use indexing (variable_name[index_number]) to find the corresponding letters. The lowercase letters are now added to the variable name <lower_case_letters> that stores an empty string.

We return the variable <lowercase_letters> by printing it outside the loop.

for char in word:
      if alphabet.index(char) > 25:
          lowercase_letters += alphabet[alphabet.index(char)-26]
  print(lowercase_letters)

This is what the code looks like when we bring it all together:

def change_to_lowercase(word):

  alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
  lowercase_letters = ''

  for char in word:
      if alphabet.index(char) > 25:
          lowercase_letters += alphabet[alphabet.index(char)-26]

  return lowercase_letters

word = str(input("Enter a word: " ))
print(change_to_lowercase(word=word))

# Results
# Enter a word: FERE
# fere
# Enter a word: PYTHONISFUN
# pythonisfun

CASE II: strings with special symbols, numerals, lowercase letters alongside uppercase letters.

Before converting the uppercase letters to lowercase, there are some conditions we need to check. The conditions will check if each character <char> from the word:

• is not a letter

• has both uppercase and lowercase letters in the word. If some letters in the word are lowercase, they will be left unchanged.

After these checks, it assumes the remaining characters are uppercase letters.

To check if a character is not a letter, we use the “not in” keyword. To check if a character is lowercase, we find the index and compare it to the last count of the lowercase letters in the list.

Again, lowercase letters have indexes from 0-25, and the index of the last lowercase letter is 25. These characters are added to the variable name <lower_case_letters> that stores an empty string.

for char in word:
    if char not in alphabet or alphabet.index(char)<=25:
        lowercase_letters += char

In the above code block, we used the .index() method to find the position of letters in the alphabet.

For the remaining characters that we assume are uppercase letters, in the list of letters, the indexes of those letters are from 26 - 51. To find their corresponding lowercase letter indexes, we subtract by 26, and use the .index() method to find the letter.

Indexing = variable_name[index_number]. We add the final result to the variable storing the empty string.

for char in word:
    if char not in alphabet or alphabet.index(char)<=25:
        lowercase_letters += char
    else:
        lowercase_letters += alphabet[alphabet.index(char)-26]

Then we print lowercase_letters outside the loop:

for char in word:
    if char not in alphabet or alphabet.index(char)<=25:
        lowercase_letters += char
    else:
        lowercase_letters += alphabet[alphabet.index(char)-26]
print(lowercase_letters)

This is what the code looks like when we bring it all together:

def change_to_lowercase(word):

  alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
  lowercase_letters = ''

  for char in word:
      if char not in alphabet or alphabet.index(char)<=25:
          lowercase_letters += char
      else:
          lowercase_letters += alphabet[alphabet.index(char)-26]
  return lowercase_letters

word = str(input("Enter a word: " ))
print(change_to_lowercase(word=word))

# Results
# Enter a word: 2022BlackADAM&&
# 2022blackadam&&
# Enter a word: Weasle2@3568QQQAJHGB
# weasle2@3568qqqajhgb

How to Access Letters using the Unicode Standard

Unicode means universal character encoding standard. According to unicode.org,

"Unicode standard provides a unique number for every character, no matter what platform, device, application or language."

In simple terms, all letters from different languages have a unique number representing every character present in Unicode.

We use two methods when working with Unicode in Python: ord() and chr().

• ord(): this function accepts characters (letters in any language) and returns the unique number under the Unicode standard.

• chr(): this function accepts integers and returns the character equivalent under the Unicode standard.

Before diving into the code explanation, here is a chart containing all the unique numbers for the English alphabet, both lowercase and uppercase letters.

ASCII Chart representing the unique numbers of english alphabets

Now that we are familiar with what Unicode is and how to access the values in Python, let’s dive in.

First, create a variable that stores an input that accepts a string with uppercase letters.

Then, create the final variable that stores an empty string, which is where the lowercase letters will be stored.

word = str(input("Enter a word: ” ))
lowercase_letters = ''

Then we loop through each character in the string.

for char in word:

<char> is the new variable name that stores all the characters from the <word> variable.

CASE I: strings containing uppercase letters only.

Before converting the uppercase letters to lowercase, we need to check if each character from the word is in uppercase.

According to the Unicode chart, the capital letter A has the number “65”, and the capital letter Z has the number “90”. We check if each character <char> in <word> has numbers between 65 and 90. If they do, they are uppercase letters.

print((ord('A')))
# RESULT
# 65
print((ord('Z')))
# RESULT
# 90
print((ord('F')))
# RESULT
# 70

The ord() function returns the unique number of each letter in uppercase.

To convert uppercase letters to lowercase letters, we add the difference between both cases, “32”, to each number from the uppercase to get the lower case letters.

For example:

number_for_A = ord('A')
number_for_a = ord('a')
difference_a = number_for_a - number_for_A
print("Differences in letters" , difference_a)
print("The unique number for A", number_for_A)
print("The unique number for a", number_for_a)

 # Results
# The unique number for A 65
# The unique number for a 97
# Differences in letters 32

number_for_F = ord('F')
number_for_f = ord('f')
difference_f = number_for_f - number_for_F
print("The unique number for F", number_for_F)
print("The unique number for f", number_for_f)
print("Differences in letters" , difference_f)
# Results
# The unique number for F 70
# The unique number for f 102
# Differences in letters 32

In the above code, ‘a” is 97 on the unicode chart and ‘A’ is 65. The difference between them is 32. If we want to get the value of “a” on the chart, we add 32 to the value of A “65” and get “97”.

So to convert to lowercase, we have to add 32 to each of the numbers of the uppercase letters to get their corresponding lowercase letters.

word = str(input("Enter a word: " ))
lowercase_letters = ''
for char in word:
    if ord(char) >= 65 and ord(char) <= 90:
        char = ord(char) + 32
    print(char)
# Results
# Enter a word: REAL
# 114
# 101
# 97
# 108

In the above code, we loop through the variable <word> to get access to each character.

Then we check if each character in the variable <word> has a unique number between 65 and 90. If it does, it consists of uppercase letters.

To get the corresponding lowercase letters, we add 32. The result above prints the unique numbers of lowercase letters.

We can match the numbers with their letters by using the chr() function.

word = str(input("Enter a word: " ))
lowercase_letters = ''
for char in word:
    if ord(char) >= 65 and ord(char) <= 90:
        char = ord(char) + 32
        to_letters = chr(char)
    print(to_letters) 


# Result
# Enter a word: REAL
# r
# e
# a
# l

Now we see that the letters returned are in lowercase. To get the letters in one line, we add it to the variable that stores the empty string and return the variable.

word = str(input("Enter a word: " ))
lowercase_letters = ''
for char in word:
    if ord(char) >= 65 and ord(char) <= 90:
        char = ord(char) + 32
        to_letters = chr(char)
        lowercase_letters += to_letters
print(lowercase_letters)
# Result
# Enter a word: FERE
# fere

Here's what it looks like when we bring it all together:

def change_to_lowercase(word):
    lowercase_letters = ''
    for char in word:
        if ord(char) >= 65 and ord(char) <= 90:
            char = ord(char)+32
            to_letters = chr(char)
            lowercase_letters += to_letters
    return lowercase_letters
word = str(input("Enter a word: " ))
print(change_to_lowercase(word=word))

# Results
# Enter a word: HARDWORKPAYS
# hardworkpays
# Enter a word: PYTHONISFUN
# pythonisfun

CASE II: strings with special symbols, numerals, lowercase alongside uppercase letters.

For strings that have non-letters and some lowercase letters, we add an 'else' statement to return the values as they appear in the string. The uppercase letters are then converted to lowercase:

word = str(input("Enter a word: " ))
lowercase_letters = ''
for char in word:
    if ord(char) >= 65 and ord(char) <= 90:
        char = ord(char)+32
        to_letters = chr(char)
        lowercase_letters += to_letters
    else:
        lowercase_letters += char
print(lowercase_letters)

# Result
# Enter a word: @#&YEAERS09=
# @#&yeaers09=

Here's what it looks like when we bring it all together:

def change_to_lowercase(word):
    lowercase_letters = ''
    for char in word:
        if ord(char) >= 65 and ord(char) <= 90:
            char = ord(char)+32
            to_letters = chr(char)
            lowercase_letters += to_letters
        else:
            lowercase_letters += char
    return lowercase_letters
word = str(input("Enter a word: " ))
print(change_to_lowercase(word=word))

# Enter a word: YOUGOT#$^
# yougot#$
# Enter a word: BuLLettrAIn@2022
# bullettrain@2022

I know the second method is a lot take in but it also gets you the result, just as the first method does.

Summary

In this article, you've learnt about how to convert characters and strings from one case to another. We also took a look at the ASCII table.

The second method is more efficient and straightforward once you know how to use the two important functions. The indexes of the letters are built-in in Python, so there's no need to memorize them.

Thank you for reading!

When going through search results on the web, we pick the most relevant articles or resources that we think will help us.

Search is such a part of our lives because we cannot always have the answers. And there are various algorithms that help programs run more efficiently and deal with data more effectively.

What We'll Cover in This Tutorial

• What is a Search Algorithm?

• What is a Binary Search algorithm?

• How Binary Search Works – Divide and Conquer

• Processes involved in Binary Search Algorithms

• Methods Used in Binary Search Algorithms

• Real-life examples of Binary Search

What is a Search Algorithm?

A search algorithm works to retrieve items from any data structure. It compares the data that comes in as input to the information stored in its database and brings out the result. An example is finding your best friend’s number in your contact list of 1,000 numbers.

There are different types of search algorithms. Some of them are:

Linear search algorithms

Linear search algorithms are the simplest of all the search algorithms. As the name implies, they operate in a sequence.

Linear search checks elements in a list one after the other to find a particular key value. This key value is among other items in the list and the algorithm returns the position by going through the check.

Dijkstra's algorithm

Dijkstra's shortest path algorithm is used in more advanced searches. Dijkstra’s algorithm maps out the shortest distance between two nodes. These nodes are often route networks.

This type of search is useful when you're trying to find routes on maps. It gives you options based on finding the shortest path possible.

Binary Search Algorithm

Binary search algorithms are also known as half interval search. They return the position of a target value in a sorted list.

These algorithms use the “divide and conquer” technique to find the value's position.

Binary search algorithms and linear search algorithms are examples of simple search algorithms.

In binary search, the middle element in the list is found before comparing with the key value you are searching for. But in linear search, the elements are taken one by one in the list by looping through and comparing with the key value.

‌During Binary search, the list is split into two parts to get the middle element: there is the left side, the middle element, and the right side.

The left side contains values smaller than the middle element and the right side contains values that are greater than the middle element. This method uses a sorted list to work.

A sorted list has its items arranged in a particular order. To make search efficient for binary search, the values in the list have to be arranged in the right order to satisfy the process of search. If a list has its values mixed up, it has to be sorted by a sorting algorithm before you perform the search.

Sorting algorithms

Sorting algorithms accept an unsorted list as an input and return a list with the elements arranged in a particular order (mostly ascending order).

There are different types of sorting algorithms, like insertion sort, quick sort, bubble sort, and merge sort.

How Binary Search Works – Divide and Conquer

A binary search algorithm uses a technique called “divide and conquer” to tackle its task. The merge sort algorithm employs the same technique to sort items in a list.

In binary search algorithms, the “divide and conquer” method works this way:

• The algorithm splits the list into two parts: the left side and right side, separated by the middle element

• It creates a variable to store the value of the item to be searched for

• It picks out the middle element and compares it with the item to be searched

• If the items compared are equal, then process ends

• If not, the middle element is either greater or lesser than the item you're searching for. If the middle element is greater, the algorithm splits the list and searches for the element on the left side. If the middle element is smaller, it splits the list and searches for the element on the right side of the list.

You can implement this method using recursion or iteration in the binary search process.

How the Binary Search Algorithm Works – Step by Step

First, before performing the search, you need to sort the list.

Then you create a variable that stores the value to be searched for.

Next, the list is divided into two parts. We sum up the first and last indexes to find the index of the middle element in the list.

When the calculated value of the middle element index is a float (like 3.45), we take the whole part as the index.

Then we compare the value we're searching for and the middle element.

Binary Search Use Case

Condition 1

If the middle element is equal to the value to be searched, the position where the value is will be returned and the process is terminated.

if middle element == to_search 
    return position of middle element 
*code ends*

Using the Image above as an example:

The middle element = 23, the target value/to_search = 23. Comparing the two values, we see that they are equal on both sides. 23 appears at index 2 in the list. That is the output of the code and the process ends.

Condition 2

If the middle element is not equal to "to_search", then we check the following scenarios:

Scenario 1: if the middle element is greater than the value to be searched:

if middle element > to_search

• the search moves to the left side because the values are less than the middle element

• the position of the middle element shifts to the left by 1

• new_position = index(middle element) - 1

• a new search begins and the search ends at that new position and it takes all the values before it.

Using the image above as an example:

middle element = 23
to_search = 4
if 23 > 4

• we move to the left side because all numbers less than 23 are stored there. index (23) = 2

• new_position = index(23) - 1 = 2-1 = 1

• The search will end at index 1 and take all other value(s) before index 1

Comparing the new middle element (4) to the target value (4), we see they are equal. So the search is terminated and the output is the position "4" occupies in the list (which is index 0).

Scenario 2: if the middle element is less than the value to be searched:

if middle element < to_search

• the search moves to the right side because the values are greater than the middle element

• the position of the middle element shifts to the right by 1

• new_position = index(middle element) + 1

• a new search begins at the new position and ends at the last index in the list

• all values are taken from the new position to the end of the list

Using the first Image as an example:

middle element = 23 
to_search = 32 
if 23 > 32

• we move to the right side because all numbers greater than 23 are stored there. index(23) = 2 ,

• new_position = index(23) + 1 = 2+1 = 3

• The search will begin at index 3 and take all other value(s) after index 3

Comparing the middle element (32) to the target value (32), we see they are equal. So the search is terminated and the output is the position "4" occupies in the list (index 4).

‌‌Methods Used in Binary Search Algorithms

There are two methods that can implement the “divide and conquer” technique in the search. They are iteration and recursion.

What is Iteration?

In order to get elements from a tuple, list, or dictionary, you iterate through the items with loops.

Iteration is a repeated sequence of statements during execution and it has a countable number of values. For example, when looping through random lists, we loop through the actual variable containing the lists to get the values.

Code implementation for binary search with iteration

Here's the code:

def binary_search(list_num , to_search):
    first_index = 0
    size = len(list_num)
    last_index = size - 1
    mid_index = (first_index + last_index) // 2
    # print(mid_index)
    mid_element = list_num[mid_index]
    # print(mid_element)

    is_found = True
    while is_found:
        if first_index == last_index:
            if mid_element != to_search:
                is_found = False
                return " Does not appear in the list"

        elif mid_element == to_search:
            return f"{mid_element} occurs in position {mid_index}"

        elif mid_element > to_search:
            new_position = mid_index - 1
            last_index = new_position
            mid_index = (first_index + last_index) // 2
            mid_element = list_num[mid_index]
            if mid_element == to_search:
                return f"{mid_element} occurs in position {mid_index}"

        elif mid_element < to_search:
            new_position = mid_index + 1
            first_index = new_position
            last_index = size - 1
            mid_index = (first_index + last_index) // 2
            mid_element = list_num[mid_index]
            if mid_element == to_search:
                return f"{mid_element} occurs in position {mid_index}"



list_container = [16 , 18 , 20 , 50 , 60 , 81 , 84 , 89]
print(binary_search(list_container , 81))
print(binary_search(list_container , 10))

Now let's see what's going on here:

• First, we pass in a list and a value to be searched (to_search) as an input to a function.

• In the function, we create a variable name of first index and assign it to "0". The first index in a list is always "0".

• Then we create four variable names: "size" to store the length of the list, "last_index" to store the index of the last element, "mid_index" to store the operation of finding the middle element index, and "mid_element" to store the middle element gotten from the list using the mid index as position.

• Afterwards, we introduce a while loop to make the conditions run on repeat. Above the while loop we create a variable name "is_found" and set it to "True". This condition checks if the "item to be searched" is found or not.

• In the while loop, we check all the conditions. The first condition is to check if the middle element and the variable "to_search" are equal. If they are equal, the position of the item will be returned.

• Then we check for the second condition (if middle element != item to be searched) which leads us to the two scenarios:
  – if the middle element is greater than the item to be searched, the new position will shift to the left once. The search will begin from the first index and end at the new position which is the new last index.
  – If the middle element is less than the item to be searched, the new position will shift to the right once. The search will begin from the new position as the new first index and end at the last index.

At the end of these scenarios, we check if the new middle element is the same as the item to be searched. If it is the same, the position of the item will be returned. If not, the conditions are checked until the values are equal.

For error handling, let's say we want to search for a value that does not appear in the list. If we end at the two conditions, the loop will keep running and may eventually crash the system.

To catch the error, we set a condition to check if the first index equals the last index. Then we check if the middle element is equal to the item to be searched. If it is not equal," is found" will be "False". When you run this, it shows an empty array. In my code, the output is a statement.

The final step is to call the function and the result is displayed.

And here are the results:

If the element is in the list, the output is the position.

If the element is not in the list, the output is a statement like this:

What is ‌‌Recursion?

A function is said to be recursive if it makes reference to itself or previous term(s) to solve a task.

A recursive function is repetitive and it is executed in sequence. It starts from a complex problem and breaks things down into a simpler form.

Code implementation for binary search with recursion

With recursion, it is a bit simpler and requires less code. Here's what it looks like:

def binary_search(list_num, first_index, last_index, to_search):
    if last_index >= first_index:

        mid_index = (first_index + last_index) // 2
        mid_element = list_num[mid_index]


        if mid_element == to_search:
            return f"{mid_element} occurs in position {mid_index}"

        elif mid_element > to_search:
            new_position = mid_index - 1
            # new last index is the new position
            return binary_search(list_num, first_index, new_position, to_search)

        elif mid_element < to_search:
            new_position = mid_index + 1
             # new first index is the new position
            return binary_search(list_num, new_position, last_index, to_search)

    else:
        return " Does not appear in the list"

list_container = [ 1, 9, 11, 21, 34, 54, 67, 90 ]
search = 34
first = 0
last= len(list_container) - 1

print(binary_search(list_container,first,last,search))

• First, a function accepts four inputs: the first index, last index, list, and to_search (item to be searched).

• Then we check if the value of the last index is greater than or equal to the value of the first index. If the condition is true, we assign the operation of finding the middle element index to the variable name "mid_index". Then the middle element is gotten from the list using the mid index as position.

• We create an "if" statement under the first "if" block to check if the middle element and the variable "to_search" are equal. If they are equal, the position of the item will be returned.

• Then we check for the second condition, (if middle element != item to be searched) which leads us to two scenarios:
  – if the middle element is greater than the item to be searched, the new position will shift to the left once. The search will begin from the first index and end at the new position. We return the function and pass in the new position as the last index value.
  – if the middle element is less than the item to be searched, the new position will shift to the right once. The search will begin from the new position and end at the last index. We return the function and pass in the new position as the first index value.

• The last condition will be on the same indent as the first "if" statement. If the to_search is not in the list, it will return a statement

The final step is to call the function and the result is displayed.

And here are the results:

If the element is in the list, the output is the position:

If the element is not in the list, the output is a statement:

Real-life Examples of Binary Search‌

You might not realize it, but we perform binary search all the time. Here are a few examples of how you might use or encounter it in your daily life or work:

• Searching for a word in a dictionary

• searching for a literature text book in a literature section in a library

• searching for an element in a sorted list

• searching for students taller than 5 feet 3 inches in a line of students arranged according to their heights.

Conclusion

At the end of this article, you should be familiar with how binary search algorithms work and how to implement them in code.

It's fine if you could not grasp everything at once – just give yourself some time and practice. If you encounter any errors or have questions, you can reach out to me on Twitter.

‌‌

‌‌

‌‌

‌‌

‌‌

‌‌

‌

And even better – there are correlations between puzzle-solving and increased problem-solving skills.

Wordle is a new word puzzle game that challenges its players to guess a five-letter word in six tries.

In this tutorial, you will build a Wordle-like guessing game with the same rules as the original game. We'll build the game in Python. Working through this challenge will improve your knowledge of functions and while loops, and it will help you become more familiar with the zip method.

Prerequisites

• Basic knowledge of Python

What We'll Cover:

• How the game works

• How to write the game logic

• Results of the game

How the Game Works

The game will consist of:

• a variable that stores a five-letter word called "hidden_word".

• input from a user.

• a variable that stores the number of times (up to 6 tries) the user tries to guess the word.

• a condition to check if a letter is guessed correctly and in the right position, indicated by "✔"

• another condition to check if a letter is guessed correctly but in the wrong position, indicated by "➕"

• the final condition to check if a letter is guessed but not in the hidden word, indicated by "❌"

How to Write the Game Logic

First Function Block

First, we need to inform players about the rules. This is necessary so people know how to play properly.

Start off by creating a function with the name "game_instruction".

def game_instruction():

Then, pass in the instructions as a string to the "print" function to show the result. Wrap the strings in docstrings (""" """) because the symbols ("✔❌❌✔➕") will be wrapped in double quotations (" ") . Also each instruction will appear on a new line without using the ("\n") tag.

print("""Wordle is a single player game
A player has to guess a five letter hidden word
You have six attempts
Your Progress Guide "✔❌❌✔➕"
"✔" Indicates that the letter at that position was guessed correctly
"➕" indicates that the letter at that position is in the hidden word, but in a different position
"❌" indicates that the letter at that position is wrong, and isn't in the hidden word   """)

Each sentence is started on a new line, and it will appear that way on the console. We wrap up by calling our function so the instructions will be printed on the screen.

game_instruction()

If you get an error, it could either be that you forget to put the colon (:) at the end of the function definition def game_instruction() or your code isn't formatted properly. Pay attention to the console error logged, as it will guide you.

Bringing it together

 def game_instruction():
     print("""Wordle is a single player game
A player has to guess a five letter hidden word
You have six attempts
Your Progress Guide "✔❌❌✔➕"
"✔" Indicates that the letter at that position was guessed correctly
"➕" indicates that the letter at that position is in the hidden word, but in a different position
"❌" indicates that the letter at that position is wrong, and isn't in the hidden word   """)
game_instruction()

And finally, if you run your code and there is no result on your console, it means that you probably forgot to call the function.

Output

Game instructions for players

Second Function Block

The next step is working with the user's entry and comparing it with the hidden word. The ability to do that is essential to the game.

Create a function called "check_word". In the code block, create a variable named "hidden word" and assign it to any five letter word of your choice. This hidden word is what the user will try to guess correctly.

def check_word():
  hidden_word = "snail"

Since the player has 6 tries, assign a new variable called "attempt" to the value of "6" and create a while statement.

It's best to use a while loop here because the process runs until the user guesses the right word or exhausts their tries. The condition for the while statement to run is if the number of attempts is greater than "0".

def check_word():
  hidden_word = "snail"
  attempt = 6
  while attempt > 0:

The user's input is then created inside the while loop, and conditions are checked against the hidden word. If the user's entry is the same as the hidden word, the loop ends and the game is over.

def check_word():
  hidden_word = "snail"
  attempt = 6
  while attempt > 0:
    guess = str(input("Guess the word: "))
    if guess == hidden_word:
      print("You guessed the words correctly! WIN 🕺🕺🕺 ")
      break

Format strings ( f" ") are another method of joining variables and strings together without using the "+" sign.

Here's an example:

# Instead of,
print("you have" + attempt + " attempt(s) ,, \n") # '\n' is used for new line

# use this,
print(f"you have {attempt} attempt(s) ,, \n") # the variable to be printed is wrapped in curly braces

If the user's entry is not equal to the hidden word, introduce an else statement and all conditions will be checked in the "else" block. The attempt decreases by 1 and the attempts left are printed on the console as the user plays the game.

def check_word():
  hidden_word = "snail"
  attempt = 6
  while attempt > 0:
    guess = str(input("Guess the word: "))
    if guess == hidden_word:
      print("You guessed the words correctly! WIN 🕺🕺🕺 ")
      break
    else:
      attempt = attempt - 1
      print(f"you have {attempt} attempt(s) ,, \n ")

If the user's input does not match the hidden word, there are three conditions to be checked:

• First, if the letter is in the wrong position but in the hidden word, print a "➕" beside the letter.

• Second, if the letter is in the right position and in the hidden word, print a "✔" beside the letter.

• Third, if the letter is not in the hidden word at all, print an "❌" beside the letter.

To compare the letters both in the user's input and the hidden word, include a for loop alongside a zip() function as a statement.

for i, j in zip(food, drink):

A zip() function is a built in function that loops through items like lists and tuples. It can extract values from multiple variables of the same size.

For strings, you can't directly use the zip() function alone. The "for" loop is included to get the letters from the variables that store the strings.

Here's an example:

A user enters a five letter word and a variable with a five letter word is created. Looping through the two variables at the same time with zip(), all the elements will be printed and separated by a hyphen.

Code block

user_entry = input("spell 5 letter word: ")
default_value = "shell"
for i, j in zip(user_entry, default_value):
  print(i + " - " +  j)

Output

Back to our code:

def check_word():
  hidden_word = "snail"
  attempt = 6
  while attempt > 0:
    guess = str(input("Guess the word: "))
    if guess == hidden_word:
      print("You guessed the words correctly! WIN 🕺🕺🕺 ")
      break
    else:
      attempt = attempt - 1
      print(f"you have {attempt} attempt(s) ,, \n ")
      for char, word in zip(hidden_word, guess):
            if word in hidden_word and word in char:
                print(word + " ✔ ")

            elif word in hidden_word:
                print(word + " ➕ ")
            else:
                print(" ❌ ")

Let's go through what's happening here:

for char, word in zip(hidden_word, guess) - this statement means looping through hidden_word with variable name char and looping through guess with variable name word. All the letters in the hidden word are accessed by char and all the letters in guess are accessed by word.

Then the three conditions mentioned earlier will be checked comparing both letters in word (the user's input) and char in (hidden word):

def check_word():
  hidden_word = "snail"
  attempt = 6
  while attempt > 0:
    guess = str(input("Guess the word: "))
    if guess == hidden_word:
      print("You guessed the words correctly! WIN 🕺🕺🕺 ")
      break
    else:
      attempt = attempt - 1
      print(f"you have {attempt} attempt(s) ,, \n ")
      for char, word in zip(hidden_word, guess):
            if word in hidden_word and word in char:
                print(word + " ✔ ")

            elif word in hidden_word:
                print(word + " ➕ ")
            else:
                print(" ❌ ")
      if attempt == 0:
        print(" Game over !!!! ")

The final step is to call the function:

def check_word():
  hidden_word = "snail"
  attempt = 6
  while attempt > 0:
    guess = str(input("Guess the word: "))
    if guess == hidden_word:
      print("You guessed the words correctly! WIN 🕺🕺🕺 ")
      break
    else:
      attempt = attempt - 1
      print(f"you have {attempt} attempt(s) ,, \n ")
      for char, word in zip(hidden_word, guess):
            if word in hidden_word and word in char:
                print(word + " ✔ ")

            elif word in hidden_word:
                print(word + " ➕ ")
            else:
                print(" ❌ ")
      if attempt == 0:
        print(" Game over !!!! ")

check_word()

Bringing all the code blocks together, it should look like this:

def game_instruction():
    print("""Wordle is a single player game 
A player has to guess a five letter hidden word 
You have six attempts 
Your Progress Guide "✔❌❌✔➕"  
"✔" Indicates that the letter at that position was guessed correctly 
"➕" indicates that the letter at that position is in the hidden word, but in a different position 
"❌" indicates that the letter at that position is wrong, and isn't in the hidden word   """)


game_instruction()

def check_word():
  hidden_word = "snail"
  attempt = 6
  while attempt > 0:
    guess = str(input("Guess the word: "))
    if guess == hidden_word:
      print("You guessed the words correctly! WIN 🕺🕺🕺 ")
      break
    else:
      attempt = attempt - 1
      print(f"you have {attempt} attempt(s) ,, \n ")
      for char, word in zip(hidden_word, guess):
            if word in hidden_word and word in char:
                print(word + " ✔ ")

            elif word in hidden_word:
                print(word + " ➕ ")
            else:
                print(" ❌ ")
      if attempt == 0:
        print(" Game over !!!! ")

check_word()

Output:

Conclusion

Great job! You are done creating a word puzzle game with Python. The code sample is found here, and you can reach out to me on Twitter if you have any questions. 💙