most recent update

Author: haozeng

.DS_Store

@@ -0,0 +1,72 @@
+# Basic Idea: The idea is to separate the operators and integers into two arrays and
+# handle their operations in the correct order. After each iteration, the size of two arrays will change
+# to keep track the latest operations.
+
+# For example, we are given 5*4/2+10, and we seperate it into integers [5,4,2,10] and operators [*, /, +]
+# Step 1: 5*4 = 20, integer array became [20, 2, 10]
+# Step 2: 20/2 = 10, integer array became [10, 10]
+# Step 3: after the multiplicatio and division operations, operator array became [+]
+# Step 4: integer array became [20], which is the expected results.
+
+def bc(string)
+  # initialize the operators and integers array
+  operators = []
+  integers = []
+
+  # separate integers and operators into different arrays
+  integers = string.split(/\+|\-|\*|\//).map(&:to_i)
+  string.each_char do |c|
+    if c.match /\+|\-|\*|\//
+      operators << c
+    end
+  end
+
+  # we want to handle * and / first
+  count = 0
+  operators.each_with_index do |o, i|
+    if o.match /\*|\//
+      r = integers[i-count].send(o, integers[i+1-count])
+      integers.delete_at i+1-count
+      integers.delete_at i-count
+      integers.insert(i, r)
+      count += 1
+    end
+  end
+
+  # remove all * and / operators
+  operators = operators.select do |o|
+    !o.match /\*|\//
+  end
+
+  # we want to handle + and -
+  integers.compact!
+  count = 0
+  operators.each_with_index do |o, i|
+    if o.match /\+|\-/
+      r = integers[i-count].send(o, integers[i+1-count])
+      integers.delete_at i+1-count
+      integers.delete_at i-count
+      integers.insert(i, r)
+      count += 1
+    end
+  end
+
+  integers.compact
+end
+
+puts "5*4"
+puts bc("5*4")
+puts "5*4/2"
+puts bc("5*4/2")
+puts "5*4/2+10"
+puts bc("5*4/2+10")
+puts "100/100"
+puts bc("100/100")
+puts "10+10+10+10"
+puts bc("10+10+10+10")
+puts "10+10+10+10"
+puts bc("10+10+10+10")
+puts "10-10"
+puts bc("10-10")
+puts "10+10*10/10"
+puts bc("10+10*10/10")

README.md

@@ -0,0 +1,50 @@
+# sudo code:
+# 1. return 0 if the node is nil
+# 2. get the height and diameter from left node.
+# 3. get the height and diameter from right node.
+# 4. calculate height from previous step.
+# 5. return the diameter and its height
+require 'pry'
+
+class Node
+  attr_accessor :value, :left, :right, :name
+
+  def initialize(options={})
+    @value = options[:value]
+    @name = options[:name]
+    @left = options[:left] || nil
+    @right = options[:right] || nil
+  end
+
+  def children?
+    @left && @right
+  end
+
+  def no_children?
+    !children?
+  end
+end
+
+def diameter(node)
+  return [0, 0] if node.nil?
+
+  ld, lh = diameter(node.left)
+  rd, rh = diameter(node.right)
+
+  height = [lh, rh].max + 1
+
+  [[lh + rh + 1, ld, rd].max, height]
+end
+
+root = Node.new({:value => 1, :name => 'root'})
+child_1 = Node.new({:value => 2, :name => 'child_1'})
+child_2 = Node.new({:value => 3, :name => 'child_2'})
+grand_child_1 = Node.new({:value => 4, :name => 'grand_child_1'})
+grand_grand_child_1 = Node.new({:value => 5, :name => 'grand_grand_child_1'})
+grand_child_1.left = grand_grand_child_1
+child_1.left = grand_child_1
+root.left = child_1
+root.right = child_2
+
+height = diameter(root)
+puts height

bc_command.rb

@@ -0,0 +1,82 @@
+# Thought Process:
+# We want to use a nested hash structure as we iterate the string to save the count as well as the location 
+# of each word, so total time complexity is O(n), since we are just iterating the total string once.
+# Here I simply use ruby to demonstrate the idea and write the program
+
+# 1. Scan through the whole string and find out places where . is being used other than the end of sentence. 
+#    Replace . with {dot} in those places, Note: we want to add appropriate regrex if needed, in this case, it is i.e.
+# 2. Split the string after each sentence ending with .
+# 3. For each sentence, we want to iterate each word and count the appearance of the word and the index, the location of the word in the string.
+# 4, In the last, we iterate the nested hash and print out the word, number of its appearance and its appearing location.
+
+string = 'Given an arbitrary text document written in English, write a program that will generate a '\
+'concordance, i.e. an alphabetical list of all word occurrences, labeled with word frequencies.'\
+' Bonus: label each word with the sentence numbers in which each occurrence appeared.'
+
+def concordance(string)
+  # Initialize the hash
+  concordance = {}
+
+  # Replace the . with {dot} using regrex, and in this case it is just i.e.
+  # Split the sentence
+  string.gsub!(/(i)\.(e)\./, "i{dot}e{dot}").split('.').each_with_index do |sentence, index|
+    # Iterate words in the sentence
+    sentence.gsub(',', '').split(' ').each do |word|
+      # Change the {dot} back to .
+      word = word.gsub(/{dot}/, '.').downcase
+      # Save the index and its count in the nested hash
+      concordance[word] ||= [0, []]
+      concordance[word][0] += 1
+      concordance[word][1] << index + 1
+    end
+  end
+
+  # Print out the hash based on the format accordingly
+  concordance.sort_by { |k, _| k }.each do |pair|
+    puts "#{pair[0]} {#{pair[1][0]}:#{pair[1][1].join(',')}}"
+  end
+end
+
+# run the function
+concordance(string)
+
+
+# Execution instruction:
+# ➜  exercises git:(master) ✗ ruby bridgewater.rb
+
+# Output
+# ➜  exercises git:(master) ✗ ruby bridgewater.rb
+# a {2:1,1}
+# all {1:1}
+# alphabetical {1:1}
+# an {2:1,1}
+# appeared {1:2}
+# arbitrary {1:1}
+# bonus: {1:2}
+# concordance {1:1}
+# document {1:1}
+# each {2:2,2}
+# english {1:1}
+# frequencies {1:1}
+# generate {1:1}
+# given {1:1}
+# i.e. {1:1}
+# in {2:1,2}
+# label {1:2}
+# labeled {1:1}
+# list {1:1}
+# numbers {1:2}
+# occurrence {1:2}
+# occurrences {1:1}
+# of {1:1}
+# program {1:1}
+# sentence {1:2}
+# text {1:1}
+# that {1:1}
+# the {1:2}
+# which {1:2}
+# will {1:1}
+# with {2:1,2}
+# word {3:1,1,2}
+# write {1:1}
+# written {1:1}

binary_search_tree_diameter.rb

@@ -0,0 +1,82 @@
+# Thought Process:
+# We want to use a nested hash structure as we iterate the string to save the count as well as the location 
+# of each word, so total time complexity is O(n), since we are just iterating the total string once.
+# Here I simply use ruby to demonstrate the idea and write the program
+
+# 1. Scan through the whole string and find out places where . is being used other than the end of sentence. 
+#    Replace . with {dot} in those places, Note: we want to add appropriate regrex if needed, in this case, it is i.e.
+# 2. Split the string after each sentence ending with .
+# 3. For each sentence, we want to iterate each word and count the appearance of the word and the index, the location of the word in the string.
+# 4, In the last, we iterate the nested hash and print out the word, number of its appearance and its appearing location.
+
+string = 'Given an arbitrary text document written in English, write a program that will generate a '\
+'concordance, i.e. an alphabetical list of all word occurrences, labeled with word frequencies.'\
+' Bonus: label each word with the sentence numbers in which each occurrence appeared.'
+
+def concordance(string)
+  # Initialize the hash
+  concordance = {}
+
+  # Replace the . with {dot} using regrex, and in this case it is just i.e.
+  # Split the sentence
+  string.gsub!(/(i)\.(e)\./, "i{dot}e{dot}").split('.').each_with_index do |sentence, index|
+    # Iterate words in the sentence
+    sentence.gsub(',', '').split(' ').each do |word|
+      # Change the {dot} back to .
+      word = word.gsub(/{dot}/, '.').downcase
+      # Save the index and its count in the nested hash
+      concordance[word] ||= [0, []]
+      concordance[word][0] += 1
+      concordance[word][1] << index + 1
+    end
+  end
+
+  # Print out the hash based on the format accordingly
+  concordance.sort_by { |k, _| k }.each do |pair|
+    puts "#{pair[0]} {#{pair[1][0]}:#{pair[1][1].join(',')}}"
+  end
+end
+
+# run the function
+concordance(string)
+
+
+# Execution instruction:
+# ➜  exercises git:(master) ✗ ruby bridgewater.rb
+
+# Output
+# ➜  exercises git:(master) ✗ ruby bridgewater.rb
+# a {2:1,1}
+# all {1:1}
+# alphabetical {1:1}
+# an {2:1,1}
+# appeared {1:2}
+# arbitrary {1:1}
+# bonus: {1:2}
+# concordance {1:1}
+# document {1:1}
+# each {2:2,2}
+# english {1:1}
+# frequencies {1:1}
+# generate {1:1}
+# given {1:1}
+# i.e. {1:1}
+# in {2:1,2}
+# label {1:2}
+# labeled {1:1}
+# list {1:1}
+# numbers {1:2}
+# occurrence {1:2}
+# occurrences {1:1}
+# of {1:1}
+# program {1:1}
+# sentence {1:2}
+# text {1:1}
+# that {1:1}
+# the {1:2}
+# which {1:2}
+# will {1:1}
+# with {2:1,2}
+# word {3:1,1,2}
+# write {1:1}
+# written {1:1}