Add Codility, CTCI and update folder structure

Author: etdev

Diff for: 1_codility/1_disc_intersections/WIP-disc_intersections.rb

@@ -0,0 +1,29 @@
+def solution(a)
+  start_vals, end_vals = [], []
+  a.each_with_index do |element, i|
+    start_vals << (i - element)
+    end_vals << (i + element)
+  end
+  start_vals.sort!
+  end_vals.sort!
+
+  end_vals.each do |end_val|
+    
+  end
+end
+
+def intersect?(arr, index_a, index_b)
+  min_a, min_b = arr[index_a] - index_a, arr[index_b] - index_b
+  #puts "min_a: #{min_a}, min_b: #{min_b}"
+  range_a = ((index_a - arr[index_a])..(index_a + arr[index_a])).to_a
+  range_b = ((index_b - arr[index_b])..(index_b + arr[index_b])).to_a
+  #puts "range_a: #{range_a}, range_b: #{range_b}"
+  return true if range_a.include?(min_b) || range_b.include?(min_a)
+  false
+end 
+# test code
+=begin
+require_relative "./1-disc_intersections.rb"
+a = [1, 2, 5, 1, 20]
+intersect?(a, 0, 3)
+=end

Diff for: 1_codility/1_disc_intersections/disc_intersections.rb

@@ -0,0 +1,101 @@
+# iteration #1, O(n**2) (naive)
+=begin
+[1, 5, 2, 1, 4, 0]
+0  1   2  3  4  5
+--> center => radius = { 0: 1, 1: 5, 2: 2, 3: 1, 4: 4, 5: 0 }
+rages = [ [-1, 1], [-4, 6], [1, 4], [2, 5], [0, 8], [5, 5] ]
+
+1 (-1, 1):
+  5 (-4, 6): a starts inside b, so count += 1
+
+5 (-4, 6):
+  1 (-1, 1):
+=end
+
+def solution(a)
+  # naive - loop through and check all others
+  count = 0
+  a.each_with_index do |disc_out, i_out|
+    a.drop(i_out+1).each_with_index do |disc_in, i_in|
+      next if i_out == i_in
+      count += 1 if overlaps?(range(a, i_out), range(a, i_in))
+    end
+  end
+  count
+end
+
+def range(arr, i)
+  ((i - arr[i])..(i + arr[i])).to_a
+end
+
+def overlaps?(range_a, range_b)
+  return true if range_a.last >= range_b.first
+end
+
+a = [1, 5, 2, 1, 4, 0]
+solution(a)
+
+
+=begin
+## want to find the # of intersections of the intervals [i-A[i], i+A[i]].
+* If discs 1, 2, 3, 4, 5 exist, 1 and 2 can only intersect once.
+* Disc n can't intersect with itself.
+
+## strategy
+* Maintain a sorted array (call it starts) containing all the ``i-A[i]`` values
+* Maintain another sorted array (call it ends) containing the end values ``i+A[i]``
+* Walk the array ``starts``
+  * For the current interval, do a binary search to see where the right endpoint 
+of the interval (i.e. i+A[i]) will go, called the RANK.  Then you know it intersects
+all the
+
+
+=end
+# iteration #2 - (hopefully) optinal
+def solution(a)
+    # want to know the number of discs that start, stop
+    # at each position.  Then we can calculate how many
+    # intersections there are.
+    
+    # create a hash with default start, stop values set to 0
+    events = Hash.new{ |h, k| h[k] = {:start => 0, :stop => 0}}
+    
+    # store the start, stop vals for each element in a
+    a.each_index do |i|
+        events[i - a[i]][:start] += 1
+        events[i + a[i]][:stop] += 1
+    end
+    
+    # so now event[i][:start] is the start val for a[i]
+    # sort the events
+    sorted_events = events.sort_by { |index, val| index}
+    sorted_events.map! {|n| n[1]}
+    
+    # so now sorted_events[i] tells us how many starts and stops occured at (i, 0).
+    
+    # iterate over our sorted array of hashes which tell us how many discs start and end at each position.  There are two cases we need to worry about:
+    # 1) how many discs are already going when the new disc starts: (e[:start] * past_start)
+    # 2) if multiple discs start at the same position (e[:start] * (e[:start]-1) / 2)
+    
+    # 1) if there are 3 discs that we're in the middle of and a new disc starts, it intersects with all 3 of them.  If there are 3 discs we're in the middle of and 2 new discs start, each of them will intersect with the 3 existing ones, making six interactions.
+    # 2) If multiple discs start at the same location, some math is required.  It's groups of 2, so the number of intersections at each index is n*(n-1)/2 - for if multiple discs start at that index - plus n*past_starts for when discs are already in progress when we start a new one.  Add them all together and you have your solution.
+    
+    past_starts = 0
+    intersects = 0
+    sorted_events.each do |event|
+        intersects += event[:start] * (event[:start]-1) / 2 + event[:start] * past_starts
+        past_starts += event[:start]
+        past_starts -= event[:stop]
+    end
+    
+    intersects
+    #puts "events: #{events}"
+end
+
+
+
+
+
+
+
+

