Revise paste all | CCCPaste

--- .\make-one.py
import os
from typing import List, Tuple
from dotenv import load_dotenv

load_dotenv()

delimiter = os.environ.get('DELIMITER')

def get_files(path=".", excludes=['.exe', '.txt', '.env']) -> List[str]:

# Items in the current folder
    folder_items = os.listdir(path)

# Filter out the folders
    folders = list(
        filter(lambda x: '.' not in x, folder_items)
    )
    # Filter out the files
    files = list(
        map(
            lambda file_name: os.path.join(path, file_name),
            filter(lambda x: ('.' in x) and all(
                [exclude not in x for exclude in excludes]), folder_items)
        )
    )

# It means we're at the deepest level
    if len(folders) == 0:
        return files

# Iterate over all the folders to the files
    for folder in folders:
        files += get_files(path=os.path.join(path, folder))

# Return the files we got
    return files

def dump_into_one(files: list[str], output: str = "out.txt"):
    """
    Dumps all the files into big text file,
    delimiter=''
    """

with open(output, encoding='utf-8', mode='w+') as outFile:
        # Read and write from every single file
        content = ""

content_string = "{0} {1}\n{2}\n{0}\n"

for file in files:
            with open(file, encoding='utf-8', mode='r') as inFile:
                content += content_string.format(delimiter,
                                                 file, inFile.read())

# Write the read content
        outFile.write(content)
    return

def extract_from_dump(out_file: str = "out.txt") -> List[Tuple[str, str]]:

# Output filenames with their content
    output: List[Tuple[str, str]] = []

# Read the file and split on the delimiter
    content = ""

with open(out_file, encoding='utf-8', mode='r+') as readFile:
        content = readFile.read().split(delimiter)

# Filters for the content
    content = list(
        filter(lambda x: x != '\n' and x != delimiter and x != '', content)
    )

# Iterate over the content
    for i, file_content in enumerate(content):
        filename = file_content.split('\n')[0].strip()
        content = file_content.replace(filename, '')
        # Record this
        output.append((filename, content))

return output

if __name__ == '__main__':

def bundle_files():
        # To compress the files
        files = get_files()

for file in files:
            print(file)

dump_into_one(files)

def debundle_files():
        # To debundle the files
        files = extract_from_dump(out_file="out.txt")
        # Make the directories exist
        for (filename, file_content) in files:
            # Split the path of the file
            head, tail = os.path.split(filename)

try:
                os.mkdir(head)
            except FileExistsError:
                pass

# Write the file
            with open(filename, encoding='utf-8', mode='w+') as writeFile:
                writeFile.write(file_content)
            # end-with
        # end-for

bundle_files()
    # structure = extract_from_dump()

# for (filename, _) in structure:
    # print(filename)

# debundle_files()

---
--- .\graphs\bipartite.cpp
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

class Solution
{
    // colors a component
private:
    bool check(int start, int V, vector<int> adj[], int color[])
    {
        queue<int> q;
        q.push(start);
        color[start] = 0;
        while (!q.empty())
        {
            int node = q.front();
            q.pop();

for (auto it : adj[node])
            {
                // if the adjacent node is yet not colored
                // you will give the opposite color of the node
                if (color[it] == -1)
                {

color[it] = !color[node];
                    q.push(it);
                }
                // is the adjacent guy having the same color
                // someone did color it on some other path
                else if (color[it] == color[node])
                {
                    return false;
                }
            }
        }
        return true;
    }

public:
    bool isBipartite(int V, vector<int> adj[])
    {
        int *color = new int[V];
        for (int i = 0; i < V; i++)
            color[i] = -1;

for (int i = 0; i < V; i++)
        {
            // if not coloured
            if (color[i] == -1)
            {
                if (check(i, V, adj, color) == false)
                {
                    delete[] color;
                    return false;
                }
            }
        }

delete[] color;
        return true;
    }
};

void addEdge(vector<int> adj[], int u, int v)
{
    adj[u].push_back(v);
    adj[v].push_back(u);
}

int main()
{

// V = 4, E = 4
    vector<int> adj[4];

addEdge(adj, 0, 2);
    addEdge(adj, 0, 3);
    addEdge(adj, 2, 3);
    addEdge(adj, 3, 1);

Solution obj;
    bool ans = obj.isBipartite(4, adj);
    if (ans)
        cout << "1\n";
    else
        cout << "0\n";

return 0;
}
---
--- .\graphs\cycles.cpp
// A C++ Program to detect cycle in a graph
#include <iostream>
#include <list>
using namespace std;

