In this tutorial, you’ll to learn what the GitHub CLI is, how to install and set it up, and how to use it for everyday tasks such as creating repositories, managing issues and pull requests, working with GitHub Actions, and automating tasks using custom aliases. You’ll learn how to replace some functionalities on GitHub’s web interface with quick commands in your terminal.

Here’s what we’ll cover:

• Overview of GitHub CLI

• Key Features

• Benefits of Using GitHub CLI

• Installation and Setup

• Authenticating with a GitHub Account

• Navigating the GitHub CLI

• Managing Repositories

• Working with Pull Requests and Issues

• Pushing and Pulling Changes

• Working with GitHub Actions

• Managing Gists

• Releases and Tags

• Custom Scripts and Aliases

• Troubleshooting

• Conclusion

Overview of GitHub CLI

You can use the GitHub CLI to bridge the gap between GitHub's web interface and your local environment. You can perform various tasks such as creating issues, managing repositories, or even checking the status of your GitHub Actions workflows using the CLI. Using the CLI, you can perform almost all the tasks that you might complete on the GitHub website.

Key Features of GitHub CLI

• Repository management: Easily create, clone, view, and manage repositories.

• Pull requests and issues: Manage pull requests and issues directly from the terminal, including creating, merging, and listing them.

• GitHub Actions: Interact with workflows and manage workflow runs.

• Authentication: Provides a secure way to authenticate with your GitHub account, supporting SSH keys, tokens, and OAuth.

• Custom scripting: Lets you create custom scripts and aliases to automate repetitive tasks and streamline development processes.

Benefits of Using GitHub CLI

Suppose you’re working on a project, and you need to create a new issue on GitHub. Normally, you would switch to your browser, log in to GitHub, navigate to the repository, click on the “Issues” tab, and then click “New Issue.” With GitHub CLI, you can do all of this by typing a single command, without ever leaving your terminal. This makes your workflow faster and saves time.

Installation and Setup

To install GitHub CLI on Windows, you can use the winget package manager. Winget is a command-line tool that allows you to install software easily.

Installing GitHub CLI on Windows, macOS, and Linux

Windows:

Run the command given below:

winget install --id GitHub.cli

• winget install: Tells Windows to install a new software package.

• --id GitHub.cli: Specifies the exact package ID for GitHub CLI.

After running this command, GitHub CLI will be installed on your Windows system.

macOS:

You can use Homebrew to install GitHub CLI on macOS. Open your terminal and run:

brew install gh

Linux:

On Linux, you can use your package manager. For example, on Ubuntu, you can run:

sudo apt install gh

Authenticating with a GitHub Account

After installing GitHub CLI, the next step is to authenticate it with your GitHub account.

Run Authentication Command:

Type gh auth login in the terminal and press Enter.

gh auth login

You’ll then be prompted to select an authentication method. The recommended option is to authenticate via a web browser.

If you select the browser method, GitHub CLI will open a link in your default browser, where you can log in to GitHub.

Complete Authentication:

After logging in, the browser will confirm that the GitHub CLI is connected to your account.

You can verify the authentication status by running:

gh auth status

Navigating the GitHub CLI

The GitHub CLI is easy to navigate, and its command structure is intuitive.

Command Structure and Syntax

GitHub CLI commands follow a simple and straightforward pattern:

gh [command] [subcommand] [flags]

• Command: The main action you want to perform (for example, repo, issue, pr).

• Subcommand: A specific task within the command (for example, create, list, view).

• Flags: Optional parameters that modify the command's behavior (for example, --title, --body).

Commonly Used Commands and Flags

Here are some common GitHub CLI commands:

• Creating a repository: gh repo create

• Listing issues: gh issue list

• Creating a pull request: gh pr create

• Viewing a repository's details: gh repo view

To see all available commands and options, you can always run:

gh help

How to Manage Repositories with the GitHub CLI

Let’s go through examples of some of the commands you’ll use the most often.

Creating and Cloning Repositories

To create a new GitHub repository directly from the terminal, just use the following command:

gh repo create my-repo-name

To clone an existing repository, use the following command:

gh repo clone owner/repo-name

Managing Branches and Pull Requests

GitHub CLI allows you to handle issues and pull requests (PRs) without leaving the terminal.

Switching branches or creating pull requests is simple. To create a new branch:

git checkout -b new-branch-name

Then, to create a pull request:

gh pr create --title "Your PR Title" --body "Description of your PR"

Pushing and Pulling Changes

Push your changes to GitHub with this command:

git push origin branch-name

And pull the latest changes with:

git pull

Working with GitHub Actions

GitHub CLI also supports GitHub Actions, allowing you to manage workflows directly from your terminal.

You can manually trigger workflows using the following:

gh workflow run workflow-name

And you can monitor the status of workflows with:

gh run list

To see detailed logs of a workflow, run this:

gh run view run-id --log

Cloning and Forking Repositories

Cloning and forking are essential tasks when working on projects from other repositories.

To clone a repository, use this command:

gh repo clone <repository-name>

To fork a repository, do this:

gh repo fork <repository-url>

Example:

Here’s what it would look like:

gh repo clone example-repo