Diff for: 1_codility/1_disc_intersections/notes.md

@@ -0,0 +1,10 @@
+### The Problem (from [Codility]())
+
+### Strategy
+
+### Solution - Ruby
+### Solution - Java
+### Solution - Go
+
+### Thoughts
+

Diff for: 1_codility/2_missing_integer/2-missing_integer.rb

@@ -0,0 +1,60 @@
+# iteration 1
+def solution(a)
+    # write your code in Ruby 2.2
+    # the answer can't be greater than 100,000, so we don't care about values larger than that
+    # so remove them:
+    a.delete_if {|x| x > 100000 || x < 1}
+    elements = {}
+    a.each do |element|
+        elements[element.to_s] = true
+    end
+    1.upto(100000).each do |i|
+        return i unless elements[i.to_s]
+    end
+end
+
+# score: 88% (failed the case where the array is literally just (1..100,000).to_a which makes the answer 100,001
+# time: 13 minutes
+
+# iteration 2
+def solution(a)
+    # write your code in Ruby 2.2
+    # max 100,000 elements, so don't care about >100,000 vals# also don't care about negatives
+    a.delete_if{ |x| x < 0 || x > 100000 }
+    # likely decreased the number of elements so might as well limit the number of loops necessary
+    # could also do .uniq here to potentially decrease it further, but I think that's unnecessary
+    max_count = a.size
+    
+    # keep track of elements via keys in a hash
+    included_vals = {}
+    a.each do |element|
+        included_vals[element.to_s] ||= true
+    end
+    1.upto(max_count+1).each do |i|
+        return i unless included_vals[i.to_s]
+    end
+    
+end
+
+# score: 100%
+# time: 13:43 (wrote on paper first)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

Diff for: 1_codility/2_missing_integer/notes.md

@@ -0,0 +1,10 @@
+### The Problem (from [Codility]())
+
+### Strategy
+
+### Solution - Ruby
+### Solution - Java
+### Solution - Go
+
+### Thoughts
+

Diff for: 1_codility/3_count_div/3-count_div.rb

@@ -0,0 +1,11 @@
+def solution(a, b, k)
+    if a % k == 0
+        # first is a, then a+k, then a+2k then a+3k... up to b
+        # in other words, (B-A)/K + 1
+        return (b-a)/k + 1
+    else
+        # first is the multiple of K right before A, and so on.
+        # so (B - (A - A%K)) / 2
+        return (b-(a-a%k))/k
+    end
+end

Diff for: 1_codility/3_count_div/notes.md

@@ -0,0 +1,10 @@
+### The Problem (from [Codility]())
+
+### Strategy
+
+### Solution - Ruby
+### Solution - Java
+### Solution - Go
+
+### Thoughts
+

Diff for: 1_codility/4_distinct/4-distinct.rb

