style: comment

Author: 0x01f7

algorithms/compare_version_numbers.rb

@@ -3,13 +3,17 @@
 # Compare two version numbers version1 and version2. If version1 > version2
 # return 1, if version1 < version2 return -1, otherwise return 0. You may
 # assume that the version strings are non-empty and contain only digits and
-# the . character. The . character does not represent a decimal point and
-# is used to separate number sequences. For instance, 2.5 is not "two and a
-# half" or "half way to version three", it is the fifth second-level
-# revision of the second first-level revision. Here is an example of
-# version numbers ordering:
+# the . character. The . character does not represent a decimal point and is
+# used to separate number sequences. For instance, 2.5 is not "two and a half"
+# or "half way to version three", it is the fifth second-level revision of the
+# second first-level revision. Here is an example of version numbers ordering:
 #
 #     0.1 < 1.1 < 1.2 < 13.37
+#
+# Credits:
+#
+#     Special thanks to @ts for adding this problem and creating all test
+#     cases.
 
 
 # @param {String} version1

algorithms/container_with_most_water.rb

@@ -1,10 +1,10 @@
 # https://leetcode.com/problems/container-with-most-water/
 #
-# Given n non-negative integers a1, a2, ..., an, where each represents
-# a point at coordinate (i, ai). n vertical lines are drawn such that
-# the two endpoints of line i is at (i, ai) and (i, 0). Find two lines,
-# which together with x-axis forms a container, such that the container
-# contains the most water.
+# Given n non-negative integers a1, a2, ..., an, where each represents a point
+# at coordinate (i, ai). n vertical lines are drawn such that the two
+# endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together
+# with x-axis forms a container, such that the container contains the most
+# water.
 #
 # Note: You may not slant the container.
 

algorithms/contains_duplicate.rb

@@ -1,8 +1,8 @@
 # https://leetcode.com/problems/contains-duplicate/
 #
-# Given an array of integers, find if the array contains any duplicates.
-# Your function should return true if any value appears at least twice
-# in the array, and it should return false if every element is distinct.
+# Given an array of integers, find if the array contains any duplicates. Your
+# function should return true if any value appears at least twice in the array,
+# and it should return false if every element is distinct.
 
 
 # @param {Integer[]} nums

algorithms/contains_duplicate_ii.rb

@@ -1,8 +1,8 @@
 # https://leetcode.com/problems/contains-duplicate-ii/
 #
-# Given an array of integers and an integer k, find out whether there
-# are two distinct indices i and j in the array such that
-# nums[i] = nums[j] and the difference between i and j is at most k.
+# Given an array of integers and an integer k, find out whether there are two
+# distinct indices i and j in the array such that nums[i] = nums[j] and the
+# difference between i and j is at most k.
 
 
 # @param {Integer[]} nums

algorithms/contains_duplicate_iii.rb

@@ -1,9 +1,8 @@
 # https://leetcode.com/problems/contains-duplicate-iii/
 #
-# Given an array of integers, find out whether there are two distinct
-# indices i and j in the array such that the difference between
-# nums[i] and nums[j] is at most t and the difference between i and j
-# is at most k.
+# Given an array of integers, find out whether there are two distinct indices
+# i and j in the array such that the difference between nums[i] and nums[j] is
+# at most t and the difference between i and j is at most k.
 
 
 # @param {Integer[]} nums

algorithms/convert_sorted_array_to_binary_search_tree.rb

@@ -1,7 +1,7 @@
 # https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/
 #
-# Given an array where elements are sorted in ascending order, convert
-# it to a height balanced BST.
+# Given an array where elements are sorted in ascending order, convert it to a
+# height balanced BST.
 
 
 # Definition for a binary tree node.

algorithms/count_and_say.rb

@@ -1,15 +1,16 @@
 # https://leetcode.com/problems/count-and-say/
 #
-# The count-and-say sequence is the sequence of integers beginning
-# as follows:
+# The count-and-say sequence is the sequence of integers beginning as follows:
 #
 #     1, 11, 21, 1211, 111221, ...
 #
-# 1 is read off as "one 1" or 11.
-# 11 is read off as "two 1s" or 21.
-# 21 is read off as "one 2, then one 1" or 1211.
+#      1 is read off as "one 1" or 11.
+#     11 is read off as "two 1s" or 21.
+#     21 is read off as "one 2, then one 1" or 1211.
 #
 # Given an integer n, generate the nth sequence.
