AlgorithmTech.Tech | Explore New Technology

Exploring the Power and Potential of GPT-3: The Next Generation of AI Technology

2023-01-30T14:42:00.010+05:30

Introduction

GPT-3 (Generative Pretrained Transformer 3) is a state-of-the-art language processing AI technology developed by OpenAI. With its advanced natural language processing capabilities, GPT-3 is able to generate human-like text and perform a wide range of language-related tasks, including translation, question answering, and content creation. GPT-3's powerful and flexible architecture allows it to be used in a wide range of industries, from customer service to content creation, and its ability to quickly adapt to new tasks and changing data sets makes it a game-changer in the AI industry. With its powerful and ever-growing capabilities, GPT-3 has the potential to revolutionize the way we interact with and use language technology.

Explanation of GPT-3

GPT-3 is an advanced AI language model that is designed to generate human-like text and perform a wide range of language-related tasks. It uses a deep neural network and large amounts of training data to create a highly sophisticated model that is capable of understanding and generating text with remarkable accuracy. With its powerful language processing capabilities, GPT-3 is able to respond to natural language questions, translate text between languages, and even write complete articles or essays. The key to GPT-3's success is its ability to learn patterns and relationships in the data it is trained on, and then apply that knowledge to new and unseen data. This allows it to generate accurate and coherent text that often mimics human writing. With its impressive capabilities, GPT-3 is poised to have a major impact on industries ranging from customer service to content creation.

Importance of GPT-3 in AI and technology

GPT-3 represents a significant step forward in the field of AI and language technology. With its advanced natural language processing capabilities and ability to perform a wide range of tasks, GPT-3 has the potential to revolutionize the way we interact with and use language technology. The potential applications for GPT-3 are vast, from customer service and content creation to education and healthcare. By automating many language-related tasks that were previously performed by humans, GPT-3 has the potential to significantly increase efficiency and productivity across a wide range of industries. In addition, GPT-3's ability to quickly adapt to new data sets and new tasks makes it a highly versatile tool that can be used in a variety of different settings. With its unique combination of power, flexibility, and versatility, GPT-3 is poised to have a major impact on the future of AI and technology.

A brief history of GPT-3

GPT-3 is the latest iteration of the GPT (Generative Pre-trained Transformer) series of language models developed by OpenAI. The first GPT model was introduced in 2018 and was quickly followed by GPT-2 in 2019. Both models were highly successful and generated significant excitement and interest in the AI and language technology communities. GPT-3, however, represents a major step forward in terms of capabilities and potential applications. With its vast amounts of training data, advanced deep neural network, and sophisticated language processing capabilities, GPT-3 has been described as a "breakthrough" in the field of AI and language technology. The introduction of GPT-3 has generated a great deal of excitement and anticipation in the AI community, and its potential impact on a wide range of industries is eagerly awaited.

Understanding GPT-3

GPT-3 is an advanced artificial intelligence language model developed by OpenAI. It utilizes deep learning algorithms and a massive amount of training data to generate human-like responses to natural language inputs. This allows it to perform a wide range of language-related tasks, such as text generation, translation, question answering, and summarization, among others. Its unique combination of processing power and advanced language capabilities make GPT-3 a highly versatile tool with the potential to revolutionize the way we interact with and use language technology.

How GPT-3 works

GPT-3 works by utilizing a deep neural network and massive amounts of training data to generate human-like responses to natural language inputs. The model is trained on a vast amount of text data to learn patterns and relationships between words and phrases, allowing it to generate coherent and contextually appropriate responses to inputs.

Architecture and components of GPT-3

The GPT-3 architecture consists of a deep neural network known as a transformer. This network is trained on a massive amount of text data using unsupervised learning, meaning it generates its own labels based on patterns it recognizes in the data. The transformer network is composed of multiple layers of attention and feed-forward processing, allowing it to generate highly nuanced language responses.

The difference between GPT-3 and other language models

GPT-3 is a major advancement over previous language models, both in terms of its training data size and the sophistication of its deep learning algorithms. Additionally, GPT-3 has been designed specifically to perform a wide range of language-related tasks, making it highly versatile compared to other language models. Its advanced processing capabilities, combined with its vast amounts of training data, make it the most advanced language model currently available.

Applications of GPT-3

Chatbots and customer service
Content creation and writing
Translation and language processing
Natural language processing for various industries such as finance, legal, and healthcare
Question-answering systems
Personalized recommendation systems
Speech recognition and voice-activated technology
Sentiment analysis and emotion recognition
Text summarization and keyword extraction
Virtual writing assistants and text prediction software.

Detailed explanation for some of the applications:

Chatbots and customer service

GPT-3 has the ability to understand and respond to natural language inputs, making it ideal for use in chatbots for customer service. It can provide quick and accurate responses, reducing wait times and improving the overall customer experience.

Content creation

GPT-3 is capable of generating high-quality content in a variety of styles and formats, making it a valuable tool for content creators. From articles to social media posts, GPT-3 can save time and effort while producing unique and engaging content.

Translation

GPT-3 has the ability to translate between multiple languages, making it a valuable tool for businesses and organizations looking to expand their reach globally. Its advanced language processing capabilities allow for accurate and nuanced translations.

Research and data analysis

GPT-3 can assist with research and data analysis by processing and organizing large amounts of information. It can provide insights and findings in a fraction of the time it would take for humans to complete the same task.

Advantages of GPT-3

GPT-3 has a number of advantages that make it a top choice for various applications in AI and technology.

Natural language processing

GPT-3 has advanced natural language processing capabilities that make it possible for it to understand and respond to complex human language.

High accuracy and speed

With its powerful neural network, GPT-3 is able to deliver fast and accurate outputs, making it a reliable option for many applications.

High-quality outputs

GPT-3 is designed to produce high-quality outputs that are coherent, relevant, and engaging.

Cost-effective compared to other language models

GPT-3 is a cost-effective option compared to other language models, making it a popular choice for businesses and individuals looking to adopt AI technology.

Challenges of GPT-3

The challenges of GPT-3 lie in ensuring ethical use of the technology and addressing potential negative consequences, such as the generation of fake news and misinformation. Additionally, there are concerns around privacy and data protection, as GPT-3 processes large amounts of personal information. Furthermore, the scalability and integration of GPT-3 into various industries also pose challenges, as well as the need for more robust and diverse training data to improve the language model's accuracy and inclusivity.

Measure challenge:

Privacy and data security

As GPT-3 is a highly advanced AI model that utilizes large amounts of data, privacy and data security are a major concern. There are concerns about the collection and use of personal data by GPT-3, and the potential misuse of that data. It is important to ensure that the data used to train GPT-3 is collected and processed in a secure and ethical manner to protect users' privacy.

Bias and ethical considerations

AI models like GPT-3 can perpetuate and amplify biases that exist in the data they are trained on. This can lead to unfair and unjust outcomes for certain groups of people. It is crucial to ensure that the training data used for GPT-3 is diverse and free from biases, and to address any biases that may arise in the outputs generated by the model.

Need for human oversight

While GPT-3 can perform many tasks with high accuracy and speed, it is still limited by the data it has been trained on. There is a need for human oversight to ensure that the outputs generated by GPT-3 are accurate, ethical, and aligned with the goals of the user. Additionally, as GPT-3 is a complex AI model, there is a need for experts to monitor and maintain the model to ensure it continues to function as intended.

Future of GPT-3

The future of GPT-3 is very promising as it is paving the way for new advancements in the field of AI and NLP. With its powerful language generation capabilities and ability to perform various tasks with high accuracy, it has the potential to revolutionize multiple industries. However, it is crucial to address and mitigate the challenges associated with the technology, such as privacy concerns and ethical considerations, to ensure its responsible usage. The advancements in GPT-3 and its integration with other technologies hold the key to unlocking a world of possibilities in the near future.

Advancements in language models

The field of language models is rapidly evolving, and GPT-3 is one of the latest advancements in the field. With the increasing demand for natural language processing and AI-powered communication, language models like GPT-3 are becoming increasingly important. Advancements in this area are making language models more sophisticated and more capable of handling complex tasks.

Integration with other AI technologies

GPT-3 is a powerful language model that can be integrated with other AI technologies to create more sophisticated systems. For example, GPT-3 can be integrated with computer vision systems to enable image captioning or with speech recognition systems to enable natural language interaction. The potential for integration with other AI technologies is vast and continues to grow as the field evolves.

Potential impact on various industries

GPT-3 has the potential to have a significant impact on various industries, including customer service, content creation, and data analysis. With its advanced natural language processing capabilities, GPT-3 can automate many manual tasks and improve the efficiency and accuracy of these processes. As a result, businesses across a range of industries are exploring ways to integrate GPT-3 into their operations.

GPT-3 can be used in several ways, including:

Through an API: OpenAI offers access to GPT-3 through an API that developers can use to integrate its capabilities into their own applications.

Pre-built tools and applications: OpenAI has developed several pre-built tools and applications that make use of GPT-3, such as the OpenAI Codex, which allows users to generate code snippets based on natural language inputs.

Interactive console: OpenAI provides an interactive console that allows users to test and experiment with GPT-3's capabilities by inputting text and receiving responses in real-time.

Fine-tuning: Developers can also fine-tune GPT-3 on their own data sets to customize its capabilities for specific use cases.

To use GPT-3, you will typically need an OpenAI API key, which can be obtained by signing up for access on the OpenAI website.

You can visite office website and use here:

As chatgpt: https://chat.openai.com/chat

As Interactive console: https://beta.openai.com/playground

Conclusion

GPT-3 is a cutting-edge language model developed by OpenAI that represents a major advance in the field of AI and language technology. Its powerful natural language processing capabilities and ability to perform a wide range of language-related tasks, such as text generation, translation, and question answering, make it a highly versatile tool with the potential to revolutionize a variety of industries. With its advanced deep neural network, vast amounts of training data, and sophisticated processing algorithms, GPT-3 is poised to have a major impact on the future of AI and technology. The potential applications of GPT-3 are vast, from customer service and content creation to education and healthcare, and its unique combination of power, flexibility, and versatility make it a tool that is likely to be highly sought after by a variety of organizations in the coming years.

What are Artificial Intelligence and Machine Learning? Top 6 Machine Learning Libraries?

2022-12-04T15:04:00.025+05:30

Artificial Intelligent:

Artificial intelligence (AI) is the simulation of human intelligence processes by machines, especially computer systems. These processes include learning (the acquisition of information and rules for using the information), reasoning (using the rules to reach approximate or definite conclusions), and self-correction.

Machine Learning:

Machine learning is a subset of artificial intelligence that uses statistical techniques to give machines and systems the ability to “learn” from data without being explicitly programmed. It focuses on developing computer programs that can access data and use it to learn for themselves.

Some of the most popular libraries:

Used in machine learning are TensorFlow, Keras, Scikit-Learn, PyTorch, Microsoft Cognitive Toolkit, and Apache MXNet.

TensorFlow:

TensorFlow is an open source software library for numerical computation using dataflow graphs. It is a symbolic math library, and is also used for machine learning applications such as neural networks. With TensorFlow, we can build and train neural networks to detect and decipher patterns and correlations, and can be used for predictive analysis.

Using TensorFlow, we can create, train, and deploy machine learning models. We can use it to build, train and deploy deep learning models such as convolutional neural networks, recurrent neural networks, and long short-term memory networks. We can also use it to create and train models for natural language processing (NLP) tasks, such as text classification, sentiment analysis and question-answering.

The models we can train in TensorFlow include linear models, logistic regression, support vector machines, decision trees, random forests, and neural networks. We can also use TensorFlow to create and train deep learning models such as convolutional neural networks, recurrent neural networks, and long short-term memory networks.

Keras:

Keras is an open source deep learning library written in Python. It is designed to enable fast experimentation with deep neural networks. It is capable of running on top of TensorFlow, Microsoft Cognitive Toolkit, Theano, or PlaidML.

With Keras, users can easily build and train powerful deep learning models. It provides a wide range of model architectures, such as convolutional neural networks, recurrent neural networks, and multi-layer perceptions, as well as tools for model optimization, data pre-processing, and model evaluation.

Keras can be used to train a variety of models, including convolutional neural networks (CNNs), recurrent neural networks (RNNs), and long short-term memory (LSTM) networks. It can also be used to build custom models to solve specific tasks. For example, Keras can be used to create a model to classify images, recognize text, or predict stock prices.

Scikit-Learn:

Scikit-Learn is a free software machine learning library for the Python programming language. It features various classification, regression and clustering algorithms including support vector machines, random forests, gradient boosting, k-means and DBSCAN, and is designed to interoperate with the Python numerical and scientific libraries NumPy and SciPy.

With Scikit-Learn, you can build and evaluate machine learning models, such as supervised learning (classification and regression) algorithms and unsupervised learning algorithms (clustering). You can also optimize model hyperparameters using grid search, tune model selection and pre-processing using pipelines, and perform model selection and validation to improve accuracy and performance.

Some examples of the models that can be trained in Scikit-Learn include linear models (such as linear regression and logistic regression), ensemble methods (such as random forests and gradient boosting), and kernel-based methods (such as support vector machines and k-nearest neighbors).

PyTorch:

PyTorch is an open source machine learning library for Python, based on Torch, used for applications such as natural language processing. It provides a wide range of algorithms for deep learning and uses the power of GPUs.

With PyTorch, users can build and train neural networks for tasks such as object recognition and natural language processing. It also supports distributed training, meaning that multiple GPUs can be used in parallel for faster training.

PyTorch supports a wide range of models, including convolutional neural networks, recurrent neural networks, generative adversarial networks, and reinforcement learning. It also supports model deployment, allowing users to deploy their models in production environments.

Microsoft Cognitive Toolkit:

Microsoft Cognitive Toolkit (formerly known as CNTK) is an open-source, deep learning framework developed by Microsoft. It is used to train, evaluate and deploy deep learning models. It can be used to build and train models in a variety of popular machine learning frameworks, such as Caffe, TensorFlow, and PyTorch.

With Microsoft Cognitive Toolkit, users can build and train models for image, text, and time series data. It supports supervised, unsupervised, and reinforcement learning. It also supports both CPU and GPU training. The toolkit can be used for a variety of tasks, such as natural language processing, computer vision, speech recognition, and reinforcement learning.

The models supported by Microsoft Cognitive Toolkit include feedforward neural networks, convolutional neural networks, recurrent neural networks, and long short-term memory networks. The toolkit also supports transfer learning, which allows users to adapt pre-trained models for their own custom tasks.

Apache MXNet:

Apache MXNet is an open source deep learning framework designed for both efficiency and flexibility. It is optimized for both cloud and edge environments, allowing for easy deployment of models across a wide range of applications. It is also highly scalable, allowing for distributed training on multiple machines to improve training speed.

With Apache MXNet, users can develop, train, and deploy deep learning models for a variety of applications, such as computer vision, natural language processing, and time series analysis. It also supports a wide range of model architectures, such as convolutional neural networks, recurrent neural networks, and graph neural networks.

The models that can be trained in Apache MXNet include convolutional neural networks, recurrent neural networks, graph neural networks, generative adversarial networks, and reinforcement learning algorithms.

Explain the Binary, Octel, Decimal, and Hexadecimal number systems with examples in detail.

2022-12-03T10:23:00.003+05:30

Number Systems:

Binary Number System:

The binary number system is a base 2 system that uses only two digits (0 and 1). Each digit is referred to as a bit. A single bit can represent two values, 0 and 1, and all numbers in the binary number system are represented by combinations of 1s and 0s. For example, the binary number 101 is represented as 1 four, 0 twos, and 1 one, or 4 + 0 + 1 = 5.

Octal Number System:

The octal number system is a base 8 system that uses eight digits (0-7). The octal number system is commonly used in programming languages and is sometimes referred to as the base-8 number system. Each digit in an octal number can represent three values (0-7), and all numbers in the octal number system are represented by combinations of these digits. For example, the octal number 12 is represented as 1 eight and 2 ones, or 8 + 2 = 10.

Decimal Number System:

The decimal number system is a base 10 system that uses ten digits (0-9). The decimal number system is the most commonly used number system and is sometimes referred to as the base-10 number system. Each digit in a decimal number can represent ten values (0-9), and all numbers in the decimal number system are represented by combinations of these digits. For example, the decimal number 23 is represented as 2 tens and 3 ones, or 20 + 3 = 23.

Hexadecimal Number System:

The hexadecimal number system is a base 16 system that uses sixteen digits (0-9 and A-F). The hexadecimal number system is commonly used in computing and is sometimes referred to as the base-16 number system. Each digit in a hexadecimal number can represent sixteen values (0-9 and A-F), and all numbers in the hexadecimal number system are represented by combinations of these digits. For example, the hexadecimal number 1A is represented as 1 sixteen and 10 ones, or 16 + 10 = 26.

Write a program to insert the element at the given index in an array or list | MindTap Computing for Malik's C++ Programming 8th Edition

2022-09-07T11:00:00.024+05:30

Introduction:

Write a function, insertAt, that takes four parameters: an array of integers, the number of elements in the array, an integer (say, insertItem), and an integer (say, index). The function should insert Item in the array at the position specified by index. If index is out of range, output an appropriate message.

Source: MindTap Computing for Malik's C++ Programming From Problem Analysis to Program Design, 8th Edition, [Instant Access] (8th)-Malik, chapter 16, programming exercises 7.

Solved!

The objective of the programming exercise is to write a function that takes 4 arguments array, size of the array, the index where the element will be inserted, element to be inserted. and insert elements to the index given in the array. size of the array will be incremented.

Program:

// write function that takes 4 argument array, size of the array,
// index where the element will be inserted, element to be inserted.
// and insert element to index given in the array. size of the array will be incremented.

#include <iostream>

using namespace std;

// insertAt() that takes array, array size, index and insertItem.
// and insert elemnet at index given
void insertAt(int arr[], int &n, int index, int insertItem)
{
    // is index is less than 0.
    if (index < 0)
    {
        // print this msg.
        cout << "Index can not be less than 0!" << endl;
       return;
    }
    // else if index is greater than or equal to n.
    else if (index >= n)
    {
        // print this msg.
        cout << "Index can not be greater than or equal to " << n << "!" << endl;
       return;
    }   

    // increment size of array n.
    n++;
    // initialize j to n.
    int j = n;
    // use while loop j form n to index with decrement of 1.
    while (j >= index)
    {
        // assign value of previous element to current element.
        arr[j] = arr[j - 1];
        // decrement of 1.
        j--;
    }
    // assign insertItem to arr[index]
    // (insert at index.)
    arr[index] = insertItem;
}

// driver code.
int main()
{
    // declare array size.
    int n;
    cout << "Enter array size(<=1000): ";
    // take user input for n.
    cin >> n;

    // declare array with size 1000.
    int arr[1000];
    cout << "Enter array element" << endl;
    // take user input using for loop.
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    // declare index, insertItem
    int index, insertItem;
    // take user input .
    cout << "Enter index where element to be inserted: ";
    cin >> index;
    cout << "Enter element needed to insert at " << index << " index: ";
    cin >> insertItem;

    // calling function insertAt.
    insertAt(arr, n, index, insertItem);
    // print array using for loop.
    cout << "After inserting element " << insertItem << " at " << index << " index: ";
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;

    // end.
    return 0;
}

Output:

Image:

Write a version of the selection sort algorithm that can be used to sort a list of strings | MindTap Computing for Malik's C++ Programming 8th Edition

2022-09-06T11:00:00.013+05:30

Introduction:

Write a version of the selection sort algorithm that can be used to sort a list of strings.

Source: MindTap Computing for Malik's C++ Programming From Problem Analysis to Program Design, 8th Edition, [Instant Access] (8th)-Malik, chapter 16, programming exercises 8.

Solved!

The objective of the programming exercise is to write a function to sort a given list of strings using selection sort.

Program Plan:

· Define header section.

·     Define void selectionSort(vector<string> &arr) function that take vector of string as pass by reference.

o   Declare array size int n = arr.size().

o   Use for loop i from 0 to n-2.

§ Declare int min_index = i, tracks minimum element index in array arr[i]...arr[n-1].

§ Use for loop j from i+1 to n-1.

·       If arr[j] < arr[min_index].

o   Assignment j to min_index.

§ Swap element at index i and min_index.

·       Define main() function (testing function).

o   Declare int n variable.

o   Take user input for list size n.

o   Declare vector<string> arr(n).

o   Take user input for strings using for loop.

o   Call to function selectionSort().

o   Print the list of the string after sorting using for loop.

Program:

// write a function to sort a given list of strings using selection sort.

#include <iostream>
#include <string>
#include <vector>

using namespace std;

// selectionSort() that take vector of string as reference parameter.
// and sort given list using selection sort algorithm.
void selectionSort(vector<string> &arr)
{
    int n = arr.size();
    // for loop i from 0 to n-2.    
    for (int i = 0; i < n - 1; i++)
    {
        // set min_index to i.
        // min_index tracks minimum element index in array arr[i]...arr[n-1].
        int min_index = i;
        for (int j = i + 1; j < n; j++)
        {
            // if arr[j] is less than arr[min_index] .
            if (arr[j] < arr[min_index])
            {
                // assignment j to min_index.
                min_index = j;
            }
        }
        // swap element at index i and min_index
        swap(arr[i], arr[min_index]);
    }
}

// driver program.
int main()
{
    // declare variable n.
    int n;
    cout << "Enter size of list of string: ";
    // take user input.
    cin >> n;
    // declare vector arr of string of size n.
    vector<string> arr(n);
    // take user input for arr vector using  for loop.
    cout << "Enter " << n << " words: " << endl;
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    cout << endl;

    // call to selection sort function.
    selectionSort(arr);

    // print array after sortting.
    cout << "List of string after selection sort: ";
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << ", ";
    }
    cout << endl;

    // end.
    return 0;
}

Output:

Image:

Binary search algorithm that can be used to search a string vector object | MindTap Computing for Malik's C++ Programming 8th Edition

2022-09-05T11:00:00.001+05:30

Introduction:

Write a version of the binary search algorithm that can be used to search a string vector object. Also, write a program to test your algorithm.

Source: MindTap Computing for Malik's C++ Programming From Problem Analysis to Program Design, 8th Edition, [Instant Access] (8th)-Malik, chapter 16, programming exercises 15.

Solved!

The objective of the programming exercise is to implement a binary search algorithm to find string in vector<string> object which is sorted by selection sort.

Program Plan:

· Define header section.

· Define selectionSort() function.

· Define binSearch() function which takes array arr and string s.

o Declare left = 0 and right = arr.size() -1.

o While loop left <= right.

§ Declare m = (left + right) / 2.

§ If arr[m] == s.

· Found element s in arr at index m, return m.

§ Else if arr[m] < s.

· Set left = m + 1.

§ Else if arr[m] > s.

· Set right = m - 1.

o Return -1 if not return any value in the while loop.

· Define main() function.

o Declare n ask to take user input.

o Declare vector<string> arr of size n.

o Take user input to fill arr.

o Declare string s and take user input for s.

o Sort array using selectionSort()

o Print sorted array

o Find index p using binSearch() function call.

o Print the result using if-else

Program:

// objective of programming exercise is to implement binary search
// algorithm to find string in vector<string> object which is sorted by selection sort.

#include <iostream>
#include <vector>

using namespace std;

// selectionSort() which take vector<string> pass by reference and sort it in ascending order.
void selectionSort(vector<string> &arr)
{
    // array size.
    int n = arr.size();
    // for each index i from 0 to n-2.
    for (int i = 0; i < n - 1; i++)
    {
        // find minimum element index from i to n-1.
        int min_j = i;
        for (int j = i + 1; j < n; j++)
        {
            if (arr[j] < arr[min_j])
            {
                min_j = j;
            }
        }
        // swap it with i index element.
        swap(arr[i], arr[min_j]);
    }
}

// binSeach() which takes vector<string> arr as pass by reference and s string.
// and return index of s in arr.
// if not found return -1.
int binSeach(vector<string> &arr, string s)
{
    // set left = 0 and right = arr size - 1.
    int left = 0;
    int right = arr.size() - 1;
    // while left is less or equal right.
    while (left <= right)
    {
        // find mid point m
        int m = (left + right) / 2;
        // if arr[m] is equal to s.
        if (arr[m] == s)
        {
            // return m.
            return m;
        }
        // else if arr[m] is less than s.
        else if (arr[m] < s)
        {
            // set left equal to m+1.
            left = m + 1;
        }
        // else if arr[m] is greate than s.
        else if (arr[m] > s)
        {
            // set right equal to m-1.
            right = m - 1;
        }
    }

    // return -1 if not found.
    return -1;
}

// driver code.
int main()
{
    // ask n array size.
    int n;
    cout << "Enter array size:";
    cin >> n;

    // fill vector<string> arr of n size by user input.
    vector<string> arr(n);
    cout << "Enter " << n << " number of strings:" << endl;
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }

    // taking word to search in vector.
    string s;
    cout << "Enter word you want to seach for in sorted vector:";
    cin >> s;

    // sort array.
    selectionSort(arr);
    // print sorted array.
    cout << "Vector after sort:" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << ", ";
    }
    cout << endl;

    // find p index using function call.
    int p = binSeach(arr, s);
    // if p is -1.
    if (p == -1)
    {
        // not found.
        cout << "Entered word not found in vector." << endl;
    }
    else
    {
        // else print p index.
        cout << "Entered word found in vector at index " << p << endl;
    }

    return 0;
}

Output:

Image:

Use bubble sort, selection sort, and insertion sort to sort the array of 5000 elements and count the number of comparisons and assignments done in each sorting algorithm

2022-09-04T11:00:00.012+05:30

Introduction:

Write a program that creates three identical arrays, list1, list2, and list3 of 5,000 elements. The program then sorts list1 using bubble sort, list2 using selection sort, and list3 using insertion sort and outputs the number of comparisons and item assignments made by each sorting algorithm.

Source: MindTap Computing for Malik's C++ Programming From Problem Analysis to Program Design, 8th Edition, [Instant Access] (8th)-Malik, chapter 16, programming exercises 16.

Solved!

The objective of the programming exercise is to create 3 identical arrays of size 5000 using rand(). Sort first using bubble sort, second using selection sort, and third using insertion sort, Find the number of comparisons and assignments done for array element in each sorting algorithm. Print number of comparisons and assignments for every three sorting algorithms.

Program Plan:

· Define header section.

· Define bubbleSort(int arr[], int n, int &countComp, int &countAssign)

· Define selectionSort(int arr[], int n, int &countComp, int &countAssign)

· Define insertionSort(int arr[], int n, int &countComp, int &countAssign)

· Define main() function.

o Set seed level for rand() srand(time(0));

o Declare 3 array int l1[MAX], l2[MAX], l3[MAX].

o Use for loop i from 0 to MAX-1.

§ Declare int number = rand();

§ Initialize all element at index i using l1[i] = l2[i] = l3[i] = number

o Declare int comp1 = 0, assign1 = 0 call to bubbleSort(l1, MAX, comp1, assign1).

o Declare int comp2 = 0, assign2 = 0 call to selectionSort (l1, MAX, comp2, assign2).

o Declare int comp3 = 0, assign3 = 0 call to insertionSort (l1, MAX, comp3, assign3).

o Print the result using cout <<.

Program:

// Objective of programming exercise create 3 identical array of size 5000 using rand().
// sort first using bubbleSort, second using selectionSort, and third using insertionSort
// find number of comparisons and assignment done for array element in each sorting algo.
// print number of comparison and assignment for each three sorting algo.

#include <iostream>
#include <ctime>
#include <cstdlib>

// define macro MAX 5000.
#define MAX 5000

using namespace std;

// bubbleSort().
void bubbleSort(int arr[], int n, int &countComp, int &countAssign)
{
    // for loop i from 0 to n-2.
    for (int i = 0; i < n - 1; i++)
    {
        // for loop j from 0 to n-2-i
        for (int j = 0; j < n - 1 - i; j++)
        {
            // increment comparison count.
            countComp++;
            // comparing adjacent
            if (arr[j] > arr[j + 1])
            {
                // increment assignment count.
                countAssign++;
                // if arr[j] > arr[j+1] then swap.
                swap(arr[j], arr[j + 1]);
            }
        }
    }
}

// selectionSort().
void selectionSort(int arr[], int n, int &countComp, int &countAssign)
{
    // for loop i from 0 to n-2.
    for (int i = 0; i < n - 1; i++)
    {
        // set min_j to i.
        // min_j keep track of minimum element index in array arr[i]...arr[n-1].
        int min_j = i;
        for (int j = i + 1; j < n; j++)
        {
            // increment comparison count.
            countComp++;
            // if arr[j] is less than arr[min_j] .
            if (arr[j] < arr[min_j])
            {
                // increment assignment count.
                countAssign++;
                // assignment j to min_j.
                min_j = j;
            }
        }
        // increment assignment count.
        countAssign++;
        // swap element at index i and min_j
        swap(arr[i], arr[min_j]);
    }
}

// insertionSort().
void insertionSort(int arr[], int n, int &countComp, int &countAssign)
{
    // for loop i from 1 to n-1.
    for (int i = 1; i < n; i++)
    {
        // point is copy of element that has been inserted in sorted array arr[0]...arr[i].
        int point = arr[i + 1];
        // set j  to i-1
        int j = i - 1;
        // while j >= 0 and arr[j] > point.
        while (j >= 0 && arr[j] > point)
        {
            // increment both counter.
            countComp++;
            countAssign++;
            // assignment arr[j+1] = arr[j].
            arr[j + 1] = arr[j];
            // decrement j
            j -= 1;
        }
        // set element at index j+1 to point.
        countAssign++;
        arr[j + 1] = point;
    }
}

int main()
{
    // set seed level of rand() to time(0)
    srand(time(0));
    // create 3 list.
    int l1[MAX], l2[MAX], l3[MAX];

    // fill same random value in list.(create 3 identical array)
    for (int i = 0; i < MAX; i++)
    {
        int number = rand();
        l1[i] = l2[i] = l3[i] = number;
    }

    // call to each sorting function with corresponding list(array) as argument.
    // store each result in pair.
    int comp1 = 0, assign1 = 0;
    bubbleSort(l1, MAX, comp1, assign1);
    int comp2 = 0, assign2 = 0;
    selectionSort(l2, MAX, comp2, assign2);
    int comp3 = 0, assign3 = 0;
    insertionSort(l3, MAX, comp3, assign3);

    // print result.
    cout << "Count Of          "
         << "\tComparison"
         << "\tAssignment" << endl;
    cout << "For Bubble Sort   "
         << "\t" << comp1 << "          " << assign1 << endl;
    cout << "For Selection Sort"
         << "\t" << comp2 << "          " << assign2 << endl;
    cout << "For Insertion Sort"
         << "\t" << comp3 << "          " << assign3 << endl;

    // end.
    return 0;
}

