dsa_visualizer 0.1.0

data/lib/dsa_visualizer/algorithms/dynamic_programming.rb

@@ -0,0 +1,23 @@
+module DSAVisualizer
+  module Algorithms
+    class DynamicProgramming
+      def self.learn_intro
+        Visualizer.print_header("DYNAMIC PROGRAMMING - Optimization Technique")
+        puts "\n📚 Coming soon: Memoization and tabulation"
+        puts "Topics: Overlapping subproblems, optimal substructure"
+      end
+      
+      def self.learn_fibonacci
+        Visualizer.print_header("FIBONACCI - DP Example")
+        puts "\n📚 Coming soon: From recursion to DP"
+        puts "Topics: Top-down vs bottom-up, space optimization"
+      end
+      
+      def self.learn_knapsack
+        Visualizer.print_header("0/1 KNAPSACK PROBLEM")
+        puts "\n📚 Coming soon: Classic DP problem"
+        puts "Topics: 2D DP table, backtracking solution"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/algorithms/graph_algorithms.rb

@@ -0,0 +1,23 @@
+module DSAVisualizer
+  module Algorithms
+    class GraphAlgorithms
+      def self.learn_bfs
+        Visualizer.print_header("BREADTH-FIRST SEARCH (BFS)")
+        puts "\n📚 Coming soon: Level-order graph traversal"
+        puts "Topics: Queue-based, shortest path in unweighted graph"
+      end
+      
+      def self.learn_dfs
+        Visualizer.print_header("DEPTH-FIRST SEARCH (DFS)")
+        puts "\n📚 Coming soon: Deep exploration"
+        puts "Topics: Stack/recursion-based, cycle detection, topological sort"
+      end
+      
+      def self.learn_dijkstra
+        Visualizer.print_header("DIJKSTRA'S ALGORITHM")
+        puts "\n📚 Coming soon: Shortest path in weighted graph"
+        puts "Topics: Priority queue, greedy approach, non-negative weights"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/algorithms/greedy.rb

@@ -0,0 +1,11 @@
+module DSAVisualizer
+  module Algorithms
+    class Greedy
+      def self.learn_intro
+        Visualizer.print_header("GREEDY ALGORITHMS")
+        puts "\n📚 Coming soon: Making locally optimal choices"
+        puts "Topics: Activity selection, Huffman coding, coin change"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/algorithms/searching.rb

@@ -0,0 +1,78 @@
+module DSAVisualizer
+  module Algorithms
+    class Searching
+      def self.learn_linear
+        demo
+      end
+      
+      def self.learn_binary
+        demo
+      end
+      
+      def self.demo
+        Visualizer.print_header("SEARCHING ALGORITHMS - Core Level Visualization")
+        
+        Visualizer.print_section("1. Linear Search")
+        
+        ruby_code = <<~RUBY
+          def linear_search(arr, target)
+            arr.each_with_index do |val, idx|
+              return idx if val == target
+            end
+            -1
+          end
+        RUBY
+
+        cpp_code = <<~CPP
+          int linearSearch(int arr[], int n, int target) {
+            for(int i = 0; i < n; i++) {
+              if(arr[i] == target)
+                return i;
+            }
+            return -1;
+          }
+        CPP
+
+        explanation = "Sequential scan through array. Time: O(n), Space: O(1). Works on unsorted arrays."
+        
+        Visualizer.print_comparison(ruby_code, cpp_code, explanation)
+        
+        Visualizer.print_section("2. Binary Search")
+        
+        ruby_code2 = <<~RUBY
+          def binary_search(arr, target)
+            left, right = 0, arr.length - 1
+            while left <= right
+              mid = (left + right) / 2
+              return mid if arr[mid] == target
+              arr[mid] < target ? left = mid + 1 : right = mid - 1
+            end
+            -1
+          end
+        RUBY
+
+        cpp_code2 = <<~CPP
+          int binarySearch(int arr[], int n, int target) {
+            int left = 0, right = n - 1;
+            while(left <= right) {
+              int mid = left + (right - left) / 2;
+              if(arr[mid] == target) return mid;
+              if(arr[mid] < target) left = mid + 1;
+              else right = mid - 1;
+            }
+            return -1;
+          }
+        CPP
+
+        explanation2 = "Divide and conquer on sorted array. Time: O(log n), Space: O(1). Requires sorted input."
+        
+        Visualizer.print_comparison(ruby_code2, cpp_code2, explanation2)
+        
+        puts "\n\n🎯 Key Takeaways:".colorize(:green).bold
+        puts "  1. Linear: O(n) - works on any array"
+        puts "  2. Binary: O(log n) - requires sorted array"
+        puts "  3. Binary search eliminates half the search space each iteration"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/algorithms/sorting.rb

