diff --git a/day5/ProgrammingInCXX_d5.pdf b/ProgrammingInC++_2023.pdf
similarity index 58%
rename from day5/ProgrammingInCXX_d5.pdf
rename to ProgrammingInC++_2023.pdf
index 865b560d569fc61e5b27cd3d2e5f184a5a914578..b14e1b29de99feceb625fdda5d2fe969509452c5 100644
Binary files a/day5/ProgrammingInCXX_d5.pdf and b/ProgrammingInC++_2023.pdf differ
diff --git a/day5/ProgrammingInC++_Book.pdf b/ProgrammingInC++_Book.pdf
similarity index 100%
rename from day5/ProgrammingInC++_Book.pdf
rename to ProgrammingInC++_Book.pdf
diff --git a/day1/ProgrammingInCXX_d1.pdf b/day1/ProgrammingInCXX_d1.pdf
deleted file mode 100644
index 5946f9f685d60a947f722599d83a5f729646f1a5..0000000000000000000000000000000000000000
Binary files a/day1/ProgrammingInCXX_d1.pdf and /dev/null differ
diff --git a/day2/ProgrammingInCXX_d2.pdf b/day2/ProgrammingInCXX_d2.pdf
deleted file mode 100644
index 2650aaa10c7806d2e5ac74195503568bf8d72dcf..0000000000000000000000000000000000000000
Binary files a/day2/ProgrammingInCXX_d2.pdf and /dev/null differ
diff --git a/day2/examples/gcd.cc b/day2/examples/gcd.cc
deleted file mode 100644
index 63ccfae22a9756596a4e5f5238a5e9187110c73b..0000000000000000000000000000000000000000
--- a/day2/examples/gcd.cc
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <iostream>
-
-unsigned long euclid_gcd(unsigned long smaller, unsigned long larger)
-{
- if (smaller > larger)
- std::swap(smaller, larger);
- while (smaller != 0) {
- auto rem = larger % smaller;
- larger = smaller;
- smaller = rem;
- }
- return larger;
-}
-
-int main(int argc, char* argv[])
-{
- if (argc != 3) {
- std::cout << "Usage:\n"
- << argv[0] << " number1 number2\n";
- return 1;
- }
- unsigned long n1 = std::stoul(argv[1]), n2 = std::stoul(argv[2]);
- std::cout << euclid_gcd(n1, n2) << "\n";
-}
diff --git a/day3/ProgrammingInCXX_d3.pdf b/day3/ProgrammingInCXX_d3.pdf
deleted file mode 100644
index 6cdb2d36c6a6029045422612e6422d35a1220ef7..0000000000000000000000000000000000000000
Binary files a/day3/ProgrammingInCXX_d3.pdf and /dev/null differ
diff --git a/day4/ProgrammingInCXX_d4.pdf b/day4/ProgrammingInCXX_d4.pdf
deleted file mode 100644
index 9a5e01c9c3ae7d139326b0dd655c5d337b65ea36..0000000000000000000000000000000000000000
Binary files a/day4/ProgrammingInCXX_d4.pdf and /dev/null differ
diff --git a/day5/examples/birthday_problem.cc b/day5/examples/birthday_problem.cc
deleted file mode 100644
index 334e9c2dd9bd3999f2b826d0bac6b78517628cd0..0000000000000000000000000000000000000000
--- a/day5/examples/birthday_problem.cc
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <random>
-#include <iostream>
-#include <vector>
-#include <algorithm>
-#include <ranges>
-#include <execution>
-#include <limits>
-#include <atomic>
-#include "CountingIterator.hh"
-#include <numeric>
-// #include <tbb/scalable_allocator.h>
-
-/*
- * Run it first as it is. Then, try replacing the vector type with the
- * scalable allocator type from the Threading Building Blocks (TBB).
- * Then do the modification suggested in the function
- * probability_for_equal_birthdays(). Run the program in each variant
- * and check how long it takes by using the time command:
- *
- * time executablename [OPTIONS]
- *
- */
-namespace sr = std::ranges;
-namespace sv = std::views;
-
-template <class T>
-// using VectorType = std::vector<T, tbb::scalable_allocator<T>>;
-using VectorType = std::vector<T>;
-
-auto sample_group(size_t n) -> VectorType<int>
-{
- VectorType<int> grp(n, 0);
- static thread_local std::mt19937_64 eng{ std::random_device{}() };
- static thread_local std::uniform_int_distribution<> dist{ 0, 365 };
- auto birthdays = [&]{ return dist(eng); };
- std::generate(grp.begin(), grp.end(), birthdays);
- return grp;
-}
-
-auto probability_for_equal_birthdays(size_t group_size, size_t nexpt = 10'000'000UL) -> double
-{
- // transform_reduce(start, end, init, accumulator_op, transform_op);
- // That's the normal syntax of transform_reduce. But, there is another
- // overload that takes one extra argument at the front: an execution policy.
- // Add one extra argument to transform_reduce: std::execution::par which
- // specifies a parallel execution policy, and see what happens!
- auto nclashes = std::transform_reduce(algo_counter(0UL), algo_counter(nexpt), 0UL,
- std::plus<size_t>{},
- [&]([[maybe_unused]] auto counter) {
- auto group = sample_group(group_size);
- sr::sort(group);
- auto newend = std::unique(group.begin(), group.end());
- //group.erase(newend, group.end());
- //if (group.size() != group_size) ++nclashes;
- if (newend != group.end()) return 1UL;
- return 0UL;
- });
- return static_cast<double>(nclashes) / nexpt;
-}
-
-auto main(int argc, char* argv[]) -> int
-{
- auto target_group_size = (argc == 1 ? 50UL : std::stoul(argv[1]));
- std::cout << "Group size\tShared birthday probability\n\n";
- for (auto gs = 0UL; gs < target_group_size; ++gs) {
- std::cout << gs << "\t\t" << probability_for_equal_birthdays(gs) << "\n";
- }
-}
-
diff --git a/day5/examples/ranges/ha b/day5/examples/ranges/ha
deleted file mode 100644
index c28786308e237b04f8ffbb1798ffd95ad56e5353..0000000000000000000000000000000000000000
--- a/day5/examples/ranges/ha
+++ /dev/null
@@ -1,11 +0,0 @@
-The ranges library is an extension and generalization of the algorithms and iterator libraries that makes them more powerful by making them composable and less error-prone.
-
-The library creates and manipulates range views, lightweight objects that indirectly represent iterable sequences (ranges). Ranges are an abstraction on top of
-
- [begin, end) iterator pairs, e.g. ranges made by implicit conversion from containers. All algorithms that take iterator pairs now have overloads that accept ranges (e.g ranges::sort)
- [start, size) counted sequences, e.g. range returned by views::counted
- [start, predicate) conditionally-terminated sequences, e.g. range returned by views::take_while
- [start..) unbounded sequences, e.g. range returned by views::iota
-
-The ranges library includes range algorithms, which are applied to ranges eagerly, and range adaptors, which are applied to views lazily. Adaptors can be composed into pipelines, so that their actions take place as the view is iterated.
-