Output:

Image:

Write a program to improve the performance of the bubble sort program | MindTap Computing for Malik's C++ Programming 8th Edition

2022-09-03T13:00:00.004+05:30

Introduction:

a. It was remarked in this chapter that the performance of bubble sort can be improved if we stop the sorting process as soon as we find that in an iteration no swapping of elements takes place. Write a function that implements bubble sort algorithm using this fact. (2)

b. Using the algorithm that you designed in part (a), find the number of iterations that are needed to sort the list: 65, 14, 52, 43, 75, 25, 80, 90, 95. (2)

Write a program to test the function you designed in the above Exercise to improve the performance of bubble sort.

Source: MindTap Computing for Malik's C++ Programming From Problem Analysis to Program Design, 8th Edition, [Instant Access] (8th)-Malik, chapter 16, programming exercises 17.

Solved!

The objective of this program is to improve the performance of the bubble sort function. And test that function.

Program Plan:

· Define the header section.

· Define int bubbleSort(int arr[], int n)

o Declare int countIter = 0

o Use for loop i from 0 to n-2.

§ Declare bool swapped = false

§ Use for loop j from 0 to n-2-i.

· If arr[j] > arr[j + 1] is ture.

o Set swapped = true

o Swap element at index j and j+1 using swap(arr[j], arr[j + 1])

§ If still swapped == false

· Break the loop using break;

· Define int main() function.

o Declare array size int n;

o Take using input using cin >> n;

o Declare array int arr[n];

o Take input for array using for loop with statement cin >> arr[i];

o Declare int countIter = bubbleSort(arr, n)function call.

o Print sorted array using for loop with statement cout << arr[i] << ", "

o Print countIter

Program:

// Object of this program is to improve the performance of the bubbleSort function.

#include <iostream>

using namespace std;

// bubbleSort().
int bubbleSort(int arr[], int n)
{
    // counter for iteration.
    int countIter = 0;
    // use for loop i from 0 to n-2.
    for (int i = 0; i < n - 1; i++)
    {
        // set swapped bool value to false.
        bool swapped = false;
        // increment Iteration counter.
        countIter++;
        // for loop j from 0 to n-2-i.
        for (int j = 0; j < n - 1 - i; j++)
        {
            // check if jth element is greater than j+1th element.
            if (arr[j] > arr[j + 1])
            {
                // set swapped true.
                swapped = true;
                // and swap element.
                swap(arr[j], arr[j + 1]);
            }
        }

        // if swapped is still false.
        if (swapped == false)
        {
            // break the loop.
            break;
        }
    }
    // retrun countIter.
    return countIter;
}

// driver code.
int main()
{
    // take array size as input.
    int n;
    cout << "Enter array size:";
    cin >> n;
    // fill array with n user input.
    int arr[n];
    cout << "Enter " << n << " integers:";
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }

    // call to bubbleSort() and store countIter.
    int countIter = bubbleSort(arr, n);
    // print sorted array.
    cout << "Array is sorted:" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << ", ";
    }
    cout << endl;
    // print needed iteration after to sort array improvement .
    cout << "Number of iteration required to sort array using bubble sort:" << countIter << endl;

    // end.
    return 0;
}

Output:

Image:

Write a function that rearranges a given descending order array into ascending order without using any sorting algorithm

2022-08-29T09:22:00.002+05:30

Introduction:

Suppose that the elements of a list are in descending order and they need to be put in ascending order. Write a C++ function that takes an array of items in descending order and the number of elements in the array as input. The function rearranges the elements of the array in ascending order. Your function must not incorporate any sorting algorithms, that is, no item comparisons should take place.

Source: MindTap Computing for Malik's C++ Programming From Problem Analysis to Program Design, 8th Edition, [Instant Access] (8th)-Malik, chapter 16, programming exercises 18.

Solved!

This program aims to write a function that rearranges a given descending order array into ascending order without using any sorting algorithm.

Program Plan:

·       Define program header.

·       Define rearrange() which take arguments int arr[], int n.

o   For loop i from 0 to n/2.

§ Swap ith and ith last element using swap(arr[i], arr[n - 1 - i]);.

·       Define main() function.

o   Declare int n variable.

o   Use cout << to ask the user to input.

o   Use cin >> n to take user input.

o   Declare array arr[] of size n, this input should be in sorted order.

o   Use for loop to take user input.

o   Make function call rearrange(arr, n);

o   Use for loop to print each element using cout.

Program:

// Object of this program is to write the function
// which rearrange given descending order array into ascending order
// without using any sorting algorithm

#include <iostream>

using namespace std;

// rearrange() function which take array and array size.
void rearrange(int arr[], int n)
{
    // for loop for half value of n.
    // for loop i from 0 to n/2-1.
    for (int i = 0; i < n / 2; i++)
    {
        // swap ith element with ith last element.
        swap(arr[i], arr[n - 1 - i]);
    }
}

// driver function
int main()
{
    // ask array size.
    int n;
    cout << "Enter number of integers:";
    cin >> n;
    // fill array of size n with user input.
    int arr[n];
    cout << "Enter " << n << " integers in descending order:";
    for (int i = 0; i < n; i++)
    {
        // fill each element.
        cin >> arr[i];
    }

    // call to rearrange.
    rearrange(arr, n);
    // print array after rearrangement.
    cout << "Array after rearrangement:";
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << ", ";
    }
    cout << endl;

    // end.
    return 0;
}

Output:

Image:

Recursive Version Of The Binary Search

2022-08-28T09:42:00.002+05:30

Introduction:

The objective of the program is to write a recursive version of the binary search. And write a program to test it.

Source: MindTap Computing for Malik's C++ Programming From Problem Analysis to Program Design, 8th Edition, [Instant Access] (8th)-Malik, chapter 16, programming exercises 19.

Solved!

Program Plan:

·       Define header section.

·       Define binSearch() fuction with parameter int arr[], int left, int right, int key.

o   If left become is greater than right return -1.

o   Declare and Find mid mid = (left + right) / 2.

o   If arr[mid] is key return mid index.

o   Else if arr[mid] > key return function call binSeach(arr, left, mid-1, key) for left array search.

o   Else return function call binSeach(arr, mid + 1, right, key) for righ array search.

·       Define main() function.

o   Declare n.

o   Ask user to input array size.

o   Use cin >> to take input.

o   Declare array arr of size n.

o   Take user input for array for arr.

o   Declare key.

o   Take user input for key.

o   Call to binSearch(arr, 0, n - 1, key) and declare p to store return value.

o   Print result.

Program:

// Object of program is to write recursive version of binary search.

#include <iostream>

using namespace std;

// binSeach() which take arr[], left, right and key as argument.
int binSeach(int arr[], int left, int right, int key)
{
    // if left become is greater than right.
    if (left > right)
    {
        // return -1 (not found)
        return -1;
    }

    // find mid.
    int mid = (left + right) / 2;
    // if arr[mid] is key.
    if (arr[mid] == key)
    {
        // return mid (found at mid index.)
        return mid;
    }
    // arr[mid] > key then
    else if (arr[mid] > key)
    {
        // search left half
        // return call binSeach(arr, left, mid-1, key)
        return binSeach(arr, left, mid - 1, key);
    }
    else
    {
        // search right half
        // return call binSeach(arr, mid+1, right, key)
        return binSeach(arr, mid + 1, right, key);
    }
}

// drive function.
int main()
{
    // declare n array size.
    int n;
    cout << "Enter array size:";
    // ask array size.
    cin >> n;

    // fill array.
    int arr[n];
    cout << "Enter " << n << " number of integers in sorted in ascending order:" << endl;
    // taking user input for each array cell.
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    // declare key.
    int key;
    cout << "Enter key integer you want to seach for in sorted array:";
    // take key to search.
    cin >> key;

    // call to binSeach() with argument arr, 0, n-1, key
    int p = binSeach(arr, 0, n - 1, key);
    // print result.
    if (p == -1)
    {
        cout << "Entered integer not found in array." << endl;
    }
    else
    {
        cout << "Entered integer found in array at index " << p << endl;
    }

    return 0;
}

Output:

Image:

Secant Method Python With Desired Accuracy

2022-02-15T12:03:00.002+05:30

Introduction:

We are given a function and one interval a to b we have to find the solution of function f(x) for which f(x0) = 0.

Why is Secant Method:

We know some equations like quadratic equations and cubic equations are solvable if a solution exists. but for some complex equations solution exists but it is complex to solve them using normal maths.

Secant Method:

Let, f(x) is given, and interval a to b is given. we want to find value of x = x0 where f(x0) = 0.

1) If f(a) * f(b) >= 0:

Solution doesn't exists.

2) Find x using this x = a - f(a) * (b-a) / (f(b)-f(a))

find f(x) for this x.

3) if f(a) * f(x) < 0:

Update b = x

Else if f(x) * f(b) < 0:

Update a = x

Else if f(x) == 0:

x is solution.

Else:

The solution doesn't exist.

4) Repeat steps 2) and 3) until we get desired accuracy.

f(x) = exp(x)+2^(-x) + 2*cos(x)-6 = 0

# f() function which return value of given function.
def f(x):
    # function given in question.
    return exp(x)+2**(-x) + 2*cos(x)-6

secent() function.

# secent() function which takes 4 arguments
# f = function, a and b interval, accuracy for accuracy of result
# return solution to given function.
def secant(f, a, b, accuracy=-1e-5):
    # if f(a)*f(b) >= 0 return None.
    if f(a)*f(b) >= 0:
        return None

    # set an = a.
    an = a
    # set bn = b.
    bn = b
    # index to count iterations.
    i = 0
    # create lest of x variables to store answers for each iterations.
    # which we use to find accuracy of 1e-5 or given.
    x = [-1e10, 1e10]
    # use while loop with this Condition
    # absolute differences of last two x value is greater or equal accuracy.
    # if not then while loop ends.
    while abs(x[-1]-x[-2]) >= accuracy:
        # find xn value.
        xn = an - f(an) * (bn-an) / (f(bn)-f(an))

        # find f value for xn.
        fxn = f(xn)
        # if fan*fxn<0 set bn = xn.
        if f(an)*fxn < 0:
            an = an
            bn = xn
        # elif fxn*fbn<0 set an = xn.
        elif fxn*f(bn) < 0:
            an = xn
            bn = bn
        # if fxn is 0 return xn.
        elif fxn == 0:
            return xn
        # else return None.
        else:
            return None
        # xn append to x.
        x.append(xn)
        # increment i.
        i += 1
    # return xn based on an and bn.
    return an - f(an) * (bn-an) / (f(bn)-f(an))

Printing result:

# print solution.
print("solving : exp(x)+2^(-x) + 2*cos(x)-6 = 0")
for i in range(16):
    # find accuracy
    accuracy = 10**(-i)
    # x value for fx = 0.
    x = secant(f, 1, 2, accuracy)
    # find fx.
    fx = f(x)

    print("x = {:<19}, with {:<6}, givens f(x) = {:<25}".format(x, accuracy, fx))

Please check this tool created by me to convert the number base from 2 to 20 here: number base converter

Output:

Image:

Comment if you have any questions...

Hangman Game Using Python And C++

2022-01-13T15:05:00.004+05:30

Introduction:

Hangman word means man hanging on a string. and rules of games say that man has few numbers of lives to guess the correct word.

We have given any random word from the file of words which can be any hard or easy. if we guess the word in given lives then we saved man's life but if we fail to do so that man will die.

In the next few minutes, you are going to know what really is the hangman game? how to code it in cpp? how to code it in python?

What is hangman game:

We are given a sum n number of lives to save man's life which is currently hanging on a string through the head of the man.

We will try to guess the letter of the word which is hidden for use if we guess wrong letter then given lives are decreased by one. if we fail to guess the whole word in the given number of total lives then our man going to die.

Hangman game in C++:

We are going to implement a hangman game with 7 maximum wrong guesses. which means given lives are 7.

After 7 guesses goes wrong game was finessed and we lost the game. else if we guess the correct word we won the game.

Every time we will be getting a new random number from the file named "words.txt".

First of all import one header file <bits/stdc++.h>

#include <bits/stdc++.h>
using namespace std;

We will use this function random_word() to get the random word. see the implementation of code this will give us the equal probability of getting random word:

// this function returns random word by reading words_1.txt file.
string random_word()
{
    // open file words.txt in input file stream point.
    ifstream words;
    words.open("words.txt");
    // create set of word.
    set<string> words_set;
    string s;
    while (words >> s)
    {
        words_set.insert(s);
    }

    // convert set to vector.
    vector<string> words_array;
    for (auto word : words_set)
    {
        words_array.push_back(word);
    }

    // array size.
    int n = words_array.size();

    // set seed to time(0)
    srand(time(0));

    // random integer in range 0 to n-1.
    int random_int = rand() % n;
    // close words file.
    words.close();
    // return random_word[random_int].
    return words_array[random_int];
}

Our next function will be to print the status of the game if the letter guessed is wrong see this statues printing code below:

// print_status(guesses_done) function print status of game.
void print_status(int guesses_done)
{
    if (guesses_done == 0)
    {
        cout << "+" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "+-------" << endl;
    }
    else if (guesses_done == 1)
    {
        cout << "+----+" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "+-------" << endl;
    }
    else if (guesses_done == 2)
    {
        cout << "+----+" << endl;
        cout << "|    |" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "+-------" << endl;
    }
    else if (guesses_done == 3)
    {
        cout << "+----+" << endl;
        cout << "|    |" << endl;
        cout << "|    o" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "+-------" << endl;
    }
    else if (guesses_done == 4)
    {
        cout << "+----+" << endl;
        cout << "|    |" << endl;
        cout << "|    o" << endl;
        cout << "|    |" << endl;
        cout << "|    |" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "+-------" << endl;
    }
    else if (guesses_done == 5)
    {
        cout << "+----+" << endl;
        cout << "|    |" << endl;
        cout << "|    o" << endl;
        cout << "|   \\|" << endl;
        cout << "|    |" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "+-------" << endl;
    }
    else if (guesses_done == 6)
    {
        cout << "+----+" << endl;
        cout << "|    |" << endl;
        cout << "|    o" << endl;
        cout << "|   \\|/" << endl;
        cout << "|    |" << endl;
        cout << "|" << endl;
        cout << "|" << endl;
        cout << "+-------" << endl;
    }
    else if (guesses_done == 7)
    {
        cout << "+----+" << endl;
        cout << "|    |" << endl;
        cout << "|    o" << endl;
        cout << "|   \\|/" << endl;
        cout << "|    |" << endl;
        cout << "|   /" << endl;
        cout << "|" << endl;
        cout << "+-------" << endl;
    }
    else if (guesses_done >= 8)
    {
        cout << "+----+" << endl;
        cout << "|    |" << endl;
        cout << "|    o" << endl;
        cout << "|   \\|/" << endl;
        cout << "|    |" << endl;
        cout << "|   / \\" << endl;
        cout << "|" << endl;
        cout << "+-------" << endl;
    }
}

We want our program to give feedback to enter letters again if the user inputs the wrong letter or non-letter input for that we create a get letter function to get always a letter from the user. this function recursively returns letters.