gh repo fork https://github.com/username/repository-name

How to Work with GitHub Actions

Using the GitHub CLI, you can also manage GitHub Actions, which are automated tasks you can run in response to certain events in your repository.

Triggering and Monitoring Workflows

You can trigger a workflow manually like this:

gh workflow run <workflow-name>

And you can monitor workflow runs with this:

gh run list

Managing Workflow Runs and Logs

If you want to check the details of a specific workflow run, you can view logs directly from the CLI:

gh run view <run-id> --log

You can also use GitHub CLI commands to enhance your Continuous Integration/Continuous Deployment (CI/CD) pipelines, ensuring smooth automation and better control over our workflows.

How to Update the GitHub CLI

To make sure that you’re using the latest version of GitHub CLI with all the latest features and fixes, you can update it using winget.

winget upgrade --id GitHub.cli

• winget upgrade: Checks for updates for the specified package.

• --id GitHub.cli: Identifies the GitHub CLI package for the upgrade.

Advanced GitHub CLI Features and Integrations

The GitHub CLI is not only useful for performing basic tasks. You can also perform some advanced operations with its help.

How to Manage Gists with the GitHub CLI

Gists are a simple way to share snippets of code. You can create, list, and manage your Gists right from the CLI. Here’s how you can create a gist:

gh gist create my-code-snippet.py

To list your gists:

gh gist list

Interacting with Releases and Tags

To manage releases and tags, GitHub CLI provides commands to create, list, and delete releases. Here’s an example of creating a release:

gh release create v1.0.0

How to Extend the GitHub CLI with Custom Scripts and Aliases

You can write your own scripts and integrate them into GitHub CLI, or create aliases for commands you use frequently to save time. Aliases let you create shortcuts for commands that you use often. For example, the command given below creates an alias prlist that will show all pull requests, regardless of their state:

gh alias set prlist "pr list --state all"

In the same manner, you can create a shortcut co to quickly check out a pull request branch without typing the full command each time. The command is given below:

gh alias set co "pr checkout"

Troubleshooting Common Issues

If you face any issues, you can troubleshoot by checking the command syntax, ensuring your GitHub CLI is up to date, or consulting the documentation using the command:

gh help <command>

Conclusion

GitHub CLI is an excellent tool that helps developers work directly from the terminal. It lets you manage repositories, handle pull requests and issues, trigger and monitor GitHub Actions, and even work with Gists.

You can save time and improve productivity as developers using this powerful tool. Keep exploring its new features and stay updated with the latest version.

Tokenization is the process of breaking down text into smaller pieces, typically words or sentences, which are called tokens. These tokens can then be used for further analysis, such as text classification, sentiment analysis, or natural language processing tasks.

In this article, we’ll discuss five different ways of tokenizing text in Python using some popular libraries and methods.

Table of Contents

• How to Use the split() Method to Tokenize Text in Python

• How to Use NLTK’s word_tokenize() Function to Tokenize Text in Python

• How to Use the re.findall() Method to Tokenize Text in Python

• How to Use str.split() In Pandas to Tokenize Text in Python

• How to Use Gensim’s tokenize()

• Text Tokenization Methods in Python: When to Use

• Conclusion

How to Use the split() Method to Tokenize Text in Python

The split() Method is the most basic way to tokenize text in Python. You can use the split() method to split a string into a list based on a specified delimiter.

A delimiter is a simple character or symbol that is used to separate the pieces of text. For example: spaces(“ “), commas ( , ) , hyphens ( - ) can be used as delimiters.

By default, if we do not specify a delimiter, then the split method uses spaces as a delimiter. If we do not specify a delimiter, it splits the text wherever there are spaces.

Example Code:

text = "Ayush and Anshu are a beautiful couple"
tokens = text.split()
print(tokens)

Explanation:

In the above example code, the string is broken into words whenever a space is found. Each word in the given text becomes a separate token.

Output:

`['Ayush' , 'and' , 'Anshu' , 'are' , 'a',  'beautiful' , 'couple']`

How to Use NLTK’s word_tokenize() Function to Tokenize Text in Python

NLTK (Natural Language Toolkit) is a powerful library for NLP. You can use the word_tokenize() function to tokenize a string into words and punctuation marks. When we use word_tokenize() it recognizes punctuation as separate tokens, which is particularly useful when the meaning of the text could change depending on punctuation.

Example Code:

import nltk
from nltk.tokenize import word_tokenize

nltk.download('punkt')
text = "Ayush and Anshu are a beautiful couple"
tokens = word_tokenize(text)
print(tokens)

Explanation:

The text in the above code is tokenized into individual words. This method is different from other methods as it also treats punctuation, such as commas, question marks as separate tokens.

Output:

`['Ayush' , 'and' , 'Anshu' , 'are' , 'a', 'beautiful' , 'couple']`

Example Code with Punctuation:

import nltk
from nltk.tokenize import word_tokenize

nltk.download('punkt')
text = "Ayush and Anshu aren't a beautiful couple"
tokens = word_tokenize(text)
print(tokens)

Explanation:

In the above example, the apostrophe in “aren’t” will be handled separately.

Output:

['Ayush', 'and', 'Anshu', 'are', 'a', 'beautiful', 'couple', ',', 'are', "n't", 'they', '?']

The above output shows why the word_tokenize() method is preferred in cases where punctuation is used. This method ensures the accurate separation of tokens.

How to Use the re.findall() Method to Tokenize Text in Python

The re module allows you to define patterns to extract tokens. In Python, the re.findall() method allows us to extract tokens based on a pattern you define. For example, we can extract all words using the \w+ pattern. With re.findall(), you have complete control over how the text is tokenized.

Example Code:

import re

text = "Ayush and Anshu are a beautiful couple"
tokens = re.findall(r'\w+', text)
print(tokens)

Explanation:

In the above code, \w+ tells Python to find “word-like” sequences of characters. Punctuation is ignored, so only words are returned.

Output:

`['Ayush' , 'and' , 'Anshu' , 'are' , 'a', 'beautiful' , 'couple']`

How to Use str.split() In Pandas to Tokenize Text in Python

You can use Pandas to tokenize text in DataFrames. It provides an easy way of doing this. You can use the str.split() method to split strings into tokens. This method allows you to tokenize text in an entire column of a DataFrame, making it incredibly efficient for processing large amounts of text data at once.

Example Code:

import pandas as pd

df = pd.DataFrame({"text": ["Ayush and Anshu are a beautiful couple"]})
df['tokens'] = df['text'].str.split()
print(df['tokens'][0])

Explanation:

In the above code, the text column is split into tokens. This method is similar to Python’s basic split() method. This method is very helpful when we want to tokenize text in thousands of rows at once.

Output:

 `['Ayush' , 'and' , 'Anshu' , 'are' , 'a' 'beautiful' , 'couple']`

How to Use Gensim’s tokenize() Function to Tokenize Text in Python

Genism is a popular library in Python that is used for topic modeling and text processing. It provides a simple way to tokenize text using the tokenize() function. This method is particularly useful when we are working with text data in the context of Gensim’s other functionalities, such as building word vectors or creating topic models.

Example Code

from gensim.utils import tokenize

text = "Ayush and Anshu are a beautiful couple"
tokens = list(tokenize(text))
print(tokens)

Explanation:

In the above code, Gensim’s tokenize() function is used to break the text into individual words. It works similar to split(), but it is more powerful because it automatically removes punctuation and only keeps valid words. Since tokenize() returns an iterator, we use list() to convert it into a list of tokens.

Output:

`['Ayush' , 'and' , 'Anshu' , 'are' , 'a' , 'beautiful' , 'couple']`

Text Tokenization Methods in Python: When to Use

- When you do not need to handle punctuation or special characters. | | Using NLTK’s word_tokenize() | Uses the NLTK library to tokenize text into words and punctuation marks. | - Handling punctuation.
- Advanced NLP tasks.
- When precise tokenization is needed. | | Using Regex with re.findall() | Uses regular expressions to define patterns for token extraction. | - Full control over token patterns.
- Extracting specific patterns like hashtags or email addresses. | | Using str.split() in Pandas | Tokenizes text in DataFrames using the str.split() method. | - When working with large datasets in DataFrames.
- Efficient text processing across entire columns. | | Using Gensim’s tokenize() | Tokenizes text using the Gensim library, suitable for text processing tasks. | - When working on topic modeling or text processing with Gensim.
- Integration with Gensim’s other functionalities. |

Tokenization is a fundamental step in text processing and natural language processing (NLP), transforming raw text into manageable units for analysis. Each of the methods discussed provides unique advantages, allowing for flexibility depending on the complexity of the task and the nature of the text data.

1. Using split Method: This basic approach is suitable for simple text tokenization where punctuation and special characters are not a concern. It’s ideal for quick and straightforward tasks.

2. Using NLTK’s word_tokenize(): NLTK offers a more sophisticated tokenization approach by handling punctuation and providing support for advanced NLP tasks. This method is beneficial when working on projects that require detailed text analysis.

3. Using Regex with re.findall(): This method gives you precise control over token patterns, making it useful for extracting tokens based on specific patterns like hashtags, email addresses, or other custom tokens.

4. Using str.split() In Pandas: When dealing with large datasets within DataFrames, Pandas provides an efficient way to tokenize text across entire columns. This method is ideal for handling large-scale text data processing tasks.

5. Using Gensim’s tokenize(): For tasks related to topic modeling or when working with Gensim’s text processing functionalities, this method integrates seamlessly into Gensim’s ecosystem, facilitating tokenization in the context of more complex text analysis.

Conclusion

Selecting the right tokenization method depends on your specific requirements, such as the need for handling punctuation, processing large datasets, or integrating with advanced text analysis tools.

By understanding the strengths and appropriate use cases for each method, you can effectively prepare your text data for further analysis and modeling, ensuring that your NLP workflows are both efficient and accurate.

In this article, we will learn about infinite loops in C++, their types and causes, and their applications.

Here’s what we’ll cover:

1. What is an Infinite Loop in C++?

2. Types of Infinite Loops in C++

3. Common Causes of Accidental Infinite Loops in C++

4. Applications of Infinite Loops in C++