@@ -0,0 +1,77 @@
+module DSAVisualizer
+  module Algorithms
+    class Sorting
+      def self.learn_bubble
+        demo
+      end
+      
+      def self.learn_merge
+        puts "\n📚 Coming soon: Merge Sort - Divide and Conquer"
+      end
+      
+      def self.learn_quick
+        puts "\n📚 Coming soon: Quick Sort - Partition-based"
+      end
+      
+      def self.demo
+        Visualizer.print_header("SORTING ALGORITHMS - Core Level Visualization")
+        
+        Visualizer.print_section("1. Bubble Sort")
+        
+        ruby_code = <<~RUBY
+          def bubble_sort(arr)
+            n = arr.length
+            (n-1).times do |i|
+              (n-i-1).times do |j|
+                if arr[j] > arr[j+1]
+                  arr[j], arr[j+1] = arr[j+1], arr[j]
+                end
+              end
+            end
+            arr
+          end
+        RUBY
+
+        cpp_code = <<~CPP
+          void bubbleSort(int arr[], int n) {
+            for(int i = 0; i < n-1; i++) {
+              for(int j = 0; j < n-i-1; j++) {
+                if(arr[j] > arr[j+1]) {
+                  std::swap(arr[j], arr[j+1]);
+                }
+              }
+            }
+          }
+        CPP
+
+        explanation = "Both implementations identical in logic. Ruby's swap is cleaner syntax. Time: O(n²), Space: O(1). Stable sort."
+        
+        Visualizer.print_comparison(ruby_code, cpp_code, explanation)
+        
+        arr = [64, 34, 25, 12, 22]
+        puts "\nOriginal: #{arr.inspect}"
+        
+        # Simulate one pass
+        puts "\nAfter first pass:"
+        n = arr.length
+        (n-1).times do |j|
+          if arr[j] > arr[j+1]
+            arr[j], arr[j+1] = arr[j+1], arr[j]
+            puts "  Swapped #{arr[j+1]} and #{arr[j]}: #{arr.inspect}"
+          end
+        end
+        
+        Visualizer.print_section("2. Quick Sort")
+        puts "\nDivide and conquer algorithm"
+        puts "Average: O(n log n), Worst: O(n²)"
+        puts "In-place, not stable"
+        
+        puts "\n\n🎯 Sorting Comparison:".colorize(:green).bold
+        puts "  Bubble Sort: O(n²) - simple, slow"
+        puts "  Quick Sort: O(n log n) - fast, in-place"
+        puts "  Merge Sort: O(n log n) - stable, needs extra space"
+        puts "  Heap Sort: O(n log n) - in-place, not stable"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/algorithms/string_algorithms.rb

@@ -0,0 +1,11 @@
+module DSAVisualizer
+  module Algorithms
+    class StringAlgorithms
+      def self.learn_kmp
+        Visualizer.print_header("KMP PATTERN MATCHING")
+        puts "\n📚 Coming soon: Efficient string search"
+        puts "Topics: LPS array, O(n+m) complexity"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/cli.rb

