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/sorting/merge-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort/java/MergeSort.java | /**
* MergeSort class that implements the merge sort algorithm.
*/
public class MergeSort {
/**
* Sorts an array using the merge sort algorithm.
* @param arr The array to be sorted.
*/
public void sort(int[] arr) {
if (arr.length > 1) {
// Finding the mid of the array
int mid = arr.length / 2;
// Dividing the array elements into 2 halves
int[] leftPart = new int[mid];
int[] rightPart = new int[arr.length - mid];
System.arraycopy(arr, 0, leftPart, 0, mid);
System.arraycopy(arr, mid, rightPart, 0, arr.length - mid);
// Sorting both halves
sort(leftPart);
sort(rightPart);
// Merging the sorted halves
merge(arr, leftPart, rightPart);
}
}
/**
* Merges two subarrays into the original array.
* @param arr The original array that contains the merged result.
* @param leftPart The left subarray.
* @param rightPart The right subarray.
*/
private void merge(int[] arr, int[] leftPart, int[] rightPart) {
int i = 0, j = 0, k = 0;
// Copy data to temp arrays leftPart[] and rightPart[]
while (i < leftPart.length && j < rightPart.length) {
if (leftPart[i] <= rightPart[j]) {
arr[k] = leftPart[i];
i++;
} else {
arr[k] = rightPart[j];
j++;
}
k++;
}
// Checking if any element was left in leftPart[]
while (i < leftPart.length) {
arr[k] = leftPart[i];
i++;
k++;
}
// Checking if any element was left in rightPart[]
while (j < rightPart.length) {
arr[k] = rightPart[j];
j++;
k++;
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort/java/Main.java | /**
* Main class to demonstrate merge sort.
*/
public class Main {
/**
* The main method that runs the merge sort demonstration.
* @param args Command-line arguments (not used).
*/
public static void main(String[] args) {
int[] arr = {38, 27, 43, 3, 9, 82, 10};
System.out.println("Original array:");
printArray(arr);
MergeSort mergeSort = new MergeSort();
mergeSort.sort(arr);
System.out.println("Sorted array:");
printArray(arr);
}
/**
* Prints the elements of an array.
* @param arr The array to be printed.
*/
private static void printArray(int[] arr) {
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort/csharp/Program.cs | using System;
class Program
{
static void Main(string[] args)
{
int[] sampleList = { 38, 27, 43, 3, 9, 82, 10 };
Console.WriteLine("Original list: " + string.Join(", ", sampleList));
MergeSort(sampleList, 0, sampleList.Length - 1);
Console.WriteLine("Sorted list: " + string.Join(", ", sampleList));
}
static void MergeSort(int[] arr, int low, int high)
{
if (low < high)
{
int mid = (low + high) / 2;
MergeSort(arr, low, mid);
MergeSort(arr, mid + 1, high);
Merge(arr, low, mid, high);
}
}
static void Merge(int[] arr, int low, int mid, int high)
{
int n1 = mid - low + 1;
int n2 = high - mid;
int[] L = new int[n1];
int[] R = new int[n2];
for (int i = 0; i < n1; ++i)
{
L[i] = arr[low + i];
}
for (int j = 0; j < n2; ++j)
{
R[j] = arr[mid + 1 + j];
}
int k = low;
int lIndex = 0, rIndex = 0;
while (lIndex < n1 && rIndex < n2)
{
if (L[lIndex] <= R[rIndex])
{
arr[k] = L[lIndex];
lIndex++;
}
else
{
arr[k] = R[rIndex];
rIndex++;
}
k++;
}
while (lIndex < n1)
{
arr[k] = L[lIndex];
lIndex++;
k++;
}
while (rIndex < n2)
{
arr[k] = R[rIndex];
rIndex++;
k++;
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort/cpp/mergeSort.h | #ifndef MERGESORT_H
#define MERGESORT_H
#include <vector>
/**
* MergeSort class that implements the merge sort algorithm.
*/
class MergeSort {
public:
/**
* Sorts a vector using the merge sort algorithm.
* @param arr The vector to be sorted.
*/
void sort(std::vector<int>& arr);
private:
/**
* Merges two subarrays into the original array.
* @param arr The original array that contains the merged result.
* @param leftPart The left subarray.
* @param rightPart The right subarray.
*/
void merge(std::vector<int>& arr, std::vector<int>& leftPart, std::vector<int>& rightPart);
/**
* Prints the elements of a vector.
* @param arr The vector to be printed.
*/
void printArray(const std::vector<int>& arr);
};
#endif
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort/cpp/mergeSort.cpp | #include <iostream>
#include "mergeSort.h"
void MergeSort::sort(std::vector<int>& arr) {
if (arr.size() > 1) {
// Finding the mid of the array
int mid = arr.size() / 2;
// Dividing the array elements into 2 halves
std::vector<int> leftPart(arr.begin(), arr.begin() + mid);
std::vector<int> rightPart(arr.begin() + mid, arr.end());
// Sorting both halves
sort(leftPart);
sort(rightPart);
// Merging the sorted halves
merge(arr, leftPart, rightPart);
}
}
void MergeSort::merge(std::vector<int>& arr, std::vector<int>& leftPart, std::vector<int>& rightPart) {
int i = 0, j = 0, k = 0;
// Copy data to temp arrays leftPart[] and rightPart[]
while (i < leftPart.size() && j < rightPart.size()) {
if (leftPart[i] <= rightPart[j]) {
arr[k] = leftPart[i];
i++;
} else {
arr[k] = rightPart[j];
j++;
}
k++;
}
// Checking if any element was left in leftPart[]
while (i < leftPart.size()) {
arr[k] = leftPart[i];
i++;
k++;
}
// Checking if any element was left in rightPart[]
while (j < rightPart.size()) {
arr[k] = rightPart[j];
j++;
k++;
}
}
void MergeSort::printArray(const std::vector<int>& arr) {
for (int num : arr) {
std::cout << num << " ";
}
std::cout << std::endl;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort/cpp/main.cpp | #include <iostream>
#include <vector>
#include "mergeSort.h"
/**
* Main function to demonstrate merge sort.
*/
int main() {
std::vector<int> arr = {38, 27, 43, 3, 9, 82, 10};
std::cout << "Original array:" << std::endl;
MergeSort mergeSort;
// mergeSort.printArray(arr);
mergeSort.sort(arr);
std::cout << "Sorted array:" << std::endl;
// mergeSort.printArray(arr);
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort/zig/main.zig | const std = @import("std");
const Allocator = std.mem.Allocator;
pub fn main() void {
var sampleList: [7]u32 = [38, 27, 43, 3, 9, 82, 10];
const originalList = sampleList;
const originalListSlice = originalList[0..];
// Print original list
std.debug.print("Original list: {}\n", .{originalListSlice});
mergeSort(&sampleList);
// Print sorted list
const sortedListSlice = sampleList[0..];
std.debug.print("Sorted list: {}\n", .{sortedListSlice});
}
pub fn mergeSort(arr: []u32) void {
// Check if array can be divided
if (arr.len > 1) {
// Finding the mid of the list
const mid: usize = arr.len / 2;
// Dividing the elements into 2 halves
var leftPart: []u32 = arr[0..mid];
var rightPart: []u32 = arr[mid..];
// Sorting both halves
mergeSort(leftPart);
mergeSort(rightPart);
// Merge the sorted halves
var i: usize = 0;
var j: usize = 0;
var k: usize = 0;
while (i < leftPart.len) && (j < rightPart.len) : (i += 1; j += 1) {
if leftPart[i] <= rightPart[j] {
arr[k] = leftPart[i];
i += 1;
} else {
arr[k] = rightPart[j];
j += 1;
}
k += 1;
}
// Copy remaining elements from leftPart
while (i < leftPart.len) : (i += 1) {
arr[k] = leftPart[i];
k += 1;
}
// Copy remaining elements from rightPart
while (j < rightPart.len) : (j += 1) {
arr[k] = rightPart[j];
k += 1;
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/merge-sort/python/merge_sort.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""merge_sort.py
This module implements the merge sort algorithm, which is a
divide-and-conquer sorting algorithm. The algorithm recursively
divides a list into two halves, sorts each half, and then merges
the sorted halves to produce the final sorted list.
"""
def main() -> None:
"""Driving code."""
sample_list = [38, 27, 43, 3, 9, 82, 10]
print("Original list:", sample_list)
merge_sort(sample_list)
print("Sorted list:", sample_list)
return None
def merge_sort(input_list: list) -> None:
"""Merge sort algorithm.
Parameters:
input_list (list) -- The list of elements to be sorted.
"""
if len(input_list) > 1:
# Finding the mid of the list
mid = len(input_list) // 2
# Dividing the elements into 2 halves
left_part = input_list[:mid]
right_part = input_list[mid:]
# Sorting both halves
merge_sort(left_part)
merge_sort(right_part)
i = j = k = 0
# Copy data to temp lists left_part[] and right_part[]
while i < len(left_part) and j < len(right_part):
if left_part[i] <= right_part[j]:
input_list[k] = left_part[i]
i += 1
else:
input_list[k] = right_part[j]
j += 1
k += 1
# Checking if any element was left in left_part[]
while i < len(left_part):
input_list[k] = left_part[i]
i += 1
k += 1
# Checking if any element was left in right_part[]
while j < len(right_part):
input_list[k] = right_part[j]
j += 1
k += 1
return None
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort/java/Main.java | /**
* Main class to demonstrate the Counting Sort algorithm.
*/
public class Main {
/**
* The main method to run the Counting Sort demonstration.
*
* @param args Command line arguments (not used).
*/
public static void main(String[] args) {
char[] inputArr = {'g', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'g', 'e', 'e', 'k', 's'};
char[] sortedArr = CountingSort.countingSort(inputArr);
System.out.println("Sorted array: " + new String(sortedArr));
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort/java/CountingSort.java | import java.util.Arrays;
/**
* Class that provides a method to perform Counting Sort on an array of characters.
*/
public class CountingSort {
/**
* Sorts an array of characters using the Counting Sort algorithm.
*
* @param arr The array of characters to be sorted.
* @return The sorted array of characters.
*/
public static char[] countingSort(char[] arr) {
int n = arr.length;
// The output character array that will have sorted arr
char[] output = new char[n];
// Create a count array to store count of individual characters
int[] count = new int[256];
Arrays.fill(count, 0);
// Store count of each character
for (int i = 0; i < n; i++) {
count[arr[i]]++;
}
// Change count[i] so that count[i] now contains actual position of this character in output array
for (int i = 1; i < 256; i++) {
count[i] += count[i - 1];
}
// Build the output character array
for (int i = n - 1; i >= 0; i--) {
output[count[arr[i]] - 1] = arr[i];
count[arr[i]]--;
}
return output;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort/csharp/Program.cs | using System;
using System.Collections.Generic;
class Program
{
static void Main(string[] args)
{
List<char> inputArr = new List<char>() { 'g', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'g', 'e', 'e', 'k', 's' };
List<char> sortedArr = CountingSort(inputArr);
Console.WriteLine(string.Join(", ", sortedArr));
}
static List<char> CountingSort(List<char> arr)
{
// The output character list that will have sorted arr
List<char> output = new List<char>();
output.AddRange(new char[arr.Count]);
// Create a count array to store the count of individual characters
int[] count = new int[256];
// Store count of each character
foreach (char c in arr)
{
count[c]++;
}
// Change count[i] so that count[i] now contains the actual position of this character in the output list
for (int i = 1; i < 256; i++)
{
count[i] += count[i - 1];
}
// Build the output character list
for (int i = arr.Count - 1; i >= 0; i--) // Iterate in reverse to maintain stability
{
output[count[arr[i]] - 1] = arr[i];
count[arr[i]]--;
}
return output;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort/cpp/countingSort.cpp | #include "countingSort.h"
#include <vector>
#include <cstring>
/**
* Sorts an array of characters using the Counting Sort algorithm.
*
* @param arr The vector of characters to be sorted.
* @return The sorted vector of characters.
*/
std::vector<char> countingSort(const std::vector<char>& arr) {
int n = arr.size();
std::vector<char> output(n);
int count[256];
std::memset(count, 0, sizeof(count));
// Store count of each character
for (char ch : arr) {
count[static_cast<unsigned char>(ch)]++;
}
// Change count[i] so that count[i] now contains actual position of this character in output array
for (int i = 1; i < 256; ++i) {
count[i] += count[i - 1];
}
// Build the output character array
for (int i = n - 1; i >= 0; --i) {
output[count[static_cast<unsigned char>(arr[i])] - 1] = arr[i];
count[static_cast<unsigned char>(arr[i])]--;
}
return output;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort/cpp/CMakeLists.txt | cmake_minimum_required(VERSION 3.10)
# Project name
project(CountingSort)
# Set C++ standard
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# Include directories
include_directories(${PROJECT_SOURCE_DIR})
# Add the executable
add_executable(CountingSort main.cpp countingSort.cpp)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort/cpp/main.cpp | #include <iostream>
#include <vector>
#include "countingSort.h"
/**
* Main function to demonstrate the Counting Sort algorithm.
*
* @return Exit status.
*/
int main() {
std::vector<char> inputArr = {'g', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'g', 'e', 'e', 'k', 's'};
std::vector<char> sortedArr = countingSort(inputArr);
std::cout << "Sorted array: ";
for (char ch : sortedArr) {
std::cout << ch;
}
std::cout << std::endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort/cpp/countingSort.h | #ifndef COUNTINGSORT_H
#define COUNTINGSORT_H
#include <vector>
/**
* Function to sort an array of characters using the Counting Sort algorithm.
*
* @param arr The vector of characters to be sorted.
* @return The sorted vector of characters.
*/
std::vector<char> countingSort(const std::vector<char>& arr);
#endif // COUNTINGSORT_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort/zig/main.zig | const std = @import("std");
const Allocator = std.mem.Allocator;
pub fn main() void {
const inputArr: [13]char = ['g', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'g', 'e', 'e', 'k', 's'];
const sortedArr = countingSort(inputArr);
std.debug.print("Sorted Array: {any}\n", .{sortedArr});
}
pub fn countingSort(arr: []const u8, allocator: *Allocator) []const u8 {
const countSize: usize = 256;
var count: [countSize]u8 = undefined;
var output: []const u8 = allocator.alloc(u8, arr.len) catch unreachable;
// Initialize count array with zeros
for (count) |_, idx| {
count[idx] = 0;
}
// Store count of each character
for (arr) |char| {
count[char] += 1;
}
// Change count[i] so that count[i] now contains actual position of this character in output array
for (1 .. countSize) |i| {
count[i] += count[i - 1];
}
// Build the output character array
for (arr) |char| {
const index = count[char] - 1;
output[index] = char;
count[char] -= 1;
}
return output;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/counting-sort/python/counting_sort.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""counting_sort.py
Explanation:
Type Hints: Added type hints to the function signature.
Docstrings: Expanded the docstring to explain parameters and return values.
Array Initialization: Corrected the initialization of the output array to use empty strings instead of zeros, as we are dealing with characters.
Count Array Update: Updated the count array in a loop starting from 1 to 255 to avoid the issue of negative indexing.
Reversed Iteration: Iterated in reverse when building the output array to maintain the stability of the sorting algorithm.
"""
from typing import List
def main() -> None:
"""Driving code."""
input_arr = ['g', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'g', 'e', 'e', 'k', 's']
sorted_arr = counting_sort(input_arr)
print(sorted_arr)
return None
def counting_sort(arr: List[str]) -> List[str]:
"""Sorts a list of characters using the Counting Sort algorithm.
Parameters:
arr (List[str]) -- The list of characters to be sorted.
Returns:
List[str] -- The sorted list of characters.
"""
# The output character array that will have sorted arr
output = ['' for _ in range(len(arr))]
# Create a count array to store count of individual characters
count = [0] * 256
# Store count of each character
for char in arr:
count[ord(char)] += 1
# Change count[i] so that count[i] now contains actual position of this character in output array
for i in range(1, 256):
count[i] += count[i - 1]
# Build the output character array
for char in reversed(arr): # Iterate in reverse to maintain stability
output[count[ord(char)] - 1] = char
count[ord(char)] -= 1
return output
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort/java/HeapSort.java | /**
* HeapSort class that implements the heap sort algorithm.
*/
public class HeapSort {
/**
* Sorts an array using the heap sort algorithm.
* @param arr The array to be sorted.
*/
public void sort(int[] arr) {
int n = arr.length;
// Build heap (rearrange array)
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
// One by one extract an element from heap
for (int i = n - 1; i >= 0; i--) {
// Move current root to end
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// Call max heapify on the reduced heap
heapify(arr, i, 0);
}
}
/**
* Ensures the subtree rooted at index i satisfies the max heap property.
* @param arr The array representing the heap.
* @param n The size of the heap.
* @param i The index of the root of the subtree.
*/
void heapify(int[] arr, int n, int i) {
int largest = i; // Initialize largest as root
int left = 2 * i + 1; // left = 2*i + 1
int right = 2 * i + 2; // right = 2*i + 2
// If left child is larger than root
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
// If right child is larger than largest so far
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
// If largest is not root
if (largest != i) {
int swap = arr[i];
arr[i] = arr[largest];
arr[largest] = swap;
// Recursively heapify the affected sub-tree
heapify(arr, n, largest);
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort/java/Main.java | /**
* Main class to demonstrate heap sort.
*/
public class Main {
/**
* The main method that runs the heap sort demonstration.
* @param args Command-line arguments (not used).
*/
public static void main(String[] args) {
int[] arr = {12, 11, 13, 5, 6, 7};
System.out.println("Original array:");
printArray(arr);
HeapSort heapSort = new HeapSort();
heapSort.sort(arr);
System.out.println("Sorted array:");
printArray(arr);
}
/**
* Prints the elements of an array.
* @param arr The array to be printed.
*/
private static void printArray(int[] arr) {
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort/csharp/Program.cs | using System;
class Program
{
static void Main(string[] args)
{
int[] arr = { 12, 11, 13, 5, 6, 7 };
Console.Write("Original array: ");
PrintArray(arr);
HeapSort(arr);
Console.Write("Sorted array: ");
PrintArray(arr);
}
static void HeapSort(int[] arr)
{
int n = arr.Length;
// Build heap (rearrange array)
for (int i = n / 2 - 1; i >= 0; i--)
{
Heapify(arr, n, i);
}
// One by one extract an element from heap
for (int i = n - 1; i > 0; i--)
{
// Move current root to end
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// call max heapify on the reduced heap
Heapify(arr, i, 0);
}
}
static void Heapify(int[] arr, int n, int i)
{
int largest = i; // Initialize largest as root
int l = 2 * i + 1; // left = 2*i + 1
int r = 2 * i + 2; // right = 2*i + 2
// If left child is larger than root
if (l < n && arr[l] > arr[largest])
{
largest = l;
}
// If right child is larger than largest so far
if (r < n && arr[r] > arr[largest])
{
largest = r;
}
// If largest is not root
if (largest != i)
{
int swap = arr[i];
arr[i] = arr[largest];
arr[largest] = swap;
// Recursively heapify the affected sub-tree
Heapify(arr, n, largest);
}
}
static void PrintArray(int[] arr)
{
foreach (int num in arr)
{
Console.Write(num + " ");
}
Console.WriteLine();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort/cpp/heapSort.cpp | #include "heapSort.h"
void HeapSort::heapify(std::vector<int>& arr, int n, int i) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
if (largest != i) {
std::swap(arr[i], arr[largest]);
heapify(arr, n, largest);
}
}
void HeapSort::sort(std::vector<int>& arr) {
int n = arr.size();
// Build heap (rearrange array)
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
// One by one extract an element from heap
for (int i = n - 1; i >= 0; i--) {
// Move current root to end
std::swap(arr[0], arr[i]);
// Call max heapify on the reduced heap
heapify(arr, i, 0);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort/cpp/CMakeLists.txt | cmake_minimum_required(VERSION 3.10)
# Project name
project(HeapSort)
# Set C++ standard
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# Include directories
include_directories(${PROJECT_SOURCE_DIR})
# Add the executable
add_executable(HeapSort main.cpp heapSort.cpp)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort/cpp/main.cpp | #include <iostream>
#include "heapSort.h"
void printArray(const std::vector<int>& arr) {
for (int num : arr) {
std::cout << num << " ";
}
std::cout << std::endl;
}
int main() {
std::vector<int> arr = {12, 11, 13, 5, 6, 7};
std::cout << "Original array:" << std::endl;
printArray(arr);
HeapSort heapSort;
heapSort.sort(arr);
std::cout << "Sorted array:" << std::endl;
printArray(arr);
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort/cpp/heapSort.h | #ifndef HEAPSORT_H
#define HEAPSORT_H
#include <vector>
class HeapSort {
public:
/**
* Sorts an array using the heap sort algorithm.
* @param arr The vector to be sorted.
*/
void sort(std::vector<int>& arr);
private:
/**
* Heapifies a subtree rooted at index i.
* @param arr The vector representing the heap.
* @param n The size of the heap.
* @param i The index of the root of the subtree.
*/
void heapify(std::vector<int>& arr, int n, int i);
};
#endif
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort/zig/main.zig | const std = @import("std");
const Allocator = std.mem.Allocator;
pub fn main() void {
const arr: [6]u32 = [12, 11, 13, 5, 6, 7];
std.debug.print("Original array: {}\n", .{arr});
heapSort(&arr);
std.debug.print("Sorted array: {}\n", .{arr});
}
pub fn heapSort(arr: []const u32) void {
const n: usize = arr.len;
// Define heapify function to maintain the max-heap property
fn heapify(arr: []u32, n: usize, i: usize) void {
var largest: usize = i;
const l: usize = 2 * i + 1;
const r: usize = 2 * i + 2;
// Check if left child exists and is greater than root
if (l < n) and (arr[l] > arr[largest]) {
largest = l;
}
// Check if right child exists and is greater than the largest so far
if (r < n) and (arr[r] > arr[largest]) {
largest = r;
}
// If the largest element is not the root
if (largest != i) {
const tmp: u32 = arr[i];
arr[i] = arr[largest];
arr[largest] = tmp;
// Recursively heapify the affected sub-tree
heapify(arr, n, largest);
}
}
// Build max heap
for (i := n / 2 - 1; i >= 0; i -= 1) {
heapify(arr, n, i);
}
// Extract elements from heap one by one
for (i := n - 1; i > 0; i -= 1) {
const tmp: u32 = arr[0];
arr[0] = arr[i];
arr[i] = tmp;
// Call max heapify on the reduced heap
heapify(arr, i, 0);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/heap-sort/python/heap_sort.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""heap_sort.py
Certainly! Let's break down the `heap_sort` function and the driving code step by step to understand how the heap sort algorithm works.
### Overview of Heap Sort
Heap sort is a comparison-based sorting algorithm that uses a binary heap data structure. It involves two main steps:
1. **Building a max heap**: Rearranging the array to satisfy the max heap property, where each parent node is greater than or equal to its child nodes.
2. **Extracting elements from the heap**: Repeatedly removing the largest element from the heap and rebuilding the heap with the remaining elements.
### Detailed Explanation
#### Main Function
```python
def main() -> None:
arr = [12, 11, 13, 5, 6, 7]
print("Original array:", arr)
heap_sort(arr)
print("Sorted array:", arr)
if __name__ == "__main__":
main()
```
- The `main` function initializes an array `arr` with unsorted integers.
- It prints the original array.
- It calls the `heap_sort` function to sort the array.
- Finally, it prints the sorted array.
#### Heap Sort Function
```python
def heap_sort(arr):
n = len(arr)
```
- `heap_sort` takes an array `arr` and sorts it in place.
- `n` is the length of the array.
#### Heapify Function
```python
def heapify(arr, n, i):
largest = i # Initialize largest as root
l = 2 * i + 1 # left = 2*i + 1
r = 2 * i + 2 # right = 2*i + 2
# See if left child of root exists and is greater than root
if l < n and arr[i] < arr[l]:
largest = l
# See if right child of root exists and is greater than root
if r < n and arr[largest] < arr[r]:
largest = r
# Change root, if needed
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i] # swap
# Heapify the root.
heapify(arr, n, largest)
```
- `heapify` ensures the subtree rooted at index `i` satisfies the max heap property.
- `largest` is initialized to `i` (the root).
- `l` and `r` are the indices of the left and right children of `i`.
- The function checks if the left child exists and is greater than the root.
- It then checks if the right child exists and is greater than the largest of the root and left child.
- If the largest is not the root, it swaps the root with the largest child and recursively calls `heapify` on the affected subtree.
#### Building the Max Heap
```python
# Build a maxheap.
# Since last parent will be at ((n//2)-1) we can start at that location.
for i in range(n // 2 - 1, -1, -1):
heapify(arr, n, i)
```
- This loop builds a max heap from the input array.
- It starts from the last parent node (at index `n // 2 - 1`) and calls `heapify` for each node up to the root.
- By the end of this loop, the largest element will be at the root of the heap (index 0).
#### Extracting Elements from the Heap
```python
# One by one extract elements
for i in range(n - 1, 0, -1):
arr[i], arr[0] = arr[0], arr[i] # swap
heapify(arr, i, 0)
```
- This loop extracts the elements from the heap one by one.
- It swaps the root (the largest element) with the last element of the heap.
- It then calls `heapify` on the reduced heap (excluding the last element).
- By repeatedly moving the largest element to the end of the array and rebuilding the heap, the array becomes sorted.
### Summary
1. **Build a max heap** from the array.
2. **Repeatedly extract** the largest element from the heap, place it at the end of the array, and rebuild the heap with the remaining elements.
The result is a sorted array in ascending order.
"""
from typing import List
def main() -> None:
"""Driving code"""
arr = [12, 11, 13, 5, 6, 7]
print("Original array:", arr)
heap_sort(arr)
print("Sorted array:", arr)
return None
def heap_sort(arr):
"""Heap sort algorithm."""
n = len(arr)
def heapify(arr, n, i):
largest = i # Initialize largest as root
l = 2 * i + 1 # left = 2*i + 1
r = 2 * i + 2 # right = 2*i + 2
# See if left child of root exists and is
# greater than root
if l < n and arr[i] < arr[l]:
largest = l
# See if right child of root exists and is
# greater than root
if r < n and arr[largest] < arr[r]:
largest = r
# Change root, if needed
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i] # swap
# Heapify the root.
heapify(arr, n, largest)
# Build a maxheap.
# Since last parent will be at ((n//2)-1) we can start at that location.
for i in range(n // 2 - 1, -1, -1):
heapify(arr, n, i)
# One by one extract elements
for i in range(n - 1, 0, -1):
arr[i], arr[0] = arr[0], arr[i] # swap
heapify(arr, i, 0)
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort/java/BubbleSort.java | import javax.swing.*;
import java.awt.*;
import java.util.Arrays;
/**
* This class represents a JPanel that visualizes the Bubble Sort algorithm.
*/
public class BubbleSort extends JPanel {
public static final int WIDTH = 800;
public static final int HEIGHT = 600;
private static final int BAR_WIDTH = 20;
private static final int DELAY = 50;
private int[] array;
/**
* Constructs a BubbleSort panel with the given array of integers.
*
* @param array The array of integers to be sorted and visualized.
*/
public BubbleSort(int[] array) {
this.array = array;
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g;
// Clear the panel
g2d.setColor(Color.WHITE);
g2d.fillRect(0, 0, WIDTH, HEIGHT);
// Draw grid lines
g2d.setColor(Color.LIGHT_GRAY);
for (int i = 0; i < WIDTH; i += BAR_WIDTH) {
g2d.drawLine(i, 0, i, HEIGHT);
}
for (int i = 0; i < HEIGHT; i += BAR_WIDTH) {
g2d.drawLine(0, i, WIDTH, i);
}
// Draw bars
int max = Arrays.stream(array).max().getAsInt();
for (int i = 0; i < array.length; i++) {
int x = i * BAR_WIDTH;
int y = HEIGHT - array[i] * HEIGHT / max;
Color color = new Color(255 - array[i], 100, array[i]); // Color based on array value
g2d.setColor(color);
g2d.fillRect(x, y, BAR_WIDTH, array[i] * HEIGHT / max);
g2d.setColor(Color.BLACK);
g2d.drawRect(x, y, BAR_WIDTH, array[i] * HEIGHT / max);
// Draw value labels
g2d.setColor(Color.BLACK);
g2d.drawString(String.valueOf(array[i]), x + 2, y - 5);
}
}
/**
* Sorts the array of integers using the Bubble Sort algorithm and visualizes the sorting process.
*/
public void bubbleSort() {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
repaint();
try {
Thread.sleep(DELAY);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort/java/Main.java | import javax.swing.*;
/**
* This class serves as the entry point of the program and demonstrates the Bubble Sort algorithm by visualizing the sorting process.
*/
public class Main {
/**
* The main method initializes an array of integers, creates a JFrame for displaying the sorting visualization,
* adds a BubbleSort panel to the frame, sets up the frame's properties, makes the frame visible, and starts the sorting process.
*
* @param args The command line arguments (not used).
*/
public static void main(String[] args) {
// Initialize the array to be sorted
int[] array = {64, 34, 25, 12, 22, 11, 90};
// Create a JFrame for displaying the sorting visualization
JFrame frame = new JFrame("Bubble Sort Visualization");
// Create a BubbleSort panel with the given array
BubbleSort panel = new BubbleSort(array);
// Set the close operation of the frame
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// Add the panel to the frame
frame.add(panel);
// Set the size of the frame
frame.setSize(BubbleSort.WIDTH, BubbleSort.HEIGHT);
// Center the frame on the screen
frame.setLocationRelativeTo(null);
// Make the frame visible
frame.setVisible(true);
// Start the bubble sort algorithm
Thread sortingThread = new Thread(panel::bubbleSort);
sortingThread.start();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort/csharp/Program.cs | using System;
using System.Collections.Generic;
public class BubbleSort
{
public static void Main(string[] args)
{
List<int> unsortedList = new List<int> { 64, 34, 25, 12, 22, 11, 90 };
List<int> sortedList = BubbleSortFunction(unsortedList);
Console.WriteLine("Sorted list:");
foreach (var item in sortedList)
{
Console.Write(item + " ");
}
Console.WriteLine();
VisualizeBubbleSort(unsortedList);
}
public static List<int> BubbleSortFunction(List<int> inputList)
{
int n = inputList.Count;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n - i - 1; j++)
{
if (inputList[j] > inputList[j + 1])
{
int temp = inputList[j];
inputList[j] = inputList[j + 1];
inputList[j + 1] = temp;
}
}
}
return inputList;
}
public static void VisualizeBubbleSort(List<int> inputList)
{
Console.WriteLine("Bubble Sort Visualization");
foreach (var item in inputList)
{
Console.Write(item + " ");
}
Console.WriteLine();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort/cpp/bubbleSort.cpp | // bubbleSort.cpp
//
#include "bubbleSort.h"
#include <iostream>
#include <vector>
#include <algorithm>
#include <chrono>
#include <thread>
void bubble_sort(std::vector<int>& arr) {
int n = arr.size();
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n - i - 1; ++j) {
if (arr[j] > arr[j + 1]) {
std::swap(arr[j], arr[j + 1]);
// Visualization (pause for a short duration)
std::this_thread::sleep_for(std::chrono::milliseconds(100));
// Output the current state of the array
for (int k = 0; k < n; ++k) {
std::cout << arr[k] << " ";
}
std::cout << std::endl;
}
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort/cpp/CMakeLists.txt | cmake_minimum_required(VERSION 3.10)
# Project name
project(BubbleSort)
# Set C++ standard
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# Include directories
include_directories(${PROJECT_SOURCE_DIR})
# Add the executable
add_executable(BubbleSort main.cpp bubbleSort.cpp)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort/cpp/bubbleSort.h | // bubbleSort.h
//
#ifndef BUBBLESORT_H
#define BUBBLESORT_H
#include <vector>
void bubble_sort(std::vector<int>& arr);
#endif // BUBBLESORT_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort/cpp/main.cpp | // main.cpp
//
#include "bubbleSort.h"
#include <vector>
#include <iostream>
int main() {
std::vector<int> arr = {64, 34, 25, 12, 22, 11, 90};
std::cout << "Unsorted array: ";
for (int val : arr) {
std::cout << val << " ";
}
std::cout << std::endl;
bubble_sort(arr);
std::cout << "Sorted array: ";
for (int val : arr) {
std::cout << val << " ";
}
std::cout << std::endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort/zig/main.zig | const std = @import("std");
const io = std.io;
pub fn main() void {
// Initialize an unsorted list of integers
var unsortedList: [7]u32 = [64, 34, 25, 12, 22, 11, 90];
io.print("Unsorted list: ");
printList(unsortedList);
// Sort the list using Bubble Sort algorithm
bubbleSort(&unsortedList);
// Print the sorted list
io.print("Sorted list: ");
printList(unsortedList);
}
pub fn bubbleSort(list: []u32) void {
const len = list.len;
var swapped: bool = false;
// Perform multiple passes over the list
for (len - 1) |i| {
swapped = false;
// Compare adjacent elements and swap if necessary
for (len - 1) |j| {
if (list[j] > list[j + 1]) {
const temp = list[j];
list[j] = list[j + 1];
list[j + 1] = temp;
swapped = true;
}
}
// If no two elements were swapped, the list is already sorted
if (!swapped) {
break;
}
}
}
fn printList(list: []u32) void {
var first: bool = true;
for (list) |element| {
if (!first) {
io.print(", ");
}
first = false;
io.print("{d}", .{element});
}
io.print("\n");
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bubble-sort/python/bubble_sort.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""bubble_sort.py
Main Function (`main`):
- The `main` function serves as the entry point of the script.
- It initializes an unsorted list of integers (`unsorted_list`), prints it, sorts it using the `bubble_sort` function,
prints the sorted list, and then visualizes the sorting process using the `visualize_bubble_sort` function.
Bubble Sort Function (bubble_sort):
- The `bubble_sort` function takes a list of integers (`input_list`) as input and sorts it using the Bubble Sort algorithm.
- It iterates over the list multiple times, comparing adjacent elements and swapping them if they are in the wrong order.
- After each iteration, the largest element "bubbles up" to its correct position at the end of the list.
- The process continues until the entire list is sorted, and the sorted list is returned.
Visualization Function (visualize_bubble_sort):
- The `visualize_bubble_sort` function visualizes the sorting process of the Bubble Sort algorithm.
- It creates a figure and axes using `plt.subplots()` and plots a bar graph representing the initial state of the input list.
- It then iterates through the Bubble Sort algorithm, updating the plot at each step to reflect the changes in the list as it gets sorted.
- The `plt.pause(0.1)` function call adds a short pause between each iteration to visualize the sorting process gradually.
- Finally, it displays the fully sorted list using `plt.show()`.
"""
import matplotlib.pyplot as plt
from typing import List
def main() -> None:
"""Driving code."""
unsorted_list = [64, 34, 25, 12, 22, 11, 90]
sorted_list = bubble_sort(unsorted_list.copy())
print("Sorted list:", sorted_list)
visualize_bubble_sort(unsorted_list)
return None
def bubble_sort(input_list: List[int]) -> List[int]:
"""Sorts a list of integers using the Bubble Sort algorithm.
Parameters:
input_list (List[int]) -- The input list to be sorted.
Returns:
List[int] -- The sorted list.
"""
n = len(input_list)
for i in range(n):
for j in range(0, n-i-1):
if input_list[j] > input_list[j+1]:
input_list[j], input_list[j+1] = input_list[j+1], input_list[j]
return input_list
def visualize_bubble_sort(input_list: List[int]) -> None:
"""Visualizes the Bubble Sort algorithm sorting process.
Parameters:
input_list (List[int]) -- The input list to be sorted.
"""
fig, ax = plt.subplots()
ax.bar(range(len(input_list)), input_list)
ax.set_title('Bubble Sort Visualization')
ax.set_xlabel('Indices')
ax.set_ylabel('Values')
for i in range(len(input_list)):
for j in range(0, len(input_list)-i-1):
if input_list[j] > input_list[j+1]:
input_list[j], input_list[j+1] = input_list[j+1], input_list[j]
ax.clear()
ax.bar(range(len(input_list)), input_list)
plt.pause(0.1)
plt.show()
return None
if __name__ == "__main__":
main() |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort/java/BucketSort.java | import java.util.ArrayList;
import java.util.Collections;
/**
* This class represents Bucket sort algorithm.
*/
public class BucketSort {
/**
* Bucket sort algorithm with visualization.
*
* @param arr The array to be sorted
*/
public static void bucketSort(double[] arr) {
int n = arr.length;
if (n <= 0)
return;
// Create empty buckets
ArrayList<Double>[] buckets = new ArrayList[n];
for (int i = 0; i < n; i++) {
buckets[i] = new ArrayList<>();
}
// Initial array
System.out.print("Initial array: ");
for (double num : arr) {
System.out.print(num + " ");
}
System.out.println();
// Distribute array elements into buckets
for (double num : arr) {
int bucketIndex = (int) (num * n);
buckets[bucketIndex].add(num);
System.out.println("Element " + num + " -> Bucket " + bucketIndex);
}
// Print buckets after distribution
System.out.println("\nBuckets after distribution:");
for (int i = 0; i < n; i++) {
System.out.print("Bucket " + i + ": ");
for (double num : buckets[i]) {
System.out.print(num + " ");
}
System.out.println();
}
// Sort individual buckets
for (int i = 0; i < n; i++) {
Collections.sort(buckets[i]);
}
// Print buckets after sorting
System.out.println("\nBuckets after sorting:");
for (int i = 0; i < n; i++) {
System.out.print("Bucket " + i + ": ");
for (double num : buckets[i]) {
System.out.print(num + " ");
}
System.out.println();
}
// Concatenate all buckets into the original array
int index = 0;
for (int i = 0; i < n; i++) {
for (double num : buckets[i]) {
arr[index++] = num;
}
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort/java/Main.java | /**
* Main class to demonstrate bucket sort algorithm.
*/
public class Main {
/**
* The main method to execute the program.
*
* @param args The command-line arguments (not used)
*/
public static void main(String[] args) {
// Driving code
double[] arr = {0.78, 0.17, 0.39, 0.26, 0.72, 0.94, 0.21, 0.12, 0.23, 0.68};
BucketSort.bucketSort(arr);
// Print the sorted array
System.out.print("Sorted array: ");
for (double num : arr) {
System.out.print(num + " ");
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort/csharp/Program.cs | using System;
using System.Collections.Generic;
class Program
{
static void Main(string[] args)
{
double[] arr = { 0.78, 0.17, 0.39, 0.26, 0.72, 0.94, 0.21, 0.12, 0.23, 0.68 };
double[] sortedArr = BucketSort(arr);
Console.WriteLine(string.Join(", ", sortedArr));
}
static double[] BucketSort(double[] arr)
{
int numBuckets = arr.Length;
List<List<double>> buckets = new List<List<double>>();
for (int i = 0; i < numBuckets; i++)
{
buckets.Add(new List<double>());
}
Console.WriteLine("Initial array: " + string.Join(", ", arr));
// place each element in the appropriate bucket based on its value
foreach (double num in arr)
{
int index = (int)(num * numBuckets);
buckets[index].Add(num);
Console.WriteLine($"Element {num} -> Bucket {index}");
}
Console.WriteLine("\nBuckets after distribution:");
for (int i = 0; i < buckets.Count; i++)
{
Console.WriteLine($"Bucket {i}: [{string.Join(", ", buckets[i])}]");
}
// sort each bucket individually
foreach (List<double> bucket in buckets)
{
bucket.Sort();
}
Console.WriteLine("\nBuckets after sorting:");
for (int i = 0; i < buckets.Count; i++)
{
Console.WriteLine($"Bucket {i}: [{string.Join(", ", buckets[i])}]");
}
// concatenate all buckets into the original array
List<double> sortedArray = new List<double>();
foreach (List<double> bucket in buckets)
{
sortedArray.AddRange(bucket);
}
return sortedArray.ToArray();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort/cpp/bucketSort.h | #ifndef BUCKET_SORT_H
#define BUCKET_SORT_H
#include <vector>
class BucketSort {
public:
static void bucketSort(std::vector<double>& arr);
};
#endif // BUCKET_SORT_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort/cpp/CMakeLists.txt | cmake_minimum_required(VERSION 3.10)
# Project name
project(BucketSort)
# Set C++ standard
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# Include directories
include_directories(${PROJECT_SOURCE_DIR})
# Add the executable
add_executable(BucketSort main.cpp BucketSort.cpp)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort/cpp/main.cpp | #include <iostream>
#include "bucketSort.h"
int main() {
// Driving code
std::vector<double> arr = {0.78, 0.17, 0.39, 0.26, 0.72, 0.94, 0.21, 0.12, 0.23, 0.68};
BucketSort::bucketSort(arr);
// Print the sorted array
std::cout << "Sorted array: ";
for (double num : arr) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort/cpp/bucketSort.cpp | #include "bucketSort.h"
#include <iostream>
#include <vector>
#include <algorithm>
void BucketSort::bucketSort(std::vector<double>& arr) {
int n = arr.size();
if (n <= 0)
return;
// Create empty buckets
std::vector<std::vector<double>> buckets(n);
// Initial array
std::cout << "Initial array: ";
for (double num : arr) {
std::cout << num << " ";
}
std::cout << std::endl;
// Distribute array elements into buckets
for (double num : arr) {
int bucketIndex = static_cast<int>(num * n);
buckets[bucketIndex].push_back(num);
std::cout << "Element " << num << " -> Bucket " << bucketIndex << std::endl;
}
// Print buckets after distribution
std::cout << "\nBuckets after distribution:" << std::endl;
for (int i = 0; i < n; i++) {
std::cout << "Bucket " << i << ": ";
for (double num : buckets[i]) {
std::cout << num << " ";
}
std::cout << std::endl;
}
// Sort individual buckets
for (int i = 0; i < n; i++) {
std::sort(buckets[i].begin(), buckets[i].end());
}
// Print buckets after sorting
std::cout << "\nBuckets after sorting:" << std::endl;
for (int i = 0; i < n; i++) {
std::cout << "Bucket " << i << ": ";
for (double num : buckets[i]) {
std::cout << num << " ";
}
std::cout << std::endl;
}
// Concatenate all buckets into the original array
int index = 0;
for (int i = 0; i < n; i++) {
for (double num : buckets[i]) {
arr[index++] = num;
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort/zig/main.zig | const std = @import("std");
const Allocator = std.mem.Allocator;
pub fn main() void {
const arr = [0.78, 0.17, 0.39, 0.26, 0.72, 0.94, 0.21, 0.12, 0.23, 0.68];
const sortedArr = bucketSort(arr);
std.debug.print("{}\n", .{sortedArr});
}
pub fn bucketSort(arr: [10]f64) [10]f64 {
const numBuckets: usize = arr.len;
var buckets: [numBuckets][]f64 = undefined;
for (arr) |num| {
const index = @intCast(usize, num * numBuckets);
buckets[index] |= @intToSlice(f64, &[_]f64{num});
}
// Sort each bucket individually
for (buckets) |bucket| {
std.sort.quickSort(bucket, .{@cmpOrd(f64, @cmpFloat)});
}
var sortedArray: [10]f64 = undefined;
var idx: usize = 0;
for (buckets) |bucket| {
for (bucket) |num| {
sortedArray[idx] = num;
idx += 1;
}
}
return sortedArray;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/bucket-sort/python/bucket_sort.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""bucket_sort.py
Bucket sort is a sorting algorithm that works by distributing the elements of an array
into several groups, called buckets. Each bucket is then sorted individually, either
using a different sorting algorithm or recursively applying the bucket sort. Finally,
the sorted buckets are concatenated to form the final sorted array. This algorithm is
particularly useful when the input is uniformly distributed over a range.
Steps of Bucket Sort:
Initialization:
Determine the number of buckets you will use. Typically, this is chosen to be the same as the number of elements in the array for simplicity.
Create these empty buckets (which can be represented as lists).
Distribution:
Iterate over the original array and distribute each element into its corresponding bucket.
The bucket for each element is determined based on a function of the element's value, ensuring that elements are spread out among the buckets in a way that reflects their order.
Sorting Individual Buckets:
Once all elements are distributed into buckets, sort each bucket individually.
This sorting can be done using any suitable sorting algorithm (like insertion sort, which is efficient for small datasets typically found in each bucket).
Concatenation:
Finally, concatenate all the sorted buckets to produce the final sorted array.
Detailed Example:
Consider an array of n floating-point numbers uniformly distributed in the range [0, 1).
Step-by-step:
Initialization:
Suppose our array is [0.78, 0.17, 0.39, 0.26, 0.72, 0.94, 0.21, 0.12, 0.23, 0.68].
Create n empty buckets: buckets = [[], [], [], [], [], [], [], [], [], []].
Distribution:
For each element in the array, calculate its bucket index. This is typically index = int(num * n) where num is the element and n is the number of buckets.
Place the element into the appropriate bucket:
0.78 goes into bucket 7 (since int(0.78 * 10) = 7).
0.17 goes into bucket 1.
And so on, until all elements are distributed.
Sorting Individual Buckets:
Each bucket is sorted individually. After sorting, buckets might look like this:
Bucket 0: [0.12]
Bucket 1: [0.17, 0.21, 0.23]
Bucket 2: [0.26]
Bucket 3: [0.39]
Bucket 4: []
Bucket 5: []
Bucket 6: [0.68]
Bucket 7: [0.72, 0.78]
Bucket 8: []
Bucket 9: [0.94]
Concatenation:
Combine all sorted buckets to form the final sorted array:
[0.12, 0.17, 0.21, 0.23, 0.26, 0.39, 0.68, 0.72, 0.78, 0.94].
"""
def main() -> None:
"""Driving code."""
arr = [0.78, 0.17, 0.39, 0.26, 0.72, 0.94, 0.21, 0.12, 0.23, 0.68]
sorted_arr = bucket_sort(arr)
print(sorted_arr)
return None
def bucket_sort(arr):
"""Bucket sort algorithm."""
num_buckets = len(arr)
buckets = [[] for _ in range(num_buckets)]
print("Initial array:", arr)
# place each element in the appropriate bucket based on its value
for num in arr:
index = int(num * num_buckets)
buckets[index].append(num)
print(f"Element {num} -> Bucket {index}")
print("\nBuckets after distribution:")
for i, bucket in enumerate(buckets):
print(f"Bucket {i}: {bucket}")
# sort each bucket individually
for bucket in buckets:
bucket.sort()
print("\nBuckets after sorting:")
for i, bucket in enumerate(buckets):
print(f"Bucket {i}: {bucket}")
# concatenate all buckets into the original array
sorted_array = []
for bucket in buckets:
sorted_array.extend(bucket)
return sorted_array
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort/java/Main.java | /**
* Main class to demonstrate insertion sort.
*/
public class Main {
/**
* The main method that runs the insertion sort demonstration.
* @param args Command-line arguments (not used).
*/
public static void main(String[] args) {
int[] arr = {12, 11, 13, 5, 6};
System.out.println("Original array:");
printArray(arr);
InsertionSort insertionSort = new InsertionSort();
insertionSort.sort(arr);
System.out.println("Sorted array:");
printArray(arr);
}
/**
* Prints the elements of an array.
* @param arr The array to be printed.
*/
private static void printArray(int[] arr) {
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort/java/InsertionSort.java | /**
* InsertionSort class that implements the insertion sort algorithm.
*/
public class InsertionSort {
/**
* Sorts an array using the insertion sort algorithm.
* @param arr The array to be sorted.
*/
public void sort(int[] arr) {
System.out.println("Unsorted: ");
printArray(arr);
// Iterate over the array to be sorted
for (int i = 1; i < arr.length; i++) {
int x = arr[i]; // Get each element
int j = i - 1; // Get one position before x
// Shift elements until reaching index 0 or getting an element smaller than x
while (j >= 0 && arr[j] > x) {
arr[j + 1] = arr[j];
j--;
}
// Place x in its correct position
arr[j + 1] = x;
}
System.out.println("Sorted: ");
printArray(arr);
}
/**
* Prints the elements of an array.
* @param arr The array to be printed.
*/
private void printArray(int[] arr) {
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort/csharp/Program.cs | using System;
class Program
{
static void Main(string[] args)
{
int[] sampleList = { 12, 11, 13, 5, 6 };
Console.WriteLine("Original list: " + string.Join(", ", sampleList));
InsertionSort(sampleList);
Console.WriteLine("Sorted list: " + string.Join(", ", sampleList));
}
static void InsertionSort(int[] listToSort)
{
Console.WriteLine("Unsorted: " + string.Join(", ", listToSort));
// Iterate over the array to be sorted
for (int i = 1; i < listToSort.Length; i++)
{
int x = listToSort[i]; // Get each element
int j = i - 1; // Get one position before x
// Shift elements until reaching index 0 or getting an element smaller than x
while (j >= 0 && x < listToSort[j])
{
listToSort[j + 1] = listToSort[j];
j--;
}
// Place x in its correct position
listToSort[j + 1] = x;
}
Console.WriteLine("Sorted: " + string.Join(", ", listToSort));
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort/cpp/insertionSort.cpp | #include <iostream>
#include "insertionSort.h"
void InsertionSort::sort(std::vector<int>& arr) {
std::cout << "Unsorted: ";
printArray(arr);
// Iterate over the array to be sorted
for (size_t i = 1; i < arr.size(); ++i) {
int x = arr[i]; // Get each element
int j = i - 1; // Get one position before x
// Shift elements until reaching index 0 or getting an element smaller than x
while (j >= 0 && arr[j] > x) {
arr[j + 1] = arr[j];
j--;
}
// Place x in its correct position
arr[j + 1] = x;
}
std::cout << "Sorted: ";
printArray(arr);
}
void InsertionSort::printArray(const std::vector<int>& arr) {
for (int num : arr) {
std::cout << num << " ";
}
std::cout << std::endl;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort/cpp/insertionSort.h | #ifndef INSERTIONSORT_H
#define INSERTIONSORT_H
#include <vector>
/**
* InsertionSort class that implements the insertion sort algorithm.
*/
class InsertionSort {
public:
/**
* Sorts a vector using the insertion sort algorithm.
* @param arr The vector to be sorted.
*/
void sort(std::vector<int>& arr);
private:
/**
* Prints the elements of a vector.
* @param arr The vector to be printed.
*/
void printArray(const std::vector<int>& arr);
};
#endif
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort/cpp/main.cpp | #include <iostream>
#include <vector>
#include "insertionSort.h"
int main() {
std::vector<int> arr = {12, 11, 13, 5, 6};
std::cout << "Original array:" << std::endl;
InsertionSort insertionSort;
insertionSort.sort(arr);
std::cout << "Sorted array:" << std::endl;
// insertionSort.printArray(arr);
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort/zig/main.zig | const std = @import("std");
const Allocator = std.mem.Allocator;
pub fn main() void {
var sampleList: [5]u32 = [12, 11, 13, 5, 6];
const originalList = sampleList;
const originalListSlice = originalList[0..];
// Print original list
std.debug.print("Original list: {}\n", .{originalListSlice});
insertionSort(&sampleList);
// Print sorted list
const sortedListSlice = sampleList[0..];
std.debug.print("Sorted list: {}\n", .{sortedListSlice});
}
pub fn insertionSort(arr: []u32) void {
// Iterate over the array to be sorted
for (i := 1; i < arr.len; i += 1) : (i += 1) {
var x: u32 = arr[i]; // Get each element
var j: isize = @intCast(isize, i) - 1; // Get one position before x
// Shift elements until reaching index 0 or getting an element smaller than x
while (j >= 0) && (x < arr[@intCast(usize, j)]) : (j -= 1) {
arr[j + 1] = arr[j];
j -= 1;
}
// Place x in its correct position
arr[j + 1] = x;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/insertion-sort/python/insertion_sort.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""insertion_sort.py
This module provides an implementation of the insertion sort algorithm.
"""
def main() -> None:
"""Driving code for the insertion sort algorithm."""
sample_list = [12, 11, 13, 5, 6]
print("Original list:", sample_list)
insertion_sort(sample_list)
print("Sorted list:", sample_list)
return None
def insertion_sort(list_to_sort: list) -> None:
"""Insertion sort algorithm.
Parameters:
list_to_sort (list) -- The list of elements to be sorted.
"""
print(f"Unsorted: {list_to_sort}")
# Iterate over the array to be sorted
for i in range(1, len(list_to_sort)):
x = list_to_sort[i] # Get each element
j = i - 1 # Get one position before x
# Shift elements until reaching index 0 or getting an element smaller than x
while j >= 0 and x < list_to_sort[j]:
list_to_sort[j + 1] = list_to_sort[j]
j -= 1
# Place x in its correct position
list_to_sort[j + 1] = x
print(f"Sorted: {list_to_sort}")
return None
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag/java/TopologicalSortOfDrag.java | import java.util.*;
/**
* TopologicalSortOfDrag class that implements the topological sort algorithm.
*/
public class TopologicalSortOfDrag {
private int V; // No. of vertices
private LinkedList<Integer> adj[]; // Adjacency List
/**
* Constructor to initialize the topological sort object.
* @param v The number of vertices.
*/
public TopologicalSortOfDrag(int v) {
V = v;
adj = new LinkedList[v];
for (int i = 0; i < v; ++i)
adj[i] = new LinkedList();
}
/**
* Function to add an edge into the graph.
* @param v The source vertex.
* @param w The destination vertex.
*/
public void addEdge(int v, int w) {
adj[v].add(w);
}
/**
* A recursive function used by topologicalSort.
* @param v The current vertex.
* @param visited An array to keep track of visited vertices.
* @param stack The stack to store the topological sort order.
*/
private void topologicalSortUtil(int v, boolean visited[], Stack<Integer> stack) {
// Mark the current node as visited.
visited[v] = true;
// Recur for all the vertices adjacent to this vertex
Iterator<Integer> i = adj[v].listIterator();
while (i.hasNext()) {
int n = i.next();
if (!visited[n])
topologicalSortUtil(n, visited, stack);
}
// Push current vertex to stack which stores result
stack.push(v);
}
/**
* The main function that sorts the graph.
*/
public void topologicalSort() {
Stack<Integer> stack = new Stack<>();
// Mark all the vertices as not visited
boolean visited[] = new boolean[V];
for (int i = 0; i < V; i++)
visited[i] = false;
// Call the recursive helper function to store Topological Sort starting from all vertices one by one
for (int i = 0; i < V; i++)
if (!visited[i])
topologicalSortUtil(i, visited, stack);
// Print contents of stack
while (!stack.empty())
System.out.print(stack.pop() + " ");
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag/java/Main.java | /**
* Main class to demonstrate topological sort.
*/
public class Main {
/**
* The main method that runs the topological sort demonstration.
* @param args Command-line arguments (not used).
*/
public static void main(String args[]) {
// Create a graph given in the diagram
TopologicalSortOfDrag g = new TopologicalSortOfDrag(6);
g.addEdge(5, 2);
g.addEdge(5, 0);
g.addEdge(4, 0);
g.addEdge(4, 1);
g.addEdge(2, 3);
g.addEdge(3, 1);
System.out.println("Following is a Topological " + "sort of the given graph");
g.topologicalSort();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag/csharp/Program.cs | using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
static void Main(string[] args)
{
Graph g = new Graph(6);
g.addEdge(5, 2);
g.addEdge(5, 0);
g.addEdge(4, 0);
g.addEdge(4, 1);
g.addEdge(2, 3);
g.addEdge(3, 1);
Console.WriteLine("Following is a Topological Sort of the given graph:");
g.topologicalSort();
}
}
class Graph
{
private int V; // Number of vertices
private List<int>[] adj; // Adjacency list
public Graph(int v)
{
V = v;
adj = new List<int>[v];
for (int i = 0; i < v; ++i)
adj[i] = new List<int>();
}
// Function to add an edge to the graph
public void addEdge(int v, int w)
{
adj[v].Add(w);
}
// A recursive function used by topologicalSort
private void topologicalSortUtil(int v, bool[] visited, Stack<int> stack)
{
visited[v] = true;
foreach (int i in adj[v])
if (!visited[i])
topologicalSortUtil(i, visited, stack);
stack.Push(v);
}
// The function to do Topological Sort
public void topologicalSort()
{
Stack<int> stack = new Stack<int>();
bool[] visited = new bool[V];
for (int i = 0; i < V; i++)
if (!visited[i])
topologicalSortUtil(i, visited, stack);
while (stack.Count != 0)
Console.Write(stack.Pop() + " ");
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag/cpp/main.cpp | #include "topologicalSortOfDrag.h"
int main() {
// Create a graph given in the diagram
TopologicalSortOfDrag g(6);
g.addEdge(5, 2);
g.addEdge(5, 0);
g.addEdge(4, 0);
g.addEdge(4, 1);
g.addEdge(2, 3);
g.addEdge(3, 1);
std::cout << "Following is a Topological sort of the given graph: ";
g.topologicalSort();
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag/cpp/topologicalSortOfDrag.h | #ifndef TOPOLOGICALSORTOFDRAG_H
#define TOPOLOGICALSORTOFDRAG_H
#include <iostream>
#include <list>
#include <stack>
class TopologicalSortOfDrag {
int V; // No. of vertices
std::list<int> *adj; // Adjacency list
public:
TopologicalSortOfDrag(int V); // Constructor
void addEdge(int v, int w); // Function to add an edge to the graph
void topologicalSort(); // The function to do Topological Sort
void topologicalSortUtil(int v, bool visited[], std::stack<int> &Stack); // A recursive function used by topologicalSort
};
#endif
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag/cpp/topologicalSortOfDrag.cpp | #include "topologicalSortOfDrag.h"
TopologicalSortOfDrag::TopologicalSortOfDrag(int V) {
this->V = V;
adj = new std::list<int>[V];
}
void TopologicalSortOfDrag::addEdge(int v, int w) {
adj[v].push_back(w);
}
void TopologicalSortOfDrag::topologicalSortUtil(int v, bool visited[], std::stack<int> &Stack) {
// Mark the current node as visited
visited[v] = true;
// Recur for all the vertices adjacent to this vertex
for (auto i = adj[v].begin(); i != adj[v].end(); ++i)
if (!visited[*i])
topologicalSortUtil(*i, visited, Stack);
// Push current vertex to stack which stores result
Stack.push(v);
}
void TopologicalSortOfDrag::topologicalSort() {
std::stack<int> Stack;
// Mark all the vertices as not visited
bool *visited = new bool[V];
for (int i = 0; i < V; i++)
visited[i] = false;
// Call the recursive helper function to store Topological Sort starting from all vertices one by one
for (int i = 0; i < V; i++)
if (visited[i] == false)
topologicalSortUtil(i, visited, Stack);
// Print contents of stack
while (Stack.empty() == false) {
std::cout << Stack.top() << " ";
Stack.pop();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag/zig/main.zig | const std = @import("std");
pub fn main() void {
var g = Graph.init(6);
g.addEdge(5, 2);
g.addEdge(5, 0);
g.addEdge(4, 0);
g.addEdge(4, 1);
g.addEdge(2, 3);
g.addEdge(3, 1);
std.debug.print("Following is a Topological Sort of the given graph\n", .{});
g.topologicalSort();
}
pub fn Graph.init(vertices: usize) Graph {
return Graph{
.graph = [_][]u32{0} ** vertices,
.V = vertices,
};
}
pub fn (g *Graph) addEdge(u: u32, v: u32) void {
g.graph[u] |= v;
}
pub fn (g *Graph) topologicalSort() void {
var visited = [_]bool{false} ** g.V;
var stack = []u32{};
for (g.V).times |i| {
if (!visited[i]) {
g.topologicalSortUtil(i, &visited, &stack);
}
}
var buf: [][0]u8 = .{};
std.mem.zero(buf);
std.debug.print("{}", .{stack.toSlice(buf)});
}
pub fn (g *Graph) topologicalSortUtil(v: u32, visited: *[_]bool, stack: *[]u32) void {
visited[v] = true;
for (g.graph[v]) |i| {
if (!visited[i]) {
g.topologicalSortUtil(i, visited, stack);
}
}
stack |= v;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/topological-sort-of-dag/python/topological_sort_of_dag.py |
# recursive topological sorting
# ----------------------------
#Python program to print topological sorting of a DAG
from collections import defaultdict
def main() -> None:
"""Driving code"""
g= Graph(6)
g.addEdge(5, 2)
g.addEdge(5, 0)
g.addEdge(4, 0)
g.addEdge(4, 1)
g.addEdge(2, 3)
g.addEdge(3, 1)
print ("Following is a Topological Sort of the given graph")
g.topologicalSort()
return None
#Class to represent a graph
class Graph:
"""Class to represent a graph."""
def __init__(self,vertices) -> None:
self.graph = defaultdict(list) # dictionary containing adjacency List
self.V = vertices # number of vertices
return None
# function to add an edge to graph
def addEdge(self,u,v) -> None:
"""Add an edge to the paragraph."""
self.graph[u].append(v)
return None
# A recursive function used by topologicalSort
def topologicalSortUtil(self,v,visited,stack) -> None:
"""Recursive function sued by topological sort."""
# Mark the current node as visited.
visited[v] = True
# Recur for all the vertices adjacent to this vertex
for i in self.graph[v]:
if visited[i] == False:
self.topologicalSortUtil(i,visited,stack)
# Push current vertex to stack which stores result
stack.insert(0,v)
return None
#
def topologicalSort(self) -> None:
"""The function to do Topological Sort. It uses
recursive topologicalSortUtil()."""
# Mark all the vertices as not visited
visited = [False]*self.V
stack =[]
# Call the recursive helper function to store Topological
# Sort starting from all vertices one by one
for i in range(self.V):
if visited[i] == False:
self.topologicalSortUtil(i,visited,stack)
# Print contents of stack
print (stack)
return None
if __name__ == "__main__":
main() |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort/java/QuickSort.java | /**
* QuickSort class that implements the quick sort algorithm.
*/
public class QuickSort {
/**
* Sorts an array using the quick sort algorithm.
* @param arr The array to be sorted.
*/
public void sort(int[] arr) {
quickSort(arr, 0, arr.length - 1);
}
/**
* Recursively sorts a subarray using the quick sort algorithm.
* @param arr The array to be sorted.
* @param low The lowest index of the subarray.
* @param high The highest index of the subarray.
*/
private void quickSort(int[] arr, int low, int high) {
if (low < high) {
// Partition the array and get the pivot index
int pivotIndex = partition(arr, low, high);
// Recursively sort the subarrays
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}
/**
* Partitions the array around a pivot element and returns the pivot index.
* @param arr The array to be partitioned.
* @param low The lowest index of the subarray.
* @param high The highest index of the subarray.
* @return The pivot index.
*/
private int partition(int[] arr, int low, int high) {
int pivot = arr[high]; // Choose the last element as the pivot
int i = low - 1; // Index of smaller element
for (int j = low; j < high; j++) {
// If current element is smaller than or equal to pivot
if (arr[j] <= pivot) {
i++;
// Swap arr[i] and arr[j]
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// Swap arr[i+1] and arr[high] (or pivot)
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return i + 1;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort/java/Main.java | import java.util.Arrays;
/**
* Main class to demonstrate quick sort.
*/
public class Main {
/**
* The main method that runs the quick sort demonstration.
* @param args Command-line arguments (not used).
*/
public static void main(String[] args) {
int[] arr = {38, 27, 43, 3, 9, 82, 10};
System.out.println("Original array:");
printArray(arr);
QuickSort quickSort = new QuickSort();
quickSort.sort(arr);
System.out.println("Sorted array:");
printArray(arr);
}
/**
* Prints the elements of an array.
* @param arr The array to be printed.
*/
private static void printArray(int[] arr) {
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort/csharp/Program.cs | using System;
class Program
{
static void Main(string[] args)
{
int[] sampleList = { 38, 27, 43, 3, 9, 82, 10 };
Console.WriteLine("Original list: " + string.Join(", ", sampleList));
QuickSort(sampleList, 0, sampleList.Length - 1);
Console.WriteLine("Sorted list: " + string.Join(", ", sampleList));
}
static void QuickSort(int[] arr, int low, int high)
{
if (low < high)
{
int pi = Partition(arr, low, high);
QuickSort(arr, low, pi - 1);
QuickSort(arr, pi + 1, high);
}
}
static int Partition(int[] arr, int low, int high)
{
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++)
{
if (arr[j] < pivot)
{
i++;
Swap(arr, i, j);
}
}
Swap(arr, i + 1, high);
return i + 1;
}
static void Swap(int[] arr, int i, int j)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort/cpp/quickSort.cpp | #include "quickSort.h"
void QuickSort::sort(std::vector<int>& arr) {
quickSort(arr, 0, arr.size() - 1);
}
void QuickSort::quickSort(std::vector<int>& arr, int low, int high) {
if (low < high) {
// Partition the vector and get the pivot index
int pivotIndex = partition(arr, low, high);
// Recursively sort the subvectors
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}
int QuickSort::partition(std::vector<int>& arr, int low, int high) {
int pivot = arr[high]; // Choose the last element as the pivot
int i = low - 1; // Index of smaller element
for (int j = low; j < high; j++) {
// If current element is smaller than or equal to pivot
if (arr[j] <= pivot) {
i++;
// Swap arr[i] and arr[j]
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// Swap arr[i+1] and arr[high] (or pivot)
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return i + 1;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort/cpp/quickSort.h | #ifndef QUICKSORT_H
#define QUICKSORT_H
#include <vector>
/**
* QuickSort class that implements the quick sort algorithm.
*/
class QuickSort {
public:
/**
* Sorts a vector using the quick sort algorithm.
* @param arr The vector to be sorted.
*/
void sort(std::vector<int>& arr);
private:
/**
* Recursively sorts a subvector using the quick sort algorithm.
* @param arr The vector to be sorted.
* @param low The lowest index of the subvector.
* @param high The highest index of the subvector.
*/
void quickSort(std::vector<int>& arr, int low, int high);
/**
* Partitions the vector around a pivot element and returns the pivot index.
* @param arr The vector to be partitioned.
* @param low The lowest index of the subvector.
* @param high The highest index of the subvector.
* @return The pivot index.
*/
int partition(std::vector<int>& arr, int low, int high);
};
#endif
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort/cpp/main.cpp | #include <iostream>
#include <vector>
#include "quickSort.h"
/**
* Main function to demonstrate quick sort.
*/
int main() {
std::vector<int> arr = {38, 27, 43, 3, 9, 82, 10};
std::cout << "Original array:" << std::endl;
for (int num : arr) {
std::cout << num << " ";
}
std::cout << std::endl;
QuickSort quickSort;
quickSort.sort(arr);
std::cout << "Sorted array:" << std::endl;
for (int num : arr) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort/zig/main.zig | const std = @import("std");
pub fn main() void {
var sampleList: [7]u32 = [38, 27, 43, 3, 9, 82, 10];
const originalList = sampleList;
const originalListSlice = originalList[0..];
// Print original list
std.debug.print("Original list: {}\n", .{originalListSlice});
quickSort(&sampleList, 0, sampleList.len);
// Print sorted list
const sortedListSlice = sampleList[0..];
std.debug.print("Sorted list: {}\n", .{sortedListSlice});
}
pub fn quickSort(arr: []u32, left: usize, right: usize) void {
if left < right {
const pivot: usize = partition(arr, left, right);
quickSort(arr, left, pivot);
quickSort(arr, pivot + 1, right);
}
}
fn partition(arr: []u32, left: usize, right: usize) usize {
const pivotIndex: usize = left;
var leftIndex: usize = left + 1;
var rightIndex: usize = right;
while (leftIndex <= rightIndex) : (leftIndex += 1; rightIndex -= 1) {
while (leftIndex <= right) : (leftIndex += 1) {
if arr[leftIndex] > arr[pivotIndex] {
break;
}
}
while (rightIndex > left) : (rightIndex -= 1) {
if arr[rightIndex] <= arr[pivotIndex] {
break;
}
}
if leftIndex < rightIndex {
arr[leftIndex], arr[rightIndex] = arr[rightIndex], arr[leftIndex];
}
}
arr[pivotIndex], arr[rightIndex] = arr[rightIndex], arr[pivotIndex];
return rightIndex;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort | repos/exploratory-tech-studio/tech-studio-projects/algorithms/sorting/quick-sort/python/quick_sort.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""quick_sort.py
Quick sort is a popular sorting algorithm that follows the "divide and
conquer" strategy. It works by selecting a "pivot" element from the array
and partitioning the other elements into two sub-arrays according to whether
they are less than or greater than the pivot. The sub-arrays are then recursively
sorted.
"""
def main() -> None:
"""Driving code."""
sample_list = [38, 27, 43, 3, 9, 82, 10]
print("Original list:", sample_list)
sorted_list = quick_sort(sample_list)
print("Sorted list:", sorted_list)
def quick_sort(unsorted_list: list) -> list:
"""Sorts a list using the quick sort algorithm.
Args:
unsorted_list (list): The list to be sorted.
Returns:
list: The sorted list.
"""
elements = len(unsorted_list)
if elements < 2:
return unsorted_list
pivot = unsorted_list[0]
left = [x for x in unsorted_list[1:] if x <= pivot]
right = [x for x in unsorted_list[1:] if x > pivot]
return quick_sort(left) + [pivot] + quick_sort(right)
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/machine-learning | repos/exploratory-tech-studio/tech-studio-projects/machine-learning/detecting-credit-card-fraud/detecting_cc_fraud.py | import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
# Load and preprocess dataset
def main():
"""Main program"""
print("Loading and preprocessing data...")
# Load and preprocess credit card transaction data
X_train, X_test, y_train, y_test = load_data()
print("Building and training model...")
# Build and train fraud detection model
model = build_model(input_dim=X_train.shape[1])
model.fit(X_train, y_train, epochs=10, batch_size=32, validation_split=0.1, verbose=1)
print("Evaluating model...")
# Evaluate model
accuracy = evaluate_model(model, X_test, y_test)
print("Accuracy:", accuracy)
def evaluate_model(model, X_test, y_test):
"""Evaluates the model on the test data and returns accuracy"""
_, accuracy = model.evaluate(X_test, y_test)
return accuracy
def build_model(input_dim):
"""Builds a simple neural network model for fraud detection"""
model = Sequential([
Dense(64, activation='relu', input_dim=input_dim),
Dense(32, activation='relu'),
Dense(1, activation='sigmoid')
])
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
return model
def load_credit_card_dataset():
# Placeholder implementation, replace with your actual dataset loading logic
print("Loading credit card dataset...")
# Generate random features (X) and labels (y) for demonstration
num_samples = 1000
num_features = 10
X = np.random.rand(num_samples, num_features) # Random features
y = np.random.randint(2, size=num_samples) # Random binary labels (0 or 1)
return X, y
def load_data():
print("Loading data...")
# Load credit card transaction dataset
X, y = load_credit_card_dataset()
# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Standardize features
print("Standardizing features...")
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
return X_train, X_test, y_train, y_test
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/machine-learning | repos/exploratory-tech-studio/tech-studio-projects/machine-learning/image-creation/main.py | # Deep Convolutional GANs
# Importing the libraries
from __future__ import print_function
import torch.nn as nn
import torch.optim as optim
import torch.utils.data
import torchvision.datasets as dset
import torchvision.transforms as transforms
import torchvision.utils as vutils
from torch.autograd import Variable
def main():
"""Main program and entry point"""
# Setting some hyperparameters
batchSize = 64 # We set the size of the batch.
imageSize = 64 # We set the size of the generated images (64x64).
# Creating the transformations
transform = transforms.Compose([transforms.Resize(imageSize),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])
# Loading the dataset
dataset = dset.CIFAR10(root='./data', download=True, transform=transform)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=batchSize, shuffle=True, num_workers=2)
# Creating the generator
netG = G()
netG.apply(weights_init)
# Creating the discriminator
netD = D()
netD.apply(weights_init)
# Training the DCGANs
criterion = nn.BCELoss()
optimizerD = optim.Adam(netD.parameters(), lr=0.0002, betas=(0.5, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=0.0002, betas=(0.5, 0.999))
for epoch in range(25):
for i, data in enumerate(dataloader, 0):
# 1st Step: Updating the weights of the neural network of the discriminator
netD.zero_grad()
real, _ = data
input_data = Variable(real)
target = Variable(torch.ones(input_data.size()[0]))
output = netD(input_data)
errD_real = criterion(output, target)
noise = Variable(torch.randn(input_data.size()[0], 100, 1, 1))
fake = netG(noise)
target = Variable(torch.zeros(input_data.size()[0]))
output = netD(fake.detach())
errD_fake = criterion(output, target)
errD = errD_real + errD_fake
errD.backward()
optimizerD.step()
# 2nd Step: Updating the weights of the neural network of the generator
netG.zero_grad()
target = Variable(torch.ones(input_data.size()[0]))
output = netD(fake)
errG = criterion(output, target)
errG.backward()
optimizerG.step()
# 3rd Step: Printing the losses and saving the real images and the generated images
print('[%d/%d][%d/%d] Loss_D: %.4f Loss_G: %.4f' % (epoch, 25, i, len(dataloader), errD.item(), errG.item()))
if i % 100 == 0:
vutils.save_image(real, '%s/real_samples.png' % "./results", normalize=True)
with torch.no_grad():
fake = netG(noise)
vutils.save_image(fake.detach(), '%s/fake_samples_epoch_%03d.png' % ("./results", epoch), normalize=True)
# Defining the generator
class G(nn.Module): # We introduce a class to define the generator.
def __init__(self): # We introduce the __init__() function that will define the architecture of the generator.
super(G, self).__init__() # We inherit from the nn.Module tools.
self.main = nn.Sequential(
# We create a meta module of a neural network that will contain a sequence of modules (convolutions,
# full connections, etc.).
nn.ConvTranspose2d(100, 512, 4, 1, 0, bias=False), # We start with an inversed convolution.
nn.BatchNorm2d(512), # We normalize all the features along the dimension of the batch.
nn.ReLU(True), # We apply a ReLU rectification to break the linearity.
nn.ConvTranspose2d(512, 256, 4, 2, 1, bias=False), # We add another inversed convolution.
nn.BatchNorm2d(256), # We normalize again.
nn.ReLU(True), # We apply another ReLU.
nn.ConvTranspose2d(256, 128, 4, 2, 1, bias=False), # We add another inversed convolution.
nn.BatchNorm2d(128), # We normalize again.
nn.ReLU(True), # We apply another ReLU.
nn.ConvTranspose2d(128, 64, 4, 2, 1, bias=False), # We add another inversed convolution.
nn.BatchNorm2d(64), # We normalize again.
nn.ReLU(True), # We apply another ReLU.
nn.ConvTranspose2d(64, 3, 4, 2, 1, bias=False), # We add another inversed convolution.
nn.Tanh() # We apply a Tanh rectification to break the linearity and stay between -1 and +1.
)
def forward(self,
input_d): # We define the forward function that takes as argument an input that will be fed to
# the neural network, and that will return the output containing the generated images.
output_d = self.main(
input_d) # We forward propagate the signal through the whole neural network of the generator defined
# by self.main.
return output_d # We return the output containing the generated images.
# Defining the discriminator
class D(nn.Module): # We introduce a class to define the discriminator.
def __init__(self): # We introduce the __init__() function that will define the architecture of the discriminator.
super(D, self).__init__() # We inherit from the nn.Module tools.
self.main = nn.Sequential(
# We create a meta module of a neural network that will contain a sequence of modules (convolutions,
# full connections, etc.).
nn.Conv2d(3, 64, 4, 2, 1, bias=False), # We start with a convolution.
nn.LeakyReLU(0.2, inplace=True), # We apply a LeakyReLU.
nn.Conv2d(64, 128, 4, 2, 1, bias=False), # We add another convolution.
nn.BatchNorm2d(128), # We normalize all the features along the dimension of the batch.
nn.LeakyReLU(0.2, inplace=True), # We apply another LeakyReLU.
nn.Conv2d(128, 256, 4, 2, 1, bias=False), # We add another convolution.
nn.BatchNorm2d(256), # We normalize again.
nn.LeakyReLU(0.2, inplace=True), # We apply another LeakyReLU.
nn.Conv2d(256, 512, 4, 2, 1, bias=False), # We add another convolution.
nn.BatchNorm2d(512), # We normalize again.
nn.LeakyReLU(0.2, inplace=True), # We apply another LeakyReLU.
nn.Conv2d(512, 1, 4, 1, 0, bias=False), # We add another convolution.
nn.Sigmoid() # We apply a Sigmoid rectification to break the linearity and stay between 0 and 1.
)
def forward(self,
input_d): # We define the forward function that takes as argument an input that will be fed to the
# neural network, and that will return the output which will be a value between 0 and 1.
output_d = self.main(
input_d) # We forward propagate the signal through the whole neural network of the discriminator defined
# by self.main.
return output_d.view(-1) # We return the output which will be a value between 0 and 1.
# Defining the weights_init function that takes as input a neural network m and that will initialize all its weights.
def weights_init(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1:
m.weight.data.normal_(0.0, 0.02)
elif classname.find('BatchNorm') != -1:
m.weight.data.normal_(1.0, 0.02)
m.bias.data.fill_(0)
if __name__ == "__main__":
main() |
0 | repos/exploratory-tech-studio/tech-studio-projects/machine-learning | repos/exploratory-tech-studio/tech-studio-projects/machine-learning/image-classification/main.py | from fastapi import FastAPI, UploadFile, File
from fastapi.responses import JSONResponse
from typing import List
import torch
import torchvision.transforms as transforms
import torchvision.models as models
import uvicorn
from PIL import Image
app = FastAPI()
# Load your model during startup
@app.on_event("startup")
async def startup_event():
global model
# Load pre-trained ResNet model
model1 = models.resnet18(pretrained=True)
model1.load_state_dict(torch.load('image_classification_model.pth', map_location=torch.device('cpu')))
model1.eval()
# Load pre-trained ResNet model
model1 = models.resnet18(pretrained=True)
# Save the model's parameters
torch.save(model1.state_dict(), 'image_classification_model.pth')
# Load the state_dict into the model
state_dict = torch.load('image_classification_model.pth', map_location=torch.device('cpu'))
model1.load_state_dict(state_dict)
# Set the model to evaluation mode
model1.eval()
labels = ['cat', 'dog', 'bird', 'fish'] # Example labels for illustration purposes
# Define image transformation pipeline
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
# Define your prediction endpoint
@app.post("/predict")
async def predict(file: UploadFile = File(...)) -> JSONResponse:
# Read image file and preprocess
contents = await file.read()
image = Image.open(io.BytesIO(contents))
image = transform(image).unsqueeze(0)
# Perform model inference
with torch.no_grad():
output = model(image)
# Post-processing: Get predicted label
_, predicted = torch.max(output, 1)
predicted_label = labels[predicted.item()]
return JSONResponse(content={"prediction": predicted_label})
if __name__ == "__main__":
uvicorn.run(app, host="127.0.0.1", port=8000) |
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/strategy-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/strategy-pattern/java/Main.java | import java.util.List;
interface SortingStrategy {
List<Integer> sort(List<Integer> data);
}
class BubbleSortStrategy implements SortingStrategy {
public List<Integer> sort(List<Integer> data) {
System.out.println("Bubble sorting...");
data.sort(null);
return data;
}
}
class QuickSortStrategy implements SortingStrategy {
public List<Integer> sort(List<Integer> data) {
System.out.println("Quick sorting...");
data.sort(null);
return data;
}
}
class Sorter {
private SortingStrategy strategy;
public Sorter(SortingStrategy strategy) {
this.strategy = strategy;
}
public void setStrategy(SortingStrategy strategy) {
this.strategy = strategy;
}
public List<Integer> executeSort(List<Integer> data) {
return strategy.sort(data);
}
}
public class Main {
public static void main(String[] args) {
List<Integer> data = List.of(5, 2, 7, 1, 9);
BubbleSortStrategy bubbleSortStrategy = new BubbleSortStrategy();
Sorter sorter = new Sorter(bubbleSortStrategy);
List<Integer> sortedData = sorter.executeSort(data);
System.out.println("Sorted data (Bubble Sort): " + sortedData);
QuickSortStrategy quickSortStrategy = new QuickSortStrategy();
sorter.setStrategy(quickSortStrategy);
sortedData = sorter.executeSort(data);
System.out.println("Sorted data (Quick Sort): " + sortedData);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/strategy-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/strategy-pattern/cpp/main.cpp | #include <iostream>
#include <vector>
#include <algorithm>
class SortingStrategy {
public:
virtual std::vector<int> sort(const std::vector<int>& data) const = 0;
virtual ~SortingStrategy() {}
};
class BubbleSortStrategy : public SortingStrategy {
public:
std::vector<int> sort(const std::vector<int>& data) const override {
std::cout << "Bubble sorting..." << std::endl;
std::vector<int> sortedData = data;
std::sort(sortedData.begin(), sortedData.end());
return sortedData;
}
};
class QuickSortStrategy : public SortingStrategy {
public:
std::vector<int> sort(const std::vector<int>& data) const override {
std::cout << "Quick sorting..." << std::endl;
std::vector<int> sortedData = data;
std::sort(sortedData.begin(), sortedData.end());
return sortedData;
}
};
class Sorter {
private:
SortingStrategy* strategy;
public:
Sorter(SortingStrategy* strategy) : strategy(strategy) {}
void setStrategy(SortingStrategy* strategy) {
this->strategy = strategy;
}
std::vector<int> executeSort(const std::vector<int>& data) const {
return strategy->sort(data);
}
};
int main() {
std::vector<int> data = {5, 2, 7, 1, 9};
BubbleSortStrategy bubbleSortStrategy;
Sorter sorter(&bubbleSortStrategy);
auto sortedData = sorter.executeSort(data);
std::cout << "Sorted data (Bubble Sort): ";
for (const auto& num : sortedData) {
std::cout << num << " ";
}
std::cout << std::endl;
QuickSortStrategy quickSortStrategy;
sorter.setStrategy(&quickSortStrategy);
sortedData = sorter.executeSort(data);
std::cout << "Sorted data (Quick Sort): ";
for (const auto& num : sortedData) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/strategy-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/strategy-pattern/python/strategy_pattern.py | from abc import ABC, abstractmethod
from typing import List
class SortingStrategy(ABC):
@abstractmethod
def sort(self, data: List[int]) -> List[int]:
pass
class BubbleSortStrategy(SortingStrategy):
def sort(self, data: List[int]) -> List[int]:
print("Bubble sorting...")
return sorted(data)
class QuickSortStrategy(SortingStrategy):
def sort(self, data: List[int]) -> List[int]:
print("Quick sorting...")
return sorted(data)
class Sorter:
def __init__(self, strategy: SortingStrategy) -> None:
self._strategy = strategy
def set_strategy(self, strategy: SortingStrategy) -> None:
self._strategy = strategy
def execute_sort(self, data: List[int]) -> List[int]:
return self._strategy.sort(data)
# Client code
if __name__ == "__main__":
data = [5, 2, 7, 1, 9]
bubble_sort_strategy = BubbleSortStrategy()
sorter = Sorter(bubble_sort_strategy)
sorted_data = sorter.execute_sort(data)
print("Sorted data (Bubble Sort):", sorted_data)
quick_sort_strategy = QuickSortStrategy()
sorter.set_strategy(quick_sort_strategy)
sorted_data = sorter.execute_sort(data)
print("Sorted data (Quick Sort):", sorted_data)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/README.md | # Abstract Factory Pattern
## Description
The abstract factory pattern in software engineering is a design pattern that provides a way to create families of related objects without imposing their concrete classes, by encapsulating a group of individual factories that have a common theme without specifying their concrete classes.[1] According to this pattern, a client software component creates a concrete implementation of the abstract factory and then uses the generic interface of the factory to create the concrete objects that are part of the family. The client does not know which concrete objects it receives from each of these internal factories, as it uses only the generic interfaces of their products. This pattern separates the details of implementation of a set of objects from their general usage and relies on object composition, as object creation is implemented in methods exposed in the factory interface. [https://en.wikipedia.org/wiki/Abstract_factory_pattern](https://en.wikipedia.org/wiki/Abstract_factory_pattern)
## Scenarios
* System needs to be independent of product creation, composition, and representation
* A family of related product objects is designed to be used together
* The system needs to enforce consistency among objects created by a factory
* The system should be able to handle new types of products
## Examples of Use Cases
* GUI Toolkits
* Document Creation System
* Game Development
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/java/AbstractFactory.java | public interface AbstractFactory {
AbstractProduct createProduct();
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/java/ConcreteFactory1.java | public class ConcreteFactory1 implements AbstractFactory {
@Override
public ConcreteProductA createProduct() {
return new ConcreteProductA();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/java/AbstractProduct.java | public interface AbstractProduct {
String operation();
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/java/ConcreteProductA.java | public class ConcreteProductA implements AbstractProduct {
@Override
public String operation() {
return "ConcreteProductA operation";
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/java/Main.java | public class Main {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
clientCode(factory1);
AbstractFactory factory2 = new ConcreteFactory2();
clientCode(factory2);
}
public static void clientCode(AbstractFactory factory) {
AbstractProduct product = factory.createProduct();
System.out.println(product.operation());
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/java/ConcreteProductB.java | public class ConcreteProductB implements AbstractProduct {
@Override
public String operation() {
return "ConcreteProductB operation";
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/java/ConcreteFactory2.java | public class ConcreteFactory2 implements AbstractFactory {
@Override
public ConcreteProductB createProduct() {
return new ConcreteProductB();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/cpp/ConcreteProductA.h | #ifndef CONCRETEPRODUCTA_H
#define CONCRETEPRODUCTA_H
#include "AbstractProduct.h"
class ConcreteProductA : public AbstractProduct {
public:
std::string operation() const override {
return "ConcreteProductA operation";
}
};
#endif // CONCRETEPRODUCTA_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/cpp/ConcreteFactory1.h | #ifndef CONCRETEFACTORY1_H
#define CONCRETEFACTORY1_H
#include "AbstractFactory.h"
#include "ConcreteProductA.h"
class ConcreteFactory1 : public AbstractFactory {
public:
AbstractProduct* createProduct() const override {
return new ConcreteProductA();
}
};
#endif // CONCRETEFACTORY1_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/cpp/AbstractFactory.h | #ifndef ABSTRACTFACTORY_H
#define ABSTRACTFACTORY_H
#include "AbstractProduct.h"
class AbstractFactory {
public:
virtual ~AbstractFactory() = default;
virtual AbstractProduct* createProduct() const = 0;
};
#endif // ABSTRACTFACTORY_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/cpp/AbstractProduct.h | #ifndef ABSTRACTPRODUCT_H
#define ABSTRACTPRODUCT_H
#include <string>
class AbstractProduct {
public:
virtual ~AbstractProduct() = default;
virtual std::string operation() const = 0;
};
#endif // ABSTRACTPRODUCT_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/cpp/ConcreteFactory2.h | #ifndef CONCRETEFACTORY2_H
#define CONCRETEFACTORY2_H
#include "AbstractFactory.h"
#include "ConcreteProductB.h"
class ConcreteFactory2 : public AbstractFactory {
public:
AbstractProduct* createProduct() const override {
return new ConcreteProductB();
}
};
#endif // CONCRETEFACTORY2_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/cpp/main.cpp | #include <iostream>
#include "AbstractFactory.h"
#include "ConcreteFactory1.h"
#include "ConcreteFactory2.h"
void clientCode(const AbstractFactory& factory) {
AbstractProduct* product = factory.createProduct();
std::cout << product->operation() << std::endl;
delete product;
}
int main() {
ConcreteFactory1 factory1;
clientCode(factory1);
ConcreteFactory2 factory2;
clientCode(factory2);
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/cpp/ConcreteProductB.h | #ifndef CONCRETEPRODUCTB_H
#define CONCRETEPRODUCTB_H
#include "AbstractProduct.h"
class ConcreteProductB : public AbstractProduct {
public:
std::string operation() const override {
return "ConcreteProductB operation";
}
};
#endif // CONCRETEPRODUCTB_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/abstract-factory-pattern/python/abstract_factory_pattern.py | from abc import ABC, abstractmethod
from typing import Type, TypeVar
# Define a generic type for products
T = TypeVar('T', bound='Product')
class AbstractProduct(ABC):
"""Abstract Product interface"""
@abstractmethod
def operation(self) -> str:
pass
class ConcreteProductA(AbstractProduct):
"""Concrete Product A"""
def operation(self) -> str:
return "ConcreteProductA operation"
class ConcreteProductB(AbstractProduct):
"""Concrete Product B"""
def operation(self) -> str:
return "ConcreteProductB operation"
class AbstractFactory(ABC):
"""Abstract Factory interface"""
@abstractmethod
def create_product(self) -> AbstractProduct:
pass
class ConcreteFactory1(AbstractFactory):
"""Concrete Factory 1"""
def create_product(self) -> ConcreteProductA:
return ConcreteProductA()
class ConcreteFactory2(AbstractFactory):
"""Concrete Factory 2"""
def create_product(self) -> ConcreteProductB:
return ConcreteProductB()
def client_code(factory: AbstractFactory) -> None:
"""Client code that interacts with products through factories"""
product = factory.create_product()
print(product.operation())
# Example usage
if __name__ == "__main__":
factory1 = ConcreteFactory1()
client_code(factory1)
factory2 = ConcreteFactory2()
client_code(factory2)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern/java/Adapter.java | public class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public String request() {
return "Adapter: " + adaptee.specificRequest();
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern/java/Target.java | public interface Target {
String request();
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern/java/Main.java | public class Main {
public static void main(String[] args) {
Adaptee adaptee = new Adaptee();
Adapter adapter = new Adapter(adaptee);
clientCode(adapter);
}
public static void clientCode(Target target) {
System.out.println(target.request());
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern/java/Adaptee.java | public class Adaptee {
public String specificRequest() {
return "Adaptee's specific request";
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern/cpp/Adaptee.h | #ifndef ADAPTEE_H
#define ADAPTEE_H
#include <string>
class Adaptee {
public:
std::string specificRequest() const {
return "Adaptee's specific request";
}
};
#endif // ADAPTEE_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern/cpp/Adapter.h | #ifndef ADAPTER_H
#define ADAPTER_H
#include "Target.h"
#include "Adaptee.h"
class Adapter : public Target {
private:
Adaptee* adaptee;
public:
Adapter(Adaptee* adaptee) : adaptee(adaptee) {}
std::string request() const override {
return "Adapter: " + adaptee->specificRequest();
}
};
#endif // ADAPTER_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern/cpp/main.cpp | #include <iostream>
#include "Target.h"
#include "Adaptee.h"
#include "Adapter.h"
void clientCode(const Target* target) {
std::cout << target->request() << std::endl;
}
int main() {
Adaptee* adaptee = new Adaptee();
Adapter* adapter = new Adapter(adaptee);
clientCode(adapter);
delete adaptee;
delete adapter;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern/cpp/Target.h | #ifndef TARGET_H
#define TARGET_H
#include <string>
class Target {
public:
virtual ~Target() = default;
virtual std::string request() const = 0;
};
#endif // TARGET_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/adapter-pattern/python/adapter_pattern.py | from abc import ABC, abstractmethod
from typing import Protocol
# Target interface
class Target(Protocol):
@abstractmethod
def request(self) -> str:
pass
# Adaptee
class Adaptee:
def specific_request(self) -> str:
return "Adaptee's specific request"
# Adapter
class Adapter(Target):
def __init__(self, adaptee: Adaptee) -> None:
self.adaptee = adaptee
def request(self) -> str:
return f"Adapter: {self.adaptee.specific_request()}"
# Client code
def client_code(target: Target) -> None:
print(target.request())
# Example usage
if __name__ == "__main__":
adaptee = Adaptee()
adapter = Adapter(adaptee)
client_code(adapter)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern | repos/exploratory-tech-studio/tech-studio-projects/design-patterns/composite-pattern/java/Composite.java | import java.util.ArrayList;
import java.util.List;
// Composite class
public class Composite extends Component {
private String name;
private List<Component> children = new ArrayList<>();
public Composite(String name) {
this.name = name;
}
public void add(Component component) {
children.add(component);
}
public void remove(Component component) {
children.remove(component);
}
@Override
public void operation() {
System.out.println("Composite " + name + " operation:");
for (Component child : children) {
child.operation();
}
}
}
|
Subsets and Splits