@@ -0,0 +1,10 @@
+def solution(a)
+    # can't be more than 100,000 values, so we could track them all in a hash etc.
+    # I think I can just loop through and store the elements as keys in a hash with 
+    # val true, then count the size of the resulting hash.
+    elements = {}
+    a.each do |element|
+        elements[element.to_s] ||= true
+    end
+    elements.size
+end

Diff for: 1_codility/4_distinct/notes.md

@@ -0,0 +1,10 @@
+### The Problem (from [Codility]())
+
+### Strategy
+
+### Solution - Ruby
+### Solution - Java
+### Solution - Go
+
+### Thoughts
+

Diff for: 1_codility/5_dominator/5-dominator.rb

@@ -0,0 +1,14 @@
+def solution(a)
+    # I'm not sure about the O(1) space requirement but my idea is to store counts in a hash table
+    # with keys corresponding to the elements that have appeared, and values for their counts.
+    return -1 unless a.is_a?(Array) && a.size > 0
+    
+    val_counts = {}
+    a.each_with_index do |element, i|
+        val_counts[element.to_s] ||= 0
+        val_counts[element.to_s] += 1
+        return i if val_counts[element.to_s] > (a.size/2)
+    end
+    -1
+    
+end

Diff for: 1_codility/5_dominator/notes.md

@@ -0,0 +1,10 @@
+### The Problem (from [Codility]())
+
+### Strategy
+
+### Solution - Ruby
+### Solution - Java
+### Solution - Go
+
+### Thoughts
+

Diff for: 1_codility/6_max_profit/6-max_profit.rb

@@ -0,0 +1,15 @@
+def solution(a)
+  return 0 if a.size < 2
+  return 0 if a.size == 2 && a[1] <= a[0]
+
+  low_so_far = a.first
+  max_profit = 0
+  # for each price in a
+  a.each do |price|
+    # set max_profit to price-low_so_far if that difference is greater than the current max_profit
+    diff_here = price - low_so_far
+    max_profit = diff_here if diff_here > max_profit
+    low_so_far = price if price < low_so_far
+  end
+  max_profit
+end

Diff for: 1_codility/6_max_profit/notes.md

@@ -0,0 +1,10 @@
+### The Problem (from [Codility]())
+
+### Strategy
+
+### Solution - Ruby
+### Solution - Java
+### Solution - Go
+
+### Thoughts
+

Diff for: 1_codility/7_max_slice_sum/7-max_slice_sum.go

@@ -0,0 +1,34 @@
+package subarray
+
+func subarray(A []int) int {
+  // keep track of:
+    // runningMax
+    // maxHere
+    // simpleMax
+    // totalMax
+
+    if len(A) == 0 { return -1 }
+    if len(A) == 1 { return A[0] }
+    var runningMax int = 0
+    var maxHere int
+    var simpleMax int = A[0]
+    var totalMax int = 0
+
+    for i := 0; i < len(A); i++ {
+      maxHere = intMax(runningMax+A[i], A[i])
+      runningMax = intMax(maxHere, 0)
+      simpleMax = intMax(simpleMax, A[i])
+      totalMax = intMax(runningMax, totalMax)
+    }
+
+    if totalMax == 0 { return simpleMax }
+    return totalMax
+}
+
+func intMax(a int, b int) int {
+  if a > b {
+    return a
+  } else {
+    return b
+  }
+}

Diff for: 1_codility/7_max_slice_sum/7-max_slice_sum.rb

@@ -0,0 +1,21 @@
+def max_slice_sum(a)
+  # return -1 in case of invalid input
+  return -1 unless a.is_a?(Array) && a.size > 0
+  # if there's only one element, return it
+  return a.first if a.size == 1
+
+  # sum we're currently adding to
+  running_sum = 0
+  max_so_far = 0
+
+  a.each do |el|
+    # max at this element
+    max_current = (el + running_sum) > el ? (el + running_sum) : el
+    running_sum = max_current > 0 ? max_current : 0
+    max_so_far = max_so_far > running_sum ? max_so_far : running_sum
+  end
+
+  # deal with the situation where there are no positive elements
+  max_so_far == 0 ? a.max : max_so_far
+end
+