5. Using Infinite Loops To Take User Input in C++

6. Conclusion

What is an Infinite Loop in C++?

An infinite loop is any loop in which the loop condition is always true, leading to the given block of code being executed an infinite number of times. They can also be called endless or non-terminating loops, which will run until the end of the program’s life.

Infinite loops are generally accidental and occur due to some mistake by the programmer. But they are pretty useful, too, in different kinds of applications, such as creating a program that does not terminate until a specific command is given.

Types of Infinite Loops in C++

There are several ways to create an infinite loop in C++, using different loop constructs such as while, for, and do-while loops. Here, we will explore each method and provide examples.

• Infinite While Loops

• Infinite For Loops

• Infinite do-while Loops

1. Infinite Loop using While Loop

This is the most popular type of while loop due to its simplicity. You just pass the value that will result in true as the condition of the while loop.

Syntax:

while(1)
    or
while(true)

Example Code:

// Example of Infinite loop in C++ using for loop
#include <iostream>
using namespace std;

int main() {
    // Infinite loop using while
    while (true) {
        cout << "This is an infinite loop." << endl;
    }
    return 0;
}

Output:

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

………………….

Infinite Loop using For Loop

In a for loop, if we remove the initialization, comparison, and update conditions, then it will result in an infinite loop.

Syntax:

for(;;)

Example Code:

//Example of Infinite loop in C++ using for loop

#include <iostream>
using namespace std;

int main() {
    // Infinite loop using for loop
    for (;;) {
        cout << "This is an infinite loop." << endl;
    }
    return 0;
}

Output:

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

……………………….

Infinite Loop using do-while Loop

Just like the other two loops discussed above, we can also create an infinite loop using a do-while loop. Although this loop is not preferred much due to its longer syntax.

Syntax:

do{
}while(1)

Example Code:

// Infinite loop in C++ using do-while loop

#include <iostream>
using namespace std;

int main() {
   // infinite do-while loop
    do {
        cout << "This is an infinite loop." << endl;
    } while (true);

    return 0;
}

Output:

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

……………………….

Common Causes of Accidental Infinite Loops in C++

Infinite loops can be both intentional and accidental. Accidental infinite loops are those which were not intended by the programmer but are caused due to some error in the program.

Following are some of the errors that may cause infinite loops in your programs unintentionally:

1. Missing Update Statements

Infinite loops are caused when you forget to add an update condition inside the loop, which will terminate the loop in the future. The following program illustrates such a scenario:

Example Code:

// Infinite loop caused due to missing update statement

#include <iostream>
using namespace std;

int main() {
    int i = 3;
    while (i < 5) {
        cout << i <<endl;
        // Missing update: i++;
    }
    return 0;
}

Output:

3

3

3

3

3

3

3

……………………

To fix the above code, we can add an update condition inside the loop like this:

// fixed code

#include<iostream>
using namespace std ;

int main() {
int i = 3;
while (i < 5) {
    cout << i << endl;
    i++; // add the condition
}

return 0 ; 

}

Output:

3

4

Incorrect Loop Conditions

The conditions mentioned inside the loop body are crucial to terminate a loop. An incorrect loop condition can result in an infinite loop. The following program illustrates such a scenario:

Example Code:

// Infinite loop caused due to incorrect loop conditions

#include <iostream>
using namespace std;

int main() {
    int i = 2;
    while (i >= 0) {  
        cout << "Hello AnshuAyush " << endl;

    }
    return 0;
}

Output:

Hello AnshuAyush

Hello AnshuAyush

Hello AnshuAyush

Hello AnshuAyush

Hello AnshuAyush

……………………..

To fix the above code, we can update i inside the loop to eventually make the condition false:

// fixed code 

#include<iostream>
using namespace std ;

int main() {
int i = 2;
while (i >= 0) {  
    cout << "Hello AnshuAyush" << endl;
    i--; // loop will stop
}

return 0 ; 

}

Ouptut:

Hello AnshuAyush

Hello AnshuAyush

Hello AnshuAyush

Logical Errors in the Loop

In many scenarios, infinite loops are caused by small logical errors in the code. The following program illustrates such a scenario:

Example Code:

#include <iostream>
using namespace std;

int main() {
    for (int i = 3; i >2; i += 2) {  
        cout <<"This is an infinite loop" << endl;
    }
    return 0;
}

Output:

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

……………………….

To fix the above code, we can either use a decreasing condition or use an incrementing loop condition.

Decreasing condition:

for (int i = 3; i > 0; i--) {
    cout <<"This is NOT an infinite loop" << endl;
}

Increasing condition:

for (int i = 3; i < 10; i += 2) {
    cout <<"Loop will end when i reaches 10" << endl;
}

Applications of Infinite Loops in C++

Infinite loops do not only occur by accident, as I mentioned above. You can also create them on purpose for different use cases. The following are some of the common applications where you might use infinite loops intentionally:

• Event loops: Many Graphical User Interfaces (GUIs) use infinite loops to keep the program running and responsive to user actions.

• Server applications: Web servers use infinite loops to continuously listen to client connections or requests.

• Embedded systems: Embedded systems, such as microcontrollers, frequently use infinite loops as their main program loops to continuously respond to external events.