class Graph
{
    // No. of vertices
    int V;

// Pointer to an array containing adjacency lists
    list<int> *adj;

// Used by isCyclic()
    bool isCyclicUtil(int v, bool visited[], bool *rs);

public:
    Graph(int V);
    void addEdge(int v, int w);
    bool isCyclic();
};

Graph::Graph(int V)
{
    this->V = V;
    adj = new list<int>[V];
}

void Graph::addEdge(int v, int w)
{
    // Add w to v’s list.
    adj[v].push_back(w);
}

// DFS function to find if a cycle exists
bool Graph::isCyclicUtil(int v, bool visited[],
                         bool *recStack)
{
    if (visited[v] == false)
    {
        // Mark the current node as visited
        // and part of recursion stack
        visited[v] = true;
        recStack[v] = true;

// Recur for all the vertices adjacent to this
        // vertex
        list<int>::iterator i;
        for (i = adj[v].begin(); i != adj[v].end(); ++i)
        {
            if (!visited[*i] && isCyclicUtil(*i, visited, recStack))
                return true;
            else if (recStack[*i])
                return true;
        }
    }

// Remove the vertex from recursion stack
    recStack[v] = false;
    return false;
}

// Returns true if the graph contains a cycle, else false
bool Graph::isCyclic()
{
    // Mark all the vertices as not visited
    // and not part of recursion stack
    bool *visited = new bool[V];
    bool *recStack = new bool[V];
    for (int i = 0; i < V; i++)
    {
        visited[i] = false;
        recStack[i] = false;
    }

// Call the recursive helper function
    // to detect cycle in different DFS trees
    for (int i = 0; i < V; i++)
        if (!visited[i] && isCyclicUtil(i, visited, recStack))
            return true;

return false;
}

// Driver code
int main()
{
    // Create a graph
    Graph g(4);
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 2);
    g.addEdge(2, 0);
    g.addEdge(2, 3);
    g.addEdge(3, 3);

// Function call
    if (g.isCyclic())
        cout << "Graph contains cycle";
    else
        cout << "Graph doesn't contain cycle";
    return 0;
}

---
--- .\graphs\main.cpp
#include <iostream>
#include "paths.hpp"
#include "prims.hpp"

int main()
{
    /*
    Graph *g = new Graph(13);

g->addNeighbors(0, {7, 9, 11});
    g->addNeighbors(1, {8, 10});
    g->addNeighbors(2, {3, 12});
    g->addNeighbors(3, {2, 4, 7});
    g->addNeighbors(4, {3});
    g->addNeighbors(5, {6});
    g->addNeighbors(6, {5});
    g->addNeighbors(7, {3, 6, 11});
    g->addNeighbors(8, {1, 12});
    g->addNeighbors(9, {8, 10});
    g->addNeighbors(10, {1});
    g->addNeighbors(11, {0});
    g->addNeighbors(12, {2, 8});

int src = 4, dest = 1;

std::cout << "Breadth First ";
    int level = g->breadthFirstSearch(src, dest);
    std::cout << std::endl;
    if (level == -1)
    {
        std::cout << "Couldn't find a path from " << src << " to " << dest << "\n";
    }

std::cout << "Depth First ";
    int dfsLevel = g->depthFirstSearch(src, dest);
    std::cout << std::endl;
    if (dfsLevel == -1)
    {
        std::cout << "Couldn't find a path from " << src << " to " << dest << "\n";
    }

// Free the taken memory
    delete g;
    */

vector<vector<pair<int, int>>> adjList{
        {{1, 1}, {2, 6}, {3, 5}},          // 0
        {{0, 1}, {2, 6}},                  // 1
        {{0, 6}, {1, 6}, {4, 7}, {5, 3}},  // 2
        {{0, 5}, {5, 2}, {6, 10}},         // 3
        {{2, 7}, {7, 12}},                 // 4
        {{2, 3}, {3, 2}, {7, 8}},          // 5
        {{3, 10}, {7, 7}, {8, 3}},         // 6
        {{4, 12}, {5, 8}, {6, 7}, {8, 8}}, // 7
        {{6, 3}, {7, 8}},                  // 8
    };

int start = 1;
    int cost = primsMinimumCostSpanningTree(start, adjList);

std::cout << "The cost of the minimum spanning tree is: " << cost << "\n";

return 0;
}
---
--- .\graphs\paths.hpp
#ifndef PATHS
#define PATHS

