Merge branch 'master' into feat/rabin-karp-sgindeed

Author: sgindeed

dynamic_programming/0/0/1_knapsack_problem.r

@@ -0,0 +1,194 @@
+# 0/1 Knapsack Problem (Dynamic Programming)
+#
+# The 0/1 Knapsack problem is one of the most classic problems in dynamic programming.
+# Given a set of items, each with a weight and a value, determine the maximum total value
+# you can obtain by putting items in a knapsack with a fixed capacity. Each item can
+# either be included (1) or excluded (0) — hence the name "0/1".
+#
+# Time Complexity: O(n * W)  where n = number of items, W = knapsack capacity
+# Space Complexity: O(n * W)  for full DP table, O(W) for optimized version
+#
+# Applications:
+# - Budget allocation problems
+# - Resource optimization (CPU scheduling, project selection)
+# - Portfolio selection in finance
+# - Cargo loading and packing
+# - Subset optimization in AI planning
+
+# Classic DP solution for 0/1 Knapsack
+knapsack_01 <- function(weights, values, capacity) {
+  #' Solve 0/1 Knapsack Problem using Dynamic Programming
+  #' @param weights: Numeric vector of item weights
+  #' @param values: Numeric vector of item values
+  #' @param capacity: Maximum weight capacity of the knapsack
+  #' @return: List containing max value, selected items, and DP table
+  
+  n <- length(values)
+  
+  # Handle edge case
+  if (n == 0 || capacity == 0) {
+    return(list(
+      max_value = 0,
+      selected_items = c(),
+      dp_table = matrix(0, nrow = n + 1, ncol = capacity + 1)
+    ))
+  }
+  
+  # Create DP table: dp[i, w] = max value using first i items with capacity w
+  dp <- matrix(0, nrow = n + 1, ncol = capacity + 1)
+  
+  # Fill DP table
+  for (i in 1:n) {
+    for (w in 0:capacity) {
+      # Don't include item i
+      dp[i + 1, w + 1] <- dp[i, w + 1]
+      
+      # Include item i (if it fits)
+      if (weights[i] <= w) {
+        include_value <- values[i] + dp[i, w - weights[i] + 1]
+        dp[i + 1, w + 1] <- max(dp[i + 1, w + 1], include_value)
+      }
+    }
+  }
+  
+  # Backtrack to find selected items
+  selected <- c()
+  i <- n
+  w <- capacity
+  
+  while (i > 0 && w > 0) {
+    # If value came from including item i
+    if (dp[i + 1, w + 1] != dp[i, w + 1]) {
+      selected <- c(i, selected)
+      w <- w - weights[i]
+    }
+    i <- i - 1
+  }
+  
+  return(list(
+    max_value = dp[n + 1, capacity + 1],
+    selected_items = selected,
+    dp_table = dp
+  ))
+}
+
+# Space-optimized version using only 1D array
+knapsack_01_optimized <- function(weights, values, capacity) {
+  #' Space optimized 0/1 Knapsack using 1D array
+  #' @return: Maximum total value
+  
+  n <- length(values)
+  
+  if (n == 0 || capacity == 0) {
+    return(0)
+  }
+  
+  dp <- rep(0, capacity + 1)
+  
+  # Process each item
+  for (i in 1:n) {
+    # Traverse from right to left to avoid overwriting needed values
+    for (w in capacity:weights[i]) {
+      if (weights[i] <= w) {
+        dp[w + 1] <- max(dp[w + 1], values[i] + dp[w - weights[i] + 1])
+      }
+    }
+  }
+  
+  return(dp[capacity + 1])
+}
+
+# Helper function to print DP table
+print_knapsack_dp <- function(dp_table, weights, values, capacity) {
+  cat("DP Table for 0/1 Knapsack:\n")
+  cat("Weights:", paste(weights, collapse = ", "), "\n")
+  cat("Values :", paste(values, collapse = ", "), "\n")
+  cat("Capacity:", capacity, "\n\n")
+  
+  # Print capacity headers
+  cat("        ")
+  cat(paste(sprintf("%3d", 0:capacity), collapse = " "))
+  cat("\n")
+  cat(paste(rep("-", 8 + 4 * (capacity + 1)), collapse = ""), "\n")
+  
+  for (i in 1:nrow(dp_table)) {
+    cat(sprintf("Item %2d | ", i - 1))
+    cat(paste(sprintf("%3d", dp_table[i, ]), collapse = " "))
+    cat("\n")
+  }
+  cat("\n")
+}
+
+# ===========================
+# Example Usage & Testing
+# ===========================
+cat("=== 0/1 Knapsack Problem (Dynamic Programming) ===\n\n")
+
+# Test 1: Basic Example
+weights <- c(1, 3, 4, 5)
+values <- c(1, 4, 5, 7)
+capacity <- 7
+
+cat("Test 1: Basic Example\n")
+cat("Weights:", paste(weights, collapse = ", "), "\n")
+cat("Values :", paste(values, collapse = ", "), "\n")
+cat("Capacity:", capacity, "\n\n")
+
+result <- knapsack_01(weights, values, capacity)
+print_knapsack_dp(result$dp_table, weights, values, capacity)
+cat("Maximum Value:", result$max_value, "\n")
+cat("Selected Item Indices:", paste(result$selected_items, collapse = ", "), "\n")
+cat("Total Weight:", sum(weights[result$selected_items]), "\n")
+cat("Total Value:", sum(values[result$selected_items]), "\n\n")
+
+# Test 2: Space Optimized Example
+cat("Test 2: Space Optimized Version\n")
+max_val_opt <- knapsack_01_optimized(weights, values, capacity)
+cat("Maximum Value (Optimized):", max_val_opt, "\n")
+cat("Verification: Both methods match:", result$max_value == max_val_opt, "\n\n")
+
+# Test 3: Larger Dataset
+cat("Test 3: Larger Dataset\n")
+set.seed(42)
+weights <- sample(1:15, 10)
+values <- sample(10:100, 10)
+capacity <- 35
+
+cat("Weights:", paste(weights, collapse = ", "), "\n")
+cat("Values :", paste(values, collapse = ", "), "\n")
+cat("Capacity:", capacity, "\n\n")
+
+large_result <- knapsack_01(weights, values, capacity)
+cat("Maximum Value:", large_result$max_value, "\n")
+cat("Selected Items:", paste(large_result$selected_items, collapse = ", "), "\n")
+cat("Total Weight:", sum(weights[large_result$selected_items]), "\n\n")
+
+# Test 4: Edge Cases
+cat("Test 4: Edge Cases\n")
+cat("Empty items:", knapsack_01(c(), c(), 10)$max_value, "\n")
+cat("Zero capacity:", knapsack_01(weights, values, 0)$max_value, "\n")
+cat("Single item fits:", knapsack_01(c(5), c(10), 10)$max_value, "\n")
+cat("Single item doesn't fit:", knapsack_01(c(10), c(10), 5)$max_value, "\n\n")
+
+# Test 5: Performance Check
+cat("Test 5: Performance Comparison (n=100)\n")
+n <- 100
+weights <- sample(1:15, n, replace = TRUE)
+values <- sample(10:100, n, replace = TRUE)
+capacity <- 200
+
+start_time <- Sys.time()
+res_std <- knapsack_01_optimized(weights, values, capacity)
+std_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("Optimized DP result:", res_std, "\n")
+cat("Time taken:", sprintf("%.4f sec", std_time), "\n")
+
+# Verify correctness
+cat("\nVerifying correctness with full DP:\n")
+start_time <- Sys.time()
+res_full <- knapsack_01(weights, values, capacity)
+full_time <- as.numeric(Sys.time() - start_time, units = "secs")
+cat("Full DP result:", res_full$max_value, "\n")
+cat("Time taken:", sprintf("%.4f sec", full_time), "\n")
+cat("Results match:", res_std == res_full$max_value, "\n")

