Merge branch 'feature/type' into develop

codejsha · codejsha · commit cde14ef06609 · 2024-11-29T20:27:10.000+09:00
diff --git a/cpp-algorithm/src/array/dutch_national_flag.cpp b/cpp-algorithm/src/array/dutch_national_flag.cpp
@@ -2,7 +2,7 @@
 
 auto DutchFlag::DutchFlagPartition1(const int pivot_index, std::vector<Color>& arr) -> std::vector<Color>
 {
-    const auto pivot = arr[pivot_index];
+    const Color pivot = arr[pivot_index];
 
     for (int i = 0; i < static_cast<Color>(arr.size()); ++i)
     {
@@ -32,7 +32,7 @@ auto DutchFlag::DutchFlagPartition1(const int pivot_index, std::vector<Color>& a
 
 auto DutchFlag::DutchFlagPartition2(const int pivot_index, std::vector<Color>& arr) -> std::vector<Color>
 {
-    const auto pivot = arr[pivot_index];
+    const Color pivot = arr[pivot_index];
 
     int smaller = 0;
     for (int i = 0; i < static_cast<Color>(arr.size()); ++i)
@@ -57,7 +57,7 @@ auto DutchFlag::DutchFlagPartition2(const int pivot_index, std::vector<Color>& a
 
 auto DutchFlag::DutchFlagPartition3(const int pivot_index, std::vector<Color>& arr) -> std::vector<Color>
 {
-    const auto pivot = arr[pivot_index];
+    const Color pivot = arr[pivot_index];
 
     int smaller = 0;
     int equal = 0;
diff --git a/cpp-algorithm/src/array/stock_trading.cpp b/cpp-algorithm/src/array/stock_trading.cpp
@@ -27,7 +27,7 @@ auto StockTrading::BuyAndSellStockOnce(const std::vector<int>& prices) -> double
 
     for (double price : prices)
     {
-        auto max_profit_sell_today = price - min_price_so_far;
+        double max_profit_sell_today = price - min_price_so_far;
         max_profit = std::max(max_profit, max_profit_sell_today);
         min_price_so_far = std::min(min_price_so_far, price);
     }
diff --git a/cpp-algorithm/src/graph/dijkstra.cpp b/cpp-algorithm/src/graph/dijkstra.cpp
@@ -29,7 +29,7 @@ void Dijkstra::Graph::DijkstraAlgorithm(Vertex& source)
 void Dijkstra::Graph::ReorderQueue(std::priority_queue<Vertex*, std::vector<Vertex*>, MinComparator>& min_queue)
 {
     auto queue = std::priority_queue<Vertex*, std::vector<Vertex*>, MinComparator>{};
-    const auto min_queue_size = static_cast<int>(min_queue.size());
+    const int min_queue_size = static_cast<int>(min_queue.size());
 
     for (int i = 0; i < min_queue_size; ++i)
     {
diff --git a/cpp-algorithm/src/greedy/activity_selection.cpp b/cpp-algorithm/src/greedy/activity_selection.cpp
@@ -15,7 +15,7 @@ auto ActivitySelection::RecursiveActivitySelector(const std::vector<int>& start,
 
     if (sub_index < size)
     {
-        auto activities = RecursiveActivitySelector(start, finish, sub_index, size);
+        std::vector<int> activities = RecursiveActivitySelector(start, finish, sub_index, size);
         activities.push_back(sub_index);
 
         return activities;
diff --git a/cpp-algorithm/src/hashtable/anonymous_letter.cpp b/cpp-algorithm/src/hashtable/anonymous_letter.cpp
@@ -56,7 +56,7 @@ auto SplitIntoWords(const std::string& str) -> std::unordered_map<std::string, i
 auto AnonymousLetter::IsWordConstructibleFromMagazine(const std::string& letter, const std::string& magazine) -> bool
 {
     // count the number of times each word appears in the letter
-    auto word_frequency_for_letter = SplitIntoWords(letter);
+    std::unordered_map<std::string, int> word_frequency_for_letter = SplitIntoWords(letter);
 
     // check if the words in magazine can cover words in letter
     for (const auto& [fst, snd] : SplitIntoWords(magazine))
diff --git a/cpp-algorithm/src/hashtable/collatz_conjecture.cpp b/cpp-algorithm/src/hashtable/collatz_conjecture.cpp
@@ -21,13 +21,13 @@ auto CollatzConjecture::GenerateCollatzSequence(const long long number,
     // if number is even, then divide it by 2
     if (number % 2 == 0)
     {
-        auto sub_sequence = GenerateCollatzSequence(number / 2, hash_table);
+        std::vector<long long> sub_sequence = GenerateCollatzSequence(number / 2, hash_table);
         sequence.insert(sequence.end(), sub_sequence.begin(), sub_sequence.end());
     }
     // if number is odd, then multiply it by 3 and add 1
     else
     {
-        auto sub_sequence = GenerateCollatzSequence(number * 3 + 1, hash_table);
+        std::vector<long long> sub_sequence = GenerateCollatzSequence(number * 3 + 1, hash_table);
         sequence.insert(sequence.end(), sub_sequence.begin(), sub_sequence.end());
     }
 
@@ -42,7 +42,7 @@ auto CollatzConjecture::FindNumbersSatisfyingCollatzConjecture(const long long n
     for (long long i = 1LL; i < number; ++i)
     {
         // if the Collatz sequence ends with 1, then satisfies the Collatz conjecture
-        if (auto sequence = GenerateCollatzSequence(i, hash_table); sequence.back() == 1)
+        if (std::vector<long long> sequence = GenerateCollatzSequence(i, hash_table); sequence.back() == 1)
         {
             satisfied_numbers.push_back(i);
         }
diff --git a/cpp-algorithm/src/hashtable/find_anagram.cpp b/cpp-algorithm/src/hashtable/find_anagram.cpp
@@ -9,7 +9,7 @@ auto FindAnagram::FindAnagramMappings(const std::vector<std::string>& dictionary
     std::unordered_map<std::string, std::vector<std::string>> dictionary_map;
     for (const std::string& word : dictionary)
     {
-        auto sorted_word = word;
+        std::string sorted_word = word;
         std::ranges::sort(sorted_word);
         dictionary_map[sorted_word].emplace_back(word);
     }
diff --git a/cpp-algorithm/src/hashtable/smallest_subarray.cpp b/cpp-algorithm/src/hashtable/smallest_subarray.cpp
@@ -14,8 +14,8 @@ auto SmallestSubarray::FindSmallestSubarrayCoveringSubset(const std::vector<std:
         ++keywords_to_cover[keyword];
     }
 
-    auto result = std::make_tuple(-1, -1);
-    auto remaining_to_cover = keywords.size();
+    std::tuple<int, int> result = std::make_tuple(-1, -1);
+    size_t remaining_to_cover = keywords.size();
 
     for (int left_index = 0, right_index = 0; right_index < static_cast<int>(paragraph.size()); ++right_index)
     {
@@ -72,11 +72,11 @@ auto SmallestSubarray::FindSmallestSubarraySequentiallyCoveringSubset(const std:
         keywords_to_index[keywords[i]] = i;
     }
 
-    auto last_occurrence = std::vector(keywords.size(), -1);
-    auto shortest_subarray_length = std::vector(keywords.size(), std::numeric_limits<int>::max());
+    std::vector<int> last_occurrence = std::vector(keywords.size(), -1);
+    std::vector<int> shortest_subarray_length = std::vector(keywords.size(), std::numeric_limits<int>::max());
 
     int shortest_distance = std::numeric_limits<int>::max();
-    auto result = std::make_tuple(-1, -1);
+    std::tuple<int, int> result = std::make_tuple(-1, -1);
 
     for (int i = 0; i < static_cast<int>(paragraph.size()); ++i)
     {
diff --git a/cpp-algorithm/src/heap/closest_star.cpp b/cpp-algorithm/src/heap/closest_star.cpp
@@ -8,7 +8,7 @@ auto ClosestStar::FindClosestStar(std::vector<Star>& stars, const int k) -> std:
 
     while (!stars.empty())
     {
-        auto star = stars.back();
+        Star star = stars.back();
         stars.pop_back();
 
         if (static_cast<int>(max_heap.size()) < k)
diff --git a/cpp-algorithm/src/linkedlist/delete_list_node.cpp b/cpp-algorithm/src/linkedlist/delete_list_node.cpp
@@ -9,7 +9,7 @@ void DeleteListNode::DeleteNodeFromList(std::shared_ptr<LinkedList::Node<int>>&
 auto DeleteListNode::DeleteNodeKthLast(std::shared_ptr<LinkedList::Node<int>>& list, int k)
     -> std::shared_ptr<LinkedList::Node<int>>
 {
-    auto dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, list});
+    const auto dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, list});
 
     auto precede = dummy_head->next;
     while (k--)
diff --git a/cpp-algorithm/src/linkedlist/list_arithmetic_operation.cpp b/cpp-algorithm/src/linkedlist/list_arithmetic_operation.cpp
@@ -4,7 +4,7 @@ auto ListArithmetic::AddTwoNumbers(std::shared_ptr<LinkedList::Node<int>>& list1
                                    std::shared_ptr<LinkedList::Node<int>>& list2)
     -> std::shared_ptr<LinkedList::Node<int>>
 {
-    auto dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
+    const auto dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
     auto iter = dummy_head;
     int carry = 0;
 
diff --git a/cpp-algorithm/src/linkedlist/merge_list.cpp b/cpp-algorithm/src/linkedlist/merge_list.cpp
@@ -6,7 +6,7 @@ auto MergeList::MergeTwoSortedLinkedList(const std::shared_ptr<LinkedList::Node<
                                          const std::shared_ptr<LinkedList::Node<int>>& list2)
     -> std::shared_ptr<LinkedList::Node<int>>
 {
-    auto dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
+    const auto dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
     auto tail = dummy_head;
     auto iter1 = list1;
     auto iter2 = list2;
@@ -29,8 +29,8 @@ auto MergeList::MergeEvenOddLinkedList(const std::shared_ptr<LinkedList::Node<in
         return list;
     }
 
-    auto even_dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
-    auto odd_dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
+    const auto even_dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
+    const auto odd_dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
     auto tails = std::vector{even_dummy_head, odd_dummy_head};
     int turn = 0;
 
diff --git a/cpp-algorithm/src/linkedlist/order_list_node.cpp b/cpp-algorithm/src/linkedlist/order_list_node.cpp
@@ -3,9 +3,9 @@
 auto OrderListNode::ListPivoting(const std::shared_ptr<LinkedList::Node<int>>& list, int x)
     -> std::shared_ptr<LinkedList::Node<int>>
 {
-    auto less_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
-    auto equal_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
-    auto greater_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
+    const auto less_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
+    const auto equal_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
+    const auto greater_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, nullptr});
 
     auto less_iter = less_head;
     auto equal_iter = equal_head;
diff --git a/cpp-algorithm/src/linkedlist/reverse_list.cpp b/cpp-algorithm/src/linkedlist/reverse_list.cpp
@@ -5,7 +5,7 @@
 auto ReverseList::ReverseSubList(std::shared_ptr<LinkedList::Node<int>> list, int start, const int finish)
     -> std::shared_ptr<LinkedList::Node<int>>
 {
-    auto dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, std::move(list)});
+    const auto dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, std::move(list)});
     auto sublist_head = dummy_head;
 
     int k = 1;
@@ -14,7 +14,7 @@ auto ReverseList::ReverseSubList(std::shared_ptr<LinkedList::Node<int>> list, in
         sublist_head = sublist_head->next;
     }
 
-    auto sublist_iter = sublist_head->next;
+    const auto sublist_iter = sublist_head->next;
     while (start++ < finish)
     {
         auto temp = sublist_iter->next;
diff --git a/cpp-algorithm/src/math/permutation.cpp b/cpp-algorithm/src/math/permutation.cpp
@@ -56,13 +56,13 @@ auto Permutation::InversePermutation(const std::vector<int>& permutation, const
 
 auto Permutation::NextPermutation(std::vector<int>& permutation) -> std::vector<int>
 {
-    auto inversionPoint = std::is_sorted_until(permutation.rbegin(), permutation.rend());
+    const auto inversionPoint = std::is_sorted_until(permutation.rbegin(), permutation.rend());
     if (inversionPoint == permutation.rend())
     {
         return {};
     }
 
-    auto leastUpperBound = std::upper_bound(permutation.rbegin(), inversionPoint, *inversionPoint);
+    const auto leastUpperBound = std::upper_bound(permutation.rbegin(), inversionPoint, *inversionPoint);
 
     std::iter_swap(inversionPoint, leastUpperBound);
     std::reverse(permutation.rbegin(), inversionPoint);
@@ -72,13 +72,13 @@ auto Permutation::NextPermutation(std::vector<int>& permutation) -> std::vector<
 
 auto Permutation::PreviousPermutation(std::vector<int>& permutation) -> std::vector<int>
 {
-    auto inversionPoint = std::is_sorted_until(permutation.rbegin(), permutation.rend(), std::greater<>());
+    const auto inversionPoint = std::is_sorted_until(permutation.rbegin(), permutation.rend(), std::greater<>());
     if (inversionPoint == permutation.rend())
     {
         return {};
     }
 
-    auto leastUpperBound = std::upper_bound(permutation.rbegin(), inversionPoint, *inversionPoint, std::greater<>());
+    const auto leastUpperBound = std::upper_bound(permutation.rbegin(), inversionPoint, *inversionPoint, std::greater<>());
 
     std::iter_swap(inversionPoint, leastUpperBound);
     std::reverse(permutation.rbegin(), inversionPoint);
diff --git a/cpp-algorithm/src/primitive/compute_parity.cpp b/cpp-algorithm/src/primitive/compute_parity.cpp
@@ -49,7 +49,7 @@ auto ComputingParity::ParityLookupTable(const unsigned long long x) -> short
 {
     constexpr int mask_size = 16;
     constexpr int bit_mask = 0xFFFF;
-    static auto precomputed_parity = BuildTable();
+    static std::array<short, 1 << 16> precomputed_parity = BuildTable();
 
     return precomputed_parity[x >> (3 * mask_size)]
            ^ precomputed_parity[(x >> (2 * mask_size)) & bit_mask]
diff --git a/cpp-algorithm/src/primitive/integer_palindrome.cpp b/cpp-algorithm/src/primitive/integer_palindrome.cpp
@@ -10,7 +10,7 @@ auto IntegerPalindrome::IsPalindromeNumber(int x) -> bool
     }
 
     const int num_digits = static_cast<int>(std::floor(log10(x))) + 1;
-    auto msd_mask = static_cast<int>(std::pow(10, num_digits - 1));
+    int msd_mask = static_cast<int>(std::pow(10, num_digits - 1));
 
     for (int i = 0; i < (num_digits / 2); ++i)
     {
diff --git a/cpp-algorithm/src/search/search_sorted_array.cpp b/cpp-algorithm/src/search/search_sorted_array.cpp
@@ -58,7 +58,7 @@ auto SearchSortedArray::SearchEntryEqualToItsIndex(const std::vector<int>& array
 
     while (left <= right)
     {
-        auto mid = left + ((right - left) / 2);
+        int mid = left + ((right - left) / 2);
         if (array[mid] > mid)
         {
             right = mid - 1;
diff --git a/cpp-algorithm/src/sort/intersect_two_sorted_array.cpp b/cpp-algorithm/src/sort/intersect_two_sorted_array.cpp
@@ -35,8 +35,8 @@ std::vector<int> IntersectTwoSortedArray::IntersectTwoSortedArray(const std::vec
                                                                   const std::vector<int>& arr2)
 {
     std::vector<int> intersection;
-    auto i = 0;
-    auto j = 0;
+    int i = 0;
+    int j = 0;
     while (i < static_cast<int>(arr1.size()) && j < static_cast<int>(arr2.size()))
     {
         if (arr1[i] == arr2[j] && (i == 0 || arr1[i] != arr1[i - 1]))
diff --git a/cpp-algorithm/src/string/convert_string.cpp b/cpp-algorithm/src/string/convert_string.cpp
@@ -27,7 +27,7 @@ auto ConvertString::IntToString(int number) -> std::string
 
 auto ConvertString::StringToInt(const std::string& str) -> int
 {
-    auto number = 0;
+    int number = 0;
     for (char i : str)
     {
         number = (number * 10) + (i - '0');
diff --git a/cpp-algorithm/src/tree/b_tree.cpp b/cpp-algorithm/src/tree/b_tree.cpp
@@ -2,28 +2,28 @@
 
 void BTree::Tree::SplitChild(Node* node, int index)
 {
-    auto left_child = node->children[index];
+    Node* left_child = node->children[index];
 
     // create a right child node,
     // and split keys, children of the left child node
 
     // create right child
-    auto right_child = new Node{};
+    Node* right_child = new Node{};
     right_child->is_leaf = left_child->is_leaf;
 
     // split keys of the left child
     // copy keys from median+1 to the end
-    auto right_keys = std::vector<char>(left_child->keys.begin() + degree, left_child->keys.end());
+    std::vector<char> right_keys = std::vector<char>(left_child->keys.begin() + degree, left_child->keys.end());
     right_child->keys = std::move(right_keys);
     // get median key
-    auto median_key = left_child->keys[degree - 1];
+    const char median_key = left_child->keys[degree - 1];
     // erase keys from median to the end
     left_child->keys.erase(left_child->keys.begin() + degree - 1, left_child->keys.end());
 
     // split children of the left child
     if (left_child->is_leaf == false)
     {
-        auto right_children = std::vector<Node*>(left_child->children.begin() + degree, left_child->children.end());
+        std::vector<Node*> right_children = std::vector<Node*>(left_child->children.begin() + degree, left_child->children.end());
         right_child->children = std::move(right_children);
         left_child->children.erase(left_child->children.begin() + degree, left_child->children.end());
     }
@@ -75,11 +75,11 @@ void BTree::Tree::InsertNonFull(Node* node, char key)
 
 void BTree::Tree::Insert(Node* node, char key)
 {
-    auto root_node = node;
+    Node* root_node = node;
 
     if (static_cast<int>(node->keys.size()) == 2 * degree - 1)
     {
-        auto new_node = new Node{};
+        Node* new_node = new Node{};
         root = new_node;
         new_node->is_leaf = false;
         new_node->children.push_back(root_node);
diff --git a/cpp-algorithm/src/tree/lowest_common_ancestor.cpp b/cpp-algorithm/src/tree/lowest_common_ancestor.cpp
@@ -53,7 +53,7 @@ auto LowestCommonAncestor::FindLowestCommonAncestor2(const BinaryTree::ExtendedN
         std::swap(iter1, iter2);
     }
 
-    auto depth_diff = std::abs(depth1 - depth2);
+    int depth_diff = std::abs(depth1 - depth2);
     while (depth_diff--)
     {
         iter1 = iter1->parent;

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`auto DutchFlag::DutchFlagPartition1(const int pivot_index, std::vector<Color>& arr) -> std::vector<Color>`
`4`	`4`	`{`
`5`		`- const auto pivot = arr[pivot_index];`
	`5`	`+ const Color pivot = arr[pivot_index];`
`6`	`6`
`7`	`7`	`for (int i = 0; i < static_cast<Color>(arr.size()); ++i)`
`8`	`8`	`{`
`@@ -32,7 +32,7 @@ auto DutchFlag::DutchFlagPartition1(const int pivot_index, std::vector<Color>& a`
`32`	`32`
`33`	`33`	`auto DutchFlag::DutchFlagPartition2(const int pivot_index, std::vector<Color>& arr) -> std::vector<Color>`
`34`	`34`	`{`
`35`		`- const auto pivot = arr[pivot_index];`
	`35`	`+ const Color pivot = arr[pivot_index];`
`36`	`36`
`37`	`37`	`int smaller = 0;`
`38`	`38`	`for (int i = 0; i < static_cast<Color>(arr.size()); ++i)`
`@@ -57,7 +57,7 @@ auto DutchFlag::DutchFlagPartition2(const int pivot_index, std::vector<Color>& a`
`57`	`57`
`58`	`58`	`auto DutchFlag::DutchFlagPartition3(const int pivot_index, std::vector<Color>& arr) -> std::vector<Color>`
`59`	`59`	`{`
`60`		`- const auto pivot = arr[pivot_index];`
	`60`	`+ const Color pivot = arr[pivot_index];`
`61`	`61`
`62`	`62`	`int smaller = 0;`
`63`	`63`	`int equal = 0;`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ auto StockTrading::BuyAndSellStockOnce(const std::vector<int>& prices) -> double`
`27`	`27`
`28`	`28`	`for (double price : prices)`
`29`	`29`	`{`
`30`		`- auto max_profit_sell_today = price - min_price_so_far;`
	`30`	`+ double max_profit_sell_today = price - min_price_so_far;`
`31`	`31`	`max_profit = std::max(max_profit, max_profit_sell_today);`
`32`	`32`	`min_price_so_far = std::min(min_price_so_far, price);`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ void Dijkstra::Graph::DijkstraAlgorithm(Vertex& source)`
`29`	`29`	`void Dijkstra::Graph::ReorderQueue(std::priority_queue<Vertex, std::vector<Vertex>, MinComparator>& min_queue)`
`30`	`30`	`{`
`31`	`31`	`auto queue = std::priority_queue<Vertex, std::vector<Vertex>, MinComparator>{};`
`32`		`- const auto min_queue_size = static_cast<int>(min_queue.size());`
	`32`	`+ const int min_queue_size = static_cast<int>(min_queue.size());`
`33`	`33`
`34`	`34`	`for (int i = 0; i < min_queue_size; ++i)`
`35`	`35`	`{`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ auto ActivitySelection::RecursiveActivitySelector(const std::vector<int>& start,`
`15`	`15`
`16`	`16`	`if (sub_index < size)`
`17`	`17`	`{`
`18`		`- auto activities = RecursiveActivitySelector(start, finish, sub_index, size);`
	`18`	`+ std::vector<int> activities = RecursiveActivitySelector(start, finish, sub_index, size);`
`19`	`19`	`activities.push_back(sub_index);`
`20`	`20`
`21`	`21`	`return activities;`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ auto SplitIntoWords(const std::string& str) -> std::unordered_map<std::string, i`
`56`	`56`	`auto AnonymousLetter::IsWordConstructibleFromMagazine(const std::string& letter, const std::string& magazine) -> bool`
`57`	`57`	`{`
`58`	`58`	`// count the number of times each word appears in the letter`
`59`		`- auto word_frequency_for_letter = SplitIntoWords(letter);`
	`59`	`+ std::unordered_map<std::string, int> word_frequency_for_letter = SplitIntoWords(letter);`
`60`	`60`
`61`	`61`	`// check if the words in magazine can cover words in letter`
`62`	`62`	`for (const auto& [fst, snd] : SplitIntoWords(magazine))`
Original file line number	Diff line number	Diff line change
`@@ -21,13 +21,13 @@ auto CollatzConjecture::GenerateCollatzSequence(const long long number,`
`21`	`21`	`// if number is even, then divide it by 2`
`22`	`22`	`if (number % 2 == 0)`
`23`	`23`	`{`
`24`		`- auto sub_sequence = GenerateCollatzSequence(number / 2, hash_table);`
	`24`	`+ std::vector<long long> sub_sequence = GenerateCollatzSequence(number / 2, hash_table);`
`25`	`25`	`sequence.insert(sequence.end(), sub_sequence.begin(), sub_sequence.end());`
`26`	`26`	`}`
`27`	`27`	`// if number is odd, then multiply it by 3 and add 1`
`28`	`28`	`else`
`29`	`29`	`{`
`30`		`- auto sub_sequence = GenerateCollatzSequence(number * 3 + 1, hash_table);`
	`30`	`+ std::vector<long long> sub_sequence = GenerateCollatzSequence(number * 3 + 1, hash_table);`
`31`	`31`	`sequence.insert(sequence.end(), sub_sequence.begin(), sub_sequence.end());`
`32`	`32`	`}`
`33`	`33`
`@@ -42,7 +42,7 @@ auto CollatzConjecture::FindNumbersSatisfyingCollatzConjecture(const long long n`
`42`	`42`	`for (long long i = 1LL; i < number; ++i)`
`43`	`43`	`{`
`44`	`44`	`// if the Collatz sequence ends with 1, then satisfies the Collatz conjecture`
`45`		`- if (auto sequence = GenerateCollatzSequence(i, hash_table); sequence.back() == 1)`
	`45`	`+ if (std::vector<long long> sequence = GenerateCollatzSequence(i, hash_table); sequence.back() == 1)`
`46`	`46`	`{`
`47`	`47`	`satisfied_numbers.push_back(i);`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ auto FindAnagram::FindAnagramMappings(const std::vector<std::string>& dictionary`
`9`	`9`	`std::unordered_map<std::string, std::vector<std::string>> dictionary_map;`
`10`	`10`	`for (const std::string& word : dictionary)`
`11`	`11`	`{`
`12`		`- auto sorted_word = word;`
	`12`	`+ std::string sorted_word = word;`
`13`	`13`	`std::ranges::sort(sorted_word);`
`14`	`14`	`dictionary_map[sorted_word].emplace_back(word);`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,8 @@ auto SmallestSubarray::FindSmallestSubarrayCoveringSubset(const std::vector<std:`
`14`	`14`	`++keywords_to_cover[keyword];`
`15`	`15`	`}`
`16`	`16`
`17`		`- auto result = std::make_tuple(-1, -1);`
`18`		`- auto remaining_to_cover = keywords.size();`
	`17`	`+ std::tuple<int, int> result = std::make_tuple(-1, -1);`
	`18`	`+ size_t remaining_to_cover = keywords.size();`
`19`	`19`
`20`	`20`	`for (int left_index = 0, right_index = 0; right_index < static_cast<int>(paragraph.size()); ++right_index)`
`21`	`21`	`{`
`@@ -72,11 +72,11 @@ auto SmallestSubarray::FindSmallestSubarraySequentiallyCoveringSubset(const std:`
`72`	`72`	`keywords_to_index[keywords[i]] = i;`
`73`	`73`	`}`
`74`	`74`
`75`		`- auto last_occurrence = std::vector(keywords.size(), -1);`
`76`		`- auto shortest_subarray_length = std::vector(keywords.size(), std::numeric_limits<int>::max());`
	`75`	`+ std::vector<int> last_occurrence = std::vector(keywords.size(), -1);`
	`76`	`+ std::vector<int> shortest_subarray_length = std::vector(keywords.size(), std::numeric_limits<int>::max());`
`77`	`77`
`78`	`78`	`int shortest_distance = std::numeric_limits<int>::max();`
`79`		`- auto result = std::make_tuple(-1, -1);`
	`79`	`+ std::tuple<int, int> result = std::make_tuple(-1, -1);`
`80`	`80`
`81`	`81`	`for (int i = 0; i < static_cast<int>(paragraph.size()); ++i)`
`82`	`82`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ auto ClosestStar::FindClosestStar(std::vector<Star>& stars, const int k) -> std:`
`8`	`8`
`9`	`9`	`while (!stars.empty())`
`10`	`10`	`{`
`11`		`- auto star = stars.back();`
	`11`	`+ Star star = stars.back();`
`12`	`12`	`stars.pop_back();`
`13`	`13`
`14`	`14`	`if (static_cast<int>(max_heap.size()) < k)`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ void DeleteListNode::DeleteNodeFromList(std::shared_ptr<LinkedList::Node<int>>&`
`9`	`9`	`auto DeleteListNode::DeleteNodeKthLast(std::shared_ptr<LinkedList::Node<int>>& list, int k)`
`10`	`10`	`-> std::shared_ptr<LinkedList::Node<int>>`
`11`	`11`	`{`
`12`		`- auto dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, list});`
	`12`	`+ const auto dummy_head = std::make_shared<LinkedList::Node<int>>(LinkedList::Node<int>{0, list});`
`13`	`13`
`14`	`14`	`auto precede = dummy_head->next;`
`15`	`15`	`while (k--)`