#include <vector>
#include <queue>
#include <stack>

template <class T>
using vector = std::vector<T>;

template <class T>
using queue = std::queue<T>;

template <class T>
using stack = std::stack<T>;

template <class T1, class T2>
using pair = std::pair<T1, T2>;

/**
 * Class to represent graphs
 */
class Graph
{
private:
    vector<vector<int>> adjList;
    int vertexCount;

/**
     * Prints the shortest path found in the graph
     * @param parent The list containing parent for each vertex
     * @param src The starting vertex of the journey
     * @param dest The ending vertex of the journey
     */
    int printShortestPath(vector<int> const &parent, const int src, const int dest)
    {
        static int level = 0;

// If we've reached the root of the shortest path tree
        if (parent[src] == -1)
        {
            std::cout << "Shortest path between " << src << " and " << dest << " is " << src << " ";
            return level;
        }
        // Recursively find the path
        printShortestPath(parent, parent[src], dest);
        level++;

if (src < vertexCount)
        {
            std::cout << src << " ";
        }
        return level;
    }

public:
    /**
     * The vertex numbers start from '0'
     */
    Graph(int vertices)
    {
        // Add empty list for the adjacency
        for (int i = 0; i < vertices; i++)
            adjList.push_back({});
        // Store the number of the vertices
        vertexCount = vertices;
    }

/**
     * Adds an edge to the graph from u -> v
     * @param u The first vertex of the dge
     * @param v The second vertex of the edge
     */
    void addEdge(int u, int v)
    {
        // Check if the vertex is within the bounds
        if (0 > u || vertexCount <= u)
            return;

if (0 > v || vertexCount <= v)
            return;

// Add the vertex to the list
        adjList[u].push_back(v);
    }

/**
     * Adds a whole list for the adjacency list
     * @param vertex The vertex to add neighbors to
     * @param neighbors The neighbor list for the vertex
     */
    void addNeighbors(const int &vertex, const vector<int> &neighbors)
    {
        adjList[vertex] = neighbors;
    }

/**
     * To perform a breadth first search on the graph
     * @param start The starting vertex of the graph
     * @param end The destination for the search
     */
    int breadthFirstSearch(int const start, int const end)
    {
        // Create a queue frontier for the search
        queue<int> q;
        // Add the start to the queue
        q.push(start);

// Make a list to keep track of parents
        vector<int> parent(vertexCount, -1);

// Make a visited list
        vector<bool> visited(vertexCount, false);
        // Mark the current node as visited
        visited[start] = true;

while (!q.empty())
        {
            // Get the current element to explore, pop it from the queue
            int current = q.front();
            q.pop();

// Check if we've reached our goal
            if (current == end)
            {
                return printShortestPath(parent, current, end);
            }

// Iterate over all the neighbors to the find the
            for (int const &neighbor : adjList[current])
            {
                if (!visited[neighbor])
                {
                    q.push(neighbor);
                    visited[neighbor] = true;
                    parent[neighbor] = current;
                }
            }
        }

// Return -1, if we don't find any path
        return -1;
    }

/**
     * To perform a depth-first search on the graph
     * @param start The starting vertex of the graph
     * @param end The destination for the search
     */
    int depthFirstSearch(int const start, int const end)
    {
        // Create a stack frontier
        stack<int> stack;
        // Keep track of the visited nodes
        vector<bool> visited(vertexCount, false);

// Make a list of parents to create a path later
        vector<int> parent(vertexCount, -1);

// Add the current node to frontier, and mark it visited
        stack.push(start);
        visited[start] = true;

// Repeat till the stack is empty
        while (!stack.empty())
        {

// Get the element at top of the stack
            int current = stack.top();
            stack.pop();

// Check if we've reached our destination
            if (current == end)
            {
                return printShortestPath(parent, current, end);
            }

// Mark this node as visited
            visited[current] = true;

// Explore all the neighbors
            for (int const &neighbor : adjList[current])
            {
                if (!visited[neighbor])
                {
                    // Add this node to the frontier to explore later
                    stack.push(neighbor);
                    // Mark the current element as parent of the neighbor (in dfs tree)
                    parent[neighbor] = current;
                    // Mark this node as visited
                    visited[neighbor] = true;
                }
            }
        }

// Return -1, if we didn't find any path
        return -1;
    }
};