@@ -0,0 +1,281 @@
+require 'io/console'
+
+module DSAVisualizer
+  class CLI
+    CURRICULUM = {
+      "1" => {
+        title: "Fundamentals",
+        topics: {
+          "1.1" => { name: "Time & Space Complexity", key: :complexity_basics },
+          "1.2" => { name: "Memory Management", key: :memory_basics },
+          "1.3" => { name: "Pointers & References", key: :pointers_basics },
+          "1.4" => { name: "Recursion Basics", key: :recursion_basics }
+        }
+      },
+      "2" => {
+        title: "Basic Data Structures",
+        topics: {
+          "2.1" => { name: "Arrays", key: :array },
+          "2.2" => { name: "Strings", key: :string },
+          "2.3" => { name: "Linked Lists", key: :linked_list },
+          "2.4" => { name: "Doubly Linked Lists", key: :doubly_linked_list },
+          "2.5" => { name: "Circular Linked Lists", key: :circular_linked_list }
+        }
+      },
+      "3" => {
+        title: "Stack & Queue",
+        topics: {
+          "3.1" => { name: "Stack (Array-based)", key: :stack },
+          "3.2" => { name: "Stack (Linked List-based)", key: :stack_linked },
+          "3.3" => { name: "Queue (Array-based)", key: :queue },
+          "3.4" => { name: "Queue (Linked List-based)", key: :queue_linked },
+          "3.5" => { name: "Circular Queue", key: :circular_queue },
+          "3.6" => { name: "Deque", key: :deque },
+          "3.7" => { name: "Priority Queue", key: :priority_queue }
+        }
+      },
+      "4" => {
+        title: "Hashing",
+        topics: {
+          "4.1" => { name: "Hash Functions", key: :hash_functions },
+          "4.2" => { name: "Hash Tables", key: :hash_table },
+          "4.3" => { name: "Collision Handling", key: :collision_handling },
+          "4.4" => { name: "Hash Maps & Sets", key: :hash_map_set }
+        }
+      },
+      "5" => {
+        title: "Trees",
+        topics: {
+          "5.1" => { name: "Binary Trees", key: :binary_tree },
+          "5.2" => { name: "Binary Search Trees", key: :bst },
+          "5.3" => { name: "Tree Traversals", key: :tree_traversals },
+          "5.4" => { name: "AVL Trees", key: :avl_tree },
+          "5.5" => { name: "Red-Black Trees", key: :red_black_tree },
+          "5.6" => { name: "B-Trees", key: :b_tree },
+          "5.7" => { name: "Segment Trees", key: :segment_tree },
+          "5.8" => { name: "Fenwick Trees", key: :fenwick_tree },
+          "5.9" => { name: "Trie", key: :trie }
+        }
+      },
+      "6" => {
+        title: "Heaps",
+        topics: {
+          "6.1" => { name: "Min Heap", key: :min_heap },
+          "6.2" => { name: "Max Heap", key: :max_heap },
+          "6.3" => { name: "Heap Operations", key: :heap_operations },
+          "6.4" => { name: "Heap Sort", key: :heap_sort }
+        }
+      },
+      "7" => {
+        title: "Graphs",
+        topics: {
+          "7.1" => { name: "Graph Representations", key: :graph_representation },
+          "7.2" => { name: "BFS (Breadth-First Search)", key: :bfs },
+          "7.3" => { name: "DFS (Depth-First Search)", key: :dfs },
+          "7.4" => { name: "Topological Sort", key: :topological_sort },
+          "7.5" => { name: "Shortest Path (Dijkstra)", key: :dijkstra },
+          "7.6" => { name: "Shortest Path (Bellman-Ford)", key: :bellman_ford },
+          "7.7" => { name: "Minimum Spanning Tree (Kruskal)", key: :kruskal },
+          "7.8" => { name: "Minimum Spanning Tree (Prim)", key: :prim },
+          "7.9" => { name: "Floyd-Warshall", key: :floyd_warshall }
+        }
+      },
+      "8" => {
+        title: "Sorting Algorithms",
+        topics: {
+          "8.1" => { name: "Bubble Sort", key: :bubble_sort },
+          "8.2" => { name: "Selection Sort", key: :selection_sort },
+          "8.3" => { name: "Insertion Sort", key: :insertion_sort },
+          "8.4" => { name: "Merge Sort", key: :merge_sort },
+          "8.5" => { name: "Quick Sort", key: :quick_sort },
+          "8.6" => { name: "Heap Sort", key: :heap_sort },
+          "8.7" => { name: "Counting Sort", key: :counting_sort },
+          "8.8" => { name: "Radix Sort", key: :radix_sort },
+          "8.9" => { name: "Bucket Sort", key: :bucket_sort }
+        }
+      },
+      "9" => {
+        title: "Searching Algorithms",
+        topics: {
+          "9.1" => { name: "Linear Search", key: :linear_search },
+          "9.2" => { name: "Binary Search", key: :binary_search },
+          "9.3" => { name: "Ternary Search", key: :ternary_search },
+          "9.4" => { name: "Jump Search", key: :jump_search },
+          "9.5" => { name: "Interpolation Search", key: :interpolation_search }
+        }
+      },
+      "10" => {
+        title: "Advanced Algorithms",
+        topics: {
+          "10.1" => { name: "Dynamic Programming Intro", key: :dp_intro },
+          "10.2" => { name: "Fibonacci (DP)", key: :dp_fibonacci },
+          "10.3" => { name: "Knapsack Problem", key: :knapsack },
+          "10.4" => { name: "Longest Common Subsequence", key: :lcs },
+          "10.5" => { name: "Matrix Chain Multiplication", key: :matrix_chain },
+          "10.6" => { name: "Greedy Algorithms", key: :greedy_intro },
+          "10.7" => { name: "Backtracking", key: :backtracking },
+          "10.8" => { name: "Divide and Conquer", key: :divide_conquer }
+        }
+      },
+      "11" => {
+        title: "String Algorithms",
+        topics: {
+          "11.1" => { name: "Pattern Matching (Naive)", key: :pattern_naive },
+          "11.2" => { name: "KMP Algorithm", key: :kmp },
+          "11.3" => { name: "Rabin-Karp", key: :rabin_karp },
+          "11.4" => { name: "Z Algorithm", key: :z_algorithm }
+        }
+      },
+      "12" => {
+        title: "Advanced Data Structures",
+        topics: {
+          "12.1" => { name: "Disjoint Set (Union-Find)", key: :union_find },
+          "12.2" => { name: "Suffix Array", key: :suffix_array },
+          "12.3" => { name: "Suffix Tree", key: :suffix_tree },
+          "12.4" => { name: "Skip List", key: :skip_list }
+        }
+      }
+    }
+
+    def self.start
+      new.run
+    end
+
+    def run
+      loop do
+        clear_screen
+        print_header
+        print_menu
+        choice = get_input
+        
+        break if choice == "0"
+        handle_choice(choice)
+      end
+      
+      puts "\n👋 Happy Learning! Keep practicing DSA!".colorize(:green)
+    end
+
+    private
+
+    def clear_screen
+      system('cls') || system('clear')
+    end
+
+    def print_header
+      puts "╔" + "═" * 78 + "╗"
+      puts "║" + " DSA VISUALIZER - Zero to Hero ".center(78).colorize(:cyan).bold + "║"
+      puts "║" + " Ruby vs C++ Implementation Comparison ".center(78).colorize(:yellow) + "║"
+      puts "╚" + "═" * 78 + "╝"
+      puts ""
+    end
+
+    def print_menu
+      puts "📚 CURRICULUM".colorize(:green).bold
+      puts "─" * 80
+      
+      CURRICULUM.each do |section_num, section|
+        puts "\n#{section_num}. #{section[:title]}".colorize(:yellow).bold
+        section[:topics].each do |topic_num, topic|
+          puts "   #{topic_num}. #{topic[:name]}"
+        end
+      end
+      
+      puts "\n" + "─" * 80
+      puts "Commands:".colorize(:cyan)
+      puts "  • Enter topic number (e.g., 2.1 for Arrays)"
+      puts "  • Type 'progress' to see your learning progress"
+      puts "  • Type 'notes' to view saved notes"
+      puts "  • Type '0' to exit"
+      puts "─" * 80
+    end
+
+    def get_input
+      print "\n➤ Enter your choice: ".colorize(:green)
+      gets.chomp.strip
+    end
+
+    def handle_choice(choice)
+      case choice.downcase
+      when 'progress'
+        show_progress
+      when 'notes'
+        show_notes
+      else
+        run_topic(choice)
+      end
+    end
+
+    def run_topic(topic_code)
+      section_num = topic_code.split('.').first
+      section = CURRICULUM[section_num]
+      
+      unless section
+        puts "\n❌ Invalid section number!".colorize(:red)
+        wait_for_key
+        return
+      end
+      
+      topic = section[:topics][topic_code]
+      
+      unless topic
+        puts "\n❌ Invalid topic number!".colorize(:red)
+        wait_for_key
+        return
+      end
+      
+      clear_screen
+      DSAVisualizer.learn(topic[:key])
+      mark_completed(topic_code)
+      wait_for_key
+    end
+
+    def show_progress
+      clear_screen
+      puts "\n📊 YOUR LEARNING PROGRESS".colorize(:cyan).bold
+      puts "─" * 80
+      
+      completed = load_progress
+      total = CURRICULUM.values.sum { |s| s[:topics].size }
+      
+      puts "\nCompleted: #{completed.size}/#{total} topics"
+      puts "Progress: #{'█' * (completed.size * 50 / total)}#{'░' * (50 - completed.size * 50 / total)} #{(completed.size * 100 / total)}%"
+      
+      if completed.any?
+        puts "\n✅ Completed Topics:"
+        completed.each { |topic| puts "   • #{topic}" }
+      end
+      
+      wait_for_key
+    end
+
+    def show_notes
+      clear_screen
+      puts "\n📝 YOUR NOTES".colorize(:cyan).bold
+      puts "─" * 80
+      puts "\nFeature coming soon! Notes will be saved automatically as you learn."
+      wait_for_key
+    end
+
+    def mark_completed(topic_code)
+      completed = load_progress
+      completed << topic_code unless completed.include?(topic_code)
+      save_progress(completed)
+    end
+
+    def load_progress
+      file = File.join(Dir.home, '.dsa_visualizer_progress')
+      return [] unless File.exist?(file)
+      File.read(file).split("\n")
+    end
+
+    def save_progress(completed)
+      file = File.join(Dir.home, '.dsa_visualizer_progress')
+      File.write(file, completed.join("\n"))
+    end
+
+    def wait_for_key
+      puts "\n\nPress any key to continue...".colorize(:light_black)
+      STDIN.getch
+    end
+  end
+end