// get_letter() which return a letter entered by user.
char get_letter()
{
    // asking for input.
    cout << "Enter the alphabet:";
    // if length of L is 1
    string L;
    cin >> L;
    if (L.size() == 1)
    {
        // return L.
        return L[0];
    }
    else
    {
        // else ask to try again.
        cout << "please try again to input";
        // and recursively return call of get_letter() function.
        return get_letter();
    }
}

Now our main game() function goes here:

In starting of the main function create variables that are needed and call the functions which we have created above when they are needed.

While loop to check guess done is less than max guesses.

If the guess is correct then update guessed word and non-guessed word accordingly.

// game() function which starts game.
void game()
{
    // guesses allocated 7.
    int max_guesses = 7;
    // set guesses_done = 0 to count wrong guesses.
    int guesses_done = 0;

    // get hidden_word;
    string hidden_word = random_word();

    // length of hidden_word.
    int n_length = hidden_word.size();
    // guessed word which tracks guessed letter recode.
    string guessed_word = "";
    for (int i = 0; i < n_length; i++)
    {
        guessed_word += '*';
    }

    // notguessed word which tracks letter recode which are not guessed.
    string notguessing_word = hidden_word;

    // printing total number of guesses use has and length of hidden word.
    cout << "Guess the " << n_length << " letter word " << guessed_word << ", You have " << max_guesses << " guesses." << endl;

    // store guessed letter.
    set<char> guessed_letter;

    // print starting status.
    print_status(guesses_done);

    // run while loop for guesses_done < max_guesses
    while (guesses_done < max_guesses)
    {
        // use get_letter() function to get always letter.
        char guess = get_letter();
        // store copy of guess.
        char copy_guess = guess;
        // find index of letter form notguessed_word list.
        int index_l;
        // checking if letter is found in uppercase or lowercase.
        guess = tolower(guess);
        index_l = notguessing_word.find(guess);
        if (index_l == notguessing_word.npos)
        {
            guess = toupper(guess);
            index_l = notguessing_word.find(guess);
        }
        if (index_l == notguessing_word.npos)
        {
            guess = copy_guess;
        }
        // if guess letter found in notguessing_word.
        if (index_l != notguessing_word.npos)
        {
            for (int i = 0; i < n_length; i++)
            {
                if (notguessing_word[i] == guess)
                {
                    // set guessed_word index_l th element equal to  guess letter.
                    guessed_word[i] = guess;
                    // erase letter form notguessed_word by using '*' character.
                    notguessing_word[i] = '*';
                }
            }
            // print msg of correct guess.
            cout << "Correct guess " << guessed_word << endl;
        }
        else
        {
            // if it is from previously guessed letter.
            if (guessed_letter.find(guess) != guessed_letter.end())
            {
                cout << "letter had been tried before so, not counted as guess." << endl;
            }
            // else
            else
            {
                // print Incorrect msg.
                cout << "Incorrect letter." << endl;
                // count Incorrect guess
                guesses_done++;
                // print status
                print_status(guesses_done);
            }
        }

        // insert upper and lower of guess letter to guessed_letter
        guessed_letter.insert(tolower(guess));
        guessed_letter.insert(toupper(guess));
        // print total remaining guesses.
        cout << " You have " << max_guesses - guesses_done << " guesses." << endl;
        // check if word is complated or not
        // if '*' not in guessed_word then guessing is complated.
        if (guessed_word.find('*') == guessed_word.npos)
        {
            // print won msg.
            cout << "Yes!!! The correct word is " << guessed_word << "! you won the game." << endl;

            // ask to play again.
            string new_game;
            cout << "Do you want to start a new game?(Yes/No):";
            cin >> new_game;
            transform(new_game.begin(), new_game.end(), new_game.begin(), ::tolower);
            if (new_game == "yes")
            {
                cout << "Game is restarted....";
                // if input is yes call recursively game() to restart game.
                game();
                break;
            }
            else
            {
                break;
            }
        }
        // else if guesses_done become max_guesses.
        else if (guesses_done >= max_guesses)
        {
            // print status.
            print_status(guesses_done + 1);
            // print loss msg.
            cout << "No!!! The correct word is " << hidden_word << "! you loss the game." << endl;
            // ask to play again.
            string new_game;
            cout << "Do you want to start a new game?(Yes/No):";
            cin >> new_game;
            transform(new_game.begin(), new_game.end(), new_game.begin(), ::tolower);
            if (new_game == "yes")
            {
                cout << "Game is restarted....";
                // if input is yes call recursively game() to restart game.
                game();
                break;
            }
            else
            {
                break;
            }
        }
    }
}

Call game function from the main function.

// starting point.
int main()
{
    game();
    return 0;
}

Output of C++ program hangman game:

Python program with a different example

import random

# get_letter() function which always return a letter (string of 1 length).
def get_letter():
    # asking for input.
    L = input("Enter the alphabet:")
    # if length of L is 1
    if(len(L) == 1):
        # return L.
        return L
    else:
        # else ask to try again.
        print("please try again to input")
        # and recursively return call of get_letter() function.
        return get_letter()


# return string of status of hangman.
def display_hangman(attempts):
    stages = ["""
                   --------
                   |      |
                   |      O
                   |     \\|/
                   |      |
                   |     / \\
                   -
                   """,
              """
                   --------
                   |      |
                   |      O
                   |     \\|/
                   |      |
                   |
                   -
                   """,
              """
                   --------
                   |      |
                   |      O
                   |     \\|
                   |      |
                   |
                   -
                   """,
              """
                   --------
                   |      |
                   |      O
                   |      |
                   |      |
                   |
                   -
                   """,
              """
                   --------
                   |      |
                   |      O
                   |
                   |
                   |
                   -
                   """,
              """
                   --------
                   |      |
                   |
                   |
                   |
                   |
                   -
                   """
              ]
    return (stages[attempts])

# game() function.
def game():
    # create empty dictionary.
    d = dict()
    d['Animals'] = ['dolphin', 'shark', 'coyote', 'hippopotamus', 'elephant', 'rhinoceros', 'squid', 'cardinal',
                    'wolverine', 'alpaca']
    d['Food'] = ['spaghetti', 'pizza', 'burrito', 'sushi', 'taco', 'cheeseburger', 'bratwurst', 'guacamole',
                 'cheesecake', 'cheesesteak']
    d['Brands'] = ['mcdonalds', 'chevrolet', 'mercedes', 'amazon', 'google', 'delta', 'microsoft', 'disney',
                   'boeing', 'comcast']
    # asking to Choose category.
    category = input('Choose a category: Animals, Food, Brands: ')
    # asking to choose a level
    level = input("Choose a category: first, second, three: ")
    length_by_level = 0
    # if level is first add 5 to length_by_level
    if(level == "first"):
        length_by_level += 5
    # else if level is second add 9 to length_by_level
    elif(level == "second"):
        length_by_level += 9
    # else add 20 to length_by_level
    else:
        length_by_level += 20

    # filter string by length.
    if category == 'Food':
        original_word = random.choice(
            list(filter(lambda x: x.__len__() <= length_by_level, d['Food'])))
    elif category == 'Animals':
        original_word = random.choice(
            list(filter(lambda x: len(x) <= length_by_level, d['Animals'])))
    elif category == 'Brands':
        original_word = random.choice(
            list(filter(lambda x: len(x) <= length_by_level, d['Brands'])))
    else:
        print("Invalid category choice")
        quit()

    # welcome_message
    print("The Hangman Game")
    # copy of hidden_word.
    hidden_word = original_word
    # length of hidden_word
    n_length = len(hidden_word)
    # guesses allocated 5.
    max_guesses = 5
    # guessed word which tracks guessed letter recode.
    guessed_word = list('-'*n_length)
    # notguessed word which tracks letter recode which are not guessed.
    notguessed_word = list(hidden_word)
    # printing total number of guesses use has and length of hidden word.
    print(
        f"Guess the {n_length} letter word {''.join(guessed_word)}, You have {max_guesses} guesses.")
    guesses_done = 0

    # printing hangman here list of string in display_hangman is in reverse order so i have printed it reversely by passing negative index to print appropriately.
    print(display_hangman(-guesses_done-1))

    # run while loop for guesses_done < max_guesses
    while guesses_done < max_guesses:
        # use get_letter() function to get always letter.
        guess = get_letter()

        # if guess is from notguessed_word letter. do this
        if(guess in notguessed_word):
            # find index of letter form notguessed_word list.
            index_l = notguessed_word.index(guess)
            # set guessed_word index_l th element equal to  guess letter.
            guessed_word[index_l] = guess
            # erase letter form notguessed_word by using '-' character.
            notguessed_word[index_l] = '-'
            # print msg of correct guess.
            print(f"Correct guess {''.join(guessed_word)}")

        else:
            # else print msg of Incorrect guess.
            print("Incorrect letter.")
            # count Incorrect guess
            guesses_done += 1
            print(display_hangman(-guesses_done-1))

        # print total remaining guesses.
        print(f" You have {max_guesses - guesses_done} guesses.")

        # check if word is complated or not
        # if '-' not in guessed_word then guessing is complated.
        if('-' not in guessed_word):
            # print won msg.
            print(
                f"Yes!!! The correct word is {hidden_word}! you won the game.")
            # ask to play again.
            new_game = input("Do you want to start a new game?(Yes/No):")
            new_game = new_game.lower()
            if(new_game == 'yes'):
                print("Game is restarted....")
                # if input is yes call recursively game() to restart game.
                game()
                break
            else:
                break

        # else if guesses_done become max_guesses.
        elif(guesses_done >= max_guesses):
            # printing last stage of hangman.
            print(display_hangman(-6))
            # print loss msg.
            print(
                f"No!!! The correct word is {''.join(hidden_word)}! you loss the game.")
            # ask to play again.
            new_game = input("Do you want to start a new game?(Yes/No):")
            new_game = new_game.lower()
            if(new_game == 'yes'):
                print("Game is restarted....")
                # if input is yes call recursively game() to restart game.
                game()
                break
            else:
                break
    # thanks to user.
    print("Thank you for playing Hangman!")


if __name__ == '__main__':
    game()

Output of Python program hangman game:

Find the type of Quadrilateral with given 4 points of the quadrilateral in cpp and python.

C++ code image:

Python code image:

Prove Numpy Is Faster Than Normal List (python)

2022-01-10T19:03:00.013+05:30

Introduction:

We know numpy is the fast and efficient library to process numeric data that we study in every course of python or data science and on the internet but we don't know how fast numpy really is.

But today I will show you how fast numpy is? and why is that fast over normal python? with an example.

In the next few minutes, you are going to know what is numpy? why is numpy faster than normal python? python array vs numpy array. proof of numpy fastness.

What is numpy:

Numpy open-source python library with the additional support of large, multi-dimensional arrays, matrices, and enrich collections of math operations and array operations.

Using numpy we can achieve c nad c++ like the speed of array processing in python that is not possible without numpy.

Numpy is used to perform wide range of operations on large numerical array in efficient way. and I will prove that in the next section.

Why is numpy faster than python list and how numpy different from python list?

In numpy when we create the numpy array then numpy will allocate contiguous memory block of the array which is different from the python list structure. In python list, it is linked list like structure of small memory blocks each of that can store the only unit amount of data on it.

Numpy array structure is the sequence of memory locations in the disk and python list is collection of the clustered memory locations in the disk.

Memory access in numpy is faster due to the contiguous block of the memory location. Reading and writing of data in memory become easy and fast in numpy arrays. But in the case of numpy list, all memory blocks (segments) are scattered in memory so accessing a particular memory location is hard and slow in python list.

Python list is flexible and numpy array is fast.

Numpy is so fast because it uses a highly optimized library for matrix operations called the BLAS library. This library is written in Fortran and is used in many scientific computing packages. BLAS stands for Basic Linear Algebra Subprograms and is used to perform basic linear algebra operations like matrix multiplication, addition, and subtraction. Additionally, numpy makes use of vectorization and other optimizations that reduce the amount of code needed to perform operations on matrices, drastically reducing the amount of time needed to perform calculations.

proof of numpy fastness:

Example:

I have created two functions with the same input and same output but different implementations.

If our input is n = 6 then the output will be:

for n = 8 output will be:

In short, we are creating a pascal triangle inside the two-dimensional array of size n x n.

Both functions take n number as an argument and return a numpy array of size n x n.

Importing needed libraries:

# import numpy and time .
import numpy as np
import time
import matplotlib.pyplot as plt

function1:

We will be going to implement an addition operation using for loop on created numpy array of size n x n.

function1:

# function1() which return numpy array of n x n size filled with pascal triangle.
# using two for loop
def function1(n):
    # create array of size n x n filled with 0.
    arr = np.zeros((n, n),dtype=np.int32)
    # iterate i using  for loop from 1 to n-1
    for i in range(1,n):
        # set first element to i.
        arr[i][0] = i
        # iterate using j for loop from 1 to n-1
        for j in range(1,n):
            # fill arr[i][j] with value of arr[i-1][j-1] + arr[i-1][j]
            arr[i][j] = arr[i-1][j-1] + arr[i-1][j]
    # return array.
    return arr

function2:

We will be going to implement an addition operation using numpy array addition on created numpy array of size n x n.

function2:

# function2() which return numpy array of n x n size filled with pascal triangle.
# using one for loop with numpy vectorization
def function2(n):
    # create array of size n x n filled with 0.
    arr = np.zeros((n, n),dtype=np.int32)
    # iterate i using for loop from 1 to n-1.
    for i in range(1, n):
        # set first element to i.
        arr[i][0] = i
        # create addition array with addition of every arr[i-1][j-1] with arr[i-1][j]
        addition = arr[i-1][0:n-1]+arr[i-1][1:n]
        # add 0 to first index to reach size of n.
        addition = np.insert(addition, 0, 0)
        # add it to arr[i].
        arr[i] = arr[i] + addition
    # return array.
    return arr

Testing of function1 and function2:

Counting time:

Now, we are going to count time required for specific input not for n = 6 not for n = 8 but for n from [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096].

These are numbers that can be generated by simply placing 2's power 0 to 12.

we will count time using the start time and end time as before and after calling functions and with different of them we will find the required time.

For function1:

# list to store execution time.
function1_execution_time = []
# N size.
Ni = 1
for i in range(13):
    # start time.
    start_time = time.time()
    # calling function1()
    function1(Ni)
    # end time.
    end_time = time.time()
    # append difference.
    function1_execution_time.append(end_time - start_time)
    # multiply Ni by 2.
    Ni*=2
    
function1_execution_time

Output for function1:

For function2:

# same as above.
function2_execution_time = []
Ni = 1

for i in range(13):
    start_time = time.time()
    # calling function2()
    function2(Ni)
    end_time = time.time()
    function2_execution_time.append(end_time - start_time)
    Ni*=2

function2_execution_time

Output for function2:

We can see from the above two outputs that function1 time is increasing exponentially with inputs power of 2 as compared to function2.

Plotting:

The latest plot is the graph of the time required for one call vs input power of 2.

# ploting.
plt.figure(figsize=(16,9))
# first line for function1.
plt.plot(x,function1_execution_time,label="normal for loop",marker="o")
# second line for function2.
plt.plot(x,function2_execution_time,label="numpy array operation",marker="o")
# seting label and title
plt.xlabel("array size N")
plt.ylabel("execution time in second")
plt.title("Execution time for two function which does same thing in different ways.")
# set x ticks to x array(size of input.).
plt.xticks(x)
# show legend and plot.
plt.legend()
plt.show()