#endif
---
--- .\graphs\prims.cpp
#include <stdio.h>
#include <limits.h>
#define vertices 5 /*Define the number of vertices in the graph*/
/* create minimum_key() method for finding the vertex that has minimum key-value and that is not added in MST yet */
int minimum_key(int k[], int mst[])
{
    int minimum = INT_MAX, min, i;

/*iterate over all vertices to find the vertex with minimum key-value*/
    for (i = 0; i < vertices; i++)
        if (mst[i] == 0 && k[i] < minimum)
            minimum = k[i], min = i;
    return min;
}
/* create prim() method for constructing and printing the MST.
The g[vertices][vertices] is an adjacency matrix that defines the graph for MST.*/
void prim(int g[vertices][vertices])
{
    /* create array of size equal to total number of vertices for storing the MST*/
    int parent[vertices];
    /* create k[vertices] array for selecting an edge having minimum weight*/
    int k[vertices];
    int mst[vertices];
    int i, count, edge, v; /*Here 'v' is the vertex*/
    for (i = 0; i < vertices; i++)
    {
        k[i] = INT_MAX;
        mst[i] = 0;
    }
    k[0] = 0;       /*It select as first vertex*/
    parent[0] = -1; /* set first value of parent[] array to -1 to make it root of MST*/
    for (count = 0; count < vertices - 1; count++)
    {
        /*select the vertex having minimum key and that is not added in the MST yet from the set of vertices*/
        edge = minimum_key(k, mst);
        mst[edge] = 1;
        for (v = 0; v < vertices; v++)
        {
            if (g[edge][v] && mst[v] == 0 && g[edge][v] < k[v])
            {
                parent[v] = edge, k[v] = g[edge][v];
            }
        }
    }
    /*Print the constructed Minimum spanning tree*/
    printf("\n Edge \t  Weight\n");
    for (i = 1; i < vertices; i++)
        printf(" %d <-> %d    %d \n", parent[i], i, g[i][parent[i]]);
}
int main()
{
    int g[vertices][vertices] = {
        {0, 0, 3, 0, 0},
        {0, 0, 10, 4, 0},
        {3, 10, 0, 2, 6},
        {0, 4, 2, 0, 1},
        {0, 0, 6, 1, 0},
    };
    prim(g);
    return 0;
}
---
--- .\graphs\strongly.cpp
// Program to check if the given directed graph
// is strongly connected or not.
#include <iostream>
#include <list>
#include <queue>
using namespace std;

class Graph
{
    int vertices; // To store no. of vertices
    list<int> *adjList;

// Function to print DFS starting from v
    void BFSUtil(int v, bool visited[]);

public:
    Graph(int V)
    {
        this->vertices = V;
        adjList = new list<int>[V];
    }
    ~Graph() { delete[] adjList; }

// Function to add an edge
    void addEdge(int v, int w);

// Function that returns if the
    // graph is strongly connected or not.
    bool isStronglyConnected();

// Function that returns reverse (or transpose)
    // of this graph
    Graph getTranspose();
};

// A recursive function to print DFS starting from v
void Graph::BFSUtil(int v, bool visited[])
{
    // Creating a queue for BFS traversal
    list<int> queue;
    visited[v] = true;
    queue.push_back(v);

list<int>::iterator i;

while (!queue.empty())
    {
        // Dequeue a vertex from queue
        v = queue.front();
        queue.pop_front();
        for (i = adjList[v].begin(); i != adjList[v].end(); ++i)
        {
            if (!visited[*i])
            {
                visited[*i] = true;
                queue.push_back(*i);
            }
        }
    }
}

Graph Graph::getTranspose()
{
    Graph g(vertices);
    for (int v = 0; v < vertices; v++)
    {
        list<int>::iterator i;
        for (i = adjList[v].begin(); i != adjList[v].end(); ++i)
            g.adjList[*i].push_back(v);
    }
    return g;
}

void Graph::addEdge(int v, int w)
{
    adjList[v].push_back(w);
}

// Function that returns true if graph
// is strongly connected
bool Graph::isStronglyConnected()
{
    // Step 1: Mark all the vertices as not
    // visited (For first BFS)
    bool *visited = new bool[vertices];
    for (int i = 0; i < vertices; i++)
        visited[i] = false;

// Do BFS traversal starting from the first vertex.
    BFSUtil(0, visited);

// If BFS traversal doesn’t visit all vertices
    // return false.
    for (int i = 0; i < vertices; i++)
        if (visited[i] == false)
        {
            delete[] visited;
            return false;
        }

// Create a reversed graph
    Graph gr = getTranspose();

// Step 4: Mark all the vertices as not
    // visited (For second BFS)
    for (int i = 0; i < vertices; i++)
        visited[i] = false;

gr.BFSUtil(0, visited);

// If all vertices are not visited in the second DFS
    // return false
    for (int i = 0; i < vertices; i++)
        if (visited[i] == false)
        {
            delete[] visited;
            return false;
        }

delete[] visited;
    return true;
}