data/lib/dsa_visualizer/comparator.rb

@@ -0,0 +1,57 @@
+module DSAVisualizer
+  class Comparator
+    def self.compare_memory_model(concept)
+      case concept
+      when :array
+        ruby_model = <<~RUBY
+          # Ruby Array (Dynamic)
+          arr = [1, 2, 3]
+          # Internally: Array of object references
+          # Each element is a pointer to Ruby object
+          # Heap allocated, garbage collected
+        RUBY
+
+        cpp_model = <<~CPP
+          // C++ Array (Static)
+          int arr[3] = {1, 2, 3};
+          // Contiguous memory block
+          // Direct values, no indirection
+          // Stack or heap allocated
+        CPP
+
+        explanation = "Ruby arrays store references to objects (indirection), while C++ arrays store actual values in contiguous memory. Ruby provides dynamic sizing with overhead, C++ offers fixed size with better cache locality."
+
+        Visualizer.print_comparison(ruby_model, cpp_model, explanation)
+
+      when :pointer
+        ruby_model = <<~RUBY
+          # Ruby (No explicit pointers)
+          obj = Object.new
+          ref = obj  # Reference copy
+          # Both point to same object
+          # Managed by GC
+        RUBY
+
+        cpp_model = <<~CPP
+          // C++ (Explicit pointers)
+          int* ptr = new int(42);
+          int* ref = ptr;  // Pointer copy
+          // Manual memory management
+          delete ptr;  // Must free
+        CPP
+
+        explanation = "Ruby abstracts pointers as object references with automatic memory management. C++ exposes raw pointers requiring manual allocation/deallocation, offering more control but more responsibility."
+
+        Visualizer.print_comparison(ruby_model, cpp_model, explanation)
+      end
+    end
+
+    def self.compare_complexity(operation, ruby_complexity, cpp_complexity, explanation)
+      puts "\n⏱️  Time Complexity Comparison:".colorize(:yellow).bold
+      puts "   Operation: #{operation}"
+      puts "   Ruby:  #{ruby_complexity}".colorize(:red)
+      puts "   C++:   #{cpp_complexity}".colorize(:green)
+      puts "   Why: #{explanation}"
+    end
+  end
+end