• User inputs: Infinite loops are also used to wait for valid user inputs. The loop keeps running until a valid input is provided by the user. We’ll look at an example of this one.

Using Infinite Loops to Take User Input in C++

Infinite loops are commonly used in scenarios where a program needs to continuously take user input until a specific condition is met, such as exiting the program or getting a valid user input. The following program demonstrates how we can take user input from the user until a specific condition is met:

Example Code:

// C++ Program to take user input from users using infinite loops

#include <iostream>
#include <string>
using namespace std;

int main() {
    string input;

    while (true) {
        cout << "Enter a command (type 'exit' to quit): ";
        getline(cin, input);

        if (input == "exit") {
        // Exit the loop if the user types 'exit'
            break; 
        }

        cout << "You entered: " << input << endl;
        // Process the input
    }
    cout << "Program exited." << endl;
    return 0;
}

Output:

Enter a command (type 'exit' to quit): Anshu

You entered: Anshu

Enter a command (type 'exit' to quit): Ayush

You entered: Ayush

Enter a command (type 'exit' to quit): exit

Program exited.

Conclusion

Infinite loops aren’t always dangerous. They can be very useful when used with proper control, like break statements or condition checks. But if you use them carelessly, they can crash your program.

So just make sure you check your loop conditions and test your code using print statements between the programs to discover any unexpected behavior. In sum, infinite loops can be very powerful when handled carefully but can be very risky if left unchecked.

And if you'd like to support me and my work directly so I can keep creating these tutorials, you can do so here. Thank you!

In this article, we will look at some of the most commonly used built-in functions in C++ so you can start using them in your code.

What we’ll cover:

1. The sqrt() Function

2. The pow() Function

3. The sort() Function

4. The find() Function

5. The binarysearch() Function

6. The max() Function

7. The min() Function

8. The swap() Function

9. The toupper() Function

10. The tolower() Function

The sqrt() Function

You use the sqrt() function to determine the square root of the value of type double. It is defined inside the <cmath> header file.

Syntax:

sqrt (n)

Parameter: This function takes only one parameter of type double which is a number we want to find the square root of.

Return Type: The square root of the value of type double.

Example Code

Let’s look at an example so you can see how this function works:

// C++ program to see the use of sqrt() function
#include <cmath>     
#include <iostream>  

using namespace std;  
int main()
{
    double x = 100;

    double answer;

    // Use the sqrt() function to calculate the square root of the number
    answer = sqrt(x);

    // Print the result 
    cout << answer << endl;

    return 0;
}

Output:

10

The pow() Function

You use the pow() function to find the value of the given number raised to some power. This function is also defined inside the <cmath> header file.

Syntax:

double pow(double x, double y);

Parameters:

• x: The base number.

• y: The exponential power.

Return Type: value of x raised to the power y.

Example Code:

Let’s look at an example to see how this works:

// C++ program to see the use of the pow() function
#include <cmath>
#include <iostream>
using namespace std;

int main()
{
 // Declare an integer variable 'base' 
    int base = 5;

// Declare an integer variable 'exponent' 
    int exponent = 3;

// pow(5, 3) means 5^3 which is 5*5*5 = 125
// Use the pow() function to calculate base raised to the power of exponent
    int answer = pow(base, exponent);

// output the result
    cout << answer << endl;
}

Output:

125

The sort() Function

The sort() function is part of STL's <algorithm> header. It is a function template that you can use to sort the random access containers, such as vectors, arrays, and so on.

Syntax:

sort (arr , arr + n, comparator)

Parameters:

• arr: The pointer or iterator to the first element of the array.

• arr + n: The pointer to the imaginary element next to the last element of the array.

• comparator: The unary predicate function that is used to sort the value in some specific order. The default value of this sorts the array in ascending order.

Return Value: This function does not return any value.

Example Code:

Let’s look at an example:

#include <iostream>     
#include <algorithm>    // Header file that includes the sort() function

using namespace std;    

int main()
{
    // Declare and initialize an integer array with unsorted elements
    int arr[] = { 13, 15, 12, 14, 11, 16, 18, 17 };

    // Calculate the number of elements in the array
    int n = sizeof(arr) / sizeof(arr[0]);

    // Use the built-in sort() function from the algorithm library
    sort(arr, arr + n);

    // Print the sorted array using a loop
    for (int i = 0; i < n; ++i)
        cout << arr[i] << " ";  

    return 0;
}

Output:

11 12 13 14 15 16 17 18

The find() Function

The find() function is also part of the STL <algorithm> library. You use this function to find a value in the given range. You can use it with both sorted and unsorted datasets as it implements a linear search algorithm.

Syntax:

find(startIterator, endIterator, key)

Parameters:

• startIterator: Iterates to the beginning of the range.

• endIterator: Iterates to the end of the range.

• key: The value to be searched.

Return Value: If the element is found, then the iterator is set to the element. Otherwise, it iterates to the end.

Example Code:

Let’s look at an example to better understand how it works:

// C++ program to see the the use of the find() function

#include <algorithm>   // Required for the find() function
#include <iostream>    
#include <vector>      

using namespace std;   