// Driver program to test the above functions
int main()
{
    Graph g1(7);
    g1.addEdge(0, 1);
    g1.addEdge(1, 2);
    g1.addEdge(2, 3);
    g1.addEdge(3, 0);
    g1.addEdge(2, 4);
    g1.addEdge(4, 2);
    g1.addEdge(4, 5);
    g1.addEdge(5, 6);
    g1.addEdge(6, 4);

g1.isStronglyConnected() ? cout << "Yes" : cout << "No";
    return 0;
}
---
--- .\graphs\topologicalSorting.cpp
#include <iostream>
#include <vector>
#include <stack>
using namespace std;

// Function to perform DFS and topological sorting
void topologicalSortUtil(int v, vector<vector<int>> &adj,
                         vector<bool> &visited,
                         stack<int> &Stack)
{
    // Mark the current node as visited
    visited[v] = true;

// Recur for all adjacent vertices
    for (int i : adj[v])
    {
        if (!visited[i])
            topologicalSortUtil(i, adj, visited, Stack);
    }

// Push current vertex to stack which stores the result
    Stack.push(v);
}

// Function to perform Topological Sort
void topologicalSort(vector<vector<int>> &adj, int V)
{
    stack<int> Stack; // Stack to store the result
    vector<bool> visited(V, false);

// Call the recursive helper function to store
    // Topological Sort starting from all vertices one by
    // one
    for (int i = 0; i < V; i++)
    {
        if (!visited[i])
            topologicalSortUtil(i, adj, visited, Stack);
    }

// Print contents of stack
    while (!Stack.empty())
    {
        cout << Stack.top() << " ";
        Stack.pop();
    }
}

int main()
{

// Number of nodes
    int V = 4;

// Edges
    vector<vector<int>> edges = {{0, 1}, {1, 2}, {3, 1}, {3, 2}};

// Graph represented as an adjacency list
    vector<vector<int>> adj(V);

for (auto i : edges)
    {
        adj[i[0]].push_back(i[1]);
    }

cout << "Topological sorting of the graph: ";
    topologicalSort(adj, V);

return 0;
}
---
--- .\knapsack\knapsack.cpp
#include <iostream>
#include <vector>
using namespace std;

/**
 * @param itemCount The number of items to pick from
 * @param sackWeight The weight of the knapsack
 * @param weights The weights to pick from
 * @param profits The profits relating to the weights
 * @param pickSeq The picking sequence of the items (0 or 1)
 */
int knapsackForItem(int itemCount, int sackWeight, vector<int> const &weights, vector<int> const &profits, vector<bool> &pickSeq, vector<vector<int>> memTable = {})
{

// If the item is non-existent or the sack weight
    // is non-existent, then return
    if (itemCount <= 0 || sackWeight <= 0)
        return 0;

// Check if we have memoized answer
    if (memTable.size() != 0 && memTable[itemCount - 1][sackWeight - 1] != -1)
    {
        return memTable[itemCount - 1][sackWeight - 1];
    }

// If the weight of the current item is more than
    // the sack weight, then return
    if (weights[itemCount - 1] > sackWeight)
    {
        // We cannot fit this item in the sack
        pickSeq[itemCount - 1] = false;

// Get the result from the table if possible
        if (memTable.size() != 0 && memTable[itemCount - 1][sackWeight - 1] != -1)
            return memTable[itemCount - 1][sackWeight - 1];

// Memoize the result
        int result = knapsackForItem(itemCount - 1, sackWeight, weights, profits, pickSeq);

if (memTable.size() != 0)
        {
            memTable[itemCount - 1][sackWeight - 1] = result;
            return memTable[itemCount - 1][sackWeight - 1];
        }

// We're not given a memTable
        return result;
    }

/* Else, we need to get the result where the profit is maximum */

// Not picking the item
    int notPicking = knapsackForItem(itemCount - 1, sackWeight, weights, profits, pickSeq);
    // Picking the item
    int picking = knapsackForItem(itemCount - 1, sackWeight - weights[itemCount - 1], weights, profits, pickSeq) + profits[itemCount - 1];

// If we're given a memTable
    if (memTable.size() != 0)
    {
        memTable[itemCount - 1][sackWeight - 1] = max(notPicking, picking);
    }

if (notPicking > picking)
    {
        pickSeq[itemCount - 1] = false;
        std::cout << "Not picking the item with weight: " << weights[itemCount - 1] << "\n";
        return notPicking;
    }
    else
    {
        pickSeq[itemCount - 1] = true;
        std::cout << "Picking the item with weight: " << weights[itemCount - 1] << "\n";
        return picking;
    }
}

