chore: sync and correct typo in Project Euler p7

Author: Jessica Yung

.DS_Store

@@ -0,0 +1,7 @@
+solveMeFirst a b = a + b
+
+main = do
+    val1 <- readLn
+    val2 <- readLn
+    let sum = solveMeFirst val1 val2
+    print sum

functional-programming/haskell-io-template.hs

@@ -0,0 +1,3 @@
+-- print "Hello World"
+hello_world = putStrLn "Hello World"
+

functional-programming/introduction.hs

@@ -0,0 +1,87 @@
+def is_pivot_index(current_word, previous_word):
+    """Return a boolean indicating whether the current word is 
+    ordered before the previous word, i.e. if the current word 
+    is the rotation point.
+    """
+    if current_word < previous_word:
+        return True
+    else:
+        return False
+    
+def brute_force_one(words):
+    """Returns the index of the 'rotation point'.
+    Time complexity: O(n)
+    Space complexity: O(1)
+     """
+    if is_pivot_index(words[0], words[-1]):
+        print(i, words[i])
+        return i
+    else:
+        number_of_words = len(words)
+        for i in range(1, number_of_words):
+            if is_pivot_index(words[i], words[i-1]):
+                print(i, words[i])
+                return i
+                break
+
+def binary_search(words):
+    """Returns the index of the 'rotation point'.
+    Time complexity: O(logn)
+    Space complexity: O(1)
+    """
+    if is_pivot_index(words[0], words[-1]):
+        print(i, words[i])
+        return i
+    else:
+        # Binary tree to speed things up.
+        floor_index = 0
+        ceiling_index = len(words)
+        
+        # Todo: Check if int ruins alg
+        found_pivot = False
+        while found_pivot = False:
+            halfway_distance = int((ceiling_index - floor_index)/2)
+            current_index = floor_index + halfway_distance
+            floor_word = word[floor_index]
+            current_word = word[current_index]
+            if prev_word > current_word:
+                # Then rotation point is in first half of current interval
+
+                # Check if current word is rotation point
+                if is_pivot_index(current_word, words[current - 1]):
+                    # If it is, we are done.
+                    found_pivot = True
+                    return current
+
+                else:
+                    # Reset the distance 
+                    ceiling_index = current_index
+                    current_temp = current
+                    current = current - (current - prev) / 2
+                    prev = current_temp
+            else:
+                # Pivot is in second half of current interval
+                floor_index = current_index
+
+        # Get index of the first lettor of the first word, init_index
+        # Get the index of the first letter of the middle word
+        # Do is_pivot_index
+        # If
+        # 
+
+# Test case
+words_one = [
+    'ptolemaic',
+    'retrograde',
+    'supplant',
+    'undulate',
+    'xenoepist',
+    'asymptote', # <-- rotates here!
+    'babka',
+    'banoffee',
+    'engender',
+    'karpatka',
+    'othellolagkage',
+]
+
+print(brute_force_one(words_one))

interview-cake/13-find-rotation-point.py

@@ -0,0 +1,38 @@
+  def binary_search(target, nums):
+    # see if target appears in nums
+
+    # we think of floor_index and ceiling_index as "walls" around
+    # the possible positions of our target so by -1 below we mean
+    # to start our wall "to the left" of the 0th index
+    # (we /don't/ mean "the last index")
+    floor_index = -1
+    ceiling_index = len(nums)
+
+    # if there isn't at least 1 index between floor and ceiling,
+    # we've run out of guesses and the number must not be present
+    while floor_index + 1 < ceiling_index:
+
+        # find the index ~halfway between the floor and ceiling
+        # we use integer division, so we'll never get a "half index"
+        distance = ceiling_index - floor_index
+        half_distance = distance / 2
+        guess_index = floor_index + half_distance
+
+        guess_value = nums[guess_index]
+
+        if guess_value == target:
+            return True
+
+        if guess_value > target:
+
+            # target is to the left
+            # so move ceiling to the left
+            ceiling_index = guess_index
+
+        else:
+
+            # target is to the right
+            # so move floor to the right
+            floor_index = guess_index
+
+    return False

interview-cake/binary-search.py

@@ -0,0 +1,53 @@
+# Confirm PEP8 says var[i+1] as opposed to var[i + 1]
+
+def string_to_array(string):
+	"""
+
+	"""
+	array = []
+	for i in range(len(string)):
+		array.append(string[i])
+	return array
+
+def remove_whitespaces(array):
+	for i in range(len(array)):
+		if array[i] == ' ':
+			del array[i]
+	return array
+
+def sort_array(array):
+	# Quicksort
+	pass
+
+def check_if_perm_of_palindrome(sorted_array):
+	"""Checks if a sorted array is a permutation of a palindrome."""
+	i = 0
+	singles = 0
+	while i < len(sorted_array):
+		if i == len(sorted_array) - 1:
+			if singles == 0:
+				return True
+			else:
+				return False
+		elif sorted_array[i] == sorted_array[i+1]:
+			i = i + 2
+		elif sorted_array[i] != sorted_array[i+1]:
+			if singles == 0:
+				i = i + 1
+			else:
+				return False
+
+# Read input
+string = str(input())
+
+# Make string an array
+array = string_to_array(string)
+
+# Tidy up string by removing whitespaces and making all lower case.
+array = remove_whitespaces(array).lower()
+
+# Sort string. E.g. input 'Tact Coa' -> 'aaccott' after this stage.
+sorted_array = sort_array(string)
+
+# 
+check_if_perm_of_palindrome(sorted_array)

laakmann-mcdowell/1-arrays-and-strings/1.4-palindrome-permutation.py

@@ -0,0 +1,8 @@
+"""
+2.1 Remove Duplicates
+
+Write code to remove duplicates from an unsorted linked list.
+
+How would you solve this problem if a temporary buffer is not allowed?
+"""
+

laakmann-mcdowell/2-linked-lists/2.1-remove-duplicates.py

@@ -0,0 +1,8 @@
+
+def ll_length(node):
+	pass
+
+def sum_lists(ll_one_node, ll_two_node):
+	if ll_length(ll_one_node) != ll_length(ll_two_node):
+		pass
+		# 

laakmann-mcdowell/2-linked-lists/2.5-sum-lists.py

@@ -0,0 +1,41 @@
+"""
+Linked Lists in Python
+
+Taken from InterviewCake August 2016
+"""
+
+class LinkedListNode():
+	"""Singly Linked List Nodes"""
+	def __init__(self, value):
+#		super(LinkedListNode, self).__init__()
+		self.value = value
+		self.next = None
+
+
+# Build a singly linked list
+
+a = LinkedListNode(5)
+b = LinkedListNode(1)
+c = LinkedListNode(9)
+
+a.next = b
+b.next = c
+
+class DLinkedListNode():
+	"""Doubly Linked List Nodes"""
+	def __init__(self, arg):
+#		super(DLinkedListNode, self).__init__()
+		self.arg = arg
+		self.next = None
+		self.previous = None
+		
+# Build a doubly linked list
+
+# Put b after a
+a.next = b
+b.previous = a
+
+# Put c after b
+b.next = c
+c.previous = b
+

laakmann-mcdowell/2-linked-lists/linked-list-classes.py

@@ -0,0 +1,19 @@
+// Creating a Linked List
+
+class Node {
+	Node next = null;
+	int data;
+
+	public Node(int d) {
+		data = d;
+	}
+
+	void appendToTail(int d) {
+		Node end = new Node(d);
+		Node n = this;
+		while (n.next != null) {
+			n = n.next;
+		}
+		n.next = end;
+	}
+}