# flat\_map

***

**1. Flatten a Vector of Vectors**

```cpp
#include <vector>
#include <iostream>
#include <algorithm>

int main() {
  std::vector<std::vector<int>> v = {{1, 2}, {3, 4}, {5, 6}};

  std::vector<int> flattened = std::vector<int>(v.size() * v[0].size());
  std::transform(v.begin(), v.end(), flattened.begin(),
                 [](const std::vector<int>& inner) { return inner.begin(); });

  for (int num : flattened) {
    std::cout << num << " ";
  }

  return 0;
}
```

**2. Flatten a Map of Vectors**

```cpp
#include <map>
#include <vector>
#include <iostream>
#include <algorithm>

int main() {
  std::map<std::string, std::vector<int>> m = {{"a", {1, 2}}, {"b", {3, 4}}, {"c", {5, 6}}};

  std::vector<int> flattened = std::vector<int>();
  for (auto pair : m) {
    flattened.insert(flattened.end(), pair.second.begin(), pair.second.end());
  }

  for (int num : flattened) {
    std::cout << num << " ";
  }

  return 0;
}
```

**3. Flatten a Set of Vectors**

```cpp
#include <set>
#include <vector>
#include <iostream>
#include <algorithm>

int main() {
  std::set<std::vector<int>> s = {{1, 2}, {3, 4}, {5, 6}};

  std::vector<int> flattened = std::vector<int>();
  for (auto inner : s) {
    flattened.insert(flattened.end(), inner.begin(), inner.end());
  }

  for (int num : flattened) {
    std::cout << num << " ";
  }

  return 0;
}
```

**4. Flatten a List of Tuples**

```cpp
#include <list>
#include <tuple>
#include <iostream>
#include <algorithm>

int main() {
  std::list<std::tuple<int, int>> l = {{1, 2}, {3, 4}, {5, 6}};

  std::vector<int> flattened = std::vector<int>();
  std::transform(l.begin(), l.end(), std::back_inserter(flattened),
                 [](const std::tuple<int, int>& t) { return std::get<0>(t); });

  for (int num : flattened) {
    std::cout << num << " ";
  }

  return 0;
}
```

**5. Flatten a Vector of Optionals**

```cpp
#include <vector>
#include <optional>
#include <iostream>
#include <algorithm>

int main() {
  std::vector<std::optional<int>> v = {{1}, {2}, {std::nullopt}, {4}, {5}};

  std::vector<int> flattened = std::vector<int>();
  std::transform(v.begin(), v.end(), std::back_inserter(flattened),
                 [](const std::optional<int>& o) { return o.value(); });

  for (int num : flattened) {
    std::cout << num << " ";
  }

  return 0;
}
```

**6. Flatten a Map of Optionals**

```cpp
#include <map>
#include <optional>
#include <iostream>
#include <algorithm>

int main() {
  std::map<std::string, std::optional<int>> m = {{"a", 1}, {"b", 2}, {"c", std::nullopt}, {"d", 4}, {"e", 5}};

  std::vector<int> flattened = std::vector<int>();
  for (auto pair : m) {
    if (pair.second.has_value()) {
      flattened.push_back(pair.second.value());
    }
  }

  for (int num : flattened) {
    std::cout << num << " ";
  }

  return 0;
}
```

**7. Flatten a Set of Optionals**

```cpp
#include <set>
#include <optional>
#include <iostream>
#include <algorithm>

int main() {
  std::set<std::optional<int>> s = {{1}, {2}, {std::nullopt}, {4}, {5}};

  std::vector<int> flattened = std::vector<int>();
  for (auto o : s) {
    if (o.has_value()) {
      flattened.push_back(o.value());
    }
  }

  for (int num : flattened) {
    std::cout << num << " ";
  }

  return 0;
}
```

**8. Flatten a List of Iterables**

```cpp
#include <list>
#include <vector>
#include <iostream>
#include <algorithm>

int main() {
  std::list<std::vector<int>> l = {{1, 2}, {3, 4}, {5, 6}};

  std::vector<int> flattened = std::vector<int>();
  std::transform(l.begin(), l.end(), std::back_inserter(flattened),
                 [](const std::vector<int>& v) { return v.begin(); });

  for (int num : flattened) {
    std::cout << num << " ";
  }

  return 0;
}
```

**9. Flatten a Vector of Pairs**

```cpp
#include <vector>
#include <pair>
#include <iostream>
#include <algorithm>

int main() {
  std::vector<std::pair<int, int>> v = {{1, 2}, {3, 4}, {5, 6}};

  std::vector<int> flattened = std::vector<int>();
  std::transform(v.begin(), v.end(), std::back_inserter(flattened),
                 [](const std::pair<int, int>& p) { return p.first; });

  for (int num : flattened) {
    std::cout << num << " ";
  }

  return 0;
}
```

**10. Flatten a Map of Pairs**

```cpp
#include <map>
#include <pair>
#include <iostream>
#include <algorithm>

int main() {
  std::map<std::string, std::pair<int, int>> m = {{"a", {1, 2}}, {"b", {3

```