/**
 * Returns the answer using memoized
 */
int optimalKnapsack(int itemCount, int sackWeight, vector<int> const &weights, vector<int> const &profits, vector<bool> &pickSeq)
{
    // Make a memoized table
    vector<vector<int>> memTable(itemCount, vector<int>(sackWeight, -1));

// Return the memoized version
    return knapsackForItem(itemCount, sackWeight, weights, profits, pickSeq, memTable);
}

int main()
{

/*
        Consider the problem where
        weights = {3, 4, 6, 5}
        profits = {2, 3, 1, 4}

The max weight is: 8 Kgs
    */

// The weights for the item to pick
    vector<int> weights{3, 4, 6, 5};

// The profits corresponding to those items
    vector<int> profits{2, 3, 1, 4};

// Number of items to pick from
    const int itemCount = 4;

// The maximum carry weight for the sack
    const int maxWeight = 8;

// The picking sequence
    vector<bool> pickSeq(itemCount, false);

int maxProfit = optimalKnapsack(itemCount, maxWeight, weights, profits, pickSeq);

std::cout << "Max profit from the knapsack is: " << maxProfit << std::endl;

// Picking sequence
    std::cout << "Answer to 0-1 Knapsack: [ ";
    for (bool const &didPick : pickSeq)
    {
        std::cout << didPick << " ";
    }
    std::cout << "]" << std::endl;

return 0;
}
---
--- .\multilpication\strassen.cpp
#include <iostream>
#include <vector>

using namespace std;

// Function to add two matrices
vector<vector<int>> matrixAdd(const vector<vector<int>> &A, const vector<vector<int>> &B)
{
    int n = A.size();
    vector<vector<int>> C(n, vector<int>(n));
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            C[i][j] = A[i][j] + B[i][j];
        }
    }
    return C;
}

// Function to subtract two matrices
vector<vector<int>> matrixSubtract(const vector<vector<int>> &A, const vector<vector<int>> &B)
{
    int n = A.size();
    vector<vector<int>> C(n, vector<int>(n));
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            C[i][j] = A[i][j] - B[i][j];
        }
    }
    return C;
}

// Function to multiply two matrices using Strassen's algorithm
vector<vector<int>> strassenMultiply(const vector<vector<int>> &A, const vector<vector<int>> &B)
{
    int n = A.size();

// Base case: If the matrix size is 1x1
    if (n == 1)
    {
        vector<vector<int>> C(1, vector<int>(1));
        C[0][0] = A[0][0] * B[0][0];
        return C;
    }

// Splitting matrices into quadrants
    int mid = n / 2;
    vector<vector<int>> A11(mid, vector<int>(mid)), A12(mid, vector<int>(mid)), A21(mid, vector<int>(mid)), A22(mid, vector<int>(mid));
    vector<vector<int>> B11(mid, vector<int>(mid)), B12(mid, vector<int>(mid)), B21(mid, vector<int>(mid)), B22(mid, vector<int>(mid));

for (int i = 0; i < mid; i++)
    {
        for (int j = 0; j < mid; j++)
        {
            A11[i][j] = A[i][j];
            A12[i][j] = A[i][j + mid];
            A21[i][j] = A[i + mid][j];
            A22[i][j] = A[i + mid][j + mid];

B11[i][j] = B[i][j];
            B12[i][j] = B[i][j + mid];
            B21[i][j] = B[i + mid][j];
            B22[i][j] = B[i + mid][j + mid];
        }
    }

// Calculating intermediate matrices
    vector<vector<int>> M1 = strassenMultiply(matrixAdd(A11, A22), matrixAdd(B11, B22));
    vector<vector<int>> M2 = strassenMultiply(matrixAdd(A21, A22), B11);
    vector<vector<int>> M3 = strassenMultiply(A11, matrixSubtract(B12, B22));
    vector<vector<int>> M4 = strassenMultiply(A22, matrixSubtract(B21, B11));
    vector<vector<int>> M5 = strassenMultiply(matrixAdd(A11, A12), B22);
    vector<vector<int>> M6 = strassenMultiply(matrixSubtract(A21, A11), matrixAdd(B11, B12));
    vector<vector<int>> M7 = strassenMultiply(matrixSubtract(A12, A22), matrixAdd(B21, B22));

// Calculating result matrix
    vector<vector<int>> C(n, vector<int>(n));
    vector<vector<int>> C11 = matrixAdd(matrixSubtract(matrixAdd(M1, M4), M5), M7);
    vector<vector<int>> C12 = matrixAdd(M3, M5);
    vector<vector<int>> C21 = matrixAdd(M2, M4);
    vector<vector<int>> C22 = matrixAdd(matrixSubtract(matrixAdd(M1, M3), M2), M6);

// Combining result quadrants into the result matrix
    for (int i = 0; i < mid; i++)
    {
        for (int j = 0; j < mid; j++)
        {
            C[i][j] = C11[i][j];
            C[i][j + mid] = C12[i][j];
            C[i + mid][j] = C21[i][j];
            C[i + mid][j + mid] = C22[i][j];
        }
    }

return C;
}