int main()
{
    // Initialize a vector 
    vector<int> dataset{ 12, 28, 16, 7, 33, 43 };

    // Use the find() function to search for the value 7
    auto index = find(dataset.begin(), dataset.end(), 7);

    // Check if the element was found
    if (index != dataset.end()) {
        // If found, print the position (index) by subtracting the starting iterator
        cout << "The element is found at the "
             << index - dataset.begin() << "nd index";
    }
    else {
        // If not found
        cout << "Element not found";
   }
    return 0;
}

Output:

The element is found at the 3rd index

The binary_search() Function

The binary_search() function is also used to find an element in the range – but this function implements binary search instead of linear search as compared to the find() function. It’s also faster than the find() function, but you can only use it on sorted datasets with random access. It’s defined inside the <algorithm> header file.

Syntax:

binary_search (starting_pointer , ending_pointer , target);

Parameters:

• starting_pointer: Pointer to the start of the range.

• ending_pointer: Pointer to the element after the end of the range.

• target: Value to be searched in the dataset.

Return Value:

• Returns true if the target is found.

• Else return false.

Example Code:

Let’s check out an example to see how it works:

// C++ program for the binary_search() function

#include <algorithm>   
#include <iostream>    
#include <vector>      

using namespace std;   

int main()
{
    // Initialize a sorted vector of integers
    vector<int> arr = { 56, 57, 58, 59, 60, 61, 62 };

    // binary_search() works only on sorted containers
    if (binary_search(arr.begin(), arr.end(), 62)) {
        // If found, print that the element is present
        cout << 62 << " is present in the vector.";
    }
    else {
        // If not found, print that the element is not present
        cout << 16 << " is not present in the vector";
    }

    cout << endl;
}

Output:

62 is present in the vector.

The max() Function

You can use the std::max() function to compare two numbers and find the bigger one between them. It’s also defined inside the <algorithm> header file.

Syntax:

max (a , b)

Parameters:

• a: First number

• b: Second number

Return Value:

• This function returns the larger number between the two numbers a and b.

• If the two numbers are equal, it returns the first number.

Example Code:

Here’s an example:

// max() function

#include <algorithm>  
#include <iostream>   
using namespace std;

int main()
{
    // Declare two integer variables
    int a = 8 ;
    int b = 10 ;

    // Use the max() function to find the larger number between a and b
    int maximum = max(a, b);

    // Display the result with a meaningful message
    cout << "The maximum of " << a << " and " << b << " is: " << maximum << endl;

    return 0;
}

Output:

The maximum of 8 and 10 is: 10

The min() Function

You can use the std::min() function to compare two numbers and find the smaller of the two. It’s also defined inside the <algorithm> header file.

Syntax:

min (a , b)

Parameters:

• a: First number

• b: Second number

Return Value:

• This function returns the smaller number between the two numbers a and b.

• If the two numbers are equal, it returns the first number.

Example Code:

Here’s an example:

// use of the min() function

#include <algorithm>  // For the built-in min() function
#include <iostream>   
using namespace std;

int main()
{
    // Declare two integer variables to store user input
    int a = 4 ;
    int b = 8 ;

    // Use the min() function to find the smaller 
    int smallest = min(a, b);

    // Display the result 
    cout << "The smaller number between " << a << " and " << b << " is: " << smallest << endl;

    return 0;
}

Output:

The smaller number between 4 and 8 is: 4

The swap() Function

The std::swap() function lets you swap two values. It’s defined inside <algorithm> header file.

Syntax:

swap(a , b);

Parameters:

• a: First number

• b: Second number

Return Value: This function does not return any value.

Example:

Here’s how it works:

//  use of the swap() function

#include <algorithm>  // For the built-in swap() function
#include <iostream>   
using namespace std;

int main()
{
    int firstNumber = 8 ;
    int secondNumber = 9 ;


    // Use the built-in swap() function to exchange values
    swap(firstNumber, secondNumber);

    // Display values after swapping
    cout << "After the swap:" << endl;
    cout << firstNumber << " " << secondNumber << endl;

    return 0;
}

Output:

After the swap:

9 8

The tolower() Function

You can use the tolower() function to convert a given alphabet character to lowercase. It’s defined inside the <cctype> header.

Syntax:

tolower (c);

Parameter(s):

• c: The character to be converted.

Return Value:

• Lowercase of the character c.

• Returns c if c is not a letter.

Example Code:

Here’s how it works:

// C++ program

// use of tolower() function

#include <cctype>     
#include <iostream>   
using namespace std;

int main()
{
    // Declare and initialize a string with uppercase characters
    string str = "FRECODECAMP";

    for (auto& a : str) {
        a = tolower(a);
    }

    // Print the modified string 
    cout << str;

    return 0;
}

Output:

freecodecamp

The toupper() Function

You can use the toupper() function to convert the given alphabet character to uppercase. It’s defined inside the <cctype> header.

Syntax:

toupper (c);

Parameters:

• c: The character to be converted.

Return Value

• Uppercase of the character c.

• Returns c if c is not a letter.

Example Code:

Here’s how it works:

// use of toupper() function

#include <cctype>     
#include <iostream>   
using namespace std;