Output:

Conclusion:

With the numpy, we can achieve efficiency and code simplicity in over-program or software. And we can perform large size of array operations efficiently.

Please check this tool created by me to convert the number base from 2 to 20 here: number base converter

Hangman game in cpp and python

Complete code:

Number Converter Calculator

2022-01-08T14:38:00.029+05:30

To convert in 4 main systems:

To convert in 2 to 20 base number system:

Try it:

Number Converter Calculator

open in new tab

Find the type of Quadrilateral with given 4 points of the quadrilateral in cpp and python.

2022-01-06T15:00:00.030+05:30

Given quadrilateral:

You are only given 4 points of the quadrilaterals.

question is how can you find the type of given quadrilateral.

here, points input is in clock wish direction from a,b,c to d.

Explanation:

First of all, we are trying to find all measure angles and edges weights.

Use the formula below to find the weights of edges.

Use the formula below which references to triangle below to find the measure angles of quadrilaterals.

Here we need to find Diagonal ac and bd given in the image of the quadrilateral.

Now using conditions we can easily find which type of quadrilateral we have.

Code in python Image:

python Cpp:

import math

if __name__ == "__main__":
    print("Enter 4 point coordinates of quadrilateral separated by space in sequence:")
    # array
    # read 8 number
    points = list(map(int,input().split()))    

    # create separate variable for coordinates
    xa = points[0]
    ya = points[1]
    xb = points[2]
    yb = points[3]
    xc = points[4]
    yc = points[5]
    xd = points[6]
    yd = points[7]

    # edge of quadrilateral using edge formula
    # finding edge using distance formula.
    a = math.sqrt((xb - xa) * (xb - xa) + (yb - ya) * (yb - ya))
    b = math.sqrt((xc - xb) * (xc - xb) + (yc - yb) * (yc - yb))
    c = math.sqrt((xd - xc) * (xd - xc) + (yd - yc) * (yd - yc))
    d = math.sqrt((xa - xd) * (xa - xd) + (ya - yd) * (ya - yd))

    # diagonal of quadrilateral
    # find diagonals.
    diagonal_ac = math.sqrt((xc - xa) * (xc - xa) + (yc - ya) * (yc - ya))
    diagonal_bd = math.sqrt((xd - xb) * (xd - xb) + (yd - yb) * (yd - yb))

    # angles
    # angles of quadrilateral
    # find angle using angle formula.
    A = math.acos((a * a + d * d - diagonal_bd * diagonal_bd) / (2 * a * d))
    B = math.acos((b * b + a * a - diagonal_ac * diagonal_ac) / (2 * b * a))
    C = math.acos((c * c + b * b - diagonal_bd * diagonal_bd) / (2 * c * b))
    D = math.acos((d * d + c * c - diagonal_ac * diagonal_ac) / (2 * d * c))

    # result.
    # if angles are equal means(90*)
    if (A == B and A == C and A == D):
    
        # if edge size are equal
        if (a == b and a == c and a == d):
            # square
            print("Quadrilateral is square...\n")
            print("area of square :", a * a)
        
        # else
        else:
            # rectangular
            print("Quadrilateral is rectangular...\n")
            print("area of square :", a * b)
        
    
    # angles are not equal but edges are equal
    elif (a == b and a == c and a == d):
        # diamond
        print("Quadrilateral is diamond(Rhombus)...\n")
    
    # opposite edges(sides) are equal
    elif (a == c and b == d):
        # parallelogram
        print("Quadrilateral is parallelogram...")
    
    else:
        print("Quadrilateral is just a quadrilateral...\n")
    

Code in cpp Image:

Code Cpp:

// for input and output:
#include <iostream>
// for math function cos inverse.
#include <cmath>

// namespace.
using namespace std;

// driver
int main()
{
    // array
    int points[8];
    printf("Enter 4 point coordinates of quadrilateral separated by space in sequence:");
    // read 8 number
    for (int i = 0; i < 8; i++)
    {
        cin >> points[i];
    }

    // create separate variable for coordinates
    int xa, ya, xb, yb, xc, yc, xd, yd;
    xa = points[0], ya = points[1];
    xb = points[2], yb = points[3];
    xc = points[4], yc = points[5];
    xd = points[6], yd = points[7];

    // edge of quadrilateral using edge formula
    float a, b, c, d;
    // finding edge using distance formula.
    a = sqrt((xb - xa) * (xb - xa) + (yb - ya) * (yb - ya));
    b = sqrt((xc - xb) * (xc - xb) + (yc - yb) * (yc - yb));
    c = sqrt((xd - xc) * (xd - xc) + (yd - yc) * (yd - yc));
    d = sqrt((xa - xd) * (xa - xd) + (ya - yd) * (ya - yd));

    // diagonal of quadrilateral
    // find diagonals.
    float diagonal_ac = sqrt((xc - xa) * (xc - xa) + (yc - ya) * (yc - ya));
    float diagonal_bd = sqrt((xd - xb) * (xd - xb) + (yd - yb) * (yd - yb));

    // angles
    float A, B, C, D; // angles of quadrilateral
    // find angle using angle formula.
    A = acos((a * a + d * d - diagonal_bd * diagonal_bd) / (2 * a * d));
    B = acos((b * b + a * a - diagonal_ac * diagonal_ac) / (2 * b * a));
    C = acos((c * c + b * b - diagonal_bd * diagonal_bd) / (2 * c * b));
    D = acos((d * d + c * c - diagonal_ac * diagonal_ac) / (2 * d * c));

    // result.
    // if angles are equal means(90*)
    if (A == B && A == C && A == D)
    {
        // if edge size are equal
        if (a == b && a == c && a == d)
        {
            // square
            printf("Quadrilateral is square...\n");
            printf("area of square : %f", a * a);
        }
        // else
        else
        {
            // rectangular
            printf("Quadrilateral is rectangular...\n");
            printf("area of square : %f", a * b);
        }
    }
    // angles are not equal but edges are equal
    else if (a == b && a == c && a == d)
    {
        // diamond
        printf("Quadrilateral is diamond(Rhombus)...\n");
    }
    // opposite edges(sides) are equal
    else if (a == c && b == d)
    {
        // parallelogram
        printf("Quadrilateral is parallelogram...");
    }
    else
    {
        printf("Quadrilateral is just a quadrilateral...\n");
    }
    return 0;
}

Input:

here inputed points are (1,1), (1,0), (0,0) and (0,1).

output:

Read also:

Python string-formatting best example.

Creating header file in cpp.

python string formatting example with the explanation

2021-09-01T18:11:00.005+05:30

Preview what we going to learn:

Write a program in Python using the following scenario:

Your customer is a restaurant owner that wants to be able to advertise online in chat rooms, but they have an ever-changing menu. Write a program in Python that will prompt the user for the name of a restaurant, three menu items, and their prices. See example input and output below.

This is the solution to the assignment which you can download here.

Example:

Input:

Famous Bill's Eatery
BLT Sandwich
11.99
Fries
1.49
Drink
1.19

Output:

Python code:

# max len 25
restaurant = input()
# item 1
# max len 12
item1 = input()
# max 99.99
item1_price = float(input())
# item 2
item2 = input()
item2_price = float(input())
# item 3
item3 = input()
item3_price = float(input())
# size of display 33 
br = '*'*33

print()
print(br)

a = "{}{:^25}{}".format('*'*4, restaurant, '*'*4)
print(a)

print(br)

b = "* "+"{:<23}".format(item1)+"{:>6}".format('$'+str(item1_price))+" *"
print(b)

c = "* "+"{:<23}".format(item2)+"{:>6}".format('$'+str(item2_price))+" *"
print(c)

d = "* "+"{:<23}".format(item3)+"{:>6}".format('$'+str(item3_price))+" *"
print(d)

print(br)

Terminal output and input:

Explanation:

There are many ways to solve this problem but we can use string formatting in python to do this task accurately.

Example:

s = "{} and {} and {}".format(1,2,3)

var = "string"
s = "this is a {}".format(var)

These are normal examples of string formatting.

printing output:

br = '*'*33
print(br)

This print ‘*’ 33 times in the first row.

a = "{}{:^25}{}".format('*'*4, restaurant, '*'*4)
print(a)

Here “{:^25}”.format(restaurant) formats string and create 25 length string with restaurant name in the center-aligned of the string.

b = "* "+"{:<23}".format(item1)+"{:>6}".format('$'+str(item1_price))+" *"
print(b)

Here “{:<23}”.format(item1) formats string and create 23 length string with item1 value left-aligned.

and Here “{:>6}”.format(item1_price) formats string and create 6 length string with item1_price value right-aligned.

Repeat this step for item 2 and 3:

c = "* "+"{:<23}".format(item2)+"{:>6}".format('$'+str(item2_price))+" *"
print(c)

d = "* "+"{:<23}".format(item3)+"{:>6}".format('$'+str(item3_price))+" *"
print(d)

print(br)

This is the end of the display.

These are python articles you like...:

Image of code:

how to create own header files in cpp? and inside, header files how to create functions and objects and also use them?

2021-09-01T17:09:00.006+05:30

Preview what we going to learn:

This is also the solution to this assignment you can download this file.

Here 3 files are created date.hpp, date.cpp, and main.cpp:

date.hpp

#include <string>
#include <ctime>
using namespace std;
 
#ifndef DATE_H // This definition  protect the header against
#define DATE_H // multiple inclusions.
 
class Date // date class
{
private:           // Data fields
    int day = 0;   //day
    int month = 0; //month
    int year = 0;  // year
 
public:
    // constructor
    Date();
    // constructor for seting value at declartion time in d/m/y form.
    Date(int d, int m, int y);
 
    // data seting mathod for Date to d/m/y.
    void DateSet(int d, int m, int y);
 
    int DateDay();   // accessing mathod for Day.
    int DateMonth(); // accessing mathod for Month.
    int DateYear();  // accessing mathod for Year.
 
    string ToString(); // returns string form of date.
    void DatePrint();  // prints Date.
};
 
Date DateNow(); // accessing todays date.
 
#endif

#ifndef DATE_H

#define DATE_H

// our code.

#endif

Using In this method we can protect the header against multiple inclusions.
date.hpp file only contain declarations.

Declarations in Date class

class Date // date class
{
private:           // Data fields
    int day = 0;   //day
    int month = 0; //month
    int year = 0;  // year

public:
    // constructor
    Date();
    // constructor for seting value at declartion time in d/m/y form.
    Date(int d, int m, int y);

    // data seting mathod for Date to d/m/y.
    void DateSet(int d, int m, int y);

    int DateDay();   // accessing mathod for Day.
    int DateMonth(); // accessing mathod for Month.
    int DateYear();  // accessing mathod for Year.

    string ToString(); // returns string form of date.
    void DatePrint();  // prints Date.
};

We declare a function DateNow() out of class

Date DateNow(); // accessing todays date.

date.cpp

#include <iostream>
#include <string>
#include <ctime> // header for accessing current time.
#include "date.hpp"
using namespace std;
 
//All implimentation of "date.hpp" is here:
 
// function to convert date in to string form
string Date::ToString()
{
    string s = "";
    s += to_string(day);
    s += '/' + to_string(month);
    s += '/' + to_string(year);
    return s;
}
 
// Default constructor.
Date::Date()
{
    DateSet(0, 0, 0);
}
 
// constructor for setting value at declartion time.
Date::Date(int d, int m, int y)
{
    DateSet(d, m, y);
}
 
// method for setting value of date object.
void Date::DateSet(int d, int m, int y)
{
    day = d;
    month = m;
    year = y;
}
 
// mathod for access day.
int Date::DateDay()
{
    return day;
}
 
// mathod for access month.
int Date::DateMonth()
{
    return month;
}
 

// mathod for access year.
int Date::DateYear()
{
    return year;
}
 
// mathod for printing date.
void Date::DatePrint()
{
    cout << ToString() << endl;
}
 
// function for creating date object of today's date.
Date DateNow()
{
    // Default value.
    Date d(1, 1, 1970);
 
    time_t t = time(0L); // Stores the current time in t.
 
    if (t == (time_t)(-1))
    {
        return d;
    }
 
    tm *tp;             // In C this would have been struct tm
    tp = localtime(&t); // Turns t into a tm structure
 
    // setting date.
    // Perversely, months are 0-11
    // The tm structure uses 2-digit years
    d.DateSet(tp->tm_mday, tp->tm_mon + 1, tp->tm_year + 1900);
 
    // return object
    return d;
}
 
 

All setter and getter methods of class Date are implemented here.
You can see comments on the code for details.

main.cpp

#include <iostream>
#include <string>
#include "date.hpp"
#include "date.cpp"
#include "date.hpp"
using namespace std;
 
// driver code
int main()
{
    // testing constructor.
    Date d(20, 6, 2021);// d object is created. 
 
    // testing setter method.
    Date v;
    v.DateSet(19, 6, 2021);
 
    // testing of DatePrint();
    cout << "\nd:";
    d.DatePrint();
 
    cout << "v:";
    v.DatePrint();
 
    // testing getter mathod.
    cout << "\nValues of date v :" << endl;
    cout << "v.day  :" << v.DateDay() << endl;
    cout << "v.month:" << v.DateMonth() << endl;
    cout << "v.year :" << v.DateYear() << endl;
 
    // testing ToString() mathod.
    cout << "\nString form of date v :" << v.ToString() << endl;
 
    // testing DateNow() function which gives todays date.
    Date today = DateNow();
    cout << "\nTodays Date :" << today.ToString() << endl;
    return 0;
}

Testing of all methods of an object, Date is done here.

Output

all code Images:

data.hpp

data.cpp

main.cpp

Queries For Finding Sum Between Two Cells Of 3D Integers Array.

2021-08-06T11:24:00.005+05:30

prerequisite: Prefix Sum – 3D

Given a 3-Dimensional array of integers A[L][R][C]. where L, R, and C are dimensions of the array (Layer, Row, Column). there are large number of queries to find the sum of integers between given cells inclusively. (find the sum of sub 3d array of the given array).

similar articles for 2d array matrix: Submatrix Sum Queries

The total number of Queries is Q. Each query consist of 6 integers k1,i1,j1,k2,i2,j2 indexes of array, and you have to answer sum of integers between A[k1][i1][j1] and A[k2][i2][j2] inclusively.

Example:

Input:
array:
int A[L][R][C] = {
    {{1, 1, 1, 1}, // Layer 1
        {1, 1, 1, 1},
        {1, 1, 1, 1},
        {1, 1, 1, 1}},

    {{1, 1, 1, 1}, // Layer 2
        {1, 1, 1, 1},
        {1, 1, 1, 1},
        {1, 1, 1, 1}},

    {{1, 1, 1, 1}, // Layer 3
        {1, 1, 1, 1},
        {1, 1, 1, 1},
        {1, 1, 1, 1}},

    {{1, 1, 1, 1}, // Layer 4
        {1, 1, 1, 1},
        {1, 1, 1, 1},
        {1, 1, 1, 1}}
};	
Queries:
query = {
        {0, 0, 0, 1, 1, 1},
        {1, 1, 1, 3, 3, 3},
        {0, 1, 1, 3, 3, 3},
        {0, 0, 0, 3, 3, 3}
    };