// Function to print a matrix
void printMatrix(const vector<vector<int>> &matrix)
{
    int n = matrix.size();
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }
}

int main()
{
    vector<vector<int>> A = {{1, 2}, {3, 4}};
    vector<vector<int>> B = {{5, 6}, {7, 8}};

cout << "Matrix A:" << endl;
    printMatrix(A);
    cout << endl;

cout << "Matrix B:" << endl;
    printMatrix(B);
    cout << endl;

cout << "Result of matrix multiplication (Strassen's algorithm):" << endl;
    vector<vector<int>> C = strassenMultiply(A, B);
    printMatrix(C);

return 0;
}
---
--- .\sorting\countSort.hpp
#ifndef COUNT_SORT
#define COUNT_SORT

/**
 * Sorts the array using count-sort
 * @param array The array to sort
 * @param size The length of the array to sort
 */
void countSort(int array[], int size)
{
    int maxElement = array[0];
    for (int i = 1; i < size; i++)
    {
        if (array[i] > maxElement)
            maxElement = array[i];
    }

// Initialize count array with all elements as 0
    int *count = new int[maxElement + 1];
    // Initialize it with zeros
    for (size_t j = 0; j < maxElement + 1; j++)
        count[j] = 0;

// Count the occurrences of each element
    for (int i = 0; i < size; i++)
    {
        count[array[i]]++;
    }

// Fill the original array with sorted elements
    int index = 0;
    for (int i = 0; i <= maxElement; i++)
    {
        while (count[i] > 0)
        {
            array[index++] = i;
            count[i]--;
        }
    }
    delete[] count;
}

#endif
---
--- .\sorting\heapSort.hpp
#ifndef HEAP_SORT
#define HEAP_SORT

/**
 * Swaps two values
 * @param a The first value to swap
 * @param b The second value to swap with
 */
template <class T>
void swap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

/**
 * Builds a max heap from the given array
 * @param array The array to perform max-heapify on
 * @param size The length of the array
 * @param i The index to start heapify with '0' for root
 */
void maxHeapify(int array[], int size, int i)
{
    int largest = i;       // Initialize largest as the root
    int left = 2 * i + 1;  // Left child of the root
    int right = 2 * i + 2; // Right child of the root

// Find the new largest element
    if (left < size && array[left] > array[largest])
        largest = left;
    if (right < size && array[right] > array[largest])
        largest = right;

// If the largest is not the root, then swap
    if (largest != i)
    {
        swap(array[i], array[largest]);
        // Recursively heapify the affected sub-tree
        maxHeapify(array, size, largest);
    }
}

/**
 * Sorts the array using heap sort
 * @param array The array to sort
 * @param size The length of the array
 */
void heapSort(int array[], int size)
{
    // Build a max-heap (rearrange array)
    for (int i = (size / 2) - 1; i >= 0; i--)
    {
        maxHeapify(array, size, i);
    }

// One-by-one extract an element from the heap
    for (int i = size - 1; i >= 0; i--)
    {
        // Move the current root to the end
        swap(array[0], array[i]);

// Call the max heapify on the reduced heap
        maxHeapify(array, i, 0);
    }
}

#endif
---
--- .\sorting\insertionSort.hpp

#ifndef INSERTION_SORT
#define INSERTION_SORT

/**
 * Insertion Sort (in-place)
 * @param array The array to sort
 * @param size The size of the array
 */
