stuff from comp

src/main-utd-bob-spring-q1.cpp

@@ -0,0 +1,43 @@
+
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <iterator>
+#include <sstream>
+#include <string>
+#include <vector>
+std::vector<float> read_input() {
+  std::ios::sync_with_stdio(false);
+  std::cin.tie(nullptr);
+
+  std::string line = std::string{};
+  std::getline(std::cin, line);
+
+  std::istringstream iss = std::istringstream{line};
+
+  return std::vector<float>{std::istream_iterator<float>{iss},
+                            std::istream_iterator<float>{}};
+}
+
+int main(int argc, char *argv[]) {
+  std::vector<float> input = read_input();
+
+  input.erase(std::remove_if(input.begin(), input.end(),
+                             [](uint32_t x) { return x == 0; }),
+              input.end());
+  switch (input.size()) {
+  case 0:
+    std::printf("%.2f", (float)24);
+    break;
+  case 2:
+    std::printf("%.2f", input.at(0) + input.at(1) +
+                            (416 - input.at(0) - input.at(1)) / 50);
+    break;
+  case 1:
+    std::printf("%.2f", input.at(0) + 2 * ((416 - input.at(0)) / (51)));
+    break;
+  case 3:
+    std::printf("%.2f", input.at(0) + input.at(1) + input.at(2));
+    break;
+  }
+}

src/main-utd-bob-spring-q2.cpp

@@ -0,0 +1,49 @@
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <sys/types.h>
+#include <vector>
+
+std::vector<int> read_input() {
+  std::ios::sync_with_stdio(false);
+  std::cin.tie(nullptr);
+
+  std::string line = std::string{};
+  std::getline(std::cin, line);
+  std::getline(std::cin, line);
+  std::istringstream iss = std::istringstream{line};
+
+  return std::vector<int>{std::istream_iterator<int>{iss},
+                          std::istream_iterator<int>{}};
+}
+int main(int argc, char *argv[]) {
+  std::vector<int> input = read_input();
+  if (input.size() < 2) {
+    std::printf("0");
+    return 0;
+  }
+
+  for (int i = 0; i < static_cast<int>(input.size()); i++) {
+    input[i] = input[i] - i;
+  }
+
+  int current_max = std::numeric_limits<int>::min();
+  for (size_t i = 1; i < input.size(); i++) {
+    auto iter_delim = input.cbegin() + i;
+    int max_end_stub = *std::max_element(iter_delim, input.cend());
+    int min_start_stub = *std::min_element(input.cbegin(), iter_delim);
+    int difference = max_end_stub - min_start_stub;
+    current_max = std::max(difference, current_max);
+  }
+
+  std::printf("%d", current_max);
+
+  return 0;
+}

src/main-utd-bob-spring-tmie.cpp

@@ -0,0 +1,82 @@
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <iostream>
+#include <iterator>
+#include <map>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+struct TmieInput {
+  uint32_t rows;
+  uint32_t columns;
+  std::shared_ptr<std::vector<std::vector<uint32_t>>> graph;
+};
+
+TmieInput pull_input() {
+  uint32_t rows;
+  uint32_t columns;
+  std::cin >> rows;
+  std::cin >> columns;
+
+  std::shared_ptr<std::vector<std::vector<uint32_t>>> graph =
+      std::make_shared<std::vector<std::vector<uint32_t>>>(
+          rows, std::vector<uint32_t>(columns));
+  for (uint32_t i = 0; i < rows; i++) {
+    for (uint32_t j = 0; j < columns; j++) {
+      (*graph)[i][j] = 0;
+      std::cin >> (*graph)[i][j];
+    }
+  }
+  return TmieInput{rows, columns, graph};
+}
+
+void clear_island_dfs(uint32_t target, uint32_t r, uint32_t c,
+                      std::shared_ptr<std::vector<std::vector<uint32_t>>> data) {
+  std::vector<std::pair<uint32_t, uint32_t>> stack = {{r, c}};
+  while (!stack.empty()) {
+    const auto [current_r, current_c] = stack.back();
+    stack.pop_back();
+
+    if (current_r >= data->size() || current_c >= data->at(current_r).size())
+      continue;
+    if (data->at(current_r)[current_c] != target)
+      continue;
+
+    data->at(current_r)[current_c] = 0;
+    if (current_r > 0)
+      stack.push_back({current_r - 1, current_c});
+    if (current_c > 0)
+      stack.push_back({current_r, current_c - 1});
+    stack.push_back({current_r + 1, current_c});
+    stack.push_back({current_r, current_c + 1});
+  }
+}
+int main(int argc, char *argv[]) {
+  std::ios::sync_with_stdio(false);
+  std::cin.tie(nullptr);
+  TmieInput input = pull_input();
+  std::map<uint32_t, uint32_t> terrain_counts = {};
+  for (uint32_t i = 0; i < input.rows; i++) {
+    for (uint32_t j = 0; j < input.columns; j++) {
+      const uint32_t terrain_type = input.graph->at(i)[j];
+      if (terrain_type == 0)
+        continue;
+
+      clear_island_dfs(terrain_type, i, j, input.graph);
+      terrain_counts[terrain_type] = terrain_counts[terrain_type] + 1;
+    }
+  }
+  if (terrain_counts.size() == 0)
+    std::printf("0");
+  for (auto iterator = terrain_counts.cbegin();
+       iterator != terrain_counts.cend(); iterator++) {
+    std::printf("%d %d \n", iterator->first, iterator->second);
+  }
+  return 0;
+}