All Query is in form of k1,i1,j1,k2,i2,j2.
here 4 query are given.

Output:
Query 1 : 8
Query 2 : 27
Query 3 : 36
Query 4 : 64

Approach:

First of all, calculate the prefix sum of given array A[L][R][C].
and then collect indexes of two given cells from the query array.
store prefix sum up to A[k2][i2][j2].

// store prefix sum up to A[k2][i2][j2]:
int sum = pre[k2][i2][j2];

apply following operations using if conditions to remove unnecessary cells and remove overlapping.

// unnecessary cells and overlaping removal steps
// using if conditions :
if (j1 > 0)
{
    sum -= pre[k2][i2][j1 - 1];
}
if (k1 > 0)
{
    sum -= pre[k1 - 1][i2][j2];
}
if (i1 > 0)
{
    sum -= pre[k2][i1 - 1][j2];
}

if (k1 > 0 && i1 > 0)
{
    sum += pre[0][0][j2];
}
if (i1 > 0 && j1 > 0)
{
    sum += pre[k2][0][0];
}
if (j1 > 0 && k1 > 0)
{
    sum += pre[0][i2][0];
}

if (k1 > 0 && i1 > 0 && j1 > 0)
{
    sum -= pre[k1 - 1][i1 - 1][j1 - 1];
}

Implementation:
All calculation of prefix sum is taken from prefix sum of 3d array.
C++ Implementation:
// C++ program for the above approach.
#include <bits/stdc++.h>
using namespace std;

// Declaring size of the array
#define L 4 // Layer
#define R 4 // Row
#define C 4 // Column

// Calculating prefix sum array
void prefixSum3d(int A[L][R][C], int pre[L][R][C])
{
    // Step 0:
    pre[0][0][0] = A[0][0][0];

    // Step 1: Filling the first row,
    // column, and pile of ceils.
    // Using prefix sum of 1d array
    for (int i = 1; i < L; i++)
        pre[i][0][0] = pre[i - 1][0][0] + A[i][0][0];

    for (int i = 1; i < R; i++)
        pre[0][i][0] = pre[0][i - 1][0] + A[0][i][0];

    for (int i = 1; i < C; i++)
        pre[0][0][i] = pre[0][0][i - 1] + A[0][0][i];

    // Step 2: Filling the cells
    // of sides(made up using cells)
    // which have common element A[0][0][0].
    // using prefix sum on 2d array
    for (int k = 1; k < L; k++)
    {
        for (int i = 1; i < R; i++)
        {
            pre[k][i][0] = A[k][i][0] + pre[k - 1][i][0] + pre[k][i - 1][0] - pre[k - 1][i - 1][0];
        }
    }
    for (int i = 1; i < R; i++)
    {
        for (int j = 1; j < C; j++)
        {
            pre[0][i][j] = A[0][i][j] + pre[0][i - 1][j] + pre[0][i][j - 1] - pre[0][i - 1][j - 1];
        }
    }
    for (int j = 1; j < C; j++)
    {
        for (int k = 1; k < L; k++)
        {
            pre[k][0][j] = A[k][0][j] + pre[k - 1][0][j] + pre[k][0][j - 1] - pre[k - 1][0][j - 1];
        }
    }

    // Step 3: Filling value
    // in remaining cells using formula
    for (int k = 1; k < L; k++)
    {
        for (int i = 1; i < R; i++)
        {
            for (int j = 1; j < C; j++)
            {
                pre[k][i][j] = A[k][i][j]

                               + pre[k - 1][i][j] + pre[k][i - 1][j] + pre[k][i][j - 1]

                               - pre[k - 1][i - 1][j] - pre[k][i - 1][j - 1] - pre[k - 1][i][j - 1]

                               + pre[k - 1][i - 1][j - 1];
            }
        }
    }
    // we don't have to return pre array because
    // pre array is passed by reference
}

// Driver Code
int main()
{
    // given array:
    int A[L][R][C] = {
        {{1, 1, 1, 1}, // Layer 1
         {1, 1, 1, 1},
         {1, 1, 1, 1},
         {1, 1, 1, 1}},

        {{1, 1, 1, 1}, // Layer 2
         {1, 1, 1, 1},
         {1, 1, 1, 1},
         {1, 1, 1, 1}},

        {{1, 1, 1, 1}, // Layer 3
         {1, 1, 1, 1},
         {1, 1, 1, 1},
         {1, 1, 1, 1}},

        {{1, 1, 1, 1}, // Layer 4
         {1, 1, 1, 1},
         {1, 1, 1, 1},
         {1, 1, 1, 1}}};

    // given queries:
    vector<vector<int>> query = {
        {0, 0, 0, 1, 1, 1},
        {1, 1, 1, 3, 3, 3},
        {0, 1, 1, 3, 3, 3},
        {0, 0, 0, 3, 3, 3}};
    int Q = query.size();

    int pre[L][R][C];
    prefixSum3d(A, pre);

    for (int i = 0; i < Q; i++)
    {
        // collect indexes of two given cells from the query array:
        int k1 = query[i][0], i1 = query[i][1], j1 = query[i][2];
        int k2 = query[i][3], i2 = query[i][4], j2 = query[i][5];

        // store prefix sum up to A[k2][i2][j2]:
        int sum = pre[k2][i2][j2];

        // unnecessary cells and overlaping removal steps
        // using if conditions :
        if (j1 > 0)
        {
            sum -= pre[k2][i2][j1 - 1];
        }
        if (k1 > 0)
        {
            sum -= pre[k1 - 1][i2][j2];
        }
        if (i1 > 0)
        {
            sum -= pre[k2][i1 - 1][j2];
        }

        if (k1 > 0 && i1 > 0)
        {
            sum += pre[0][0][j2];
        }
        if (i1 > 0 && j1 > 0)
        {
            sum += pre[k2][0][0];
        }
        if (j1 > 0 && k1 > 0)
        {
            sum += pre[0][i2][0];
        }

        if (k1 > 0 && i1 > 0 && j1 > 0)
        {
            sum -= pre[k1 - 1][i1 - 1][j1 - 1];
        }
        // printing answer:
        cout << "Query " << i + 1 << " : ";
        cout << sum << endl;
    }

    return 0;
}



Python Implementation:
# python program to calculate prefix sum of 3d array
# Declaring size of the array
L = 4  # Layer
R = 4  # Row
C = 4  # Column

# Calculating prefix


def prefixSum3d(A):

    pre = [[[0 for a in range(C)]
            for b in range(R)]
           for d in range(L)]

    pre[0][0][0] = A[0][0][0]

    # Step 1: Filling the first row,column, and pile of ceils.
    # Using prefix sum of 1d array
    for i in range(1, L):
        pre[i][0][0] = pre[i - 1][0][0] + A[i][0][0]

    for i in range(1, R):
        pre[0][i][0] = pre[0][i - 1][0] + A[0][i][0]

    for i in range(1, C):
        pre[0][0][i] = pre[0][0][i - 1] + A[0][0][i]

    # Step 2: Filling the cells of sides(made up using cells)
    # which have common element A[0][0][0].
    # using prefix sum on 2d array
    for k in range(1, L):
        for i in range(1, R):
            pre[k][i][0] = (A[k][i][0] + pre[k - 1][i][0] + pre[k][i - 1][0]
                            - pre[k - 1][i - 1][0])
    for i in range(1, R):
        for j in range(1, C):
            pre[0][i][j] = (A[0][i][j] + pre[0][i - 1][j] + pre[0][i][j - 1]
                            - pre[0][i - 1][j - 1])
    for j in range(1, C):
        for k in range(1, L):
            pre[k][0][j] = (A[k][0][j] + pre[k - 1][0][j] + pre[k][0][j - 1]
                            - pre[k - 1][0][j - 1])

    # Step 3: Filling value in remaining cells using formula
    for k in range(1, L):
        for i in range(1, R):
            for j in range(1, C):
                pre[k][i][j] = (A[k][i][j]

                                + pre[k - 1][i][j]
                                + pre[k][i - 1][j]
                                + pre[k][i][j - 1]

                                - pre[k - 1][i - 1][j]
                                - pre[k][i - 1][j - 1]
                                - pre[k - 1][i][j - 1]

                                + pre[k - 1][i - 1][j - 1])

    return pre


# Driver program to test above function
# given array:
A = [
    [[1, 1, 1, 1],  # Layer 1
     [1, 1, 1, 1],
     [1, 1, 1, 1],
     [1, 1, 1, 1]],

    [[1, 1, 1, 1],  # Layer 2
     [1, 1, 1, 1],
     [1, 1, 1, 1],
     [1, 1, 1, 1]],

    [[1, 1, 1, 1],  # Layer 3
     [1, 1, 1, 1],
     [1, 1, 1, 1],
     [1, 1, 1, 1]],

    [[1, 1, 1, 1],  # Layer 4
     [1, 1, 1, 1],
     [1, 1, 1, 1],
     [1, 1, 1, 1]]
]
# given queries:
query = [
    [0, 0, 0, 1, 1, 1],
    [1, 1, 1, 3, 3, 3],
    [0, 1, 1, 3, 3, 3],
    [0, 0, 0, 3, 3, 3]
]
Q = len(query)

# calculating prefix sum:
pre = prefixSum3d(A)

# calculating answer for each query:
for i in range(Q):
    # collect indexes of two given cells from the query array:
    k1 = query[i][0]
    i1 = query[i][1]
    j1 = query[i][2]
    k2 = query[i][3]
    i2 = query[i][4]
    j2 = query[i][5]

    # store prefix sum up to A[k2][i2][j2]
    sum = pre[k2][i2][j2]

    # overlaping removal steps using if conditions :
    if j1 > 0:
        sum -= pre[k2][i2][j1-1]
    if k1 > 0:
        sum -= pre[k1-1][i2][j2]
    if i1 > 0:
        sum -= pre[k2][i1-1][j2]

    if k1 > 0 and i1 > 0:
        sum += pre[0][0][j2]
    if i1 > 0 and j1 > 0:
        sum += pre[k2][0][0]
    if j1 > 0 and k1 > 0:
        sum += pre[0][i2][0]

    if k1 > 0 and i1 > 0 and j1 > 0:
        sum -= pre[k1-1][i1-1][j1-1]

    # printing answer:
    print("Query", i+1, end=" : ")
    print(sum)



Complexity:
Prefix sum: 
Time Complexity: O(L*R*C)  
Auxiliary Space: O(L*R*C)
Query:
Here all Query Answer takes O(1) Time, the total time complexity is O(Q).
and space required is O(Q*6).
Time Complexity: O(Q)
Auxiliary Space: O(Q)
Final Complexity:
Time Complexity: O(L*R*C+Q)  
Auxiliary Space: O(L*R*C+Q)
C++ image:

Python image:

Read also:
python string formatting best example with the best explanation
how to create own header files in cpp? and inside, header files how to create functions and objects and also use them?

All Sorting Algorithm Implementation in Python

2021-07-28T13:11:00.005+05:30

Here you can find all Implementation of sorting algorithms in python which sorts the array in Increasing Order (Ascending Order).

Bubble sort:
Insertion sort:
Selection sort:
Merge sort:

Read Also:All Sorting Algorithm In C++

Bubble Sort:

Implementation:

# python implementation of Bubble sort

# Bubble Sort function
def bubble_sort(arr, n):
    # iterate i from 0 to n-1
    for i in range(n):
        # variable for checking if swap is done or not
        swapped = 0
        # iterate j form 0 to n-2
        for j in range(n-1):
            # compare two neighbors at j index
            if arr[j] > arr[j + 1]:
                # if first is greater than second then swap element
                # swapping
                arr[j], arr[j+1] = arr[j+1], arr[j]
                # swapping is done
                swapped = 1

        # if swapping is not done then arr is sorted
        # then return function to break for loop
        if swapped == 0:
            return


# Driver code:
arr = [1, 5, 8, 9, 2, 0, 323, 4, 0, 65, 6, 3, 1, 23, 5]
n = len(arr)
bubble_sort(arr, n)

# printing sorted array
print("sorted array")
for i in range(n):
    print(arr[i], end=' ')
print()

Output:

sorted array:
0 0 1 1 2 3 4 5 5 6 8 9 23 65 323

Insertion Sort:

Implementation:

# python implementation of insertion sort

# insertion sort function
def insertion_sort(arr, n):
    # iterate i form 1 to n-1
    for i in range(1, n):
        # here arr[0...i-1] is sorted in every iteration

        # key which we will inserting
        key = arr[i]

        # point to last element of sorted array
        j = i - 1

        # shift elements greater than key
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        # please key element to appropriate please
        arr[j + 1] = key


# Driver code:
arr = [1, 5, 8, 9, 2, 65, 6, 3, 1, 23, 5]
n = len(arr)
insertion_sort(arr, n)

# printing sorted array
print("sorted array")
for i in range(n):
    print(arr[i], end=' ')
print()

Output:

sorted array:
1 1 2 3 5 5 6 8 9 23 65

Selection Sort:

Implementation:

# python implementation of selection sort

# selection sort function
def selection_sort(arr, n):
    # iterate i from 0 to n-2
    for i in range(n-1):
        # consider arr[i...n] array
        min_index = i
        # find min element index
        for j in range(i + 1, n):
            if arr[min_index] > arr[j]:
                min_index = j

        # swapping min element with first element for array.
        arr[i], arr[min_index] = arr[min_index], arr[i]


# Driver code:
arr = [1, 5, 8, 9, 2, 67895, 99999, 6, 3, 1, 23, 5]
n = len(arr)
selection_sort(arr, n)

# printing sorted array
print("sorted array")
for i in range(n):
    print(arr[i], end=' ')
print()

Output:

sorted array:
1 1 2 3 5 5 6 8 9 23 67895 99999

Merge Sort:

Implementation:

# python program for merge sort

# Merge to subarray of array
# first_array = array[start..mid]
# second_array = array[mid+1..end]
def Merge(array, start, mid, end):
    # creating to temp subarray
    first_array = []
    second_array = []

    # copy first_array
    for i in range(start, mid+1):
        first_array.append(array[i])

    # copy second_array
    for i in range(mid + 1, end+1):
        second_array.append(array[i])

    # index reference
    i = 0                        # for first_array
    j = 0                        # for second_array
    main_i = start               # for main array
    size_1 = len(first_array)    # size of first_array
    size_2 = len(second_array)   # size of second_array

    # merge subarray first_array and second_array into array[start..end]
    while i < size_1 and j < size_2:
        if first_array[i] <= second_array[j]:
            array[main_i] = first_array[i]
            i += 1
        else:
            array[main_i] = second_array[j]
            j += 1
        main_i += 1

    # copy remaining element of first_array
    while i < size_1:
        array[main_i] = first_array[i]
        i += 1
        main_i += 1

    # copy remaining element of second_array
    while j < size_2:
        array[main_i] = second_array[j]
        j += 1
        main_i += 1

# main merge Sort function


def mergeSort(array, start, end):
    if start >= end:
        return

    # finding mid point
    mid = start + (end - start) // 2
    # divide
    mergeSort(array, start, mid)
    mergeSort(array, mid + 1, end)

    # conquer
    Merge(array, start, mid, end)


# driver code
# declaring  array
array = [1, 12, 5, 4, 78, 9, 5, 6, 3, 2, 1, 4]
n = len(array)
mergeSort(array, 0, n - 1)
# array is sorted