data/lib/dsa_visualizer/data_structures/array.rb

@@ -0,0 +1,109 @@
+module DSAVisualizer
+  module DataStructures
+    class Array
+      def self.learn
+        demo
+      end
+      
+      def self.demo
+        Visualizer.print_header("ARRAY - Core Level Visualization")
+        
+        # Memory Model Comparison
+        Visualizer.print_section("1. Memory Model")
+        Comparator.compare_memory_model(:array)
+        
+        # Creation and Memory Allocation
+        Visualizer.print_section("2. Array Creation")
+        tracker = MemoryTracker.new
+        
+        Visualizer.print_step(1, "Creating array in Ruby")
+        arr = [10, 20, 30, 40, 50]
+        tracker.track_allocation("Array", arr.size, arr)
+        
+        puts "\nRuby internals:"
+        puts "  - Array object created on heap"
+        puts "  - Stores references to Integer objects"
+        puts "  - Dynamic resizing capability"
+        Visualizer.visualize_memory_layout("Ruby Array", arr)
+        
+        puts "\nC++ equivalent:"
+        puts "  int arr[5] = {10, 20, 30, 40, 50};"
+        puts "  - Contiguous memory block"
+        puts "  - Each int: 4 bytes"
+        puts "  - Total: 20 bytes (5 × 4)"
+        puts "  - Stack allocated (if local)"
+        
+        # Access Operation
+        Visualizer.print_section("3. Element Access")
+        Visualizer.print_step(2, "Accessing element at index 2")
+        
+        element = arr[2]
+        tracker.track_operation("Access", "arr[2] = #{element}")
+        Visualizer.visualize_array(arr, 2)
+        
+        puts "\n🔍 Ruby Process:"
+        puts "  1. Check bounds (raises error if out of range)"
+        puts "  2. Calculate: base_address + (index × pointer_size)"
+        puts "  3. Dereference pointer to get object"
+        puts "  4. Return object reference"
+        
+        puts "\n🔍 C++ Process:"
+        puts "  1. Calculate: base_address + (index × sizeof(int))"
+        puts "  2. Direct memory access"
+        puts "  3. Return value (no indirection)"
+        
+        Comparator.compare_complexity(
+          "Array Access",
+          "O(1) - with bounds checking overhead",
+          "O(1) - direct memory access",
+          "Both are constant time, but C++ is faster due to no bounds checking and direct value access"
+        )
+        
+        # Insertion
+        Visualizer.print_section("4. Insertion")
+        Visualizer.print_step(3, "Inserting 25 at index 2")
+        
+        puts "\nBefore:"
+        Visualizer.visualize_array(arr)
+        
+        arr.insert(2, 25)
+        tracker.track_operation("Insert", "Inserted 25 at index 2")
+        
+        puts "\nAfter:"
+        Visualizer.visualize_array(arr, 2)
+        
+        puts "\n🔄 Ruby Process:"
+        puts "  1. Check if resize needed (capacity vs size)"
+        puts "  2. If needed: allocate new array (2× capacity)"
+        puts "  3. Shift elements right from index 2"
+        puts "  4. Insert new element"
+        puts "  5. Update size"
+        
+        puts "\n🔄 C++ Process (std::vector):"
+        puts "  1. Check capacity"
+        puts "  2. If needed: allocate new memory"
+        puts "  3. Copy elements to new location"
+        puts "  4. Shift elements using memmove"
+        puts "  5. Insert element"
+        
+        Comparator.compare_complexity(
+          "Array Insertion (middle)",
+          "O(n) - must shift elements",
+          "O(n) - must shift elements",
+          "Both require shifting elements. Ruby has additional overhead from object reference management."
+        )
+        
+        # Memory Summary
+        tracker.print_summary
+        
+        # Key Takeaways
+        puts "\n\n🎯 Key Takeaways:".colorize(:green).bold
+        puts "  1. Ruby arrays are dynamic and store object references"
+        puts "  2. C++ arrays can be static (fixed) or dynamic (std::vector)"
+        puts "  3. Ruby provides safety (bounds checking) at cost of performance"
+        puts "  4. C++ provides speed at cost of safety (manual management)"
+        puts "  5. Both use contiguous memory, but Ruby adds indirection layer"
+      end
+    end
+  end
+end