int main()
{
    // Declare and initialize a string 
    string str = "freecodecamp";

    for (auto& a : str) {
        a = toupper(a);
    }

    // Output the converted uppercase string
    cout << str;

    return 0;
}

Output:

FREECODECAMP

Conclusion

Inbuilt functions are helpful tools in competitive programming and in common programming tasks. These help in improving code readability and enhance the efficiency of code. In the above article, we discussed some very useful common inbuilt functions. Some common inbuilt functions are max(), min(), sort(), and sqrt(), etc. By using these inbuilt libraries, we can reduce boilerplate code and speed up the process of software development. These help in writing more concise, reliable, and maintainable C++ programs.

And if you'd like to support me and my work directly so I can keep creating these tutorials, you can do so here. Thank you!

In this article, we’ll look at a common problem: we are given the dimensions of a triangle, and our task is to calculate its area. You can calculate the area of a triangle using different formulas, depending on the information you have about the triangle. Here, you’re going to learn how to do it using PHP.

After reading this tutorial:

• You will understand the basic logic behind calculating the area of a triangle.

• You will know how to write PHP code that calculates the triangle’s area using pre-defined and user-entered values.

• You will know how to apply this logic in small projects and assignments.

Table of Contents

1. Prerequisites

2. Find the Area of a Triangle Using Direct Formulas

3. Find the Area of a Triangle Using the Base and Height Approach

4. Find the Area of a Triangle Using Heron's Formula

5. Find the Area of a Triangle Using Two Sides and Included Angle (Trigonometric Formula)

6. Conclusion

Prerequisites

You’ll understand this guide more easily if you have some knowledge about a few things:

Basic PHP

You’ll need to know basic PHP syntax to fully understand the problem. If you know how to write a simple echo statement or create a variable in PHP, then you should be good to go.

Local PHP Environment

To run the PHP code successfully, you should have local PHP development, such as XAMPP or WAMP, on your machine. You can also use online PHP editors like PHP Fiddle or OnlineGDB to run a PHP script without any installation.

In this tutorial we are going to explore three approaches to determine the area of the triangle in PHP based on the amount of information available about the triangle.

• Base and Height Formula Approach: This approach is applicable when you have the perpendicular height from the base and length of the base in the problem.

• Heron’s Formula: This approach is used to calculate the area of triangle when you have the lengths of all three sides of the triangle.

• Trigonometric Formula Approach: This approach is applied on the problem when you have the length of two sides and the included angle between them.

First, let’s go back to math class and use some direct formulas to find the area.

Find the Area of a Triangle Using Direct Formulas

Example 1:

In this first example, you’re given the input base and height of a triangle. You have to return the area of the triangle. For this example, you’ll use a direct formula to calculate the area of the triangle.

Input:

Base = 5,

Height = 10

You can calculate the area of the triangle using the formula:

$$Area = (Base * Height) / 2$$

So, if you plug in the values you have, you get: (5* 10) / 2 = 25.

Output:

Area = 25

Example 2:

In this second example, you’re given the length of two sides of a triangle and one angle between them. You have to return the area of the triangle. In this example, you’ll use another direct formula to calculate the area of the triangle.

Input:

Side A = 7, Side B = 9, Angle between them = 60°

In this case, you’ll use the formula:

$$Area = (1/2) A B * sin(Angle).$$

Then just substitute in the values you’ve been given to find the area.

Output:

Area = 27.33 (approximately)

Now let’s look at some different approaches to finding the area of a triangle using PHP.

Find the Area of a Triangle Using the Base and Height Approach

This is the simplest and most direct approach for calculating the area of a triangle when you know the base and height. In this approach, you’ll directly put values in the formula and find the area of the triangle – but you’ll do it with PHP code.

First, define the base and height of the triangle. Then apply the formula for the area of the triangle. As we saw above, the formula for the area of a triangle is:

$$Area = (Base * Height) / 2$$

After calculating the area of the triangle, output the answer.

Alright, so here’s how we can implement that in PHP:

<?php
// Define the base and height
$base = 5;
$height = 10;

// Calculate the area
$area = ($base * $height) / 2;

// Output the result
echo "The area of the triangle is: " . $area . " square units.";
?>

Output:

The area of the triangle is 25 square units.

In the above code, first we initialize the base and height of triangle in two variables. Then we plug those values into the area formula. PHP calculates the area of the triangle and displays the answer.

Time Complexity: In the above approach, we are using the direct formula to calculate and return the area of the triangle, so the time complexity will be constant at O(1). The constant time complexity is efficient as it will remain constant, regardless of the size or values of the base and height.

Space Complexity: The Space Complexity will be O(1). The space used by the above program is constant, which ensures minimal use of memory. This space complexity is ideal in environments where memory efficiency is a priority.

We use the above approach when we have the length of the base and height of the triangle (whether directly given or easily measurable in a right angle triangle). This method works best for right-angled triangles.

Find the Area of a Triangle Using Heron's Formula

Heron’s formula is named after a Greek mathematician named Heron of Alexandria. Heron’s formula is useful when you know the lengths of all three sides of the triangle and you want to calculate the area without needing the height. This formula works for any type of triangle, including scalene triangles (triangles with sides of all different lengths).