print("sorted array:")
for i in range(n):
    print(array[i], end=' ')
print()

Output:

sorted array:
1 1 2 3 4 4 5 5 6 9 12 78

Read Also:Merge Sort Algorithm

Image of code:

Bubble sort:

Insertion sort:

Selection sort:

Merge sort:

All Sorting Algorithms Implementation In c++

2021-07-26T17:41:00.041+05:30

All Sorting Algorithms In c++: Best Sorting Algorithm Code in cpp

Here you can find all Implementation of sorting algorithms in c++ which sorts the array in Increasing Order (Ascending Order).

Bubble sort:
Insertion sort:
Selection sort:
Merge sort:

Read Also:All Sorting Algorithm In python

Bubble Sort:

Implementation:

// c++ implementation of Bubble sort
#include <bits/stdc++.h>
using namespace std;

// Bubble Sort function
void bubble_sort(int arr[], int n)
{
    // iterate i from 0 to n-1
    for (int i = 0; i < n; i++)
    {
        // variable for checking if swap is done or not
        int swapped = 0;
        // iterate j form 0 to n-2
        for (int j = 0; j < n - 1; j++)
        {
            // compare two neighbors at j index
            if (arr[j] > arr[j + 1])
            {
                // if first is greater than second then swap element
                int temp;
                // swapping
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;

                // swapping is done
                swapped = 1;
            }
        }

        // if swapping is not done then arr is sorted
        // then return function to break for loop
        if (swapped == 0)
        {
            return;
        }
    }
}

// Driver code:
int main()
{
    int arr[] = {1, 5, 8, 9, 2, 0, 323, 4, 0, 65, 6, 3, 1, 23, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, n);

    // printing sorted array
    cout << "sorted array:" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << ' ';
    }
    cout << endl;

    return 0;
}

Output:

sorted array:
0 0 1 1 2 3 4 5 5 6 8 9 23 65 323

Insertion Sort:

Implementation:

// c++ implementation of insertion sort
#include <bits/stdc++.h>
using namespace std;

// insertion sort function
void insertion_sort(int arr[], int n)
{
    // iterate i form 1 to n-1
    for (int i = 1; i < n; i++)
    {
        // here arr[0...i-1] is sorted in every iteration

        // key which we will inserting
        int key = arr[i];

        // point to last element of sorted array
        int j = i - 1;

        // shift elements greater than key
        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j--;
        }
        // please key element to appropriate please
        arr[j + 1] = key;
    }
}

// Driver code:
int main()
{
    int arr[] = {1, 5, 8, 9, 2, 65, 6, 3, 1, 23, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    insertion_sort(arr, n);

    // printing sorted array
    cout << "sorted array:" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << ' ';
    }
    cout << endl;

    return 0;
}

Output:

sorted array:
1 1 2 3 5 5 6 8 9 23 65

Selection Sort:

Implementation:

// c++ implementation of selection sort
#include <bits/stdc++.h>
using namespace std;

// selection sort function
void selection_sort(int arr[], int n)
{
    // iterate i from 0 to n-2
    for (int i = 0; i < n - 1; i++)
    {
        // consider arr[i...n] array
        int min_index = i;
        // find min element index
        for (int j = i + 1; j < n; j++)
        {
            if (arr[min_index] > arr[j])
            {
                min_index = j;
            }
        }

        // swapping min element with first element for array.
        int temp;
        temp = arr[i];
        arr[i] = arr[min_index];
        arr[min_index] = temp;
    }
}

// Driver code:
int main()
{
    int arr[] = {1, 5, 8, 9, 2, 67895, 99999, 6, 3, 1, 23, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    selection_sort(arr, n);

    // printing sorted array
    cout << "sorted array:" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << ' ';
    }
    cout << endl;

    return 0;
}

Output:

sorted array:
1 1 2 3 5 5 6 8 9 23 67895 99999

Merge Sort:

Implementation:

//c++ program for merge sort
#include <bits/stdc++.h>
using namespace std;

// Merge to subarray of array
// first_array = array[start..mid]
// second_array = array[mid+1..end]
void Merge(vector<int> &array, int start, int mid, int end)
{
    // creating to temp subarray
    vector<int> first_array;
    vector<int> second_array;

    // copy first_array
    for (int i = start; i <= mid; i++)
    {
        first_array.push_back(array[i]);
    }

    // copy second_array
    for (int i = mid + 1; i <= end; i++)
    {
        second_array.push_back(array[i]);
    }

    // index reference
    int i = 0;                        // for first_array
    int j = 0;                        // for second_array
    int main_i = start;               // for main array
    int size_1 = first_array.size();  // size of first_array
    int size_2 = second_array.size(); // size of second_array

    // merge subarray first_array and second_array into array[start..end]
    while (i < size_1 && j < size_2)
    {
        if (first_array[i] <= second_array[j])
        {
            array[main_i] = first_array[i];
            i++;
        }
        else
        {
            array[main_i] = second_array[j];
            j++;
        }
        main_i++;
    }

    // copy remaining element of first_array
    while (i < size_1)
    {
        array[main_i] = first_array[i];
        i++;
        main_i++;
    }

    // copy remaining element of second_array
    while (j < size_2)
    {
        array[main_i] = second_array[j];
        j++;
        main_i++;
    }
}

// main merge Sort function
void merge_sort(vector<int> &array, int start, int end)
{
    if (start >= end)
    {
        return;
    }

    // finding mid point
    int mid = start + (end - start) / 2;
    // divide
    merge_sort(array, start, mid);
    merge_sort(array, mid + 1, end);

    // conquer
    Merge(array, start, mid, end);
}

// driver code
int main()
{
    // declaring  array
    vector<int> array = {1, 12, 5, 4, 78, 9, 5, 6, 3, 2, 1, 4};
    int n = array.size();
    merge_sort(array, 0, n - 1);
    // array is sorted

    cout << "sorted array:" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << array[i] << ' ';
    }
    cout << endl;
}

Output:

sorted array:
1 1 2 3 4 4 5 5 6 9 12 78

Print N Rows of Pascal's Triangle in C++ and Python

2021-07-23T20:14:00.194+05:30

Pascal's triangle

Pascal's triangle is made up of a triangular array filled with binomial coefficients. binomial coefficients occur in binomial expansion. the ith row of pascal's triangle represents coefficients of (a+b)^(i-1) binomial expansion coefficients.

7-row pascal's triangle.

Example:

Input:

 N = 9;

Output:

 pascal's triangle of 9 Rows...
 rows 1 : 1
 rows 2 : 1 1
 rows 3 : 1 2 1
 rows 4 : 1 3 3 1
 rows 5 : 1 4 6 4 1
 rows 6 : 1 5 10 10 5 1
 rows 7 : 1 6 15 20 15 6 1
 rows 8 : 1 7 21 35 35 21 7 1
 rows 9 : 1 8 28 56 70 56 28 8 1

Explanation:

Create two arrays temp[] with no element and arr[] with element equals to 1.

Iterate process N times for N rows.

print arr[]
Add 1 to back of temp[]
Iterate form j = 0 to arr.size()-1 and add arr[j]+arr[j+1] to back of temp[].
Add again 1 to back of temp[]

this process print N rows of Pascal's triangle.

Implementation:

C++ Implementation:

// C++ code for Pascal's Triangle
#include <bits/stdc++.h>
using namespace std;

// printPascal() function for printing pascal's triangle.
void printPascal(int N)
{
    // declaring 2 array
    vector<int> arr = {1}; // current row.
    vector<int> temp;

    cout << "pascal's triangle of " << N << " Rows..." << endl;
    // calculating next rows.
    for (int i = 0; i < N; i++)
    {
        // printing current row.
        cout << "rows " << i + 1 << " : ";
        for (int j = 0; j < arr.size(); j++)
        {
            cout << arr[j] << ' ';
        }
        cout << endl;

        // calculating next rows.
        temp.push_back(1);
        for (int j = 0; j < arr.size() - 1; j++)
        {
            temp.push_back(arr[j] + arr[j + 1]);
        }
        temp.push_back(1);

        // copy next row to current row.
        arr = temp;
        // initialize temp to empty array.
        temp = vector<int>();
    }
}

// Driver code
int main()
{
    int N = 9;
    printPascal(N);
    return 0;
}

Python Implementation:

# python code for Pascal's Triangle
# printPascal() function for printing pascal's triangle.
def printPascal(N):
    # declaring 2 array
    arr = [1]
    temp = []

    print("pascal's triangle of", N, "Rows...")
    # calculating next rows.
    for i in range(N):
        # printing current row.
        print("rows", i+1, end=" : ")
        for j in range(len(arr)):
            print(arr[j], end=' ')
        print()

        # calculating next rows.
        temp.append(1)
        for j in range(len(arr)-1):
            temp.append(arr[j] + arr[j + 1])
        temp.append(1)

        # copy next row to current row.
        arr = temp
        # initialize temp to empty array.
        temp = []


# Driver code
N = 9
printPascal(N)

Output:

pascal's triangle of 9 Rows...
rows 1 : 1
rows 2 : 1 1
rows 3 : 1 2 1
rows 4 : 1 3 3 1
rows 5 : 1 4 6 4 1
rows 6 : 1 5 10 10 5 1
rows 7 : 1 6 15 20 15 6 1
rows 8 : 1 7 21 35 35 21 7 1
rows 9 : 1 8 28 56 70 56 28 8 1

Time Complexity: O(N^2)

Auxiliary Space: O(N)

Read Also:Prefix Sum of 2D Array

Prefix Sum For Array (Cumulative Sum)

2021-07-21T12:45:00.008+05:30

Use:

The prefix sum algorithm is very popular and also used in competitive programming. Mostly used in subarray sum find in constant time.

Problem:

Given an array of integers array[L], where L is the length of the array. you have to compute the prefix sum (prefix array) prefix[L] of array[L]. where prefix[i] represents the sum of all cells between array[0] to array[i] inclusively.

Example:

Input:

array = {1, 2, 3, 4, 5, 6, 7};

Output:

prefix Sum is:

1 3 6 10 15 21 28

Explanation:

First of all, fill the first element of the array as it is.

Then iterate through 1 to L in the array and add the previous element of prefix[] to the coronet element using this formula.

Formula:

prefix[i] = array[i] + prefix[i - 1];

Implementation:

C++ implementation:

// C++ program for prefix sum of array

#include <bits/stdc++.h>

using namespace std;

// computing prefix sum

void prefixSum(vector<int> array)

{

int L = array.size();

vector<int> prefix(L);

// copy first element of array

prefix[0] = array[0];

// previous element to the coronet element

for (int i = 1; i < L; i++)

{

prefix[i] = array[i] + prefix[i - 1];

}

cout << "prefix Sum is:" << endl;

for (int i = 0; i < L; i++)

{

cout << prefix[i] << ' ';

}

cout << endl;

}

// Driver code

int main()

{

vector<int> array = {1, 2, 3, 4, 5, 6, 7};

prefixSum(array);

}

Python implementation:

# python program for prefix sum of array

# computing prefix sum

def prefixSum(array):

L = len(array)

prefix = [0 for i in range(L)]

# copy the first element.

prefix[0] = array[0]

# previous element to the coronet element

for i in range(1, L):

prefix[i] = array[i] + prefix[i - 1]

# Display prefix sum.

print("prefix Sum is:")

for i in range(L):

print(prefix[i], end=' ')

print()

# Driver code

array = [1, 2, 3, 4, 5, 6, 7]

prefixSum(array)

Output:

prefix Sum is:

1 3 6 10 15 21 28

Time Complexity: O(L)

Auxiliary Space: O(L)

where L is the length of the array.

Prefix Sum For 2D Array (Prefix Sum Of Matrix)

2021-07-19T19:55:00.020+05:30

Prefix Sum For 2D Array - Compute Prefix Sum For two Dimensional Array(Prefix Sum Of Matrix).

Given a 2-Dimensional array of integers array[R][C], where R and C are dimensions of the array (Row and Column). Find prefix sum 2d array for it.

Let Prefix sum 3d array be prefix[R][C]. Here prefix[i][j] gives sum of all integers between prefix[0][0] and prefix[i][j] (including both).

Example:

Input:

array[R][C] = {{2, 2, 2, 2},

               {2, 2, 2, 2},

               {2, 2, 2, 2},

               {2, 2, 2, 2}};

given 4x4 size 2-Dimensional  array

Output:

prefix sum is:
2 4 6 8
4 8 12 16
6 12 18 24
8 16 24 32

Image for formula creation.

Explanation:Explanation of formula:

Consider the above image for the formula explanation. if we want to find prefix sum value in a white cell, we have to add the prefix sum of neighbor orange cells and subtract red cells to remove overlappings.

Step 0:

Fill array[0] = prefix[0]

Step 1:

Fill first row and column using prefix sum for 1d array.

check this here for 1d prefix sum: prefix sum for 1d array

Step 2:

Fill all remaining cells using the formula discussed above.

Formula:

prefix[i][j] = array[i][j]
             + prefix[i - 1][j] 
             + prefix[i][j - 1] 
             - prefix[i - 1][j - 1];

Implementation:

C++ Implementation:

// C++ Program to find prefix sum of 2d array
#include <bits/stdc++.h>
using namespace std;

// Declaring size of the array
#define R 4 // Rows
#define C 4 // Columns

// Calculating prefix sum
void prefixSum2d(int array[R][C])
{
    int prefix[R][C];
    // Step 0:
    prefix[0][0] = array[0][0];

    // Step 1: Filling the first row and column
    // using prefix sum for 1d array
    for (int i = 1; i < C; i++)
        prefix[0][i] = prefix[0][i - 1] + array[0][i];

    for (int i = 1; i < R; i++)
        prefix[i][0] = prefix[i - 1][0] + array[i][0];

    // Step 2: Filling value in remaining cells
    // using formula
    for (int i = 1; i < R; i++)
    {
        for (int j = 1; j < C; j++)
        {
            prefix[i][j] = array[i][j]
                         + prefix[i - 1][j] 
                         + prefix[i][j - 1] 
                         - prefix[i - 1][j - 1];
        }
    }

    // Displaying final prefix sum of array
    cout << "prefix sum is:" << endl;
    for (int i = 0; i < R; i++)
    {
        for (int j = 0; j < C; j++)
            cout << prefix[i][j] << " ";
        cout << "\n";
    }
}

// Driver program to test above function
int main()
{
    int array[R][C] = {{2, 2, 2, 2},
                       {2, 2, 2, 2},
                       {2, 2, 2, 2},
                       {2, 2, 2, 2}};

    prefixSum2d(array);
    return 0;
}

Python Implementation:

# python Program to find prefix sum of 2d array

# Declaring size of the array
R = 4 # Rows
C = 4 # Columns

# Calculating prefix sum
def prefixSum2d(array):
    prefix = [[0 for a in range(R)] 
                for b in range(C)]
    # Step 0:
    prefix[0][0] = array[0][0]

    # Step 1: Filling the first row and column
    # using prefix sum for 1d array
    for i in range(1,C):
        prefix[0][i] = prefix[0][i - 1] + array[0][i]

    for i in range(1,R):
        prefix[i][0] = prefix[i - 1][0] + array[i][0]

    # Step 2: Filling value in remaining cells
    # using formula
    for i in range(1,R):
        for j in range(1,C):
            prefix[i][j] = (array[i][j]
                         + prefix[i - 1][j] 
                         + prefix[i][j - 1] 
                         - prefix[i - 1][j - 1])

    # Displaying final prefix sum of array
    print("prefix sum is:")
    for i in range(R):
        for j in range(C): 
            print(prefix[i][j], end=' ')
        print()

