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
 

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/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/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;

src/year2019/day13.rs

@@ -92,7 +92,7 @@ pub fn part2(input: &[i64]) -> i64 {
         }
 
         // Non essential but hilarious. Enable feature then run program in a command line
-        // conosle to observe an animated game of breakout.
+        // console to observe an animated game of breakout.
         #[cfg(feature = "frivolity")]
         draw(&tiles, stride, score, blocks);
     }

src/year2019/day17.rs

@@ -214,7 +214,7 @@ fn segments(path: &str) -> impl Iterator<Item = (&str, &str)> {
 
 #[cfg(not(feature = "frivolity"))]
 fn visit(mut computer: Computer) -> i64 {
-    // Disable continous video feed
+    // Disable continuous video feed
     computer.input_ascii("n\n");
 
     let mut result = 0;
@@ -235,7 +235,7 @@ fn visit(mut computer: Computer) -> i64 {
     let mut previous = ' ';
     let mut buffer = String::new();
 
-    // Enable continous video feed
+    // Enable continuous video feed
     computer.input_ascii("y\n");
 
     while let State::Output(next) = computer.run() {

src/year2019/day24.rs

@@ -19,7 +19,7 @@
 //! For example the bitmask for position `a` is `100010` and for position `h` is `1000101000100`.
 //!
 //! For each generation we bitwise `AND` each position with its mask, then use the [`count_ones`]
-//! intrinsic to to efficiently find the number of neighbors.
+//! intrinsic to efficiently find the number of neighbors.
 //!
 //! ## Part Two
 //!

src/year2020/day20.rs

@@ -15,7 +15,7 @@
 //! ## Part One
 //!
 //! First we calculate the frequency of each edge, both forwards and backwards as tiles can be in
-//! any orientation. As there only 2¹⁰ or 1024 possible edge values we can use an array intead of a
+//! any orientation. As there only 2¹⁰ or 1024 possible edge values we can use an array instead of a
 //! hashtable for speed, converting the edges into a binary number to index the array.
 //!
 //! This results in 96 values that occur once and 528 values that occur twice. Then for every tile