Add snippet generation (#84)

snippets/go/sort_bubble_sort_test.go

@@ -0,0 +1,50 @@
+// bubble sort!
+//
+// docs: https://en.wikipedia.org/wiki/Bubble_sort
+//
+// bubble sort steps through a list, comparing adjacent elements and swapping them if they
+// are in the wrong order. it passes through the list repeatedly until the list is sorted
+
+// bubble_sort is the top level function responsible for ... bubble sorting!
+func bubbleSort(inputList []string) (outputList []string) {
+	// setup defaults
+	outputList = inputList
+	isSorted := false
+
+	// continuously do sorting rounds as long as the list remains unsorted
+	for isSorted == false {
+		outputList, isSorted = doSortingRound(outputList)
+	}
+
+	return outputList
+}
+
+// doSortingRound does the "actual sorting"
+func doSortingRound(inputList []string) (outputList []string, isSorted bool) {
+	isSorted = true
+
+	for index, element := range inputList {
+		if index == 0 {
+			// we compare (index VS index - 1) so theres
+			// nothing to compare when looking at the 0th index
+			outputList = []string{element}
+		} else if element < outputList[index-1] {
+			// if this element is less than the previous element then swap their order
+			visitedElements := outputList[:index-1]
+			previousElement := outputList[index-1]
+			// append a list of
+			//	- all the list elements we've visited already
+			//	- the current element
+			//	- the previous element
+			// which has the effect of swapping the order of the current and previous
+			// elements, while also keeping all of the visited elements in place
+			outputList = append(visitedElements, element, previousElement)
+			isSorted = false
+		} else {
+			// otherwise append
+			outputList = append(outputList, element)
+		}
+	}
+
+	return outputList, isSorted
+}

snippets/go/sort_builtin_test.go

@@ -0,0 +1,5 @@
+func builtinSort(inputList []string) (outputList []string) {
+	outputList = inputList
+	sort.Strings(outputList)
+	return outputList
+}

snippets/go/sort_insertion_sort_test.go

@@ -0,0 +1,34 @@
+// insertion sort!
+//
+// docs: https://en.wikipedia.org/wiki/Insertion_sort
+//
+// Insertion sort steps through an input list, using it to grow an output list.
+// On every step, it sorts the current element into its proper location on the
+// output list.It continues until the input list is empty.
+
+func insertionSort(inputList []string) (outputList []string) {
+
+	for idx, element := range inputList {
+		outputList = append(outputList, element)
+		outputList = sortElementAtIndex(outputList, element, idx)
+	}
+
+	return outputList
+}
+
+func sortElementAtIndex(inputList []string, element string, idx int) (outputList []string) {
+	outputList = inputList
+	targetIndex := idx
+
+	for (targetIndex != 0) && (element < outputList[targetIndex-1]) {
+		outputList = swapWithPrevious(outputList, targetIndex)
+		targetIndex = targetIndex - 1
+	}
+
+	return outputList
+}
+
+func swapWithPrevious(list []string, idx int) []string {
+	list[idx], list[idx-1] = list[idx-1], list[idx]
+	return list
+}

snippets/go/sort_merge_sort_test.go

@@ -0,0 +1,69 @@
+// merge sort!
+//
+// docs: https://leetcode.com/explore/learn/card/recursion-ii/470/divide-and-conquer/2868/
+
+func MergeSort(inputList []string) (sortedList []string) {
+
+	var doMergeInput [][]string
+	for _, item := range inputList {
+		doMergeInput = append(doMergeInput, []string{item})
+	}
+
+	doMergeOutput, _ := mergeSortRound(doMergeInput, 0)
+	sortedList = doMergeOutput[0]
+
+	return sortedList
+}
+
+func mergeSortRound(inputList [][]string, inputRound int) (outputList [][]string, outputRound int) {
+
+	// "round" is used for debugging
+	outputRound = inputRound + 1
+
+	// merge each pair, ignoring potential odd items
+	for i := 0; i < len(inputList)/2*2; i += 2 {
+		outputList = append(
+			outputList,
+			merge(inputList[i], inputList[i+1]),
+		)
+	}
+
+	// handle odd items
+	if len(inputList)%2 == 1 {
+		outputList = append(outputList, inputList[len(inputList)-1])
+	}
+
+	// recurse!
+	if len(outputList) != 1 {
+		return mergeSortRound(outputList, outputRound)
+	}
+
+	return outputList, outputRound
+}
+
+func merge(left []string, right []string) (result []string) {
+	leftIndex, rightIndex := 0, 0
+
+	for (leftIndex < len(left)) || (rightIndex < len(right)) {
+
+		if leftIndex == len(left) {
+			// boundary check on first list, append from second list
+			result = append(result, right[rightIndex])
+			rightIndex++
+		} else if rightIndex == len(right) {
+			// boundary check on second list, append from first list
+			result = append(result, left[leftIndex])
+			leftIndex++
+		} else if left[leftIndex] < right[rightIndex] {
+			// comparison check, append from first list
+			result = append(result, left[leftIndex])
+			leftIndex++
+		} else {
+			// implicit comparison check, append from second list
+			result = append(result, right[rightIndex])
+			rightIndex++
+		}
+	}
+
+	return result
+}

snippets/go/sort_selection_sort_test.go

@@ -0,0 +1,37 @@
+// selection sort!
+//
+// docs: https://en.wikipedia.org/wiki/Selection_sort
+//
+// Selection sort looks through every element an input list, and finds the
+// smallest element. That element is then appended to the end of an output list.
+// When it reaches the end of the input list, all of the output elements will
+// be sorted.
+
+func selectionSort(inputList []string) (sortedList []string) {
+	unsortedList := inputList
+	inputListLength := len(inputList)
+
+	for i := 0; i < inputListLength; i++ {
+		smallestIndex := findSmallestIndex(unsortedList)
+		smallestElement := unsortedList[smallestIndex]
+		sortedList = append(sortedList, smallestElement)
+		unsortedList = removeIndex(unsortedList, smallestIndex)
+	}
+
+	return sortedList
+}
+
+func findSmallestIndex(inputList []string) (smallestIndex int) {
+	for index, element := range inputList {
+		if element < inputList[smallestIndex] {
+			smallestIndex = index
+		}
+	}
+
+	return smallestIndex
+}
+
+func removeIndex(inputList []string, index int) (outputList []string) {
+	outputList = append(inputList[:index], inputList[index+1:]...)
+	return outputList
+}

snippets/js/sort_bubble_sort.js

@@ -0,0 +1,35 @@
+function doSorting(inputList) {
+  return bubbleSort(inputList);
+}
+
+function bubbleSort(inputList) {
+  outputList = inputList;
+  isSorted = false;
+
+  while (isSorted === false) {
+    outputList, (isSorted = doSortingRound(outputList));
+  }
+
+  return outputList;
+}
+
+function doSortingRound(inputList) {
+  outputList = [];
+  isSorted = true;
+
+  inputList.forEach((element, index) => {
+    if (index === 0) {
+      outputList.push(element);
+    } else if (element < outputList[index - 1]) {
+      previousElement = outputList[index - 1];
+      outputList.pop();
+      outputList.push(element);
+      outputList.push(previousElement);
+      isSorted = false;
+    } else {
+      outputList.push(element);
+    }
+  });
+
+  return outputList, isSorted;
+}

snippets/js/sort_builtin.js

@@ -0,0 +1,5 @@
+function doSorting(inputList) {
+  outputList = inputList;
+  outputList.sort();
+  return outputList;
+}

snippets/js/sort_insertion_sort.js

@@ -0,0 +1,41 @@
+// insertion sort!
+//
+// docs: https://en.wikipedia.org/wiki/Insertion_sort
+//
+// Insertion sort steps through an input list, using it to grow an output list.
+// On every step, it sorts the current element into its proper location on the
+// output list.It continues until the input list is empty.
+
+function doSorting(inputList) {
+  return insertionSort(inputList);
+}
+
+function insertionSort(inputList) {
+  outputList = [];
+
+  inputList.forEach((element, idx) => {
+    outputList.push(element);
+    outputList = sortElementAtIndex(outputList, element, idx);
+  });
+
+  return outputList;
+}
+
+function sortElementAtIndex(inputList, element, idx) {
+  target_index = idx;
+  outputList = inputList;
+
+  while (target_index != 0 && element < outputList[target_index - 1]) {
+    swapWithPrevious(outputList, target_index);
+    target_index -= 1;
+  }
+
+  return outputList;
+}
+
+function swapWithPrevious(list, idx) {
+  tmp = list[idx - 1];
+  list[idx - 1] = list[idx];
+  list[idx] = tmp;
+  return list;
+}

snippets/js/sort_selection_sort.js

@@ -0,0 +1,48 @@
+// selection sort!
+//
+// docs: https://en.wikipedia.org/wiki/Selection_sort
+//
+// Selection sort looks through every element an input list, and finds the
+// smallest element. That element is then appended to the end of an output list.
+// When it reaches the end of the input list, all of the output elements will
+// be sorted.
+
+function doSorting(inputList) {
+  return selectionSort(inputList);
+}
+
+function selectionSort(inputList) {
+  sortedElements = [];
+  unsortedElements = inputList;
+  inputListLength = inputList.length;
+
+  for (let index = 0; index < inputListLength; index++) {
+    // console.log("--- for (let index = 0; index < inputList.length; index++) { ---");
+    // console.log("unsortedElements => " + unsortedElements);
+    // console.log("sortedElements => " + sortedElements);
+
+    smallestIndex = findSmallestIndex(unsortedElements);
+    smallestElement = unsortedElements[smallestIndex];
+    sortedElements.push(smallestElement);
+    unsortedElements.splice(smallestIndex, 1);
+
+    // console.log("smallestIndex => " + smallestIndex);
+    // console.log("smallestElement => " + smallestElement);
+    // console.log("unsortedElements => " + unsortedElements);
+    // console.log("sortedElements => " + sortedElements);
+  }
+
+  return sortedElements;
+}
+
+function findSmallestIndex(inputList) {
+  smallestIndex = 0;
+
+  inputList.forEach((element, index) => {
+    if (element < inputList[smallestIndex]) {
+      smallestIndex = index;
+    }
+  });
+
+  return smallestIndex;
+}

snippets/python/sort_bubble_sort.py

@@ -0,0 +1,54 @@
+# bubble sort!
+#
+# docs: https://en.wikipedia.org/wiki/Bubble_sort
+#
+# bubble sort steps through a list, comparing adjacent elements and swapping them if they
+# are in the wrong order. it passes through the list repeatedly until the list is sorted
+
+
+def do_sorting(input_list):
+    return bubble_sort(input_list)
+
+
+# bubble_sort is the top level function responsible for ... bubble sorting!
+def bubble_sort(input_list: list[str]) -> list[str]:
+    # set defaults
+    output_list = input_list
+    is_sorted = False
+
+    # continuously do sorting rounds as long as the list remains unsorted
+    while is_sorted is False:
+        output_list, is_sorted = do_sorting_round(output_list)
+
+    # mission accomplished! ✨
+    return output_list
+
+
+# do_sorting_round does the "actual sorting"
+def do_sorting_round(input_list: list[str]) -> (list[str], bool):
+    # set defaults
+    output_list = []
+    is_sorted = True
+
+    for index, element in enumerate(input_list):
+        # we compare (index VS index - 1) so there's
+        # nothing to compare when looking at the 0th index
+        if index == 0:
+            output_list.append(element)
+            continue
+
+        # grab (index - 1)
+        previous_element = output_list[index - 1]
+
+        # if this element is less than the previous element then swap their order
+        if element < previous_element:
+            output_list.pop()
+            output_list.append(element)
+            output_list.append(previous_element)
+            is_sorted = False
+        # otherwise append
+        else:
+            output_list.append(element)
+
+    return output_list, is_sorted
+

snippets/python/sort_builtin.py

@@ -0,0 +1,4 @@
+
+def do_sorting(input_list):
+    return sorted(input_list)
+