# Driver program to test above function
array = [
    [2,2,2,2],
    [2,2,2,2],
    [2,2,2,2],
    [2,2,2,2]
]

prefixSum2d(array)

Output:

prefix sum is:
2 4 6 8
4 8 12 16
6 12 18 24
8 16 24 32

Time Complexity: O(R*C)
Auxiliary Space: O(R*C)

Read more:
check this here for 3D prefix sum: prefix sum for 3D array

Find the type of Quadrilateral with given 4 points of the quadrilateral here.

Hangman game in cpp and python

Prove numpy is faster than normal list

Prefix Sum for 3D Array (Cumulative Sum For Three Dimensional Array).

2021-07-18T19:02:00.013+05:30

Given a 3-Dimensional array of integers A[L][R][C], where L, R, and C are dimensions of the array (Layer, Row, Column). Find prefix sum 3d array for it.

Let Prefix sum 3d array be prefix[L][R][C]. Here prefix[k][i][j] gives sum of all integers between prefix[0][0][0] and prefix[k][i][j] (including both).

Example:

Input:

array[L][R][C] = {

        {{2, 2, 2, 2}, //Layer 1

         {2, 2, 2, 2},

         {2, 2, 2, 2},

         {2, 2, 2, 2}},

        {{2, 2, 2, 2}, //Layer 2

         {2, 2, 2, 2},

         {2, 2, 2, 2},

         {2, 2, 2, 2}},

        {{2, 2, 2, 2}, //Layer 3

         {2, 2, 2, 2},

         {2, 2, 2, 2},

         {2, 2, 2, 2}},

        {{2, 2, 2, 2}, //Layer 4

         {2, 2, 2, 2},

         {2, 2, 2, 2},

         {2, 2, 2, 2}}

};

Output:

Layer 1:
2 4 6 8
4 8 12 16
6 12 18 24
8 16 24 32

Layer 2:
4 8 12 16
8 16 24 32
12 24 36 48
16 32 48 64

Layer 3:
6 12 18 24
12 24 36 48
18 36 54 72
24 48 72 96

Layer 4:
8 16 24 32
16 32 48 64
24 48 72 96
32 64 96 128

Explanation:

Step 0:

Element at (0,0,0) is directly filled.

prefix[0][0][0] = array[0][0][0]

Step 1:

Fill cells of three edges (parallel to x, y, z-axis and made up using cells) using prefix sum on the one-dimensional array.

check this article for 1d prefix sum: prefix sum for 1d array

These edges have common element prefix[0][0][0].

Step 2:

Fill cells of three sides (parallel to xy, yz, zx-plane and made up using cells) using prefix sum on the two-dimensional array.

check this article for 2d prefix sum: prefix sum for 2d array

These sides have common element prefix[0][0][0].

Step 3:

Fill all remaining cells using the general formula.

prefix[k][i][j] = array[k][i][j] 

            + prefix[k - 1][i][j] 
            + prefix[k][i - 1][j] 
            + prefix[k][i][j - 1] 

            - prefix[k - 1][i - 1][j] 
            - prefix[k][i - 1][j - 1] 
            - prefix[k - 1][i][j - 1] 

            + prefix[k - 1][i - 1][j - 1];

Implimentation:

C++ Implimentation:

// C++ program to calculate prefix sum of 3d array
#include <bits/stdc++.h>
using namespace std;

// Declaring size of the array
#define L 4 //Layer
#define R 4 //Row
#define C 4 //Column

// Calculating prefix
void prefixSum3d(int array[L][R][C])
{
    int prefix[L][R][C];

    prefix[0][0][0] = array[0][0][0];

    // Step 1: Filling the first row,column, and pile of ceils.
    // Using prefix sum of 1d array
    for (int i = 1; i < L; i++)
        prefix[i][0][0] = prefix[i - 1][0][0] + array[i][0][0];

    for (int i = 1; i < R; i++)
        prefix[0][i][0] = prefix[0][i - 1][0] + array[0][i][0];

    for (int i = 1; i < C; i++)
        prefix[0][0][i] = prefix[0][0][i - 1] + array[0][0][i];

    // Step 2: Filling the cells of sides(made up using cells)
    // which have common element array[0][0][0].
    // using prefix sum on 2d array
    for (int k = 1; k < L; k++)
    {
        for (int i = 1; i < R; i++)
        {
            prefix[k][i][0] = array[k][i][0] 
            + prefix[k - 1][i][0] + prefix[k][i - 1][0] 
                            - prefix[k - 1][i - 1][0];
        }
    }
    for (int i = 1; i < R; i++)
    {
        for (int j = 1; j < C; j++)
        {
            prefix[0][i][j] = array[0][i][j] 
            + prefix[0][i - 1][j] + prefix[0][i][j - 1] 
                            - prefix[0][i - 1][j - 1];
        }
    }
    for (int j = 1; j < C; j++)
    {
        for (int k = 1; k < L; k++)
        {
            prefix[k][0][j] = array[k][0][j] 
            + prefix[k - 1][0][j] + prefix[k][0][j - 1] 
                            - prefix[k - 1][0][j - 1];
        }
    }

    // Step 3: Filling value in remaining cells using formula
    for (int k = 1; k < L; k++)
    {
        for (int i = 1; i < R; i++)
        {
            for (int j = 1; j < C; j++)
            {
                prefix[k][i][j] = array[k][i][j] 

                            + prefix[k - 1][i][j] 
                            + prefix[k][i - 1][j] 
                            + prefix[k][i][j - 1] 

                            - prefix[k - 1][i - 1][j] 
                            - prefix[k][i - 1][j - 1] 
                            - prefix[k - 1][i][j - 1] 

                            + prefix[k - 1][i - 1][j - 1];
            }
        }
    }

    // Displaying final prefix sum of array
    cout << "prefix sum is:" << endl << endl;
    for (int k = 0; k < L; k++)
    {
        cout << "Layer " << k + 1 << ":" << endl;
        for (int i = 0; i < R; i++)
        {
            for (int j = 0; j < C; j++)
            {
                cout << prefix[k][i][j] << " ";
            }
            cout << endl;
        }
        cout << endl;
    }
}


// Driver program to test above function
int main()
{
    int array[L][R][C] = {
        {{2, 2, 2, 2}, //Layer 1
         {2, 2, 2, 2},
         {2, 2, 2, 2},
         {2, 2, 2, 2}},
         
        {{2, 2, 2, 2}, //Layer 2
         {2, 2, 2, 2},
         {2, 2, 2, 2},
         {2, 2, 2, 2}},
        
        {{2, 2, 2, 2}, //Layer 3
         {2, 2, 2, 2},
         {2, 2, 2, 2},
         {2, 2, 2, 2}},
        
        {{2, 2, 2, 2}, //Layer 4
         {2, 2, 2, 2},
         {2, 2, 2, 2},
         {2, 2, 2, 2}}
    };

    prefixSum3d(array);
    return 0;
}

python code for it:

# python program to calculate prefix sum of 3d array
# Declaring size of the array
L = 4  # Layer
R = 4  # Row
C = 4  # Column

# Calculating prefix


def prefixSum3d(array):

    prefix = [[[0 for a in range(C)]
               for b in range(R)]
              for d in range(L)]

    prefix[0][0][0] = array[0][0][0]

    # Step 1: Filling the first row,column, and pile of ceils.
    # Using prefix sum of 1d array
    for i in range(1, L):
        prefix[i][0][0] = prefix[i - 1][0][0] + array[i][0][0]

    for i in range(1, R):
        prefix[0][i][0] = prefix[0][i - 1][0] + array[0][i][0]

    for i in range(1, C):
        prefix[0][0][i] = prefix[0][0][i - 1] + array[0][0][i]

    # Step 2: Filling the cells of sides(made up using cells)
    # which have common element A[0][0][0].
    # using prefix sum on 2d array
    for k in range(1, L):
        for i in range(1, R):
            prefix[k][i][0] = (array[k][i][0] 
            + prefix[k - 1][i][0] + prefix[k][i - 1][0]
                               - prefix[k - 1][i - 1][0])
    for i in range(1, R):
        for j in range(1, C):
            prefix[0][i][j] = (array[0][i][j] 
            + prefix[0][i - 1][j] + prefix[0][i][j - 1]
                               - prefix[0][i - 1][j - 1])
    for j in range(1, C):
        for k in range(1, L):
            prefix[k][0][j] = (array[k][0][j] 
            + prefix[k - 1][0][j] + prefix[k][0][j - 1]
                               - prefix[k - 1][0][j - 1])

    # Step 3: Filling value in remaining cells using formula
    for k in range(1, L):
        for i in range(1, R):
            for j in range(1, C):
                prefix[k][i][j] = (array[k][i][j]

                                   + prefix[k - 1][i][j]
                                   + prefix[k][i - 1][j]
                                   + prefix[k][i][j - 1]

                                   - prefix[k - 1][i - 1][j]
                                   - prefix[k][i - 1][j - 1]
                                   - prefix[k - 1][i][j - 1]

                                   + prefix[k - 1][i - 1][j - 1])

    # Displaying final prefix sum of array
    print("prefix sum is:")
    for k in range(L):
        print("Layer", k+1, ":")
        for i in range(R):
            for j in range(C):
                print(prefix[k][i][j], end=' ')
            print()
        print()


# Driver program to test above function
array = [
    [[2, 2, 2, 2],  # Layer 1
     [2, 2, 2, 2],
     [2, 2, 2, 2],
     [2, 2, 2, 2]],

    [[2, 2, 2, 2],  # Layer 2
     [2, 2, 2, 2],
     [2, 2, 2, 2],
     [2, 2, 2, 2]],

    [[2, 2, 2, 2],  # Layer 3
     [2, 2, 2, 2],
     [2, 2, 2, 2],
     [2, 2, 2, 2]],

    [[2, 2, 2, 2],  # Layer 4
     [2, 2, 2, 2],
     [2, 2, 2, 2],
     [2, 2, 2, 2]]
]

prefixSum3d(array)

Time Complexity: O(L*R*C)
Auxiliary Space: O(L*R*C)
Find the type of Quadrilateral with given 4 points of the quadrilateral here.

Merge Sort Algorithm in C++ and Python

2021-07-13T12:55:00.015+05:30

Like QuickSort, Merge Sort is a Divide and Conquer algorithm. It divides the input array into two halves array, calls itself for the two halves, and then merges the two sorted halves. The Merge() function is used for merging two halves.

The Merge(array, start, mid, end) is a key process that assumes that array[start..mid] and array[mid+1..end] are sorted and merges the two sorted sub-arrays into one. See the following C++ and python implementation for details.

Input:

array = {1, 12, 5, 4, 78, 9, 5, 6, 3, 2, 1, 4};

output:

sorted array:
1 1 2 3 4 4 5 5 6 9 12 78

Explanation:

mergeSort(array[], start, end):

If start < end:

Find the middle point to divide the array into two halves:

middle mid = start+ (end - start) / 2

Call mergeSort for the first half:

Call mergeSort(array, start, mid)

Call mergeSort for the second half:

Call mergeSort(array, mid+1, end)

Merge the two halves sorted in steps 2 and 3:

Call merge(array,start, mid, end)

this is an image from Wikipedia

Implementation:

C++ Implementation:

//c++ program for merge sort
#include <bits/stdc++.h>
using namespace std;

// Merge to subarray of array
// first_array = array[start..mid]
// second_array = array[mid+1..end]
void Merge(vector<int> &array, int start, int mid, int end)
{
    // creating to temp subarray
    vector<int> first_array;
    vector<int> second_array;

    // copy first_array
    for (int i = start; i <= mid; i++)
    {
        first_array.push_back(array[i]);
    }

    // copy second_array
    for (int i = mid + 1; i <= end; i++)
    {
        second_array.push_back(array[i]);
    }

    // index reference
    int i = 0;                        // for first_array
    int j = 0;                        // for second_array
    int main_i = start;               // for main array
    int size_1 = first_array.size();  // size of first_array
    int size_2 = second_array.size(); // size of second_array

    // merge subarray first_array and second_array 
    // into array[start..end]
    while (i < size_1 && j < size_2)
    {
        if (first_array[i] <= second_array[j])
        {
            array[main_i] = first_array[i];
            i++;
        }
        else
        {
            array[main_i] = second_array[j];
            j++;
        }
        main_i++;
    }

    // copy remaining element of first_array
    while (i < size_1)
    {
        array[main_i] = first_array[i];
        i++;
        main_i++;
    }

    // copy remaining element of second_array
    while (j < size_2)
    {
        array[main_i] = second_array[j];
        j++;
        main_i++;
    }
}

// main merge Sort function
void mergeSort(vector<int> &array, int start, int end)
{
    if (start >= end)
    {
        return;
    }

    // finding mid point
    int mid = start + (end - start) / 2;
    // divide
    mergeSort(array, start, mid);
    mergeSort(array, mid + 1, end);

    // conquer
    Merge(array, start, mid, end);
}

// driver code
int main()
{
    // declaring  array
    vector<int> array = {1, 12, 5, 4, 78, 9, 5, 6, 3, 2, 1, 4};
    int n = array.size();
    mergeSort(array, 0, n - 1);
    // array is sorted

    cout << "sorted array:" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << array[i] << ' ';
    }
    cout << endl;
}

Python Implementation:

# python program for merge sort

# Merge to subarray of array
# first_array = array[start..mid]
# second_array = array[mid+1..end]
def Merge(array, start, mid, end):
    # creating to temp subarray
    first_array = []
    second_array = []

    # copy first_array
    for i in range(start, mid+1):
        first_array.append(array[i])

    # copy second_array
    for i in range(mid + 1, end+1):
        second_array.append(array[i])

    # index reference
    i = 0                        # for first_array
    j = 0                        # for second_array
    main_i = start               # for main array
    size_1 = len(first_array)    # size of first_array
    size_2 = len(second_array)   # size of second_array

    # merge subarray first_array and second_array 
    # into array[start..end]
    while i < size_1 and j < size_2:
        if first_array[i] <= second_array[j]:
            array[main_i] = first_array[i]
            i += 1
        else:
            array[main_i] = second_array[j]
            j += 1
        main_i += 1

    # copy remaining element of first_array
    while i < size_1:
        array[main_i] = first_array[i]
        i += 1
        main_i += 1

    # copy remaining element of second_array
    while j < size_2:
        array[main_i] = second_array[j]
        j += 1
        main_i += 1

# main merge Sort function


def mergeSort(array, start, end):
    if start >= end:
        return

    # finding mid point
    mid = start + (end - start) // 2
    # divide
    mergeSort(array, start, mid)
    mergeSort(array, mid + 1, end)

    # conquer
    Merge(array, start, mid, end)


# driver code
# declaring  array
array = [1, 12, 5, 4, 78, 9, 5, 6, 3, 2, 1, 4]
n = len(array)
mergeSort(array, 0, n - 1)
# array is sorted

print("sorted array:")
for i in range(n):
    print(array[i], end=' ')
print()

Output:

sorted array:
1 1 2 3 4 4 5 5 6 9 12 78

Time Complexity: O(N*log N)Auxiliary Space: O(N)Read Also:All Sorting Algorithm In python