string_manipulation/longest.palindromic.subsequence.R

@@ -0,0 +1,62 @@
+# Longest Palindromic Subsequence in R
+# Author: sgindeed
+# Description: Finds and prints the longest palindromic subsequence and its length
+
+# Ask for user input
+input.string <- readline(prompt = "Enter a string: ")
+
+# Convert string to lowercase for consistency
+clean.string <- tolower(input.string)
+
+# Get length of string
+n <- nchar(clean.string)
+
+# Split string into characters
+chars <- strsplit(clean.string, "")[[1]]
+
+# Initialize DP table for lengths
+dp <- matrix(0, nrow = n, ncol = n)
+
+# Each single character is a palindrome of length 1
+for (i in seq_len(n)) {
+  dp[i, i] <- 1
+}
+
+# Fill the DP table
+for (cl in 2:n) {
+  for (i in 1:(n - cl + 1)) {
+    j <- i + cl - 1
+    if (chars[i] == chars[j] && cl == 2) {
+      dp[i, j] <- 2
+    } else if (chars[i] == chars[j]) {
+      dp[i, j] <- dp[i + 1, j - 1] + 2
+    } else {
+      dp[i, j] <- max(dp[i + 1, j], dp[i, j - 1])
+    }
+  }
+}
+
+# Function to reconstruct the subsequence
+reconstructLPS <- function(chars, dp, i, j) {
+  if (i > j) {
+    return("")
+  }
+  if (i == j) {
+    return(chars[i])
+  }
+  if (chars[i] == chars[j]) {
+    return(paste0(chars[i], reconstructLPS(chars, dp, i + 1, j - 1), chars[j]))
+  }
+  if (dp[i + 1, j] > dp[i, j - 1]) {
+    return(reconstructLPS(chars, dp, i + 1, j))
+  } else {
+    return(reconstructLPS(chars, dp, i, j - 1))
+  }
+}
+
+# Get the longest palindromic subsequence
+lps <- reconstructLPS(chars, dp, 1, n)
+
+# Display the result
+cat("Longest Palindromic Subsequence:", lps, "\n")
+cat("Length:", nchar(lps), "\n")