+#
+# Note: The sequence of integers will be represented as a string.
 
 
 # @param {Integer} n

algorithms/count_complete_tree_nodes.rb

@@ -1,6 +1,11 @@
 # https://leetcode.com/problems/count-complete-tree-nodes/
 #
 # Given a complete binary tree, count the number of nodes.
+#
+# Definition of a complete binary tree from Wikipedia: In a complete binary
+# tree every level, except possibly the last, is completely filled, and all
+# nodes in the last level are as far left as possible. It can have between
+# 1 and 2h nodes inclusive at the last level h.
 
 
 # Definition for a binary tree node.

algorithms/count_primes.rb

@@ -1,6 +1,11 @@
 # https://leetcode.com/problems/count-primes/
 #
 # Count the number of prime numbers less than a non-negative number, n.
+#
+# Credits:
+#
+#     Special thanks to @mithmatt for adding this problem and creating all
+#     test cases.
 
 
 # @param {Integer} n

algorithms/course_schedule.rb

@@ -1,23 +1,26 @@
 # https://leetcode.com/problems/course-schedule/
 #
 # There are a total of n courses you have to take, labeled from 0 to n - 1.
-# Some courses may have prerequisites, for example to take course 0 you
-# have to first take course 1, which is expressed as a pair: [0,1]. Given
-# the total number of courses and a list of prerequisite pairs, is it
-# possible for you to finish all courses?
+# Some courses may have prerequisites, for example to take course 0 you have
+# to first take course 1, which is expressed as a pair: [0,1]. Given the total
+# number of courses and a list of prerequisite pairs, is it possible for you
+# to finish all courses?
 #
 # For example:
 #
-#     2, [[1,0]]
+#     2, [[1, 0]]
 #
-# There are a total of 2 courses to take. To take course 1 you should
-# have finished course 0. So it is possible.
+# There are a total of 2 courses to take. To take course 1 you should have
+# finished course 0. So it is possible.
 #
-#     2, [[1,0],[0,1]]
+#     2, [[1, 0], [0, 1]]
 #
-# There are a total of 2 courses to take. To take course 1 you should
-# have finished course 0, and to take course 0 you should also have
-# finished course 1. So it is impossible.
+# There are a total of 2 courses to take. To take course 1 you should have
+# finished course 0, and to take course 0 you should also have finished course
+# 1. So it is impossible.
+#
+# Note: The input prerequisites is a graph represented by a list of edges, not
+# adjacency matrices.
 
 
 # @param {Integer} num_courses

algorithms/course_schedule_ii.rb

@@ -1,27 +1,30 @@
 # https://leetcode.com/problems/course-schedule-ii/
 #
 # There are a total of n courses you have to take, labeled from 0 to n - 1.
-# Some courses may have prerequisites, for example to take course 0 you
-# have to first take course 1, which is expressed as a pair: [0,1]. Given
-# the total number of courses and a list of prerequisite pairs, return the
-# ordering of courses you should take to finish all courses.
+# Some courses may have prerequisites, for example to take course 0 you have
+# to first take course 1, which is expressed as a pair: [0,1]. Given the total
+# number of courses and a list of prerequisite pairs, return the ordering of
+# courses you should take to finish all courses.
 #
 # There may be multiple correct orders, you just need to return one of them.
 # If it is impossible to finish all courses, return an empty array.
 #
 # For example:
 #
-#     2, [[1,0]]
+#     2, [[1, 0]]
 #
 # There are a total of 2 courses to take. To take course 1 you should have
-# finished course 0. So the correct course order is [0,1]
+# finished course 0. So the correct course order is [0, 1]
 #
-#     4, [[1,0],[2,0],[3,1],[3,2]]
+#     4, [[1, 0], [2, 0], [3, 1], [3, 2]]
 #
 # There are a total of 4 courses to take. To take course 3 you should have
 # finished both courses 1 and 2. Both courses 1 and 2 should be taken after
-# you finished course 0. So one correct course order is [0,1,2,3]. Another
-# correct ordering is [0,2,1,3].
+# you finished course 0. So one correct course order is [0, 1, 2, 3]. Another
+# correct ordering is [0, 2, 1, 3].
+#
+# Note: The input prerequisites is a graph represented by a list of edges, not
+# adjacency matrices.
 
 
 # @param {Integer} num_courses