void insertionSort(int array[], int size)
{
    for (int i = 1; i < size; i++)
    {
        int key = array[i];
        int j = i - 1;

while (j >= 0 && array[j] > key)
        {
            // Shift the elements to the right
            array[j + 1] = array[j];
            j = j - 1;
        }
        array[j + 1] = key;
    }
}

#endif
---
--- .\sorting\main.cpp
#include <iostream>

// Internal Dependencies
#include "insertionSort.hpp"
#include "mergeSort.hpp"
// #include "heapSort.hpp"
#include "quickSort.hpp"

/**
 * @param array The array to print
 * @param size The size of the array
 * @param endline The character at the end of the line
 */
template <class T>
void printArray(T array[], int size, char endline = '\0')
{
    std::cout << "[ ";
    for (int i = 0; i < size; i++)
        std::cout << array[i] << " ";
    std::cout << "]" << endline;
}

#include "countSort.hpp"

/**
 * The driver function of the code
 */
int main()
{

int a[] = {1, 4, 7, 4, 2, 8, 1, 9, 0, 3};

// Get the size of the array
    int size = sizeof(a) / sizeof(a[0]);

// Before sorting
    printArray(a, size, '\n');

// quickSort(a, 0, size - 1);
    countSort(a, size);

// After sorting
    printArray(a, size, '\n');

return 0;
}

---
--- .\sorting\mergeSort.hpp
#ifndef MERGE_SORT
#define MERGE_SORT

/**
 * Merges the sub-arrays
 */
void merge(int array[], int const left, int const mid, int const right)
{
    int const subArrayLeft = mid - left + 1;
    int const subArrayRight = right - mid;

// Create new temporary arrays
    int *leftArray = new int[subArrayLeft];
    int *rightArray = new int[subArrayRight];

// Copy the data of sub-arrays to this new array
    for (size_t i = 0; i < subArrayLeft; i++)
    {
        leftArray[i] = array[left + i];
    }
    for (size_t i = 0; i < subArrayRight; i++)
    {
        rightArray[i] = array[mid + 1 + i];
    }

int i = 0;    // Iterator for the left sub-array
    int j = 0;    // Iterator for the right sub-array
    int k = left; // Iterator for the merged array

while (i < subArrayLeft && j < subArrayRight)
    {
        if (leftArray[i] <= rightArray[j])
        {
            // Choose the element from the left sub-array
            array[k] = leftArray[i];
            i++;
        }
        else
        {
            // Choose the element from the right sub-array
            array[k] = rightArray[j];
            j++;
        }
        // Increment the sub-array iterator
        k++;
    }

// Add the remaining left array elements
    while (i < subArrayLeft)
    {
        array[k] = leftArray[i];
        i++;
        k++;
    }

// Add the remaining right array elements
    while (j < subArrayRight)
    {
        array[k] = rightArray[j];
        j++;
        k++;
    }

delete[] leftArray;
    delete[] rightArray;
}

/**
 * Sorts the array using merge sort, (in-place)
 * @param array The array to sort
 * @param begin The beginning of the index in the array
 * @param end The end index of the array (should be 'length-1')
 */
void mergeSort(int array[], int const begin, int const end)
{
    if (begin >= end)
        return;
    // Get the middle of the array and divide it there
    int mid = (begin + end) / 2;
    // Sort the left half of the array
    mergeSort(array, begin, mid);
    // Sort the right half of the array
    mergeSort(array, mid + 1, end);
    // Merge the two halves
    merge(array, begin, mid, end);
}

#endif
---
--- .\sorting\quickSort.hpp
#ifndef QUICK_SORT
#define QUICK_SORT

/**
 * Swaps two values
 * @param a The first value to swap
 * @param b The second value to swap with
 */
template <class T>
void swap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

/**
 * Function to partition the array and return the pivot index
 */
int partition(int array[], int low, int high)
{
    // Choosing the last element as pivot
    int pivot = array[high];
    // Index of the smaller element
    int i = low - 1;

for (int j = low; j <= high - 1; j++)
    {
        // If the current element is smaller than or equal to pivot
        if (array[j] <= pivot)
        {
            i++; // Increment the index of smaller element
            swap(array[i], array[j]);
        }
    }
    swap(array[i + 1], array[high]);
    return (i + 1);
}

void quickSort(int array[], int low, int high)
{
    if (low >= high)
        return;

// Partitioning index
    int pi = partition(array, low, high);
    // Separately sort elements before and after partition
    quickSort(array, low, pi - 1);
    quickSort(array, pi + 1, high);
}

#endif
---