Tidy comments

Author: maneatingape

CONTRIBUTING.md

@@ -20,7 +20,7 @@ It should generally fall into one of the following two categories:
 
 When contributing to this project, you must agree that you have authored 100% of the content,
 that you have the necessary rights to the content and that the content you contribute
-may be provided under the project licence.
+may be provided under the project license.
 
 ## Guidelines
 

README.md

@@ -42,7 +42,7 @@ Place input files in `input/yearYYYY/dayDD.txt` including leading zeroes. For ex
 
 **Document**
 * Build docs including private items `cargo doc --document-private-items`
-* Build doc then open HTML landing page `cargo doc --document-private-items --open`
+* Build docs then open HTML landing page `cargo doc --document-private-items --open`
 
 **Miscellaneous**
 * Code quality lints `cargo clippy`

src/util/grid.rs

@@ -16,10 +16,10 @@
 //!   assert_eq!(grid[point], b'2');
 //! ```
 //!
-//! A convenience [`parse`] method creates a `Grid` directly from a 2 dimenionsal set of
-//! ASCII characters, a common occurence in Advent of Code inputs. The [`same_size_with`] function
+//! A convenience [`parse`] method creates a `Grid` directly from a 2 dimensional set of
+//! ASCII characters, a common occurrence in Advent of Code inputs. The [`same_size_with`] function
 //! creates a grid of the same size, that can be used for in BFS algorithms for tracking visited
-//! location or for tracking cost in Djikstra.
+//! location or for tracking cost in Dijkstra.
 //!
 //! [`Point`]: crate::util::point
 //! [`parse`]: Grid::parse

src/year2015/day17.rs

@@ -59,7 +59,7 @@ pub fn part1(input: &[u32]) -> u32 {
     input.iter().sum()
 }
 
-/// We want the number of combination with the fewest containers, so find first non-zero value.
+/// We want the number of combinations with the fewest containers, so find first non-zero value.
 pub fn part2(input: &[u32]) -> u32 {
     *input.iter().find(|&&n| n > 0).unwrap()
 }

src/year2016/day15.rs

@@ -6,7 +6,7 @@
 //!
 //! For simplicity we use the "search by sieving" method. We start at zero with a step the size of
 //! the first integer. Then we search for each subsequent integer located at the correct offset of
-//! minutes and multiply the step by the new integer. This preserve the relative offset at each step
+//! minutes and multiply the step by the new integer. This preserves the relative offset at each step
 //! in the next search.
 use crate::util::iter::*;
 use crate::util::parse::*;

src/year2016/day16.rs

@@ -32,7 +32,7 @@
 //!
 //! Now for the really neat part. We can recursively find the number of ones in `y` by repeating
 //! the same process by setting the new `length` to `next`. We keep recursing until the length
-//! is less the size of the inital input and we can lookup the final count from the prefix sum.
+//! is less the size of the initial input and we can lookup the final count from the prefix sum.
 use crate::util::parse::*;
 
 /// Build a prefix sum of the number of ones at each length in the pattern

src/year2017/day03.rs

@@ -19,7 +19,7 @@
 //!                                                          ------------>
 //! ```
 //!
-//! The first component is the horizonal or vertical distance from the centre to the ring,
+//! The first component is the horizontal or vertical distance from the centre to the ring,
 //! in this case 2 steps. The second component is the distance from the target number to the
 //! center of each edge, in this case 2 - 1 = 1.
 //!

src/year2017/day24.rs

@@ -1,18 +1,18 @@
 //! # Electromagnetic Moat
 //!
-//! Both parts are calculated at the same time by recurively building all possible bridge
-//! combinations. Two optimizations are used to speed things up ten times
+//! Both parts are calculated at the same time by recursively building all possible bridge
+//! combinations. Two optimizations are used to speed things up ten times.
 //!
 //! First ports that only appear in two components are merged. For example `2/17` and `17/3`
 //! becomes a single component `2/3` with a weight of 39 and a length of 2. This shaves about 30%
 //! off the time needed.
 //!
 //! The second optimization is far more critical and reduces the time needed by 85%. The
-//! observation is that compenets with two ports the same, for example `7/7` are always optimal
+//! observation is that components with two ports the same, for example `7/7` are always optimal
 //! to pick first, as they increase strength and length without changing the port number.
 //!
 //! If we can place such a component then there's no need to consider further components which
-//! reduces the total number of combination to consider.
+//! reduces the total number of combinations to consider.
 use crate::util::bitset::*;
 use crate::util::iter::*;
 use crate::util::parse::*;

src/year2018/day09.rs

@@ -34,7 +34,7 @@
 //! ```
 //!
 //! Things start to get interesting at the 19th marble. When we pick the 23rd marble this will
-//! be 7 places counter clockwise, so we can optimize by not adding it at all the the circle.
+//! be 7 places counter clockwise, so we can optimize by not adding it at all to the circle.
 //! Instead we save the value for later.
 //!
 //! ```none

src/year2018/day16.rs

@@ -74,7 +74,7 @@ pub fn part2(input: &Input) -> usize {
 
     while let Some(index) = masks.iter().position(|m| m.count_ones() == 1) {
         let mask = masks[index];
-        // This opcode has only 1 possible mapping, so remove possbility from other opcodes.
+        // This opcode has only 1 possible mapping, so remove possibility from other opcodes.
         masks.iter_mut().for_each(|m| *m &= !mask);
         // Add mapping.
         convert[index] = mask.trailing_zeros() as usize;