Here’s Heron’s formula to calculate the area of a triangle:

$$√s(s−a)(s−b)(s−c) ​$$

Where:

• s = semi-perimeter = (a+b+c)/2 is the semi-perimeter of the triangle.

• a, b, and c are the lengths of the sides.

First, we define the three sides of the triangle. Then, we check all three conditions of the Triangle Inequality Theorem which states that if the sum of two sides is greater than the third side, then it is a valid triangle, and the given sides can form a triangle.

We can calculate the semi-perimeter of the triangle using the formula s = a+b+c/2. Then we can apply Heron's formula to calculate the area. After calculating the area, then output the answer.

Here’s how you can implement this in PHP:

<?php
// Define the sides of the triangle
$a = 7;
$b = 9;
$c = 10;

// Check if the sides form a valid triangle using the Triangle Inequality Theorem
if (($a + $b > $c) && ($a + $c > $b) && ($b + $c > $a)) {

    // Calculate the semi-perimeter
    $s = ($a + $b + $c) / 2;

    // Calculate the area using Heron's formula
    $area = sqrt($s * ($s - $a) * ($s - $b) * ($s - $c));

    // Output the result
    echo "The area of the triangle is: " . $area . " square units.";

} else {
    // If the sides can't form a valid triangle
    echo "The given sides do not form a valid triangle.";
}
?>

Output:

The area of the triangle is: 27.321 square units.

In the above code, we first create three variables to store the lengths of the triangle’s sides, and check if the given sides form a valid triangle or not using the Triangle Inequality Theorem. Then we calculate the semi-perimeter using the formula: s = a + b + c / 2. We put the value of the semi-perimeter and lengths of all sides in Heron’s formula to calculate the area. The area of triangle is returned after calculating using the formula.

Time Complexity: There is a total fixed number of operations such as addition, subtraction, multiplication, and square root. These operations don’t depend on input size as they are performed only a fixed number of times. This means that the time complexity is constant O(1).

Space Complexity: We have used a fixed number of variables to calculate the area of the triangle. We have not used any additional data structures such as arrays or objects. The memory usage in the program is constant, which is better for low-memory environments. The space complexity is constant O(1).

This approach works best when the lengths of all sides are given. This approach is used mainly for scalene or isosceles triangles where height is directly not given. This approach can work for any type of triangle, however – scalene, isosceles, or equilateral.

Find the Area of a Triangle Using Two Sides and Included Angle (Trigonometric Formula)

In this approach, we will see a different variation of the problem. When you know two sides of a triangle and the included angle between them, you can calculate the area using this formula:

$$Area = 1/2 × a × b × sin(θ)$$

Where:

• a and b are the lengths of the two sides.

• θ is the included angle between the two sides, measured in degrees or radians.

Using the above formula, you can calculate the area of a triangle without needing its height. First, you define the two sides of the triangle and the angle between them. Then you convert the angle from degrees to radians if needed (in PHP, you can use deg2rad() to convert degrees to radians). Then you apply the formula.

After calculating the area of the triangle, output the result.

Here’s how to implement this in PHP:

<?php
// Define the two sides and the included angle
$a = 7;
$b = 9;
$angle = 60; // Angle in degrees

// Convert the angle from degrees to radians
$angle_in_radians = deg2rad($angle);

// Calculate the area using the formula
$area = 0.5 * $a * $b * sin($angle_in_radians);

// Output the result
echo "The area of the triangle is: " . $area . " square units.";
?>

Output:

The area of the triangle is: 27.321 square units.

Explanation:

In the above case, we’re using the formula:

Area of Triangle = 1/2 × a × b × sin(θ)

And we’re substituting the following values into the formula:

Area= 1/2 × 7 × 9 × sin(60 ∘) ≈ 27.321

In the code, we declared two variables to store the length of the two sides of the triangle, and the variable $angle hold the included angle in degrees. We used deg2rad(), a PHP built-in function which converts an angle from degrees to radians. Then, we applied the actual formula: Area = 1/2 × 7 × 9 × sin(60 ∘). PHP stores the final answer in the $area variable.

Time Complexity: We are using the direct formula to calculate the area of a triangle when the length of two sides and the angle between them are given. The constant time complexity is O(1).

Space Complexity: Similarly, it does not take any extra space or use any data structures. It uses a single variable to store the result, which is why the space complexity is constant O(1).

This approach is perfect for the problem in which two sides and the included angle (angle between those sides) are known. You can use it when you cannot easily calculate the height of the triangle. This problem has real-life applications in geometry problems, CAD applications, or physics simulations. This method is very accurate and doesn’t require the length of all sides.

Conclusion

In this article, you’ve learned how you can calculate the area of a triangle, both manually and using PHP. You have seen different approaches and learned about which one is best given the information you have. First, we discussed the base and height approach, then looked at Heron’s formula, and finally examined how to handle things when two sides and the included angle are given.

Understanding the logic behind each of these approaches helps you choose the right one based on the given data.

And if you'd like to support me and my work directly so I can keep creating these tutorials, you can do so here. Thank you!