Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/conjugate-gradient | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/conjugate-gradient/python/conjugate_gradient.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""conjugate_gradient.py
The Conjugate Gradient (CG) method is an iterative algorithm used to solve systems of linear equations of the form Ax = b, where A is a symmetric positive-definite matrix. Here's how the algorithm works:
Initialization: Start with an initial guess x0 for the solution.
Residual Calculation: Compute the residual r0 = b - Ax0.
Direction Calculation: Choose a search direction p0 = r0.
Iteration: Repeat the following steps until convergence or a maximum number of iterations:
Compute Ap = A * p.
Compute the step size alpha = (r^T * r) / (p^T * A * p).
Update the solution x = x + alpha * p.
Update the residual r = r - alpha * A * p.
Compute the new residual norm rsnew = r^T * r.
Check for convergence: if rsnew is sufficiently small, exit the loop.
Update the search direction p = r + (rsnew / rsold) * p, where rsold is the norm of the previous residual.
Termination: Return the final solution x and the number of iterations.
In the example usage, we demonstrate how to solve a linear system using the Conjugate Gradient method. We define the coefficient matrix A and the right-hand side vector b, provide an initial guess x0 for the solution, and call the conjugate_gradient function to obtain the solution and the number of iterations required for convergence. Adjustments to the tolerance and maximum number of iterations can be made based on the desired level of accuracy and computational resources available.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
from typing import Callable, List, Tuple
import numpy as np
def main() -> None:
"""Driving code and main function"""
# Example: Solve a linear system using Conjugate Gradient method
A = np.array([[4, 1], [1, 3]])
b = np.array([1, 2])
x0 = np.array([0, 0])
solution, iterations = conjugate_gradient(A, b, x0)
print("Solution:", solution)
print("Number of iterations:", iterations)
return None
def conjugate_gradient(A: np.ndarray, b: np.ndarray, x0: np.ndarray, tol: float = 1e-6, max_iter: int = 1000) -> Tuple[np.ndarray, int]:
"""Solve a linear system Ax = b using the Conjugate Gradient method.
Args:
A (np.ndarray): Coefficient matrix.
b (np.ndarray): Right-hand side vector.
x0 (np.ndarray): Initial guess for the solution.
tol (float, optional): Tolerance for convergence. Defaults to 1e-6.
max_iter (int, optional): Maximum number of iterations. Defaults to 1000.
Returns:
Tuple[np.ndarray, int]: Solution vector and number of iterations.
"""
x = x0.copy()
r = b - A @ x
p = r.copy()
rsold = np.dot(r, r)
for i in range(max_iter):
Ap = A @ p
alpha = rsold / np.dot(p, Ap)
x = x + alpha * p
r = r - alpha * Ap
rsnew = np.dot(r, r)
if np.sqrt(rsnew) < tol:
break
p = r + (rsnew / rsold) * p
rsold = rsnew
return x, i+1
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/simulated-annealing | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/simulated-annealing/java/SimulatedAnnealing.java | import java.util.Random;
import java.util.function.Function;
public class SimulatedAnnealing {
/**
* Solves optimization problems using Simulated Annealing.
*
* @param objectiveFunction Objective function to minimize.
* @param initialSolution Initial solution vector.
* @param temperature Initial temperature parameter.
* @param coolingRate Cooling rate parameter.
* @param maxIter Maximum number of iterations.
* @return The best solution found and its corresponding objective function value as an array.
*/
public static double[] simulatedAnnealing(Function<double[], Double> objectiveFunction, double[] initialSolution, double temperature, double coolingRate, int maxIter) {
double[] currentSolution = initialSolution.clone();
double currentEnergy = objectiveFunction.apply(currentSolution);
double[] bestSolution = currentSolution.clone();
double bestEnergy = currentEnergy;
Random random = new Random();
for (int iter = 0; iter < maxIter; iter++) {
double[] proposedSolution = new double[currentSolution.length];
for (int i = 0; i < currentSolution.length; i++) {
proposedSolution[i] = currentSolution[i] + random.nextGaussian() * 0.1; // Perturb the current solution
}
double proposedEnergy = objectiveFunction.apply(proposedSolution);
double deltaEnergy = proposedEnergy - currentEnergy;
if (deltaEnergy < 0 || Math.random() < Math.exp(-deltaEnergy / temperature)) {
currentSolution = proposedSolution;
currentEnergy = proposedEnergy;
if (currentEnergy < bestEnergy) {
bestSolution = currentSolution.clone();
bestEnergy = currentEnergy;
}
}
temperature *= coolingRate; // Cool down temperature
}
return new double[]{bestEnergy};
}
public static void main(String[] args) {
// Example: Minimize a simple objective function using Simulated Annealing
Function<double[], Double> objectiveFunction = x -> {
double sum = 0;
for (double value : x) {
sum += Math.pow(value, 2);
}
return sum;
};
double[] initialSolution = new double[]{2.0, 3.0, 1.5};
double temperature = 100.0;
double coolingRate = 0.95;
int maxIter = 1000;
double[] result = simulatedAnnealing(objectiveFunction, initialSolution, temperature, coolingRate, maxIter);
System.out.println("Best energy: " + result[0]);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/simulated-annealing | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/simulated-annealing/cpp/main.cpp | #include <iostream>
#include <vector>
#include <cmath>
#include <random>
#include <functional>
using namespace std;
// Define the type of the objective function
using ObjectiveFunction = function<double(const vector<double>&)>;
/**
* Solves optimization problems using Simulated Annealing.
*
* @param objectiveFunction Objective function to minimize.
* @param initialSolution Initial solution vector.
* @param temperature Initial temperature parameter.
* @param coolingRate Cooling rate parameter.
* @param maxIter Maximum number of iterations.
* @return The best solution found and its corresponding objective function value as a vector.
*/
vector<double> simulatedAnnealing(ObjectiveFunction objectiveFunction, const vector<double>& initialSolution, double temperature, double coolingRate, int maxIter) {
vector<double> currentSolution = initialSolution;
double currentEnergy = objectiveFunction(currentSolution);
vector<double> bestSolution = currentSolution;
double bestEnergy = currentEnergy;
random_device rd;
mt19937 gen(rd());
uniform_real_distribution<double> dis(-0.1, 0.1); // Perturbation range
for (int iter = 0; iter < maxIter; iter++) {
vector<double> proposedSolution = currentSolution;
for (double& value : proposedSolution) {
value += dis(gen); // Perturb the current solution
}
double proposedEnergy = objectiveFunction(proposedSolution);
double deltaEnergy = proposedEnergy - currentEnergy;
if (deltaEnergy < 0 || dis(gen) < exp(-deltaEnergy / temperature)) {
currentSolution = proposedSolution;
currentEnergy = proposedEnergy;
if (currentEnergy < bestEnergy) {
bestSolution = currentSolution;
bestEnergy = currentEnergy;
}
}
temperature *= coolingRate; // Cool down temperature
}
return bestSolution;
}
int main() {
// Example: Minimize a simple objective function using Simulated Annealing
ObjectiveFunction objectiveFunction = [](const vector<double>& x) {
double sum = 0;
for (double value : x) {
sum += pow(value, 2);
}
return sum;
};
vector<double> initialSolution = {2.0, 3.0, 1.5};
double temperature = 100.0;
double coolingRate = 0.95;
int maxIter = 1000;
vector<double> result = simulatedAnnealing(objectiveFunction, initialSolution, temperature, coolingRate, maxIter);
cout << "Best solution: ";
for (double value : result) {
cout << value << " ";
}
cout << endl;
cout << "Best energy: " << objectiveFunction(result) << endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/simulated-annealing | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/simulated-annealing/python/simulated_annealing.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""simulated_annealing.py
The Simulated Annealing (SA) algorithm is a probabilistic optimization technique inspired by the process of annealing in metallurgy. Here's how the algorithm works:
Initialization: Start with an initial solution and an initial temperature.
Iteration: Repeat the following steps until convergence or a maximum number of iterations:
Generate a new solution by perturbing the current solution.
Evaluate the objective function value for the new solution.
If the new solution is better (lower objective function value), accept it as the current solution.
If the new solution is worse, accept it with a certain probability based on the temperature and the magnitude of the deterioration.
Decrease the temperature according to a cooling schedule.
Termination: Return the best solution found and its corresponding objective function value.
In the example usage, we demonstrate how to minimize a simple objective function using Simulated Annealing. We define the objective function to minimize, provide an initial solution, set the initial temperature, cooling rate, and maximum number of iterations, and call the simulated_annealing function to obtain the best solution and its corresponding objective function value. Adjustments to parameters such as the temperature, cooling rate, and perturbation magnitude can be made based on the specific optimization problem being solved.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
from typing import Callable, Tuple
import numpy as np
def main() -> None:
"""Driving code and main function"""
# Example: Minimize a simple objective function using Simulated Annealing
def objective_function(x: np.ndarray) -> float:
return np.sum(np.square(x))
initial_solution = np.array([2.0, 3.0, 1.5])
temperature = 100.0
cooling_rate = 0.95
max_iter = 1000
best_solution, best_energy = simulated_annealing(objective_function, initial_solution, temperature, cooling_rate, max_iter)
print("Best solution:", best_solution)
print("Best energy:", best_energy)
return None
def simulated_annealing(objective_function: Callable[[np.ndarray], float], initial_solution: np.ndarray, temperature: float, cooling_rate: float, max_iter: int) -> Tuple[np.ndarray, float]:
"""Solve optimization problems using Simulated Annealing.
Args:
objective_function (Callable[[np.ndarray], float]): Objective function to minimize.
initial_solution (np.ndarray): Initial solution vector.
temperature (float): Initial temperature parameter.
cooling_rate (float): Cooling rate parameter.
max_iter (int): Maximum number of iterations.
Returns:
Tuple[np.ndarray, float]: Best solution found and its corresponding objective function value.
"""
current_solution = initial_solution.copy()
current_energy = objective_function(current_solution)
best_solution = current_solution.copy()
best_energy = current_energy
for _ in range(max_iter):
proposed_solution = current_solution + np.random.normal(scale=0.1, size=current_solution.shape)
proposed_energy = objective_function(proposed_solution)
delta_energy = proposed_energy - current_energy
if delta_energy < 0 or np.random.rand() < np.exp(-delta_energy / temperature):
current_solution = proposed_solution
current_energy = proposed_energy
if current_energy < best_energy:
best_solution = current_solution
best_energy = current_energy
temperature *= cooling_rate
return best_solution, best_energy
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/machine-learning/linear-regression | repos/exploratory-tech-studio/tech-studio-projects/algorithms/machine-learning/linear-regression/java/LinearRegression.java | import java.util.Arrays;
/**
* LinearRegression.java
*
* Linear regression is a statistical method used to model the relationship between
* a dependent variable and one or more independent variables. The goal is to find
* the coefficients (parameters) of the linear equation that best fits the observed data.
*
* Matrix Formulation: The linear regression problem can be represented in matrix form
* as X * coefficients = y, where X is the matrix of independent variables (features),
* coefficients is the vector of unknown parameters, and y is the vector of observed
* output values.
*
* Least Squares Method: The coefficients are computed using the least squares method,
* which minimizes the sum of squared differences between the observed and predicted
* output values.
*
* Coefficient of Determination (R^2): The coefficient of determination, often denoted
* as R^2, measures the proportion of the variance in the dependent variable that is
* predictable from the independent variables. It ranges from 0 to 1, with higher values
* indicating a better fit of the model to the data.
*
* Example Usage: In the main method, an example usage of the linearRegression function
* is provided. We define a matrix of input data X and corresponding output values y,
* and then call the linearRegression function to find the coefficients and the coefficient
* of determination. Finally, we print the results.
*/
public class LinearRegression {
/**
* Main method for driving code and example usage of linear regression.
*/
public static void main(String[] args) {
// Example: Linear regression
double[][] X = {{1, 2}, {1, 3}, {1, 4}, {1, 5}};
double[] y = {2, 3, 4, 5};
double[] coefficients = linearRegression(X, y);
System.out.println("Coefficients: " + Arrays.toString(coefficients));
System.out.println("Coefficient of Determination (R^2): " + calculateRSquared(X, y, coefficients));
}
/**
* Perform linear regression to find the coefficients.
*
* @param X Matrix of independent variables (features).
* @param y Vector of dependent variable (target).
* @return Coefficients (parameters) of the linear regression.
*/
public static double[] linearRegression(double[][] X, double[] y) {
int n = X[0].length;
int m = X.length;
// Add a column of ones for the intercept term
double[][] X_with_intercept = new double[m][n + 1];
for (int i = 0; i < m; i++) {
X_with_intercept[i][0] = 1;
System.arraycopy(X[i], 0, X_with_intercept[i], 1, n);
}
// Compute the coefficients using the least squares method
Matrix X_matrix = new Matrix(X_with_intercept);
Matrix y_matrix = new Matrix(y, m);
Matrix coefficients_matrix = X_matrix.transpose().times(X_matrix).inverse().times(X_matrix.transpose()).times(y_matrix);
return coefficients_matrix.getColumnPackedCopy();
}
/**
* Calculate the coefficient of determination (R^2).
*
* @param X Matrix of independent variables (features).
* @param y Vector of dependent variable (target).
* @param coefficients Coefficients of the linear regression.
* @return Coefficient of determination (R^2).
*/
public static double calculateRSquared(double[][] X, double[] y, double[] coefficients) {
int n = X[0].length;
int m = X.length;
// Add a column of ones for the intercept term
double[][] X_with_intercept = new double[m][n + 1];
for (int i = 0; i < m; i++) {
X_with_intercept[i][0] = 1;
System.arraycopy(X[i], 0, X_with_intercept[i], 1, n);
}
// Compute the predicted values
double[] y_pred = new double[m];
for (int i = 0; i < m; i++) {
for (int j = 0; j <= n; j++) {
y_pred[i] += X_with_intercept[i][j] * coefficients[j];
}
}
// Compute the total sum of squares
double ss_total = 0;
for (double value : y) {
ss_total += Math.pow(value - mean(y), 2);
}
// Compute the residual sum of squares
double ss_residual = 0;
for (int i = 0; i < m; i++) {
ss_residual += Math.pow(y[i] - y_pred[i], 2);
}
// Compute the coefficient of determination (R^2)
return 1 - (ss_residual / ss_total);
}
/**
* Calculate the mean of an array of values.
*
* @param arr Input array.
* @return Mean of the array.
*/
public static double mean(double[] arr) {
double sum = 0;
for (double value : arr) {
sum += value;
}
return sum / arr.length;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/machine-learning/linear-regression | repos/exploratory-tech-studio/tech-studio-projects/algorithms/machine-learning/linear-regression/cpp/main.cpp | #include <iostream>
#include <vector>
/**
* LinearRegression.cpp
*
* Linear regression is a statistical method used to model the relationship between
* a dependent variable and one or more independent variables. The goal is to find
* the coefficients (parameters) of the linear equation that best fits the observed data.
*
* Matrix Formulation: The linear regression problem can be represented in matrix form
* as X * coefficients = y, where X is the matrix of independent variables (features),
* coefficients is the vector of unknown parameters, and y is the vector of observed
* output values.
*
* Least Squares Method: The coefficients are computed using the least squares method,
* which minimizes the sum of squared differences between the observed and predicted
* output values.
*
* Coefficient of Determination (R^2): The coefficient of determination, often denoted
* as R^2, measures the proportion of the variance in the dependent variable that is
* predictable from the independent variables. It ranges from 0 to 1, with higher values
* indicating a better fit of the model to the data.
*
* Example Usage: In the main function, an example usage of the linearRegression function
* is provided. We define a matrix of input data X and corresponding output values y,
* and then call the linearRegression function to find the coefficients and the coefficient
* of determination. Finally, we print the results.
*/
using namespace std;
// Class to represent a matrix
class Matrix {
public:
vector<vector<double>> data;
// Constructor
Matrix(const vector<vector<double>>& data) : data(data) {}
// Transpose operation
Matrix transpose() const {
vector<vector<double>> result(data[0].size(), vector<double>(data.size()));
for (size_t i = 0;
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/machine-learning/linear-regression | repos/exploratory-tech-studio/tech-studio-projects/algorithms/machine-learning/linear-regression/python/linear_regression.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""linear_regression.py
Linear regression is a statistical method used to model the relationship between a dependent variable and one or more independent variables. The goal is to find the coefficients (parameters) of the linear equation that best fits the observed data.
Matrix Formulation: The linear regression problem can be represented in matrix form as X * coefficients = y, where X is the matrix of independent variables (features), coefficients is the vector of unknown parameters, and y is the vector of observed output values.
Least Squares Method: The coefficients are computed using the least squares method, which minimizes the sum of squared differences between the observed and predicted output values.
Coefficient of Determination (R^2): The coefficient of determination, often denoted as R^2, measures the proportion of the variance in the dependent variable that is predictable from the independent variables. It ranges from 0 to 1, with higher values indicating a better fit of the model to the data.
Example Usage: In the if __name__ == "__main__": block, an example usage of the linear_regression function is provided. We define a matrix of input data X and corresponding output values y, and then call the linear_regression function to find the coefficients and the coefficient of determination. Finally, we print the results.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
import numpy as np
from typing import Tuple
def main() -> None:
"""Driving code and main function"""
# Example: Linear regression
X = np.array([[1, 2], [1, 3], [1, 4], [1, 5]])
y = np.array([2, 3, 4, 5])
coefficients, r_squared = linear_regression(X, y)
print("Coefficients:", coefficients)
print("Coefficient of Determination (R^2):", r_squared)
return None
def linear_regression(X: np.ndarray, y: np.ndarray) -> Tuple[np.ndarray, float]:
"""Perform linear regression to find the coefficients and the coefficient of determination (R^2).
Args:
X (np.ndarray): Matrix of independent variables (features).
y (np.ndarray): Vector of dependent variable (target).
Returns:
Tuple[np.ndarray, float]: A tuple containing the coefficients (parameters) and the coefficient of determination.
"""
# Add a column of ones for the intercept term
X_with_intercept = np.column_stack([np.ones(len(X)), X])
# Compute the coefficients using the least squares method
coefficients = np.linalg.lstsq(X_with_intercept, y, rcond=None)[0]
# Compute the predicted values
y_pred = np.dot(X_with_intercept, coefficients)
# Compute the total sum of squares
ss_total = np.sum((y - np.mean(y)) ** 2)
# Compute the residual sum of squares
ss_residual = np.sum((y - y_pred) ** 2)
# Compute the coefficient of determination (R^2)
r_squared = 1 - (ss_residual / ss_total)
return coefficients, r_squared
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/cryptography/rsa-encryption | repos/exploratory-tech-studio/tech-studio-projects/algorithms/cryptography/rsa-encryption/java/TravellingSalesmanProblem.java | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class TravellingSalesmanProblem {
private static final int INF = Integer.MAX_VALUE;
public static List<Integer> findMinPath(int[][] graph) {
int n = graph.length;
List<Integer> path = new ArrayList<>();
for (int i = 0; i < n; ++i) {
path.add(i);
}
int minPathCost = INF;
List<Integer> minPath = new ArrayList<>();
do {
int pathCost = 0;
for (int i = 0; i < n - 1; ++i) {
if (graph[path.get(i)][path.get(i + 1)] == 0) {
pathCost = INF;
break;
}
pathCost += graph[path.get(i)][path.get(i + 1)];
}
if (graph[path.get(n - 1)][path.get(0)] == 0) {
pathCost = INF;
} else {
pathCost += graph[path.get(n - 1)][path.get(0)];
}
if (pathCost < minPathCost) {
minPathCost = pathCost;
minPath = new ArrayList<>(path);
}
} while (nextPermutation(path));
return minPath;
}
private static boolean nextPermutation(List<Integer> list) {
int n = list.size();
int i = n - 2;
while (i >= 0 && list.get(i) >= list.get(i + 1)) {
i--;
}
if (i < 0) {
return false;
}
int j = n - 1;
while (list.get(i) >= list.get(j)) {
j--;
}
Collections.swap(list, i, j);
Collections.reverse(list.subList(i + 1, n));
return true;
}
public static void main(String[] args) {
int[][] graph = {
{0, 10, 15, 20},
{10, 0, 35, 25},
{15, 35, 0, 30},
{20, 25, 30, 0}
};
List<Integer> minPath = findMinPath(graph);
System.out.print("Minimum Path: ");
for (int node : minPath) {
System.out.print(node + " ");
}
System.out.println();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/cryptography/rsa-encryption | repos/exploratory-tech-studio/tech-studio-projects/algorithms/cryptography/rsa-encryption/cpp/main.cpp | #include <iostream>
#include <vector>
#include <algorithm>
#include <limits>
using namespace std;
const int INF = numeric_limits<int>::max();
vector<int> findMinPath(const vector<vector<int>>& graph) {
int n = graph.size();
vector<int> path;
for (int i = 0; i < n; ++i) {
path.push_back(i);
}
int minPathCost = INF;
vector<int> minPath;
do {
int pathCost = 0;
for (int i = 0; i < n - 1; ++i) {
if (graph[path[i]][path[i + 1]] == 0) {
pathCost = INF;
break;
}
pathCost += graph[path[i]][path[i + 1]];
}
if (graph[path[n - 1]][path[0]] == 0) {
pathCost = INF;
} else {
pathCost += graph[path[n - 1]][path[0]];
}
if (pathCost < minPathCost) {
minPathCost = pathCost;
minPath = path;
}
} while (next_permutation(path.begin() + 1, path.end()));
return minPath;
}
int main() {
vector<vector<int>> graph = {
{0, 10, 15, 20},
{10, 0, 35, 25},
{15, 35, 0, 30},
{20, 25, 30, 0}
};
vector<int> minPath = findMinPath(graph);
cout << "Minimum Path: ";
for (int node : minPath) {
cout << node << " ";
}
cout << endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/cryptography/rsa-encryption | repos/exploratory-tech-studio/tech-studio-projects/algorithms/cryptography/rsa-encryption/python/rsa-encryption.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""travelling_salesman_problem.py
The RSA encryption algorithm relies on the mathematical properties of modular arithmetic and prime
factorization. Here's a brief explanation of how the program works:
generate_keypair: This function generates a public-private key pair for RSA encryption. It takes
two prime numbers p and q as input and returns the public key (e, n) and the private key (d, n).
The public key consists of e (the encryption exponent) and n (the modulus), while the private key
consists of d (the decryption exponent) and n.
encrypt: This function encrypts a message using RSA encryption. It takes the message as input and
uses the public key (e, n) to encrypt the message.
decrypt: This function decrypts a ciphertext using RSA decryption. It takes the ciphertext as input
and uses the private key (d, n) to decrypt the ciphertext.
gcd, egcd, and modinv: These are helper functions used to compute the greatest common divisor,
extended Euclidean algorithm, and modular multiplicative inverse, respectively. They are used
internally by the RSA encryption and decryption functions.
Example Usage: The example usage section demonstrates how to generate a key pair, encrypt a message,
and decrypt the ciphertext.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
from sys import maxsize
from itertools import permutations
from typing import List, Tuple
def main() -> None:
"""Driving code and main function"""
# Example usage
p = 61
q = 53
public_key, private_key = generate_keypair(p, q)
message = 42
print(f"Original Message: {message}")
ciphertext = encrypt(message, public_key)
print(f"Encrypted Message: {ciphertext}")
decrypted_message = decrypt(ciphertext, private_key)
print(f"Decrypted Message: {decrypted_message}")
return None
def gcd(a: int, b: int) -> int:
"""Compute the greatest common divisor of two integers.
Args:
a (int): The first integer.
b (int): The second integer.
Returns:
int: The greatest common divisor of a and b.
"""
while b != 0:
a, b = b, a % b
return a
def egcd(a: int, b: int) -> Tuple[int, int, int]:
"""Extended Euclidean Algorithm.
Args:
a (int): The first integer.
b (int): The second integer.
Returns:
Tuple[int, int, int]: A tuple (gcd, x, y) such that gcd(a, b) = ax + by.
"""
if a == 0:
return b, 0, 1
else:
gcd, x, y = egcd(b % a, a)
return gcd, y - (b // a) * x, x
def modinv(a: int, m: int) -> int:
"""Compute the modular multiplicative inverse of a modulo m.
Args:
a (int): The integer.
m (int): The modulus.
Returns:
int: The modular multiplicative inverse of a modulo m.
"""
gcd, x, y = egcd(a, m)
if gcd != 1:
raise Exception("Modular inverse does not exist")
else:
return x % m
def generate_keypair(p: int, q: int) -> Tuple[Tuple[int, int], Tuple[int, int]]:
"""Generate a public-private key pair for RSA encryption.
Args:
p (int): A prime number.
q (int): Another prime number.
Returns:
Tuple[Tuple[int, int], Tuple[int, int]]: A tuple containing the public key (e, n)
and the private key (d, n).
"""
n = p * q
phi = (p - 1) * (q - 1)
# Choose an integer e such that e and phi are coprime
e = 2
while gcd(e, phi) != 1:
e += 1
# Compute the modular multiplicative inverse of e modulo phi
d = modinv(e, phi)
return (e, n), (d, n)
def encrypt(message: int, public_key: Tuple[int, int]) -> int:
"""Encrypt a message using RSA encryption.
Args:
message (int): The message to be encrypted.
public_key (Tuple[int, int]): The public key (e, n).
Returns:
int: The encrypted message.
"""
return pow(message, public_key[0], public_key[1])
def decrypt(ciphertext: int, private_key: Tuple[int, int]) -> int:
"""Decrypt a ciphertext using RSA decryption.
Args:
ciphertext (int): The ciphertext to be decrypted.
private_key (Tuple[int, int]): The private key (d, n).
Returns:
int: The decrypted message.
"""
return pow(ciphertext, private_key[0], private_key[1])
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/cryptography/sha256-hashing | repos/exploratory-tech-studio/tech-studio-projects/algorithms/cryptography/sha256-hashing/java/SHA256.java | import java.math.BigInteger;
public class SHA256 {
private static final int[] K = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};
private static final int[] H = {
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
};
private static int[] sha256(byte[] message) {
int[] words = new int[64];
int ml = message.length * 8;
// Pre-processing: Padding the message
int index = 0;
for (byte b : message) {
words[index >> 2] |= (b & 0xFF) << (24 - (index % 4) * 8);
index++;
}
words[index >> 2] |= 0x80 << (24 - (index % 4) * 8);
index++;
// Append the message length as a 64-bit big-endian integer
int offset = words.length - 2;
words[offset] = ml >>> 32;
words[offset + 1] = ml;
// Process the message in 512-bit chunks
for (int chunkStart = 0; chunkStart < words.length; chunkStart += 16) {
int[] chunk = new int[64];
System.arraycopy(words, chunkStart, chunk, 0, 16);
// Extend the 16 32-bit words into 64 32-bit words
for (int i = 16; i < 64; i++) {
int s0 = Integer.rotateRight(chunk[i - 15], 7) ^ Integer.rotateRight(chunk[i - 15], 18) ^ (chunk[i - 15] >>> 3);
int s1 = Integer.rotateRight(chunk[i - 2], 17) ^ Integer.rotateRight(chunk[i - 2], 19) ^ (chunk[i - 2] >>> 10);
chunk[i] = chunk[i - 16] + s0 + chunk[i - 7] + s1;
}
int[] hash = new int[H.length];
System.arraycopy(H, 0, hash, 0, H.length);
// Main loop
for (int i = 0; i < 64; i++) {
int S1 = Integer.rotateRight(hash[4], 6) ^ Integer.rotateRight(hash[4], 11) ^ Integer.rotateRight(hash[4], 25);
int ch = (hash[4] & hash[5]) ^ (~hash[4] & hash[6]);
int temp1 = hash[7] + S1 + ch + K[i] + chunk[i];
int S0 = Integer.rotateRight(hash[0], 2) ^ Integer.rotateRight(hash[0], 13) ^ Integer.rotateRight(hash[0], 22);
int maj = (hash[0] & hash[1]) ^ (hash[0] & hash[2]) ^ (hash[1] & hash[2]);
int temp2 = S0 + maj;
hash[7] = hash[6];
hash[6] = hash[5];
hash[5] = hash[4];
hash[4] = hash[3] + temp1;
hash[3] = hash[2];
hash[2] = hash[1];
hash[1] = hash[0];
hash[0] = temp1 + temp2;
}
// Add the compressed chunk to the current hash value
for (int i = 0; i < H.length; i++) {
H[i] += hash[i];
}
}
return H;
}
private static String toHexString(int[] array) {
StringBuilder sb = new StringBuilder();
for (int value : array) {
sb.append(String.format("%08x", value));
}
return sb.toString();
}
public static String sha256(byte[] message) {
return toHexString(sha256(message));
}
public static void main(String[] args) {
byte[] message = "Hello, world!".getBytes();
System.out.println("Message: " + new String(message));
System.out.println("SHA-256 Hash: " + sha256(message));
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/cryptography/sha256-hashing | repos/exploratory-tech-studio/tech-studio-projects/algorithms/cryptography/sha256-hashing/cpp/main.cpp | #include <iostream>
#include <cstdint>
#include <cstring>
#include <vector>
class SHA256 {
private:
static const uint32_t K[64];
static const uint32_t H[8];
static uint32_t rightRotate(uint32_t x, int n) {
return (x >> n) | (x << (32 - n));
}
static std::vector<uint32_t> sha256(const uint8_t* message, size_t length) {
std::vector<uint32_t> words(64, 0);
size_t ml = length * 8;
// Pre-processing: Padding the message
size_t index = 0;
for (size_t i = 0; i < length; ++i) {
words[index >> 2] |= static_cast<uint32_t>(message[i]) << (24 - (index % 4) * 8);
index++;
}
words[index >> 2] |= 0x80 << (24 - (index % 4) * 8);
index++;
// Append the message length as a 64-bit big-endian integer
size_t offset = words.size() - 2;
words[offset] = ml >> 32;
words[offset + 1] = ml;
// Process the message in 512-bit chunks
for (size_t chunkStart = 0; chunkStart < words.size(); chunkStart += 16) {
std::vector<uint32_t> chunk(words.begin() + chunkStart, words.begin() + chunkStart + 16);
// Extend the 16 32-bit words into 64 32-bit words
for (size_t i = 16; i < 64; i++) {
uint32_t s0 = rightRotate(chunk[i - 15], 7) ^ rightRotate(chunk[i - 15], 18) ^ (chunk[i - 15] >> 3);
uint32_t s1 = rightRotate(chunk[i - 2], 17) ^ rightRotate(chunk[i - 2], 19) ^ (chunk[i - 2] >> 10);
chunk.push_back(chunk[i - 16] + s0 + chunk[i - 7] + s1);
}
std::vector<uint32_t> hash(H, H + 8);
// Main loop
for (size_t i = 0; i < 64; i++) {
uint32_t S1 = rightRotate(hash[4], 6) ^ rightRotate(hash[4], 11) ^ rightRotate(hash[4], 25);
uint32_t ch = (hash[4] & hash[5]) ^ (~hash[4] & hash[6]);
uint32_t temp1 = hash[7] + S1 + ch + K[i] + chunk[i];
uint32_t S0 = rightRotate(hash[0], 2) ^ rightRotate(hash[0], 13) ^ rightRotate(hash[0], 22);
uint32_t maj = (hash[0] & hash[1]) ^ (hash[0] & hash[2]) ^ (hash[1] & hash[2]);
uint32_t temp2 = S0 + maj;
hash[7] = hash[6];
hash[6] = hash[5];
hash[5] = hash[4];
hash[4] = hash[3] + temp1;
hash[3] = hash[2];
hash[2] = hash[1];
hash[1] = hash[0];
hash[0] = temp1 + temp2;
}
// Add the compressed chunk to the current hash value
for (size_t i = 0; i < 8; i++) {
H[i] += hash[i];
}
}
return H;
}
public:
static std::string sha256(const uint8_t* message, size_t length) {
std::vector<uint32_t> result = sha256(message, length);
std::string hash;
for (uint32_t val : result) {
char buffer[9];
snprintf(buffer, sizeof(buffer), "%08x", val);
hash += buffer;
}
return hash;
}
};
const uint32_t SHA256::K[64] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/cryptography/sha256-hashing | repos/exploratory-tech-studio/tech-studio-projects/algorithms/cryptography/sha256-hashing/python/sha256_hashing.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""travelling_salesman_problem.py
The Secure Hash Algorithm (SHA-256) is a cryptographic hash function that produces a 256-bit (32-byte) hash
value. The algorithm operates on messages of any length less than $2^{64}$ bits, and it produces a fixed-size
output regardless of the size of the input message.
The SHA-256 algorithm consists of several logical steps:
Pre-processing: Padding the message to ensure its length is congruent to 448 modulo 512. This is
followed by appending the message length in bits as a 64-bit big-endian integer.
Breaking the message into 512-bit chunks: The message is divided into chunks of 512 bits (64 bytes).
Processing each chunk: Each chunk is processed in the main loop, where it is divided into 16 32-bit words.
These words are extended into 64 32-bit words using a specified algorithm. The main loop then operates
on these words to produce intermediate hash values.
Updating the hash values: After processing each chunk, the current hash values are updated based on the
intermediate hash values.
Producing the final hash value: Once all chunks have been processed, the final hash value is obtained by
concatenating the current hash values in a specific order and converting them to hexadecimal format.
The sha256 function provided in the code computes the SHA-256 hash of a given message. It takes a bytes
object as input and returns the hash value as a hexadecimal string. The example usage demonstrates how to
hash a message using this function.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
import math
from typing import List, Tuple
# Constants defined by the SHA-256 algorithm
K = [
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
]
# Initial hash values (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19)
H = [
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
]
def main() -> None:
"""Driving code and main function"""
message = b'Hello, world!'
hashed_message = sha256(message)
print(f"Message: {message.decode()}")
print(f"SHA-256 Hash: {hashed_message}")
return None
def right_rotate(x: int, n: int) -> int:
"""Perform a right rotate operation on an integer.
Args:
x (int): The integer to be rotated.
n (int): The number of positions to rotate by.
Returns:
int: The result of the right rotate operation.
"""
return (x >> n) | (x << (32 - n)) & 0xFFFFFFFF
def sha256(message: bytes) -> str:
"""Compute the SHA-256 hash of a message.
Args:
message (bytes): The input message to be hashed.
Returns:
str: The SHA-256 hash of the message in hexadecimal format.
"""
# Pre-processing: Padding the message
ml = len(message) * 8
message += b'\x80' # Append a single '1' bit
while (len(message) * 8) % 512 != 448:
message += b'\x00' # Append zeros until the length is congruent to 448 mod 512
message += ml.to_bytes(8, 'big') # Append the message length as a 64-bit big-endian integer
# Process the message in 512-bit chunks
chunks = [message[i:i+64] for i in range(0, len(message), 64)]
for chunk in chunks:
# Break chunk into 16 32-bit words
words = [int.from_bytes(chunk[i:i+4], 'big') for i in range(0, 64, 4)]
# Extend the 16 32-bit words into 64 32-bit words
for i in range(16, 64):
s0 = right_rotate(words[i-15], 7) ^ right_rotate(words[i-15], 18) ^ (words[i-15] >> 3)
s1 = right_rotate(words[i-2], 17) ^ right_rotate(words[i-2], 19) ^ (words[i-2] >> 10)
words.append((words[i-16] + s0 + words[i-7] + s1) & 0xFFFFFFFF)
# Initialize hash values for this chunk
a, b, c, d, e, f, g, h = H
# Main loop
for i in range(64):
S1 = right_rotate(e, 6) ^ right_rotate(e, 11) ^ right_rotate(e, 25)
ch = (e & f) ^ (~e & g)
temp1 = (h + S1 + ch + K[i] + words[i]) & 0xFFFFFFFF
S0 = right_rotate(a, 2) ^ right_rotate(a, 13) ^ right_rotate(a, 22)
maj = (a & b) ^ (a & c) ^ (b & c)
temp2 = (S0 + maj) & 0xFFFFFFFF
h = g
g = f
f = e
e = (d + temp1) & 0xFFFFFFFF
d = c
c = b
b = a
a = (temp1 + temp2) & 0xFFFFFFFF
# Add the compressed chunk to the current hash value
H[0] = (H[0] + a) & 0xFFFFFFFF
H[1] = (H[1] + b) & 0xFFFFFFFF
H[2] = (H[2] + c) & 0xFFFFFFFF
H[3] = (H[3] + d) & 0xFFFFFFFF
H[4] = (H[4] + e) & 0xFFFFFFFF
H[5] = (H[5] + f) & 0xFFFFFFFF
H[6] = (H[6] + g) & 0xFFFFFFFF
H[7] = (H[7] + h) & 0xFFFFFFFF
# Produce the final hash value
return ''.join(format(x, '08x') for x in H)
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/divide-and-conquer/lowest-common-ancestor | repos/exploratory-tech-studio/tech-studio-projects/algorithms/divide-and-conquer/lowest-common-ancestor/java/LowestCommonAncestor.java | import java.util.ArrayList;
import java.util.List;
class Node {
int val;
Node left, right;
Node(int key) {
val = key;
left = right = null;
}
}
public class LowestCommonAncestor {
/**
* Find the path from the root node to the given node.
*
* @param root The root of the tree.
* @param path List to store the path.
* @param k The target node value.
* @return True if the path exists, otherwise false.
*/
private static boolean findPath(Node root, List<Integer> path, int k) {
// Base Case
if (root == null)
return false;
// Store the current node in the path
path.add(root.val);
// Check if the current node is the target node
if (root.val == k)
return true;
// Check if the target node is found in the left or right subtree
if ((root.left != null && findPath(root.left, path, k)) ||
(root.right != null && findPath(root.right, path, k)))
return true;
// If the target node is not found, remove the current node from the path and return false
path.remove(path.size() - 1);
return false;
}
/**
* Find the lowest common ancestor (LCA) of two nodes in a binary tree.
*
* @param root The root of the tree.
* @param n1 The value of the first node.
* @param n2 The value of the second node.
* @return The value of the lowest common ancestor, or -1 if either node is not present.
*/
public static int findLCA(Node root, int n1, int n2) {
List<Integer> path1 = new ArrayList<>();
List<Integer> path2 = new ArrayList<>();
// Find paths from root to n1 and root to n2. If either n1 or n2 is not present, return -1
if (!findPath(root, path1, n1) || !findPath(root, path2, n2))
return -1;
// Compare the paths to get the first different value
int i;
for (i = 0; i < path1.size() && i < path2.size(); i++) {
if (!path1.get(i).equals(path2.get(i)))
break;
}
return path1.get(i - 1);
}
public static void main(String[] args) {
// Example usage
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);
// Example call to find the lowest common ancestor of nodes 4 and 6
int lca = findLCA(root, 4, 6);
System.out.println("Lowest Common Ancestor of 4 and 6: " + lca);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/divide-and-conquer/lowest-common-ancestor | repos/exploratory-tech-studio/tech-studio-projects/algorithms/divide-and-conquer/lowest-common-ancestor/cpp/main.cpp | #include <iostream>
#include <vector>
using namespace std;
class Node {
public:
int val;
Node* left;
Node* right;
Node(int key) {
val = key;
left = right = nullptr;
}
};
/**
* Find the path from the root node to the given node.
*
* @param root The root of the tree.
* @param path Vector to store the path.
* @param k The target node value.
* @return True if the path exists, otherwise false.
*/
bool findPath(Node* root, vector<int>& path, int k) {
// Base Case
if (root == nullptr)
return false;
// Store the current node in the path
path.push_back(root->val);
// Check if the current node is the target node
if (root->val == k)
return true;
// Check if the target node is found in the left or right subtree
if ((root->left && findPath(root->left, path, k)) ||
(root->right && findPath(root->right, path, k)))
return true;
// If the target node is not found, remove the current node from the path and return false
path.pop_back();
return false;
}
/**
* Find the lowest common ancestor (LCA) of two nodes in a binary tree.
*
* @param root The root of the tree.
* @param n1 The value of the first node.
* @param n2 The value of the second node.
* @return The value of the lowest common ancestor, or -1 if either node is not present.
*/
int findLCA(Node* root, int n1, int n2) {
vector<int> path1, path2;
// Find paths from root to n1 and root to n2. If either n1 or n2 is not present, return -1
if (!findPath(root, path1, n1) || !findPath(root, path2, n2))
return -1;
// Compare the paths to get the first different value
int i;
for (i = 0; i < path1.size() && i < path2.size(); i++) {
if (path1[i] != path2[i])
break;
}
return path1[i - 1];
}
int main() {
// Example usage
Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(3);
root->left->left = new Node(4);
root->left->right = new Node(5);
root->right->left = new Node(6);
root->right->right = new Node(7);
// Example call to find the lowest common ancestor of nodes 4 and 6
int lca = findLCA(root, 4, 6);
cout << "Lowest Common Ancestor of 4 and 6: " << lca << endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/divide-and-conquer/lowest-common-ancestor | repos/exploratory-tech-studio/tech-studio-projects/algorithms/divide-and-conquer/lowest-common-ancestor/python/lowest_common_ancestor.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""lowest_common_ancestor.py
The Lowest Common Ancestor (LCA) algorithm is used to find the lowest common ancestor of two nodes in a tree or directed acyclic graph (DAG). The lowest common ancestor of two nodes u and v in a tree is the lowest (i.e., deepest) node that has both u and v as descendants.
Here's a general overview of the LCA algorithm:
Tree Representation: The tree is typically represented as an adjacency list, adjacency matrix, or as a collection of nodes with parent pointers.
Depth Calculation: First, calculate the depth (or level) of each node in the tree. This can be done using a depth-first search (DFS) or breadth-first search (BFS) traversal.
Parent Pointers: Next, create parent pointers for each node, allowing you to navigate from a node to its parent.
Finding the LCA: Given two nodes u and v, compare their depths. If u is deeper than v, move u up the tree until it is at the same level as v. Similarly, if v is deeper, move v up the tree until it is at the same level as u. Then, simultaneously move both u and v up the tree until they meet at the lowest common ancestor.
Here's a high-level overview of the steps involved in finding the LCA of two nodes u and v:
Calculate the depths of nodes u and v.
Move the deeper node up the tree until it is at the same level as the other node.
Move both nodes up the tree simultaneously until they meet at the lowest common ancestor.
The time complexity of the LCA algorithm depends on the method used to traverse the tree and calculate depths. In a binary tree, the time complexity is typically O(log N), where N is the number of nodes in the tree. However, in a general tree or DAG, the time complexity may vary depending on the specific implementation.
Overall, the LCA algorithm is a fundamental operation in tree and graph algorithms, commonly used in applications such as finding the nearest common ancestor in genealogical trees, solving various graph-related problems, and implementing efficient data structures like disjoint-set forests.
.. _PEP 484:
https://www.python.org/dev/peps/pep-0484/
"""
class Node:
"""
A class representing an individual node in a binary tree
"""
def __init__(self, key):
self.left = None
self.right = None
self.val = key
def find_lca(root, n1, n2):
# To store paths to n1 and n2 from the root
path1 = []
path2 = []
# Find paths from root to n1 and root to n2.
# If either n1 or n2 is not present, return -1
if (not find_path(root, path1, n1) or not find_path(root, path2, n2)):
return -1
# Compare the paths to get the first different value
i = 0
while(i < len(path1) and i < len(path2)):
if path1[i] != path2[i]:
break
i += 1
return path1[i-1]
# Finds the path from the root node to the given root of the tree.
# Stores the path in a list path[], returns true if the path
# exists, otherwise false
def find_path(root, path, k):
# Base Case
if root is None:
return False
# Store the current node in the path
path.append(root.val)
# Check if the current node is the target node
if root.val == k:
return True
# Check if the target node is found in the left or right subtree
if ((root.left is not None and find_path(root.left, path, k)) or
(root.right is not None and find_path(root.right, path, k))):
return True
# If the target node is not found in the subtree rooted with root, remove the current node from the path and return False
path.pop()
return False
if __name__ == '__main__':
# Example usage
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
root.right.left = Node(6)
root.right.right = Node(7)
# Example call to find the lowest common ancestor of nodes 4 and 6
lca = find_lca(root, 4, 6)
print("Lowest Common Ancestor of 4 and 6:", lca)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/binary-search-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/binary-search-tree/java/Main.java | package algorithms.trees.binary-search-tree.java;
public class Main {
public static void main(String[] args) {
// Example: Create a binary search tree and perform insertions
BinarySearchTree bst = new BinarySearchTree();
int[] keys = { 10, 5, 15, 3, 7, 12, 17 };
for (int key : keys) {
bst.insert(key);
}
// Perform inorder traversal to print keys in sorted order
System.out.println("Inorder traversal of the binary search tree:");
bst.inorderTraversal();
// Search for a key in the binary search tree
int searchKey = 7;
TreeNode result = bst.search(searchKey);
if (result != null) {
System.out.println("Key " + searchKey + " found in the binary search tree.");
} else {
System.out.println("Key " + searchKey + " not found in the binary search tree.");
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/binary-search-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/binary-search-tree/java/BinarySearchTree.java | public class BinarySearchTree {
private TreeNode root;
/**
* TreeNode: Represents a node in the binary search tree.
*/
private static class TreeNode {
int key;
TreeNode left;
TreeNode right;
TreeNode(int key) {
this.key = key;
left = null;
right = null;
}
}
/**
* Constructor: Initializes an empty binary search tree.
*/
public BinarySearchTree() {
root = null;
}
/**
* Insert a key into the binary search tree.
*
* @param key The key to be inserted.
*/
public void insert(int key) {
root = insertRec(root, key);
}
/**
* Recursively insert a key into the binary search tree.
*
* @param root The root of the current subtree.
* @param key The key to be inserted.
* @return The root of the updated subtree.
*/
private TreeNode insertRec(TreeNode root, int key) {
if (root == null) {
return new TreeNode(key);
}
if (key < root.key) {
root.left = insertRec(root.left, key);
} else if (key > root.key) {
root.right = insertRec(root.right, key);
}
return root;
}
/**
* Search for a key in the binary search tree.
*
* @param key The key to search for.
* @return The TreeNode containing the key, or null if key is not found.
*/
public TreeNode search(int key) {
return searchRec(root, key);
}
/**
* Recursively search for a key in the binary search tree.
*
* @param root The root of the current subtree.
* @param key The key to search for.
* @return The TreeNode containing the key, or null if key is not found.
*/
private TreeNode searchRec(TreeNode root, int key) {
if (root == null || root.key == key) {
return root;
}
if (key < root.key) {
return searchRec(root.left, key);
} else {
return searchRec(root.right, key);
}
}
/**
* Perform an inorder traversal of the binary search tree.
*/
public void inorderTraversal() {
inorderTraversalRec(root);
System.out.println();
}
/**
* Recursively perform an inorder traversal of the binary search tree.
*
* @param root The root of the current subtree.
*/
private void inorderTraversalRec(TreeNode root) {
if (root != null) {
inorderTraversalRec(root.left);
System.out.print(root.key + " ");
inorderTraversalRec(root.right);
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/binary-search-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/binary-search-tree/cpp/BinarySearchTree.cpp | #include <iostream>
class BinarySearchTree {
private:
struct TreeNode {
int key;
TreeNode* left;
TreeNode* right;
TreeNode(int key) : key(key), left(nullptr), right(nullptr) {}
};
TreeNode* root;
/**
* Recursively insert a key into the binary search tree.
*
* @param root The root of the current subtree.
* @param key The key to be inserted.
* @return The root of the updated subtree.
*/
TreeNode* insertRec(TreeNode* root, int key) {
if (root == nullptr) {
return new TreeNode(key);
}
if (key < root->key) {
root->left = insertRec(root->left, key);
} else if (key > root->key) {
root->right = insertRec(root->right, key);
}
return root;
}
/**
* Recursively search for a key in the binary search tree.
*
* @param root The root of the current subtree.
* @param key The key to search for.
* @return The TreeNode containing the key, or nullptr if key is not found.
*/
TreeNode* searchRec(TreeNode* root, int key) {
if (root == nullptr || root->key == key) {
return root;
}
if (key < root->key) {
return searchRec(root->left, key);
} else {
return searchRec(root->right, key);
}
}
/**
* Recursively perform an inorder traversal of the binary search tree.
*
* @param root The root of the current subtree.
*/
void inorderTraversalRec(TreeNode* root) {
if (root != nullptr) {
inorderTraversalRec(root->left);
std::cout << root->key << " ";
inorderTraversalRec(root->right);
}
}
public:
/**
* Constructor: Initializes an empty binary search tree.
*/
BinarySearchTree() : root(nullptr) {}
/**
* Insert a key into the binary search tree.
*
* @param key The key to be inserted.
*/
void insert(int key) {
root = insertRec(root, key);
}
/**
* Search for a key in the binary search tree.
*
* @param key The key to search for.
* @return The TreeNode containing the key, or nullptr if key is not found.
*/
TreeNode* search(int key) {
return searchRec(root, key);
}
/**
* Perform an inorder traversal of the binary search tree.
*/
void inorderTraversal() {
inorderTraversalRec(root);
std::cout << std::endl;
}
};
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/binary-search-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/binary-search-tree/cpp/main.cpp | int main() {
// Example: Create a binary search tree and perform insertions
BinarySearchTree bst;
int keys[] = {10, 5, 15, 3, 7, 12, 17};
for (int key : keys) {
bst.insert(key);
}
// Perform inorder traversal to print keys in sorted order
std::cout << "Inorder traversal of the binary search tree:" << std::endl;
bst.inorderTraversal();
// Search for a key in the binary search tree
int searchKey = 7;
BinarySearchTree::TreeNode* result = bst.search(searchKey);
if (result != nullptr) {
std::cout << "Key " << searchKey << " found in the binary search tree." << std::endl;
} else {
std::cout << "Key " << searchKey << " not found in the binary search tree." << std::endl;
}
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/minimum-spanning-tree-with-kruskal | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/minimum-spanning-tree-with-kruskal/java/Main.java | public class Main {
public static void main(String[] args) {
// Example usage
Graph g = new Graph(4);
g.addEdge(0, 1, 10);
g.addEdge(0, 2, 6);
g.addEdge(0, 3, 5);
g.addEdge(1, 3, 15);
g.addEdge(2, 3, 4);
// Function call
g.kruskalMST();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/minimum-spanning-tree-with-kruskal | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/minimum-spanning-tree-with-kruskal/java/Graph.java | import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Graph {
private int V;
private List<Edge> graph;
public Graph(int vertices) {
V = vertices;
graph = new ArrayList<>();
}
public void addEdge(int u, int v, int w) {
graph.add(new Edge(u, v, w));
}
private int find(int[] parent, int i) {
if (parent[i] != i) {
parent[i] = find(parent, parent[i]);
}
return parent[i];
}
private void union(int[] parent, int[] rank, int x, int y) {
int rootX = find(parent, x);
int rootY = find(parent, y);
if (rank[rootX] < rank[rootY]) {
parent[rootX] = rootY;
} else if (rank[rootX] > rank[rootY]) {
parent[rootY] = rootX;
} else {
parent[rootY] = rootX;
rank[rootX]++;
}
}
public void kruskalMST() {
List<Edge> result = new ArrayList<>();
int i = 0;
int e = 0;
Collections.sort(graph, Comparator.comparingInt(Edge::getWeight));
int[] parent = new int[V];
int[] rank = new int[V];
for (int node = 0; node < V; ++node) {
parent[node] = node;
}
while (e < V - 1) {
Edge edge = graph.get(i++);
int u = edge.getU();
int v = edge.getV();
int x = find(parent, u);
int y = find(parent, v);
if (x != y) {
e++;
result.add(edge);
union(parent, rank, x, y);
}
}
int minimumCost = 0;
System.out.println("Edges in the constructed MST:");
for (Edge edge : result) {
int u = edge.getU();
int v = edge.getV();
int weight = edge.getWeight();
minimumCost += weight;
System.out.println(u + " -- " + v + " == " + weight);
}
System.out.println("Minimum Spanning Tree: " + minimumCost);
}
static class Edge {
private int u;
private int v;
private int weight;
public Edge(int u, int v, int weight) {
this.u = u;
this.v = v;
this.weight = weight;
}
public int getU() {
return u;
}
public int getV() {
return v;
}
public int getWeight() {
return weight;
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/minimum-spanning-tree-with-kruskal | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/minimum-spanning-tree-with-kruskal/cpp/Graph.cpp | #include "Graph.h"
#include <algorithm>
#include <iostream>
Graph::Graph(int vertices) : V(vertices) {}
void Graph::addEdge(int u, int v, int w) {
graph.push_back(std::make_tuple(u, v, w));
}
int Graph::find(std::vector<int>& parent, int i) {
if (parent[i] != i) {
parent[i] = find(parent, parent[i]);
}
return parent[i];
}
void Graph::unionSets(std::vector<int>& parent, std::vector<int>& rank, int x, int y) {
int rootX = find(parent, x);
int rootY = find(parent, y);
if (rank[rootX] < rank[rootY]) {
parent[rootX] = rootY;
} else if (rank[rootX] > rank[rootY]) {
parent[rootY] = rootX;
} else {
parent[rootY] = rootX;
rank[rootX]++;
}
}
void Graph::KruskalMST() {
std::vector<std::tuple<int, int, int>> result;
int i = 0;
int e = 0;
std::sort(graph.begin(), graph.end(), [](const std::tuple<int, int, int>& a, const std::tuple<int, int, int>& b) {
return std::get<2>(a) < std::get<2>(b);
});
std::vector<int> parent(V);
std::vector<int> rank(V, 0);
for (int node = 0; node < V; ++node) {
parent[node] = node;
}
while (e < V - 1) {
int u, v, w;
std::tie(u, v, w) = graph[i++];
int x = find(parent, u);
int y = find(parent, v);
if (x != y) {
e++;
result.push_back(std::make_tuple(u, v, w));
unionSets(parent, rank, x, y);
}
}
int minimumCost = 0;
std::cout << "Edges in the constructed MST:" << std::endl;
for (const auto& edge : result) {
int u, v, weight;
std::tie(u, v, weight) = edge;
minimumCost += weight;
std::cout << u << " -- " << v << " == " << weight << std::endl;
}
std::cout << "Minimum Spanning Tree: " << minimumCost << std::endl;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/minimum-spanning-tree-with-kruskal | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/minimum-spanning-tree-with-kruskal/cpp/Graph.h | #ifndef GRAPH_H
#define GRAPH_H
#include <vector>
#include <tuple>
class Graph {
public:
Graph(int vertices);
void addEdge(int u, int v, int w);
void KruskalMST();
private:
int V;
std::vector<std::tuple<int, int, int>> graph;
int find(std::vector<int>& parent, int i);
void unionSets(std::vector<int>& parent, std::vector<int>& rank, int x, int y);
};
#endif // GRAPH_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/minimum-spanning-tree-with-kruskal | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/minimum-spanning-tree-with-kruskal/cpp/main.cpp | #include "Graph.h"
int main() {
// Example usage
Graph g(4);
g.addEdge(0, 1, 10);
g.addEdge(0, 2, 6);
g.addEdge(0, 3, 5);
g.addEdge(1, 3, 15);
g.addEdge(2, 3, 4);
// Function call
g.KruskalMST();
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/fenwick-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/fenwick-tree/java/FenwickTree.java | public class FenwickTree {
private int size;
private int[] tree;
public FenwickTree(int size) {
this.size = size;
this.tree = new int[size + 1];
}
public void update(int index, int delta) {
while (index <= size) {
tree[index] += delta;
index += index & -index;
}
}
public int query(int index) {
int result = 0;
while (index > 0) {
result += tree[index];
index -= index & -index;
}
return result;
}
public int rangeQuery(int start, int end) {
return query(end) - (start > 0 ? query(start - 1) : 0);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/fenwick-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/fenwick-tree/java/Main.java | public class Main {
public static void main(String[] args) {
// Example usage
int[] nums = {1, 3, 5, 7, 9, 11, 13, 15};
FenwickTree fenwickTree = new FenwickTree(nums.length);
for (int i = 0; i < nums.length; i++) {
fenwickTree.update(i + 1, nums[i]);
}
// Print prefix sums
for (int i = 0; i <= nums.length; i++) {
System.out.println("Prefix sum up to index " + i + ": " + fenwickTree.query(i));
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/fenwick-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/fenwick-tree/cpp/FenwickTree.h | #ifndef FENWICKTREE_H
#define FENWICKTREE_H
#include <vector>
class FenwickTree {
private:
int size;
std::vector<int> tree;
public:
FenwickTree(int size);
void update(int index, int delta);
int query(int index);
int rangeQuery(int start, int end);
};
#endif
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/fenwick-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/fenwick-tree/cpp/main.cpp | #include <iostream>
#include "FenwickTree.h"
int main() {
// Example usage
std::vector<int> nums = {1, 3, 5, 7, 9, 11, 13, 15};
FenwickTree fenwickTree(nums.size());
for (int i = 0; i < nums.size(); ++i) {
fenwickTree.update(i + 1, nums[i]);
}
// Print prefix sums
for (int i = 0; i <= nums.size(); ++i) {
std::cout << "Prefix sum up to index " << i << ": " << fenwickTree.query(i) << std::endl;
}
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/fenwick-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/fenwick-tree/cpp/FenwickTree.cpp | #include "FenwickTree.h"
FenwickTree::FenwickTree(int size) : size(size), tree(size + 1, 0) {}
void FenwickTree::update(int index, int delta) {
while (index <= size) {
tree[index] += delta;
index += index & -index;
}
}
int FenwickTree::query(int index) {
int result = 0;
while (index > 0) {
result += tree[index];
index -= index & -index;
}
return result;
}
int FenwickTree::rangeQuery(int start, int end) {
return query(end) - (start > 0 ? query(start - 1) : 0);
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree/java/PrefixTreeTest.java | import org.junit.Assert;
import org.junit.Test;
import java.awt.geom.CubicCurve2D;
public class PrefixTreeTest {
@Test
public void insertTest() {
PrefixTree tree = new PrefixTree();
tree.insert("cat".toCharArray(), 1);
tree.insert("door".toCharArray(), 2);
tree.insert("cats".toCharArray(), 3);
System.out.println(tree.root);
Assert.assertTrue(tree.root.getChildren('c').getChildren('a').getChildren('t').isWord);
Assert.assertEquals('c', tree.root.getChildren('c').c);
Assert.assertEquals(0, tree.root.getChildren('c').id);
Assert.assertEquals('a', tree.root.getChildren('c').getChildren('a').c);
Assert.assertEquals(0, tree.root.getChildren('c').getChildren('a').id);
Assert.assertEquals('t', tree.root.getChildren('c').getChildren('a').getChildren('t').c);
Assert.assertEquals(1, tree.root.getChildren('c').getChildren('a').getChildren('t').id);
}
@Test
public void findTest() {
PrefixTree tree = new PrefixTree();
tree.insert("cat".toCharArray(), 1);
tree.insert("door".toCharArray(), 2);
tree.insert("cats".toCharArray(), 3);
Assert.assertEquals(3, tree.find("cats".toCharArray()).id);
Assert.assertEquals(2, tree.find("door".toCharArray()).id);
Assert.assertEquals(1, tree.find("cat".toCharArray()).id);
Assert.assertTrue(tree.find("cat".toCharArray()).isWord);
Assert.assertTrue(tree.find("cats".toCharArray()).isWord);
Assert.assertTrue(tree.find("door".toCharArray()).isWord);
Assert.assertNull(tree.find("canfind".toCharArray()));
}
@Test
public void deleteTest() {
PrefixTree tree = new PrefixTree();
tree.insert("cat".toCharArray(), 1);
tree.insert("cats".toCharArray(), 2);
tree.insert("door".toCharArray(), 3);
tree.insert("done".toCharArray(), 4);
tree.insert("horse".toCharArray(), 5);
System.out.println(tree.root);
tree.delete("horse".toCharArray());
System.out.println(tree.root);
tree.delete("cat".toCharArray());
System.out.println(tree.root);
tree.delete("cats".toCharArray());
System.out.println(tree.root);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree/java/PrefixNode.java | import java.util.HashMap;
import java.util.Map;
public class PrefixNode {
char c;
int id;
Map<Character, PrefixNode> children;
boolean isWord = false;
public PrefixNode() {
c = 0;
id = 0;
}
public PrefixNode(char c, int id) {
this.c = c;
this.id = id;
}
public boolean hasChildren(char c) {
return (children != null && children.containsKey(c));
}
public PrefixNode getChildren(char c) {
if (!hasChildren(c)) return null;
return children.get(c);
}
public void addChildren(PrefixNode node) {
if (children == null) children = new HashMap<Character, PrefixNode>();
if (!hasChildren(node.c)) children.put(node.c, node);
}
public boolean canDelete() {
if (children == null || children.size() == 0) return true;
return false;
}
@Override
public String toString() {
if(children != null) return c + (isWord?"." + id:"") + "->[" + children.values() + "]";
return c + "." + id;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree/java/Main.java | public class Main {
public static void main(String[] args) {
char[] charArray = {'a','b','a','b','a','a','b','a','b'};
char[] charPattern = {'a','b'};
PrefixTree pft = new PrefixTree();
pft.insert(charArray, 2);
}
} |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree/java/PrefixTree.java | public class PrefixTree {
PrefixNode root;
public PrefixTree() {
root = new PrefixNode();
}
/**
* r->cat
* _
* @param word
* @param id
*/
public void insert(char[] word, int id) {
PrefixNode current = root;
for (int i=0; i<word.length; i++) {
if (current.hasChildren(word[i])) {
current = current.getChildren(word[i]);
} else {
PrefixNode node = new PrefixNode(word[i], 0);
current.addChildren(node);
current = node;
}
}
current.isWord = true;
current.id = id;
}
public PrefixNode find(char[] word) {
PrefixNode current = root;
for(int i=0; i<word.length; i++) {
if (current.hasChildren(word[i])) {
current = current.getChildren(word[i]);
} else {
return null;
}
}
return current;
}
public boolean delete(char[] word) {
return delete(word, root, 0);
}
public boolean delete(char[] word, PrefixNode node, int wIndex) {
if (wIndex == word.length-1) {
PrefixNode w = node.getChildren(word[wIndex]);
w.isWord = false;
w.id = 0;
if (w.canDelete()) {
node.children.remove(word[wIndex]);
return true;
}
} else {
if (!node.hasChildren(word[wIndex])) return false;
boolean canDelete = delete(word, node.getChildren(word[wIndex]), ++wIndex);
if (canDelete) {
if (node.getChildren(word[--wIndex]).isWord) return false;
node.children.remove(word[wIndex]);
return true;
}
}
return false;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree/cpp/Trie.h | #ifndef TRIE_H
#define TRIE_H
#include "TrieNode.h"
#include <string>
class Trie {
public:
TrieNode* root;
Trie();
void insert(std::string word);
bool search(std::string word);
bool starts_with(std::string prefix);
};
#endif // TRIE_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree/cpp/Trie.cpp | #include "Trie.h"
Trie::Trie() {
root = new TrieNode();
}
void Trie::insert(std::string word) {
TrieNode* node = root;
for (char c : word) {
if (node->children.find(c) == node->children.end()) {
node->children[c] = new TrieNode();
}
node = node->children[c];
}
node->is_end_of_word = true;
}
bool Trie::search(std::string word) {
TrieNode* node = root;
for (char c : word) {
if (node->children.find(c) == node->children.end()) {
return false;
}
node = node->children[c];
}
return node->is_end_of_word;
}
bool Trie::starts_with(std::string prefix) {
TrieNode* node = root;
for (char c : prefix) {
if (node->children.find(c) == node->children.end()) {
return false;
}
node = node->children[c];
}
return true;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree/cpp/TrieNode.cpp | #include "TrieNode.h"
TrieNode::TrieNode() {
is_end_of_word = false;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree/cpp/TrieNode.h | #ifndef TRIE_NODE_H
#define TRIE_NODE_H
#include <unordered_map>
class TrieNode {
public:
std::unordered_map<char, TrieNode*> children;
bool is_end_of_word;
TrieNode();
};
#endif // TRIE_NODE_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/prefix-tree/cpp/main.cpp | #include <iostream>
#include "Trie.h"
int main() {
Trie trie;
std::vector<std::string> words = {"apple", "banana", "apricot", "app", "bat", "cat", "car"};
for (std::string word : words) {
trie.insert(word);
}
std::cout << trie.search("apple") << std::endl; // Output: 1
std::cout << trie.search("banana") << std::endl; // Output: 1
std::cout << trie.search("apricot") << std::endl; // Output: 1
std::cout << trie.search("app") << std::endl; // Output: 1
std::cout << trie.search("bat") << std::endl; // Output: 1
std::cout << trie.search("cat") << std::endl; // Output: 1
std::cout << trie.search("car") << std::endl; // Output: 1
std::cout << trie.search("ap") << std::endl; // Output: 0
std::cout << trie.search("ba") << std::endl; // Output: 0
std::cout << trie.search("ca") << std::endl; // Output: 0
std::cout << trie.search("b") << std::endl; // Output: 0
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree/java/KDTree.java | import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class KDTree {
private Node root;
public KDTree(List<int[]> points) {
root = buildTree(points, 0);
}
private Node buildTree(List<int[]> points, int axis) {
if (points.isEmpty()) {
return null;
}
points.sort(Comparator.comparingInt(point -> point[axis]));
int medianIdx = points.size() / 2;
int[] median = points.get(medianIdx);
int nextAxis = (axis + 1) % median.length;
Node node = new Node(median, axis);
node.setLeft(buildTree(points.subList(0, medianIdx), nextAxis));
node.setRight(buildTree(points.subList(medianIdx + 1, points.size()), nextAxis));
return node;
}
public int[] nearestNeighbor(int[] target) {
int[] best = new int[]{Integer.MAX_VALUE, -1};
nearestNeighbor(root, target, best);
return Arrays.copyOf(best, best.length);
}
private void nearestNeighbor(Node node, int[] target, int[] best) {
if (node == null) {
return;
}
int distance = calculateDistance(node.getPoint(), target);
if (distance < best[0]) {
best[0] = distance;
best[1] = node.getPoint()[0];
}
int axis = node.getAxis();
if (target[axis] < node.getPoint()[axis]) {
nearestNeighbor(node.getLeft(), target, best);
if ((node.getPoint()[axis] - target[axis]) * (node.getPoint()[axis] - target[axis]) < best[0]) {
nearestNeighbor(node.getRight(), target, best);
}
} else {
nearestNeighbor(node.getRight(), target, best);
if ((target[axis] - node.getPoint()[axis]) * (target[axis] - node.getPoint()[axis]) < best[0]) {
nearestNeighbor(node.getLeft(), target, best);
}
}
}
private int calculateDistance(int[] point1, int[] point2) {
int distance = 0;
for (int i = 0; i < point1.length; i++) {
distance += (point1[i] - point2[i]) * (point1[i] - point2[i]);
}
return distance;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree/java/Main.java | import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<int[]> points = Arrays.asList(
new int[]{2, 3},
new int[]{5, 4},
new int[]{9, 6},
new int[]{4, 7},
new int[]{8, 1},
new int[]{7, 2}
);
KDTree kdTree = new KDTree(points);
int[] target = new int[]{5, 5};
int[] nearestNeighbor = kdTree.nearestNeighbor(target);
System.out.println("The nearest neighbor of " + Arrays.toString(target) + " is " + Arrays.toString(nearestNeighbor));
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree/java/Node.java | public class Node {
private int[] point;
private int axis;
private Node left;
private Node right;
public Node(int[] point, int axis) {
this.point = point;
this.axis = axis;
this.left = null;
this.right = null;
}
public int[] getPoint() {
return point;
}
public int getAxis() {
return axis;
}
public Node getLeft() {
return left;
}
public Node getRight() {
return right;
}
public void setLeft(Node left) {
this.left = left;
}
public void setRight(Node right) {
this.right = right;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree/cpp/KDTree.cpp | #include "KDTree.h"
#include <algorithm>
#include <limits>
KDTree::KDTree(std::vector<std::vector<int>>& points) {
root = buildTree(points, 0);
}
Node* KDTree::buildTree(std::vector<std::vector<int>>& points, int axis) {
if (points.empty()) {
return nullptr;
}
std::sort(points.begin(), points.end(), [axis](const auto& a, const auto& b) {
return a[axis] < b[axis];
});
int medianIdx = points.size() / 2;
std::vector<int> median = points[medianIdx];
int nextAxis = (axis + 1) % median.size();
Node* node = new Node(median, axis);
node->setLeft(buildTree(std::vector<std::vector<int>>(points.begin(), points.begin() + medianIdx), nextAxis));
node->setRight(buildTree(std::vector<std::vector<int>>(points.begin() + medianIdx + 1, points.end()), nextAxis));
return node;
}
std::vector<int> KDTree::nearestNeighbor(std::vector<int>& target) {
std::vector<int> best = {std::numeric_limits<int>::max(), -1};
nearestNeighbor(root, target, best);
return best;
}
void KDTree::nearestNeighbor(Node* node, std::vector<int>& target, std::vector<int>& best) {
if (node == nullptr) {
return;
}
int distance = calculateDistance(node->getPoint(), target);
if (distance < best[0]) {
best[0] = distance;
best[1] = node->getPoint()[0];
}
int axis = node->getAxis();
if (target[axis] < node->getPoint()[axis]) {
nearestNeighbor(node->getLeft(), target, best);
if ((node->getPoint()[axis] - target[axis]) * (node->getPoint()[axis] - target[axis]) < best[0]) {
nearestNeighbor(node->getRight(), target, best);
}
} else {
nearestNeighbor(node->getRight(), target, best);
if ((target[axis] - node->getPoint()[axis]) * (target[axis] - node->getPoint()[axis]) < best[0]) {
nearestNeighbor(node->getLeft(), target, best);
}
}
}
int KDTree::calculateDistance(std::vector<int>& point1, std::vector<int>& point2) {
int distance = 0;
for (size_t i = 0; i < point1.size(); i++) {
distance += (point1[i] - point2[i]) * (point1[i] - point2[i]);
}
return distance;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree/cpp/main.cpp | #include <iostream>
#include "KDTree.h"
int main() {
std::vector<std::vector<int>> points = {
{2, 3},
{5, 4},
{9, 6},
{4, 7},
{8, 1},
{7, 2}
};
KDTree kdTree(points);
std::vector<int> target = {5, 5};
std::vector<int> nearestNeighbor = kdTree.nearestNeighbor(target);
std::cout << "The nearest neighbor of [5, 5] is [" << nearestNeighbor[0] << ", " << nearestNeighbor[1] << "]" << std::endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree/cpp/KDTree.h | #ifndef KDTREE_H
#define KDTREE_H
#include "Node.h"
#include <vector>
class KDTree {
private:
Node* root;
Node* buildTree(std::vector<std::vector<int>>& points, int axis);
void nearestNeighbor(Node* node, std::vector<int>& target, std::vector<int>& best);
int calculateDistance(std::vector<int>& point1, std::vector<int>& point2);
public:
KDTree(std::vector<std::vector<int>>& points);
std::vector<int> nearestNeighbor(std::vector<int>& target);
};
#endif
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree/cpp/Noide.h | #ifndef NODE_H
#define NODE_H
#include <vector>
class Node {
private:
std::vector<int> point;
int axis;
Node* left;
Node* right;
public:
Node(std::vector<int> point, int axis);
std::vector<int> getPoint();
int getAxis();
Node* getLeft();
Node* getRight();
void setLeft(Node* left);
void setRight(Node* right);
};
#endif
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/kd-tree/cpp/Node.cpp | #include "Node.h"
Node::Node(std::vector<int> point, int axis) : point(point), axis(axis), left(nullptr), right(nullptr) {}
std::vector<int> Node::getPoint() {
return point;
}
int Node::getAxis() {
return axis;
}
Node* Node::getLeft() {
return left;
}
Node* Node::getRight() {
return right;
}
void Node::setLeft(Node* left) {
this->left = left;
}
void Node::setRight(Node* right) {
this->right = right;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree/java/SplayNode.java | /**
* Represents a node in the splay tree.
*/
public class SplayNode {
public int key;
public SplayNode left;
public SplayNode right;
/**
* Constructs a new SplayNode with the given key.
* @param key The key value of the node.
*/
public SplayNode(int key) {
this.key = key;
this.left = null;
this.right = null;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree/java/SplayTree.java | /**
* Represents the splay tree data structure.
*/
public class SplayTree {
private SplayNode root;
/**
* Constructs an empty SplayTree.
*/
public SplayTree() {
this.root = null;
}
/**
* Inserts a key into the splay tree.
* @param key The key to insert.
*/
public void insert(int key) {
this.root = insert(this.root, key);
}
/**
* Helper method to insert a key into the splay tree.
* @param node The root node of the current subtree.
* @param key The key to insert.
* @return The updated root node of the subtree.
*/
private SplayNode insert(SplayNode node, int key) {
if (node == null)
return new SplayNode(key);
if (key < node.key) {
node.left = insert(node.left, key);
} else if (key > node.key) {
node.right = insert(node.right, key);
}
return node;
}
/**
* Searches for a key in the splay tree.
* @param key The key to search for.
* @return True if the key is found, otherwise false.
*/
public boolean search(int key) {
this.root = splay(this.root, key);
return this.root != null && this.root.key == key;
}
/**
* Performs the splay operation on the tree.
* @param node The root node of the current subtree.
* @param key The key to splay.
* @return The updated root node of the subtree.
*/
private SplayNode splay(SplayNode node, int key) {
if (node == null || node.key == key)
return node;
if (key < node.key) {
if (node.left == null)
return node;
if (key < node.left.key) {
node.left.left = splay(node.left.left, key);
node = rotateRight(node);
} else if (key > node.left.key) {
node.left.right = splay(node.left.right, key);
if (node.left.right != null)
node.left = rotateLeft(node.left);
}
return rotateRight(node);
} else {
if (node.right == null)
return node;
if (key > node.right.key) {
node.right.right = splay(node.right.right, key);
node = rotateLeft(node);
} else if (key < node.right.key) {
node.right.left = splay(node.right.left, key);
if (node.right.left != null)
node.right = rotateRight(node.right);
}
return rotateLeft(node);
}
}
/**
* Performs a left rotation on the given node.
* @param node The node to rotate.
* @return The new root node after rotation.
*/
private SplayNode rotateLeft(SplayNode node) {
SplayNode newRoot = node.right;
node.right = newRoot.left;
newRoot.left = node;
return newRoot;
}
/**
* Performs a right rotation on the given node.
* @param node The node to rotate.
* @return The new root node after rotation.
*/
private SplayNode rotateRight(SplayNode node) {
SplayNode newRoot = node.left;
node.left = newRoot.right;
newRoot.right = node;
return newRoot;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree/java/Main.java | /**
* Main class to demonstrate SplayTree functionality.
*/
public class Main {
/**
* Main method to execute the program.
* @param args Command-line arguments (unused).
*/
public static void main(String[] args) {
SplayTree splayTree = new SplayTree();
int[] keys = {7, 3, 10, 2, 6, 9, 11, 1, 5, 8, 12};
for (int key : keys)
splayTree.insert(key);
System.out.println(splayTree.search(8)); // Output: true
System.out.println(splayTree.search(4)); // Output: false
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree/cpp/SplayNode.cpp | #include "SplayNode.h"
SplayNode::SplayNode(int key) {
this->key = key;
this->left = nullptr;
this->right = nullptr;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree/cpp/SplayNode.h | #ifndef SPLAY_NODE_H
#define SPLAY_NODE_H
class SplayNode {
public:
int key;
SplayNode* left;
SplayNode* right;
SplayNode(int key);
};
#endif // SPLAY_NODE_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree/cpp/main.cpp | #include "SplayTree.h"
#include <iostream>
int main() {
SplayTree splayTree;
int keys[] = {7, 3, 10, 2, 6, 9, 11, 1, 5, 8, 12};
int n = sizeof(keys) / sizeof(keys[0]);
for (int i = 0; i < n; ++i)
splayTree.insert(keys[i]);
std::cout << std::boolalpha;
std::cout << splayTree.search(8) << std::endl; // Output: true
std::cout << splayTree.search(4) << std::endl; // Output: false
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree/cpp/SplayTree.cpp | // SplayTree.cpp
#include "SplayTree.h"
SplayTree::SplayTree() {
this->root = nullptr;
}
void SplayTree::insert(int key) {
this->root = insert(this->root, key);
}
bool SplayTree::search(int key) {
this->root = splay(this->root, key);
return this->root && this->root->key == key;
}
SplayNode* SplayTree::insert(SplayNode* node, int key) {
if (!node)
return new SplayNode(key);
if (key < node->key) {
node->left = insert(node->left, key);
} else if (key > node->key) {
node->right = insert(node->right, key);
}
return node;
}
SplayNode* SplayTree::splay(SplayNode* node, int key) {
if (!node || node->key == key)
return node;
if (key < node->key) {
if (!node->left)
return node;
if (key < node->left->key) {
node->left->left = splay(node->left->left, key);
node = rotateRight(node);
} else if (key > node->left->key) {
node->left->right = splay(node->left->right, key);
if (node->left->right)
node->left = rotateLeft(node->left);
}
return rotateRight(node);
} else {
if (!node->right)
return node;
if (key > node->right->key) {
node->right->right = splay(node->right->right, key);
node = rotateLeft(node);
} else if (key < node->right->key) {
node->right->left = splay(node->right->left, key);
if (node->right->left)
node->right = rotateRight(node->right);
}
return rotateLeft(node);
}
}
SplayNode* SplayTree::rotateLeft(SplayNode* node) {
SplayNode* newRoot = node->right;
node->right = newRoot->left;
newRoot->left = node;
return newRoot;
}
SplayNode* SplayTree::rotateRight(SplayNode* node) {
SplayNode* newRoot = node->left;
node->left = newRoot->right;
newRoot->right = node;
return newRoot;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/splay-tree/cpp/SplayTree.h | // SplayTree.h
#ifndef SPLAY_TREE_H
#define SPLAY_TREE_H
#include "SplayNode.h"
class SplayTree {
private:
SplayNode* root;
SplayNode* insert(SplayNode* node, int key);
SplayNode* splay(SplayNode* node, int key);
SplayNode* rotateLeft(SplayNode* node);
SplayNode* rotateRight(SplayNode* node);
public:
SplayTree();
void insert(int key);
bool search(int key);
};
#endif // SPLAY_TREE_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/avl | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/avl/java/Main.java | public class Main {
public static void main(String[] args) {
AVLTree avlTree = new AVLTree();
int[] keys = {9, 5, 10, 0, 6, 11, -1, 1, 2};
for (int key : keys) {
avlTree.insert(key);
}
System.out.println("Inorder traversal of the AVL tree:");
avlTree.inorderTraversal();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/avl | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/avl/java/AVLNode.java | public class AVLNode {
int key;
int height;
AVLNode left, right;
public AVLNode(int key) {
this.key = key;
this.height = 1;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/avl | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/avl/cpp/AVLNode.h | #ifndef AVLNODE_H
#define AVLNODE_H
// AVLNode class represents a node in the AVL tree
class AVLNode {
public:
int key;
int height;
AVLNode* left;
AVLNode* right;
// Constructor
AVLNode(int key);
// Destructor
~AVLNode();
};
#endif
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/avl | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/avl/cpp/main.cpp | #include <iostream>
#include "AVLNode.h"
// Constructor initializes the key and sets height to 1
AVLNode::AVLNode(int key) {
this->key = key;
this->height = 1;
this->left = nullptr;
this->right = nullptr;
}
// Destructor (if needed)
AVLNode::~AVLNode() {
delete left;
delete right;
}
// AVLTree class represents a self-balancing AVL tree
class AVLTree {
public:
AVLNode* root;
// Constructor
AVLTree();
// Destructor
~AVLTree();
// Function to insert a key into the AVL tree
void insert(int key);
// Helper function to perform inorder traversal
void inorderTraversal(AVLNode* node);
private:
// Helper functions for AVL tree operations
AVLNode* insertUtil(AVLNode* node, int key);
AVLNode* rotateRight(AVLNode* y);
AVLNode* rotateLeft(AVLNode* x);
int height(AVLNode* node);
int balanceFactor(AVLNode* node);
};
// Constructor initializes the root to nullptr
AVLTree::AVLTree() {
root = nullptr;
}
// Destructor (if needed)
AVLTree::~AVLTree() {
delete root;
}
// Function to insert a key into the AVL tree
void AVLTree::insert(int key) {
root = insertUtil(root, key);
}
// Helper function to perform inorder traversal
void AVLTree::inorderTraversal(AVLNode* node) {
if (node != nullptr) {
inorderTraversal(node->left);
std::cout << node->key << " ";
inorderTraversal(node->right);
}
}
// Helper function to insert a key into the AVL tree
AVLNode* AVLTree::insertUtil(AVLNode* node, int key) {
if (node == nullptr) {
return new AVLNode(key);
}
if (key < node->key) {
node->left = insertUtil(node->left, key);
} else if (key > node->key) {
node->right = insertUtil(node->right, key);
}
// Update height of the current node
node->height = 1 + std::max(height(node->left), height(node->right));
// Perform rotations to balance the tree
int balance = balanceFactor(node);
// Left Left Case
if (balance > 1 && key < node->left->key) {
return rotateRight(node);
}
// Right Right Case
if (balance < -1 && key > node->right->key) {
return rotateLeft(node);
}
// Left Right Case
if (balance > 1 && key > node->left->key) {
node->left = rotateLeft(node->left);
return rotateRight(node);
}
// Right Left Case
if (balance < -1 && key < node->right->key) {
node->right = rotateRight(node->right);
return rotateLeft(node);
}
return node;
}
// Helper function to perform right rotation at the given node
AVLNode* AVLTree::rotateRight(AVLNode* y) {
AVLNode* x = y->left;
AVLNode* T2 = x->right;
// Perform rotation
x->right = y;
y->left = T2;
// Update heights
y->height = 1 + std::max(height(y->left), height(y->right));
x->height = 1 + std::max(height(x->left), height(x->right));
return x;
}
// Helper function to perform left rotation at the given node
AVLNode* AVLTree::rotateLeft(AVLNode* x) {
AVLNode* y = x->right;
AVLNode* T2 = y->left;
// Perform rotation
y->left = x;
x->right = T2;
// Update heights
x->height = 1 + std::max(height(x->left), height(x->right));
y->height = 1 + std::max(height(y->left), height(y->right));
return y;
}
// Helper function to calculate height of a node
int AVLTree::height(AVLNode* node) {
if (node == nullptr) {
return 0;
}
return node->height;
}
// Helper function to calculate balance factor of a node
int AVLTree::balanceFactor(AVLNode* node) {
if (node == nullptr) {
return 0;
}
return height(node->left) - height(node->right);
}
int main() {
AVLTree avlTree;
int keys[] = {9, 5, 10, 0, 6, 11, -1, 1, 2};
for (int key : keys) {
avlTree.insert(key);
}
std::cout << "Inorder traversal of the AVL tree:\n";
avlTree.inorderTraversal(avlTree.root);
std::cout << std::endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/radix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/radix-tree/java/RadixTree.java | // RadixTree.java
import java.util.HashMap;
import java.util.Map;
/**
* Represents the radix tree data structure.
*/
public class RadixTree {
private RadixNode root;
public RadixTree() {
this.root = new RadixNode(null);
}
public void insert(String word) {
RadixNode node = root;
for (char c : word.toCharArray()) {
if (node.children.containsKey(c)) {
node = node.children.get(c);
} else {
RadixNode newNode = new RadixNode(c);
node.children.put(c, newNode);
node = newNode;
}
}
}
public boolean search(String word) {
RadixNode node = root;
for (char c : word.toCharArray()) {
if (node.children.containsKey(c)) {
node = node.children.get(c);
} else {
return false;
}
}
return true;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/radix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/radix-tree/java/RadixNode.java | import java.util.HashMap;
import java.util.Map;
/**
* Represents a node in the radix tree.
*/
public class RadixNode {
Character value;
Map<Character, RadixNode> children;
public RadixNode(Character value) {
this.value = value;
this.children = new HashMap<>();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/radix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/radix-tree/java/Main.java | public class Main {
public static void main(String[] args) {
RadixTree radixTree = new RadixTree();
String[] words = {"apple", "banana", "apricot", "app", "bat", "cat", "car"};
for (String word : words) {
radixTree.insert(word);
}
System.out.println(radixTree.search("apple")); // Output: true
System.out.println(radixTree.search("banana")); // Output: true
System.out.println(radixTree.search("apricot")); // Output: true
System.out.println(radixTree.search("app")); // Output: true
System.out.println(radixTree.search("bat")); // Output: true
System.out.println(radixTree.search("cat")); // Output: true
System.out.println(radixTree.search("car")); // Output: true
System.out.println(radixTree.search("ap")); // Output: false
System.out.println(radixTree.search("ba")); // Output: false
System.out.println(radixTree.search("ca")); // Output: false
System.out.println(radixTree.search("b")); // Output: false
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/radix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/radix-tree/cpp/RadixNode.h | // RadixNode.h
#pragma once
#include <unordered_map>
/**
* Represents a node in the radix tree.
*/
class RadixNode {
public:
char value;
std::unordered_map<char, RadixNode*> children;
RadixNode(char value) : value(value) {}
};
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/radix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/radix-tree/cpp/RadixTree.h | // RadixTree.h
#include "RadixNode.h"
/**
* Represents the radix tree data structure.
*/
class RadixTree {
private:
RadixNode* root;
public:
RadixTree() {
root = new RadixNode('\0');
}
void insert(std::string word) {
RadixNode* node = root;
for (char c : word) {
if (node->children.find(c) != node->children.end()) {
node = node->children[c];
} else {
RadixNode* newNode = new RadixNode(c);
node->children[c] = newNode;
node = newNode;
}
}
}
bool search(std::string word) {
RadixNode* node = root;
for (char c : word) {
if (node->children.find(c) != node->children.end()) {
node = node->children[c];
} else {
return false;
}
}
return true;
}
};
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/radix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/radix-tree/cpp/main.cpp | // Main.cpp
#include "RadixTree.h"
#include <iostream>
#include <vector>
int main() {
RadixTree radixTree;
std::vector<std::string> words = {"apple", "banana", "apricot", "app", "bat", "cat", "car"};
for (const std::string& word : words) {
radixTree.insert(word);
}
std::cout << std::boolalpha;
std::cout << radixTree.search("apple") << std::endl; // Output: true
std::cout << radixTree.search("banana") << std::endl; // Output: true
std::cout << radixTree.search("apricot") << std::endl; // Output: true
std::cout << radixTree.search("app") << std::endl; // Output: true
std::cout << radixTree.search("bat") << std::endl; // Output: true
std::cout << radixTree.search("cat") << std::endl; // Output: true
std::cout << radixTree.search("car") << std::endl; // Output: true
std::cout << radixTree.search("ap") << std::endl; // Output: false
std::cout << radixTree.search("ba") << std::endl; // Output: false
std::cout << radixTree.search("ca") << std::endl; // Output: false
std::cout << radixTree.search("b") << std::endl; // Output: false
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/suffix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/suffix-tree/java/SuffixTree.java | public class SuffixTree {
private SuffixTreeNode root;
private String text;
public SuffixTree(String text) {
this.root = new SuffixTreeNode(-1, null);
this.text = text;
buildSuffixTree();
}
private void buildSuffixTree() {
int n = text.length();
SuffixTreeNode activeNode = root;
int activeEdge = 0;
int activeLength = 0;
int remainingSuffixCount = 0;
SuffixTreeNode lastNewNode = null;
for (int i = 0; i < n; i++) {
lastNewNode = null;
remainingSuffixCount++;
while (remainingSuffixCount > 0) {
if (activeLength == 0) {
activeEdge = i;
}
if (!activeNode.children.containsKey(text.charAt(i))) {
activeNode.children.put(text.charAt(i), new SuffixTreeNode(i, n - 1));
if (lastNewNode != null) {
lastNewNode.suffixLink = activeNode;
lastNewNode = null;
}
} else {
SuffixTreeNode nextNode = activeNode.children.get(text.charAt(activeEdge));
if (activeLength >= nextNode.end - nextNode.start + 1) {
activeEdge += nextNode.end - nextNode.start + 1;
activeLength -= nextNode.end - nextNode.start + 1;
activeNode = nextNode;
continue;
}
if (text.charAt(nextNode.start + activeLength) == text.charAt(i)) {
if (lastNewNode != null && activeNode != root) {
lastNewNode.suffixLink = activeNode;
lastNewNode = null;
}
activeLength++;
break;
}
SuffixTreeNode newNode = new SuffixTreeNode(nextNode.start, nextNode.start + activeLength - 1);
activeNode.children.put(text.charAt(activeEdge), newNode);
newNode.children.put(text.charAt(i), new SuffixTreeNode(i, n - 1));
nextNode.start += activeLength;
newNode.children.put(text.charAt(nextNode.start), nextNode);
if (lastNewNode != null) {
lastNewNode.suffixLink = newNode;
}
lastNewNode = newNode;
}
remainingSuffixCount--;
if (activeNode == root && activeLength > 0) {
activeLength--;
activeEdge = i - remainingSuffixCount + 1;
} else if (activeNode != root) {
activeNode = activeNode.suffixLink;
}
}
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/suffix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/suffix-tree/java/Main.java | package algorithms.trees.suffix-tree.java;
public class Main {
private void traverse(SuffixTreeNode node, String suffix) {
if (node.start != -1) {
System.out.println(suffix + text.substring(node.start, node.end + 1));
}
for (SuffixTreeNode child : node.children.values()) {
traverse(child, suffix + text.substring(node.start, node.end + 1));
}
}
public void printSuffixes() {
traverse(root, "");
}
public static void main(String[] args) {
String text = "banana";
SuffixTree suffixTree = new SuffixTree(text);
suffixTree.printSuffixes();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/suffix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/suffix-tree/java/SuffixTreeNode.java | import java.util.HashMap;
public class SuffixTreeNode {
public HashMap<Character, SuffixTreeNode> children;
public SuffixTreeNode suffixLink;
public int start;
public Integer end;
public SuffixTreeNode(int start, Integer end) {
this.children = new HashMap<>();
this.suffixLink = null;
this.start = start;
this.end = end;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/suffix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/suffix-tree/cpp/SuffixTreeNode.h | #include <unordered_map>
class SuffixTreeNode {
public:
std::unordered_map<char, SuffixTreeNode*> children;
SuffixTreeNode* suffixLink;
int start;
int* end;
SuffixTreeNode(int start, int* end) {
this->suffixLink = nullptr;
this->start = start;
this->end = end;
}
};
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/suffix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/suffix-tree/cpp/main.cpp | #include "SuffixTree.h"
int main() {
std::string text = "banana";
SuffixTree suffixTree(text);
suffixTree.printSuffixes();
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/suffix-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/suffix-tree/cpp/SuffixTree.h | #include "SuffixTreeNode.h"
#include <iostream>
#include <unordered_map>
class SuffixTree {
private:
SuffixTreeNode* root;
std::string text;
void buildSuffixTree() {
int n = text.length();
SuffixTreeNode* activeNode = root;
int activeEdge = 0;
int activeLength = 0;
int remainingSuffixCount = 0;
SuffixTreeNode* lastNewNode = nullptr;
for (int i = 0; i < n; i++) {
lastNewNode = nullptr;
remainingSuffixCount++;
while (remainingSuffixCount > 0) {
if (activeLength == 0) {
activeEdge = i;
}
if (activeNode->children.find(text[i]) == activeNode->children.end()) {
activeNode->children[text[i]] = new SuffixTreeNode(i, new int(n - 1));
if (lastNewNode != nullptr) {
lastNewNode->suffixLink = activeNode;
lastNewNode = nullptr;
}
} else {
SuffixTreeNode* nextNode = activeNode->children[text[activeEdge]];
if (activeLength >= *nextNode->end - nextNode->start + 1) {
activeEdge += *nextNode->end - nextNode->start + 1;
activeLength -= *nextNode->end - nextNode->start + 1;
activeNode = nextNode;
continue;
}
if (text[nextNode->start + activeLength] == text[i]) {
if (lastNewNode != nullptr && activeNode != root) {
lastNewNode->suffixLink = activeNode;
lastNewNode = nullptr;
}
activeLength++;
break;
}
SuffixTreeNode* newNode = new SuffixTreeNode(nextNode->start, new int(nextNode->start + activeLength - 1));
activeNode->children[text[activeEdge]] = newNode;
newNode->children[text[i]] = new SuffixTreeNode(i, new int(n - 1));
nextNode->start += activeLength;
newNode->children[text[nextNode->start]] = nextNode;
if (lastNewNode != nullptr) {
lastNewNode->suffixLink = newNode;
}
lastNewNode = newNode;
}
remainingSuffixCount--;
if (activeNode == root && activeLength > 0) {
activeLength--;
activeEdge = i - remainingSuffixCount + 1;
} else if (activeNode != root) {
activeNode = activeNode->suffixLink;
}
}
}
}
void traverse(SuffixTreeNode* node, std::string suffix) {
if (node->start != -1) {
std::cout << suffix + text.substr(node->start, *node->end + 1 - node->start) << std::endl;
}
for (auto const& child : node->children) {
traverse(child.second, suffix + text.substr(node->start, *node->end + 1 - node->start));
}
}
public:
SuffixTree(std::string text) {
this->root = new SuffixTreeNode(-1, nullptr);
this->text = text;
buildSuffixTree();
}
void printSuffixes() {
traverse(root, "");
}
};
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/segment-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/segment-tree/java/SegmentTreeNode.java | /**
* Represents a node in the segment tree.
*/
public class SegmentTreeNode {
int start;
int end;
int total;
SegmentTreeNode left;
SegmentTreeNode right;
public SegmentTreeNode(int start, int end) {
this.start = start;
this.end = end;
this.total = 0;
this.left = null;
this.right = null;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/segment-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/segment-tree/java/SegmentTree.java | import java.util.List;
/**
* Represents the segment tree data structure.
*/
public class SegmentTree {
private SegmentTreeNode root;
/**
* Constructs the segment tree from the given list of numbers.
*
* @param nums The list of numbers.
*/
public SegmentTree(List<Integer> nums) {
this.root = buildTree(nums, 0, nums.size() - 1);
}
private SegmentTreeNode buildTree(List<Integer> nums, int start, int end) {
if (start == end) {
SegmentTreeNode node = new SegmentTreeNode(start, end);
node.total = nums.get(start);
return node;
}
int mid = (start + end) / 2;
SegmentTreeNode leftNode = buildTree(nums, start, mid);
SegmentTreeNode rightNode = buildTree(nums, mid + 1, end);
SegmentTreeNode node = new SegmentTreeNode(start, end);
node.total = leftNode.total + rightNode.total;
node.left = leftNode;
node.right = rightNode;
return node;
}
/**
* Queries the total sum over the range [start, end].
*
* @param start The start index of the range.
* @param end The end index of the range.
* @return The total sum over the range.
*/
public int query(int start, int end) {
return query(root, start, end);
}
private int query(SegmentTreeNode node, int start, int end) {
if (node.start == start && node.end == end) {
return node.total;
}
int mid = (node.start + node.end) / 2;
if (end <= mid) {
return query(node.left, start, end);
} else if (start >= mid + 1) {
return query(node.right, start, end);
} else {
int leftSum = query(node.left, start, mid);
int rightSum = query(node.right, mid + 1, end);
return leftSum + rightSum;
}
}
/**
* Updates the value of the element at the given index.
*
* @param index The index of the element to be updated.
* @param value The new value.
*/
public void update(int index, int value) {
update(root, index, value);
}
private void update(SegmentTreeNode node, int index, int value) {
if (node.start == node.end && node.start == index) {
node.total = value;
return;
}
int mid = (node.start + node.end) / 2;
if (index <= mid) {
update(node.left, index, value);
} else {
update(node.right, index, value);
}
node.total = node.left.total + node.right.total;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/segment-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/segment-tree/java/Main.java | import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> nums = new ArrayList<>();
nums.add(1);
nums.add(3);
nums.add(5);
nums.add(7);
nums.add(9);
SegmentTree segmentTree = new SegmentTree(nums);
System.out.println(segmentTree.query(1, 3)); // Output: 15
segmentTree.update(2, 6);
System.out.println(segmentTree.query(1, 3)); // Output: 17
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/segment-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/segment-tree/cpp/main.cpp | // Main.cpp
#include "SegmentTree.h"
#include <iostream>
#include <vector>
int main() {
std::vector<int> nums = {1, 3, 5, 7, 9};
SegmentTree segmentTree(nums);
std::cout << segmentTree.query(1, 3) << std::endl; // Output: 15
segmentTree.update(2, 6);
std::cout << segmentTree.query(1, 3) << std::endl; // Output: 17
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/segment-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/segment-tree/cpp/SegmentTree.h | // SegmentTree.h
#include "SegmentTreeNode.h"
#include <vector>
/**
* Represents the segment tree data structure.
*/
class SegmentTree {
private:
SegmentTreeNode* root;
SegmentTreeNode* buildTree(const std::vector<int>& nums, int start, int end) {
if (start == end) {
SegmentTreeNode* node = new SegmentTreeNode(start, end);
node->total = nums[start];
return node;
}
int mid = (start + end) / 2;
SegmentTreeNode* leftNode = buildTree(nums, start, mid);
SegmentTreeNode* rightNode = buildTree(nums, mid + 1, end);
SegmentTreeNode* node = new SegmentTreeNode(start, end);
node->total = leftNode->total + rightNode->total;
node->left = leftNode;
node->right = rightNode;
return node;
}
int query(SegmentTreeNode* node, int start, int end) {
if (node->start == start && node->end == end) {
return node->total;
}
int mid = (node->start + node->end) / 2;
if (end <= mid) {
return query(node->left, start, end);
} else if (start >= mid + 1) {
return query(node->right, start, end);
} else {
int leftSum = query(node->left, start, mid);
int rightSum = query(node->right, mid + 1, end);
return leftSum + rightSum;
}
}
void update(SegmentTreeNode* node, int index, int value) {
if (node->start == node->end && node->start == index) {
node->total = value;
return;
}
int mid = (node->start + node->end) / 2;
if (index <= mid) {
update(node->left, index, value);
} else {
update(node->right, index, value);
}
node->total = node->left->total + node->right->total;
}
public:
SegmentTree(const std::vector<int>& nums) {
root = buildTree(nums, 0, nums.size() - 1);
}
int query(int start, int end) {
return query(root, start, end);
}
void update(int index, int value) {
update(root, index, value);
}
};
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/segment-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/segment-tree/cpp/SegmentTreeNode.h | // SegmentTreeNode.h
#pragma once
/**
* Represents a node in the segment tree.
*/
class SegmentTreeNode {
public:
int start;
int end;
int total;
SegmentTreeNode* left;
SegmentTreeNode* right;
SegmentTreeNode(int start, int end) : start(start), end(end), total(0), left(nullptr), right(nullptr) {}
};
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/nearset-neighbour-with-kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/nearset-neighbour-with-kd-tree/cpp/UnionFind.cpp | #include "UnionFind.h"
UnionFind::UnionFind(int size) {
parent.resize(size);
rank.resize(size, 0);
for (int i = 0; i < size; ++i) {
parent[i] = i;
}
}
int UnionFind::find(int u) {
if (parent[u] != u) {
parent[u] = find(parent[u]);
}
return parent[u];
}
void UnionFind::unionSets(int u, int v) {
int rootU = find(u);
int rootV = find(v);
if (rootU != rootV) {
if (rank[rootU] < rank[rootV]) {
parent[rootU] = rootV;
} else if (rank[rootU] > rank[rootV]) {
parent[rootV] = rootU;
} else {
parent[rootV] = rootU;
rank[rootU]++;
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/nearset-neighbour-with-kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/nearset-neighbour-with-kd-tree/cpp/UnionFind.h | #ifndef UNION_FIND_H
#define UNION_FIND_H
#include <vector>
class UnionFind {
private:
std::vector<int> parent;
std::vector<int> rank;
public:
UnionFind(int size);
int find(int u);
void unionSets(int u, int v);
};
#endif // UNION_FIND_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/nearset-neighbour-with-kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/nearset-neighbour-with-kd-tree/cpp/main.cpp | #include <iostream>
#include "Kruskal.h"
int main() {
// Example usage
std::vector<std::tuple<int, int, int>> graph = {
{0, 1, 4}, {0, 7, 8}, {1, 2, 8}, {1, 7, 11},
{2, 3, 7}, {2, 8, 2}, {2, 5, 4}, {3, 4, 9},
{3, 5, 14}, {4, 5, 10}, {5, 6, 2}, {6, 7, 1}, {6, 8, 6}, {7, 8, 7}
};
std::vector<std::tuple<int, int, int>> minimumSpanningTree = Kruskal::findMinimumSpanningTree(graph);
std::cout << "Minimum Spanning Tree:" << std::endl;
for (const auto& edge : minimumSpanningTree) {
std::cout << std::get<0>(edge) << " " << std::get<1>(edge) << " " << std::get<2>(edge) << std::endl;
}
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/nearset-neighbour-with-kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/nearset-neighbour-with-kd-tree/cpp/Kruskal.cpp | #include "Kruskal.h"
#include "UnionFind.h"
#include <algorithm>
std::vector<std::tuple<int, int, int>> Kruskal::findMinimumSpanningTree(std::vector<std::tuple<int, int, int>>& graph) {
std::sort(graph.begin(), graph.end(), [](const std::tuple<int, int, int>& a, const std::tuple<int, int, int>& b) {
return std::get<2>(a) < std::get<2>(b);
});
int n = graph.size();
UnionFind uf(n);
std::vector<std::tuple<int, int, int>> mst;
for (const auto& edge : graph) {
int u = std::get<0>(edge);
int v = std::get<1>(edge);
if (uf.find(u) != uf.find(v)) {
mst.push_back(edge);
uf.unionSets(u, v);
}
}
return mst;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/nearset-neighbour-with-kd-tree | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/nearset-neighbour-with-kd-tree/cpp/Kruskal.h | #ifndef KRUSKAL_H
#define KRUSKAL_H
#include <vector>
#include <tuple>
class Kruskal {
public:
static std::vector<std::tuple<int, int, int>> findMinimumSpanningTree(std::vector<std::tuple<int, int, int>>& graph);
};
#endif // KRUSKAL_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map/java/StockList.java | import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
public class StockList {
private final Map<String, StockItem> list;
public StockList() {
this.list = new LinkedHashMap<>();
}
public int addStock(StockItem item) {
if(item != null) {
// check if already have quantities of this item
StockItem inStock = list.getOrDefault(item.getName(), item);
// If there are already stocks on this item, adjust the quantity
if(inStock != item) {
item.adjustStock(inStock.quantityInStock());
}
list.put(item.getName(), item);
return item.quantityInStock();
}
return 0;
}
public int sellStock(String item, int quantity) {
StockItem inStock = list.getOrDefault(item, null);
if((inStock != null) && (inStock.quantityInStock() >= quantity) && (quantity >0)) {
inStock.adjustStock(-quantity);
return quantity;
}
return 0;
}
public StockItem get(String key) {
return list.get(key);
}
public Map<String, Double> PriceList() {
Map<String, Double> prices = new LinkedHashMap<>();
for(Map.Entry<String, StockItem> item : list.entrySet()) {
prices.put(item.getKey(), item.getValue().getPrice());
}
return Collections.unmodifiableMap(prices);
}
public Map<String, StockItem> Items() {
return Collections.unmodifiableMap(list);
}
@Override
public String toString() {
String s = "\nStock List\n";
double totalCost = 0.0;
for (Map.Entry<String, StockItem> item : list.entrySet()) {
StockItem stockItem = item.getValue();
double itemValue = stockItem.getPrice() * stockItem.quantityInStock();
s = s + stockItem + ". There are " + stockItem.quantityInStock() + " in stock. Value of items: ";
s = s + String.format("%.2f",itemValue) + "\n";
totalCost += itemValue;
}
return s + "Total stock value " + totalCost;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map/java/Main.java | import java.util.Map;
public class Main {
private static StockList stockList = new StockList();
public static void main(String[] args) {
StockItem temp = new StockItem("bread", 0.86, 100);
stockList.addStock(temp);
temp = new StockItem("cake", 1.10, 7);
stockList.addStock(temp);
temp = new StockItem("car", 12.50, 2);
stockList.addStock(temp);
temp = new StockItem("chair", 62.0, 10);
stockList.addStock(temp);
temp = new StockItem("cup", 0.50, 200);
stockList.addStock(temp);
temp = new StockItem("cup", 0.45, 7);
stockList.addStock(temp);
temp = new StockItem("door", 72.95, 4);
stockList.addStock(temp);
temp = new StockItem("juice", 2.50, 36);
stockList.addStock(temp);
temp = new StockItem("phone", 96.99, 35);
stockList.addStock(temp);
temp = new StockItem("towel", 2.40, 80);
stockList.addStock(temp);
temp = new StockItem("vase", 8.76, 40);
stockList.addStock(temp);
System.out.println(stockList);
for(String s: stockList.Items().keySet()) {
System.out.println(s);
}
Basket timsBasket = new Basket("Tim");
sellItem(timsBasket, "car", 1);
System.out.println(timsBasket);
sellItem(timsBasket, "car", 1);
System.out.println(timsBasket);
if(sellItem(timsBasket, "car", 1) != 1) {
System.out.println("There are no more cars in stock");
}
sellItem(timsBasket, "spanner", 5);
System.out.println(timsBasket);
sellItem(timsBasket, "juice", 4);
sellItem(timsBasket, "cup", 12);
sellItem(timsBasket, "bread", 1);
System.out.println(timsBasket);
System.out.println(stockList);
//temp = new StockItem("pen", 1.12);
//stockList.Items().put(temp.getName(), temp);
stockList.Items().get("car").adjustStock(2000);
stockList.get("car").adjustStock(-1000);
System.out.println(stockList);
for(Map.Entry<String, Double> price: stockList.PriceList().entrySet()) {
System.out.println(price.getKey() + " costs " + price.getValue());
}
}
public static int sellItem(Basket basket, String item, int quantity) {
//retrieve the item from stock list
StockItem stockItem = stockList.get(item);
if(stockItem == null) {
System.out.println("We don't sell " + item);
return 0;
}
if(stockList.sellStock(item, quantity) != 0) {
basket.addToBasket(stockItem, quantity);
return quantity;
}
return 0;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map/java/StockItem.java | public class StockItem implements Comparable<StockItem> {
private final String name;
private double price;
private int quantityStock = 0;
public StockItem(String name, double price) {
this.name = name;
this.price = price;
this.quantityStock = 0; // or here (but you wouldn't normally do both).
}
public StockItem(String name, double price, int quantityStock) {
this.name = name;
this.price = price;
this.quantityStock = quantityStock;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
public int quantityInStock() {
return quantityStock;
}
public void setPrice(double price) {
if(price > 0.0) {
this.price = price;
}
}
public void adjustStock(int quantity) {
int newQuantity = this.quantityStock + quantity;
if(newQuantity >=0) {
this.quantityStock = newQuantity;
}
}
@Override
public boolean equals(Object obj) {
System.out.println("Entering StockItem.equals");
if(obj == this) {
return true;
}
if((obj == null) || (obj.getClass() != this.getClass())) {
return false;
}
String objName = ((StockItem) obj).getName();
return this.name.equals(objName);
}
@Override
public int hashCode() {
return this.name.hashCode() + 31;
}
@Override
public int compareTo(StockItem o) {
System.out.println("Entering StockItem.compareTo");
if(this == o) {
return 0;
}
if(o != null) {
return this.name.compareTo(o.getName());
}
throw new NullPointerException();
}
@Override
public String toString() {
return this.name + " : price " + this.price;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map/java/Basket.java | import java.util.Collections;
import java.util.Map;
import java.util.TreeMap;
public class
Basket {
private final String name;
private final Map<StockItem, Integer> list;
public Basket(String name) {
this.name = name;
this.list = new TreeMap<>();
}
public int addToBasket(StockItem item, int quantity) {
if ((item != null) && (quantity > 0)) {
int inBasket = list.getOrDefault(item, 0);
list.put(item, inBasket + quantity);
return inBasket;
}
return 0;
}
public Map<StockItem, Integer> Items() {
return Collections.unmodifiableMap(list);
}
@Override
public String toString() {
String s = "\nShopping basket " + name + " contains " + list.size() + ((list.size() == 1) ? " item" : " items") + "\n";
double totalCost = 0.0;
for (Map.Entry<StockItem, Integer> item : list.entrySet()) {
s = s + item.getKey() + ". " + item.getValue() + " purchased\n";
totalCost += item.getKey().getPrice() * item.getValue();
}
return s + "Total cost " + totalCost;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map/cpp/treeNode.h | #ifndef TREENODE_H
#define TREENODE_H
#include <string>
// TreeNode represents a node in the binary search tree
struct TreeNode {
int key;
std::string value;
TreeNode* left;
TreeNode* right;
TreeNode(int k, const std::string& v);
};
#endif // TREENODE_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map/cpp/TreeMap.h | #ifndef TREEMAP_H
#define TREEMAP_H
#include "TreeNode.h"
#include <vector>
#include <utility>
// TreeMap represents a sorted map implemented using a binary search tree
class TreeMap {
private:
TreeNode* root;
TreeNode* put(TreeNode* node, int key, const std::string& value);
std::string get(TreeNode* node, int key);
TreeNode* remove(TreeNode* node, int key);
TreeNode* findMin(TreeNode* node);
void traverseInOrder(TreeNode* node, std::vector<std::pair<int, std::string>>& result);
public:
// Constructor
TreeMap();
// Destructor
~TreeMap();
// Method to insert or update a key-value pair in the tree
void put(int key, const std::string& value);
// Method to retrieve the value associated with the given key
std::string get(int key);
// Method to remove the key-value pair with the given key from the tree
void remove(int key);
// Method to perform an in-order traversal of the tree and return key-value pairs
std::vector<std::pair<int, std::string>> traverseInOrder();
};
#endif // TREEMAP_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map/cpp/treeNode.cpp | #include "TreeNode.h"
// Constructor
TreeNode::TreeNode(int k, const std::string& v) : key(k), value(v), left(nullptr), right(nullptr) {}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map/cpp/TreeMap.cpp | #include "TreeMap.h"
// Constructor
TreeMap::TreeMap() : root(nullptr) {}
// Destructor
TreeMap::~TreeMap() {
// Implement destructor to free memory allocated for tree nodes
// This will be called automatically when TreeMap object goes out of scope
}
// Method to insert or update a key-value pair in the tree
void TreeMap::put(int key, const std::string& value) {
root = put(root, key, value);
}
// Method to retrieve the value associated with the given key
std::string TreeMap::get(int key) {
return get(root, key);
}
// Method to remove the key-value pair with the given key from the tree
void TreeMap::remove(int key) {
root = remove(root, key);
}
// Method to perform an in-order traversal of the tree and return key-value pairs
std::vector<std::pair<int, std::string>> TreeMap::traverseInOrder() {
std::vector<std::pair<int, std::string>> result;
traverseInOrder(root, result);
return result;
}
// Private helper functions
TreeNode* TreeMap::put(TreeNode* node, int key, const std::string& value) {
// Implementation
}
std::string TreeMap::get(TreeNode* node, int key) {
// Implementation
}
TreeNode* TreeMap::remove(TreeNode* node, int key) {
// Implementation
}
TreeNode* TreeMap::findMin(TreeNode* node) {
// Implementation
}
void TreeMap::traverseInOrder(TreeNode* node, std::vector<std::pair<int, std::string>>& result) {
// Implementation
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map | repos/exploratory-tech-studio/tech-studio-projects/algorithms/trees/tree-map/cpp/main.cpp | #include <iostream>
#include "TreeMap.h"
// Main function
int main() {
// Example: Use TreeMap class by inserting key-value pairs and printing contents using in-order traversal
TreeMap treeMap;
treeMap.put(5, "five");
treeMap.put(3, "three");
treeMap.put(7, "seven");
treeMap.put(2, "two");
treeMap.put(4, "four");
treeMap.put(6, "six");
treeMap.put(8, "eight");
std::vector<std::pair<int, std::string>> contents = treeMap.traverseInOrder();
std::cout << "TreeMap contents (in-order traversal):" << std::endl;
for (const auto& pair : contents) {
std::cout << pair.first << ": " << pair.second << std::endl;
}
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/depth-first-search-for-a-graph | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/depth-first-search-for-a-graph/java/BreadthFirstSearch.java | import java.util.*;
/**
* BreadthFirstSearch.java
*
* Breadth First Search (BFS) is a fundamental graph traversal algorithm. It involves visiting
* all the connected nodes of a graph in a level-by-level manner.
*
* Breadth First Search (BFS) is a graph traversal algorithm that explores all the vertices in a
* graph at the current depth before moving on to the vertices at the next depth level. It starts
* at a specified vertex and visits all its neighbors before moving on to the next level of neighbors.
* BFS is commonly used in algorithms for pathfinding, connected components, and shortest path
* problems in graphs.
*
* Let's discuss the algorithm for the BFS:
*
* 1. Initialization: Enqueue the starting node into a queue and mark it as visited.
* 2. Exploration: While the queue is not empty:
* - Dequeue a node from the queue and visit it (e.g., print its value).
* - For each unvisited neighbor of the dequeued node:
* - Enqueue the neighbor into the queue.
* - Mark the neighbor as visited.
* 3. Termination: Repeat step 2 until the queue is empty.
*/
public class BreadthFirstSearch {
// Class to represent a graph
static class Graph {
private final Map<Integer, List<Integer>> adjList;
// Constructor
Graph() {
adjList = new HashMap<>();
}
// Function to add an edge to the graph
void addEdge(int u, int v) {
adjList.computeIfAbsent(u, k -> new ArrayList<>()).add(v);
}
// Function to perform BFS traversal
void BFS(int s) {
// Mark all the vertices as not visited
Map<Integer, Boolean> visited = new HashMap<>();
for (int key : adjList.keySet()) {
visited.put(key, false);
}
// Create a queue for BFS
Queue<Integer> queue = new LinkedList<>();
// Mark the source node as visited and enqueue it
queue.offer(s);
visited.put(s, true);
while (!queue.isEmpty()) {
// Dequeue a vertex from the queue and print it
int current = queue.poll();
System.out.print(current + " ");
// Get all adjacent vertices of the dequeued vertex
// If an adjacent vertex has not been visited, then mark it visited and enqueue it
for (int neighbor : adjList.getOrDefault(current, Collections.emptyList())) {
if (!visited.get(neighbor)) {
queue.offer(neighbor);
visited.put(neighbor, true);
}
}
}
}
}
// Driver code
public static void main(String[] args) {
// Create a graph
Graph graph = new Graph();
graph.addEdge(0, 1);
graph.addEdge(0, 2);
graph.addEdge(1, 2);
graph.addEdge(2, 0);
graph.addEdge(2, 3);
graph.addEdge(3, 3);
// Perform BFS traversal starting from vertex 2
System.out.println("Following is Breadth First Traversal (starting from vertex 2)");
graph.BFS(2);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/depth-first-search-for-a-graph | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/depth-first-search-for-a-graph/cpp/main.cpp | #include <iostream>
#include <list>
#include <queue>
#include <unordered_map>
/**
* BreadthFirstSearch.cpp
*
* Breadth First Search (BFS) is a fundamental graph traversal algorithm. It involves visiting
* all the connected nodes of a graph in a level-by-level manner.
*
* Breadth First Search (BFS) is a graph traversal algorithm that explores all the vertices in a
* graph at the current depth before moving on to the vertices at the next depth level. It starts
* at a specified vertex and visits all its neighbors before moving on to the next level of neighbors.
* BFS is commonly used in algorithms for pathfinding, connected components, and shortest path
* problems in graphs.
*
* Let's discuss the algorithm for the BFS:
*
* 1. Initialization: Enqueue the starting node into a queue and mark it as visited.
* 2. Exploration: While the queue is not empty:
* - Dequeue a node from the queue and visit it (e.g., print its value).
* - For each unvisited neighbor of the dequeued node:
* - Enqueue the neighbor into the queue.
* - Mark the neighbor as visited.
* 3. Termination: Repeat step 2 until the queue is empty.
*/
using namespace std;
// Class to represent a graph
class Graph {
unordered_map<int, list<int>> adjList;
public:
// Function to add an edge to the graph
void addEdge(int u, int v) {
adjList[u].push_back(v);
}
// Function to perform BFS traversal
void BFS(int s) {
// Mark all the vertices as not visited
unordered_map<int, bool> visited;
for (auto& pair : adjList) {
visited[pair.first] = false;
}
// Create a queue for BFS
queue<int> queue;
// Mark the source node as visited and enqueue it
queue.push(s);
visited[s] = true;
while (!queue.empty()) {
// Dequeue a vertex from the queue and print it
int current = queue.front();
queue.pop();
cout << current << " ";
// Get all adjacent vertices of the dequeued vertex
// If an adjacent vertex has not been visited, then mark it visited and enqueue it
for (int neighbor : adjList[current]) {
if (!visited[neighbor]) {
queue.push(neighbor);
visited[neighbor] = true;
}
}
}
}
};
// Driver code
int main() {
// Create a graph
Graph graph;
graph.addEdge(0, 1);
graph.addEdge(0, 2);
graph.addEdge(1, 2);
graph.addEdge(2, 0);
graph.addEdge(2, 3);
graph.addEdge(3, 3);
// Perform BFS traversal starting from vertex 2
cout << "Following is Breadth First Traversal (starting from vertex 2)" << endl;
graph.BFS(2);
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/depth-first-search-for-a-graph | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/depth-first-search-for-a-graph/python/depth_first_search_for_a_graph.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""breadth_first_search.py
Breadth First Search (BFS) is a fundamental graph traversal algorithm. It involves visiting
all the connected nodes of a graph in a level-by-level manner.
Breadth First Search (BFS) is a graph traversal algorithm that explores all the vertices in a
graph at the current depth before moving on to the vertices at the next depth level. It starts
at a specified vertex and visits all its neighbors before moving on to the next level of neighbors.
BFS is commonly used in algorithms for pathfinding, connected components, and shortest path
problems in graphs.
Let's discuss the algorithm for the BFS:
1. Initialization: Enqueue the starting node into a queue and mark it as visited.
2. Exploration: While the queue is not empty:
- Dequeue a node from the queue and visit it (e.g., print its value).
- For each unvisited neighbor of the dequeued node:
- Enqueue the neighbor into the queue.
- Mark the neighbor as visited.
3. Termination: Repeat step 2 until the queue is empty.
"""
def main():
# Driver code
# Create a graph given in the above diagram
g = Graph()
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)
print("Following is Depth First Traversal")
g.DFS()
# This code is contributed by Neelam Yadav
# Python program to print DFS traversal for complete graph
from collections import defaultdict
# This class represents a directed graph using adjacency
# list representation
class Graph:
# Constructor
def __init__(self):
# default dictionary to store graph
self.graph = defaultdict(list)
# function to add an edge to graph
def addEdge(self,u,v):
self.graph[u].append(v)
# A function used by DFS
def DFSUtil(self, v, visited):
# Mark the current node as visited and print it
visited[v]= True
print(v)
# Recur for all the vertices adjacent to
# this vertex
for i in self.graph[v]:
if visited[i] == False:
self.DFSUtil(i, visited)
# The function to do DFS traversal. It uses
# recursive DFSUtil()
def DFS(self):
V = len(self.graph) #total vertices
# Mark all the vertices as not visited
visited =[False]*(V)
# Call the recursive helper function to print
# DFS traversal starting from all vertices one
# by one
for i in range(V):
if visited[i] == False:
self.DFSUtil(i, visited)
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/shortest-path-problem-with-dijkstra | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/shortest-path-problem-with-dijkstra/java/DijkstraShortestPath.java | import java.util.*;
/**
* DijkstraShortestPath.java
*
* Dijkstra's algorithm is an algorithm for finding the shortest paths
* between nodes in a graph, which may represent, for example, road networks.
* It calculates the shortest path from a single source vertex to all other
* vertices in the graph.
*
* Let's discuss the algorithm for Dijkstra's shortest path:
*
* 1. Initialization: Initialize the distance from the source vertex to
* all other vertices as INFINITY and to itself as 0.
* 2. Select: Pick the unvisited vertex with the smallest known distance
* to the source vertex.
* 3. Update: Update the distances of the adjacent vertices of the selected
* vertex by adding the weight of the edge to the current distance.
* 4. Repeat: Repeat steps 2 and 3 until all vertices are visited.
*/
public class DijkstraShortestPath {
static final int INF = Integer.MAX_VALUE; // Represents infinity
// Class to represent a graph
static class Graph {
int V; // Number of vertices
int[][] graph; // Adjacency matrix representation of the graph
// Constructor
Graph(int v) {
V = v;
graph = new int[V][V];
}
// Function to print the solution (shortest distances)
void printSolution(int[] dist) {
System.out.println("Vertex \t Distance from Source");
for (int node = 0; node < V; ++node)
System.out.println(node + "\t\t" + dist[node]);
}
// Utility function to find the vertex with minimum distance value,
// from the set of vertices not yet included in the shortest path tree
int minDistance(int[] dist, boolean[] sptSet) {
int min = INF, minIndex = -1;
for (int v = 0; v < V; ++v) {
if (!sptSet[v] && dist[v] <= min) {
min = dist[v];
minIndex = v;
}
}
return minIndex;
}
// Function that implements Dijkstra's single source shortest path algorithm
void dijkstra(int src) {
int[] dist = new int[V]; // The output array to hold shortest distance from src to i
boolean[] sptSet = new boolean[V]; // sptSet[i] will be true if vertex i is included in shortest path tree
// Initialize all distances as INFINITE and sptSet[] as false
for (int i = 0; i < V; ++i) {
dist[i] = INF;
sptSet[i] = false;
}
// Distance of source vertex from itself is always 0
dist[src] = 0;
// Find shortest path for all vertices
for (int count = 0; count < V - 1; ++count) {
// Pick the minimum distance vertex from the set of vertices
// not yet processed. u is always equal to src in the first iteration.
int u = minDistance(dist, sptSet);
// Mark the picked vertex as processed
sptSet[u] = true;
// Update dist value of the adjacent vertices of the picked vertex
for (int v = 0; v < V; ++v) {
// Update dist[v] only if it is not in sptSet, there is an edge from
// u to v, and total weight of path from src to v through u is
// smaller than current value of dist[v]
if (!sptSet[v] && graph[u][v] != 0 && dist[u] != INF && dist[u] + graph[u][v] < dist[v]) {
dist[v] = dist[u] + graph[u][v];
}
}
}
// Print the constructed distance array
printSolution(dist);
}
}
// Driver code
public static void main(String[] args) {
// Create a graph
Graph g = new Graph(9);
g.graph = new int[][]{
{0, 4, 0, 0, 0, 0, 0, 8, 0},
{4, 0, 8, 0, 0, 0, 0, 11, 0},
{0, 8, 0, 7, 0, 4, 0, 0, 2},
{0, 0, 7, 0, 9, 14, 0, 0, 0},
{0, 0, 0, 9, 0, 10, 0, 0, 0},
{0, 0, 4, 14, 10, 0, 2, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 6},
{8, 11, 0, 0, 0, 0, 1, 0, 7},
{0, 0, 2, 0, 0, 0, 6, 7, 0}
};
// Perform Dijkstra's algorithm starting from vertex 0
System.out.println("Following is Dijkstra's shortest path algorithm (starting from vertex 0):");
g.dijkstra(0);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/shortest-path-problem-with-dijkstra | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/shortest-path-problem-with-dijkstra/cpp/main.cpp | #include <iostream>
#include <climits>
/**
* DijkstraShortestPath.cpp
*
* Dijkstra's algorithm is an algorithm for finding the shortest paths
* between nodes in a graph, which may represent, for example, road networks.
* It calculates the shortest path from a single source vertex to all other
* vertices in the graph.
*
* Let's discuss the algorithm for Dijkstra's shortest path:
*
* 1. Initialization: Initialize the distance from the source vertex to
* all other vertices as INFINITY and to itself as 0.
* 2. Select: Pick the unvisited vertex with the smallest known distance
* to the source vertex.
* 3. Update: Update the distances of the adjacent vertices of the selected
* vertex by adding the weight of the edge to the current distance.
* 4. Repeat: Repeat steps 2 and 3 until all vertices are visited.
*/
using namespace std;
#define V 9 // Number of vertices
#define INF INT_MAX // Represents infinity
// Class to represent a graph
class Graph {
public:
int graph[V][V]; // Adjacency matrix representation of the graph
// Function to print the solution (shortest distances)
void printSolution(int dist[]) {
cout << "Vertex \t Distance from Source" << endl;
for (int node = 0; node < V; ++node)
cout << node << "\t\t" << dist[node] << endl;
}
// Utility function to find the vertex with minimum distance value,
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/shortest-path-problem-with-dijkstra | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/shortest-path-problem-with-dijkstra/python/shortest_path_problem_with_dijkstra.py | # shortest path problem
# Python program for Dijkstra's single
# source shortest path algorithm. The program is
# for adjacency matrix representation of the graph
class Graph():
def __init__(self, vertices):
self.V = vertices
self.graph = [[0 for column in range(vertices)]
for row in range(vertices)]
def printSolution(self, dist):
print("Vertex \t Distance from Source")
for node in range(self.V):
print(node, "\t\t", dist[node])
# A utility function to find the vertex with
# minimum distance value, from the set of vertices
# not yet included in shortest path tree
def minDistance(self, dist, sptSet):
# Initialize minimum distance for next node
min = 1e7
# Search not nearest vertex not in the
# shortest path tree
for v in range(self.V):
if dist[v] < min and sptSet[v] == False:
min = dist[v]
min_index = v
return min_index
# Function that implements Dijkstra's single source
# shortest path algorithm for a graph represented
# using adjacency matrix representation
def dijkstra(self, src):
dist = [1e7] * self.V
dist[src] = 0
sptSet = [False] * self.V
for cout in range(self.V):
# Pick the minimum distance vertex from
# the set of vertices not yet processed.
# u is always equal to src in first iteration
u = self.minDistance(dist, sptSet)
# Put the minimum distance vertex in the
# shortest path tree
sptSet[u] = True
# Update dist value of the adjacent vertices
# of the picked vertex only if the current
# distance is greater than new distance and
# the vertex in not in the shortest path tree
for v in range(self.V):
if (self.graph[u][v] > 0 and
sptSet[v] == False and
dist[v] > dist[u] + self.graph[u][v]):
dist[v] = dist[u] + self.graph[u][v]
self.printSolution(dist)
# /shortest path problem
# shortest path program
# ---------------------
# Driver program
g = Graph(9)
g.graph = [[0, 4, 0, 0, 0, 0, 0, 8, 0],
[4, 0, 8, 0, 0, 0, 0, 11, 0],
[0, 8, 0, 7, 0, 4, 0, 0, 2],
[0, 0, 7, 0, 9, 14, 0, 0, 0],
[0, 0, 0, 9, 0, 10, 0, 0, 0],
[0, 0, 4, 14, 10, 0, 2, 0, 0],
[0, 0, 0, 0, 0, 2, 0, 1, 6],
[8, 11, 0, 0, 0, 0, 1, 0, 7],
[0, 0, 2, 0, 0, 0, 6, 7, 0]
]
g.dijkstra(0) |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/breadth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/breadth-first-search/java/BreadthFirstSearch.java | import java.util.*;
/**
* BreadthFirstSearch.java
*
* Breadth First Search (BFS) is a fundamental graph traversal algorithm. It involves visiting
* all the connected nodes of a graph in a level-by-level manner.
*
* Breadth First Search (BFS) is a graph traversal algorithm that explores all the vertices in a
* graph at the current depth before moving on to the vertices at the next depth level. It starts
* at a specified vertex and visits all its neighbors before moving on to the next level of neighbors.
* BFS is commonly used in algorithms for pathfinding, connected components, and shortest path
* problems in graphs.
*
* Let's discuss the algorithm for the BFS:
*
* 1. Initialization: Enqueue the starting node into a queue and mark it as visited.
* 2. Exploration: While the queue is not empty:
* - Dequeue a node from the queue and visit it (e.g., print its value).
* - For each unvisited neighbor of the dequeued node:
* - Enqueue the neighbor into the queue.
* - Mark the neighbor as visited.
* 3. Termination: Repeat step 2 until the queue is empty.
*/
public class BreadthFirstSearch {
// Class to represent a graph
static class Graph {
private final Map<Integer, List<Integer>> adjList;
// Constructor
Graph() {
adjList = new HashMap<>();
}
// Function to add an edge to the graph
void addEdge(int u, int v) {
adjList.computeIfAbsent(u, k -> new ArrayList<>()).add(v);
}
// Function to perform BFS traversal
void BFS(int s) {
boolean[] visited = new boolean[adjList.size()];
Queue<Integer> queue = new LinkedList<>();
// Mark the source node as visited and enqueue it
queue.offer(s);
visited[s] = true;
while (!queue.isEmpty()) {
// Dequeue a vertex from the queue and print it
int current = queue.poll();
System.out.print(current + " ");
// Get all adjacent vertices of the dequeued vertex
// If an adjacent vertex has not been visited, then mark it visited and enqueue it
for (int neighbor : adjList.getOrDefault(current, Collections.emptyList())) {
if (!visited[neighbor]) {
queue.offer(neighbor);
visited[neighbor] = true;
}
}
}
}
}
// Driver code
public static void main(String[] args) {
// Create a graph
Graph graph = new Graph();
graph.addEdge(0, 1);
graph.addEdge(0, 2);
graph.addEdge(1, 2);
graph.addEdge(2, 0);
graph.addEdge(2, 3);
graph.addEdge(3, 3);
// Perform BFS traversal starting from vertex 2
System.out.println("Following is Breadth First Traversal (starting from vertex 2)");
graph.BFS(2);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/breadth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/breadth-first-search/cpp/main.cpp | #include <iostream>
#include <list>
#include <queue>
#include <unordered_map>
/**
* BreadthFirstSearch.cpp
*
* Breadth First Search (BFS) is a fundamental graph traversal algorithm. It involves visiting
* all the connected nodes of a graph in a level-by-level manner.
*
* Breadth First Search (BFS) is a graph traversal algorithm that explores all the vertices in a
* graph at the current depth before moving on to the vertices at the next depth level. It starts
* at a specified vertex and visits all its neighbors before moving on to the next level of neighbors.
* BFS is commonly used in algorithms for pathfinding, connected components, and shortest path
* problems in graphs.
*
* Let's discuss the algorithm for the BFS:
*
* 1. Initialization: Enqueue the starting node into a queue and mark it as visited.
* 2. Exploration: While the queue is not empty:
* - Dequeue a node from the queue and visit it (e.g., print its value).
* - For each unvisited neighbor of the dequeued node:
* - Enqueue the neighbor into the queue.
* - Mark the neighbor as visited.
* 3. Termination: Repeat step 2 until the queue is empty.
*/
using namespace std;
// Class to represent a graph
class Graph {
unordered_map<int, list<int>> adjList;
public:
// Function to add an edge to the graph
void addEdge(int u, int v) {
adjList[u].push_back(v);
}
// Function to perform BFS traversal
void BFS(int s) {
vector<bool> visited(adjList.size(), false);
queue<int> q;
// Mark the source node as visited and enqueue it
q.push(s);
visited[s] = true;
while (!q.empty()) {
// Dequeue a vertex from the queue and print it
int current = q.front();
q.pop();
cout << current << " ";
// Get all adjacent vertices of the dequeued vertex
// If an adjacent vertex has not been visited, then mark it visited and enqueue it
for (int neighbor : adjList[current]) {
if (!visited[neighbor]) {
q.push(neighbor);
visited[neighbor] = true;
}
}
}
}
};
// Driver code
int main() {
// Create a graph
Graph graph;
graph.addEdge(0, 1);
graph.addEdge(0, 2);
graph.addEdge(1, 2);
graph.addEdge(2, 0);
graph.addEdge(2, 3);
graph.addEdge(3, 3);
// Perform BFS traversal starting from vertex 2
cout << "Following is Breadth First Traversal (starting from vertex 2)" << endl;
graph.BFS(2);
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/breadth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/graph/breadth-first-search/python/breadth_first_search.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""breadth_first_search.py
Breadth First Search (BFS) is a fundamental graph traversal algorithm. It involves visiting
all the connected nodes of a graph in a level-by-level manner.
Breadth First Search (BFS) is a graph traversal algorithm that explores all the vertices in a
graph at the current depth before moving on to the vertices at the next depth level. It starts
at a specified vertex and visits all its neighbors before moving on to the next level of neighbors.
BFS is commonly used in algorithms for pathfinding, connected components, and shortest path
problems in graphs.
Let's discuss the algorithm for the BFS:
1. Initialization: Enqueue the starting node into a queue and mark it as visited.
2. Exploration: While the queue is not empty:
- Dequeue a node from the queue and visit it (e.g., print its value).
- For each unvisited neighbor of the dequeued node:
- Enqueue the neighbor into the queue.
- Mark the neighbor as visited.
3. Termination: Repeat step 2 until the queue is empty.
"""
# Python3 Program to print BFS traversal
# from a given source vertex. BFS(int s)
# traverses vertices reachable from s.
from collections import defaultdict
def main():
""""""
# Driver code
# Create a graph given in
# the above diagram
g = Graph()
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)
print ("Following is Breadth First Traversal"
" (starting from vertex 2)")
g.BFS(2)
# This class represents a directed graph
# using adjacency list representation
class Graph:
# Constructor
def __init__(self):
# default dictionary to store graph
self.graph = defaultdict(list)
# function to add an edge to graph
def addEdge(self,u,v):
self.graph[u].append(v)
# Function to print a BFS of graph
def BFS(self, s):
# Mark all the vertices as not visited
visited = [False] * (len(self.graph))
# Create a queue for BFS
queue = []
# Mark the source node as
# visited and enqueue it
queue.append(s)
visited[s] = True
while queue:
# Dequeue a vertex from
# queue and print it
s = queue.pop(0)
print (s, end = " ")
# Get all adjacent vertices of the
# dequeued vertex s. If a adjacent
# has not been visited, then mark it
# visited and enqueue it
for i in self.graph[s]:
if visited[i] == False:
queue.append(i)
visited[i] = True
if __name__ == '__main__':
main() |
Subsets and Splits