string_manipulation/minimum.window.substring.R

@@ -0,0 +1,66 @@
+# Minimum Window Substring in R
+# Author: sgindeed
+# Description: Finds the smallest substring of s that contains all characters of t
+
+# Ask for inputs
+s <- readline(prompt = "Enter main string: ")
+t <- readline(prompt = "Enter target characters: ")
+
+# Convert to lowercase for case-insensitivity
+s <- tolower(s)
+t <- tolower(t)
+
+# Edge case
+if (nchar(s) == 0 || nchar(t) == 0) {
+  cat("Empty input. Exiting.\n")
+  quit(save = "no")
+}
+
+# Convert to char arrays
+s_chars <- strsplit(s, "")[[1]]
+t_chars <- strsplit(t, "")[[1]]
+
+# Frequency of characters in t
+t_count <- table(t_chars)
+window_count <- list()
+
+required <- length(t_count)
+formed <- 0
+
+left <- 1
+right <- 0
+min_len <- Inf
+min_window <- ""
+
+# Sliding window
+while (right < length(s_chars)) {
+  right <- right + 1
+  char <- s_chars[right]
+  window_count[[char]] <- (window_count[[char]] %||% 0) + 1
+  
+  if (!is.na(t_count[char]) && window_count[[char]] == t_count[char]) {
+    formed <- formed + 1
+  }
+  
+  # Try to contract the window
+  while (left <= right && formed == required) {
+    if ((right - left + 1) < min_len) {
+      min_len <- right - left + 1
+      min_window <- paste0(s_chars[left:right], collapse = "")
+    }
+    
+    left_char <- s_chars[left]
+    window_count[[left_char]] <- window_count[[left_char]] - 1
+    if (!is.na(t_count[left_char]) && window_count[[left_char]] < t_count[left_char]) {
+      formed <- formed - 1
+    }
+    left <- left + 1
+  }
+}
+
+if (is.infinite(min_len)) {
+  cat("No valid window found.\n")
+} else {
+  cat("Minimum window substring:", min_window, "\n")
+  cat("Length:", min_len, "\n")
+}