# ranges

***

**1. Iterate Over a Container with a Range-Based for Loop**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};

for (int num : vec) {
    std::cout << num << " ";  // Output: 1 2 3 4 5
}
```

**2. Iterate Over a Subrange of a Container**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

for (int num : vec | std::views::drop(2) | std::views::take(5)) {
    std::cout << num << " ";  // Output: 3 4 5 6 7
}
```

**3. Iterate Over a Range of Integers**

```cpp
for (int i : std::ranges::iota_view(0, 10)) {
    std::cout << i << " ";  // Output: 0 1 2 3 4 5 6 7 8 9
}
```

**4. Iterate Over a Range of Characters**

```cpp
for (char c : std::ranges::iota_view('a', 'z' + 1)) {
    std::cout << c << " ";  // Output: a b c d e f g h i j k l m n o p q r s t u v w x y z
}
```

**5. Iterate Over a Range of Pairs**

```cpp
std::vector<std::pair<int, char>> pairs = {{1, 'a'}, {2, 'b'}, {3, 'c'}};

for (auto& pair : pairs) {
    std::cout << pair.first << " " << pair.second << "\n";  // Output: 1 a\n2 b\n3 c
}
```

**6. Iterate Over a Map**

```cpp
std::map<int, std::string> map = {{1, "one"}, {2, "two"}, {3, "three"}};

for (auto& [key, value] : map) {
    std::cout << key << " " << value << "\n";  // Output: 1 one\n2 two\n3 three
}
```

**7. Iterate Over a Set**

```cpp
std::set<int> set = {1, 2, 3, 4, 5};

for (int num : set) {
    std::cout << num << " ";  // Output: 1 2 3 4 5
}
```

**8. Iterate Over a Range of Indices**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};

for (std::size_t i : std::views::indices(vec)) {
    std::cout << i << " ";  // Output: 0 1 2 3 4
}
```

**9. Iterate Over a Range of Sizes**

```cpp
std::array<int, 5> arr;

for (std::size_t i : std::views::sizes(arr)) {
    std::cout << i << " ";  // Output: 5
}
```

**10. Iterate Over a Collection of Objects with a Member Function**

```cpp
struct Point {
    int x;
    int y;
};

std::vector<Point> points = {{1, 2}, {3, 4}, {5, 6}};

for (auto& point : points | std::views::transform(&Point::x)) {
    std::cout << point << " ";  // Output: 1 3 5
}
```

**11. Iterate Over a Range of Integers in Decreasing Order**

```cpp
for (int i : std::ranges::iota_view(10, 0, -1)) {
    std::cout << i << " ";  // Output: 10 9 8 7 6 5 4 3 2 1
}
```

**12. Iterate Over a Range of Characters in Reverse Order**

```cpp
for (char c : std::ranges::iota_view('z', 'a' - 1, -1)) {
    std::cout << c << " ";  // Output: z y x w v u t s r q p o n m
}
```

**13. Iterate Over a Range of Pairs in Reverse Order**

```cpp
std::vector<std::pair<int, char>> pairs = {{1, 'a'}, {2, 'b'}, {3, 'c'}};

for (auto& pair : pairs | std::views::reverse) {
    std::cout << pair.first << " " << pair.second << "\n";  // Output: 3 c\n2 b\n1 a
}
```

**14. Iterate Over a Map in Reverse Order**

```cpp
std::map<int, std::string> map = {{1, "one"}, {2, "two"}, {3, "three"}};

for (auto& [key, value] : map | std::views::reverse) {
    std::cout << key << " " << value << "\n";  // Output: 3 three\n2 two\n1 one
}
```

**15. Iterate Over a Set in Reverse Order**

```cpp
std::set<int> set = {1, 2, 3, 4, 5};

for (int num : set | std::views::reverse) {
    std::cout << num << " ";  // Output: 5 4 3 2 1
}
```

**16. Iterate Over a Range of Integers with a Stride**

```cpp
for (int i : std::ranges::iota_view(0, 10, 2)) {
    std::cout << i << " ";  // Output: 0 2 4 6 8
}
```

**17. Iterate Over a Range of Characters with a Stride**

```cpp
for (char c : std::ranges::iota_view('a', 'z' + 1, 3)) {
    std::cout << c << " ";  // Output: a d g j m p u x
}
```

**18. Iterate Over a Range of Pairs with a Stride**

```cpp
std::vector<std::pair<int, char>> pairs = {{1, 'a'}, {2, 'b'}, {3, 'c'}};

for (auto& pair : pairs | std::views::stride(2)) {
    std::cout << pair.first << " " << pair.second << "\n";  // Output: 1 a\n3 c
}
```

**19. Iterate Over a Map with a Stride**

```cpp
std::map<int, std::string> map = {{1, "one"}, {2, "two"}, {3, "three"}};

for (auto& [key, value] : map | std::views::stride(2)) {
    std::cout << key << " " << value << "\n";  // Output: 1 one\n3 three
}
```

**20. Iterate Over a Set with a Stride**

```cpp
std::set<int> set = {1, 2, 3, 4, 5};

for (int num : set | std::views::stride(2)) {
    std::cout << num << " ";  // Output: 1 3 5
}
```

**21. Iterate Over a Range of Integers with a Filter**

```cpp
for (int i : std::ranges::iota_view(0, 10) | std::views::filter([](int i) { return i % 2 == 0; })) {
    std::cout << i << " ";  // Output: 0 2 4 6 8
}
```

**22. Iterate Over a Range of Characters with a Filter**

```cpp
for (char c : std::ranges::iota_view('a', 'z' + 1) | std::views::filter([](char c) { return c % 2 == 0; })) {
    std::cout << c << " ";  // Output: b d f h j l n p r t v x z
}
```

**23. Iterate Over a Range of Pairs with a Filter**

```cpp
std::vector<std::pair<int, char>> pairs = {{1, 'a'}, {2, 'b'}, {3, 'c'}};

for (auto& pair : pairs | std::views::filter([](const auto& pair) { return pair.second % 2 == 0; })) {
    std::cout << pair.first << " " << pair.second << "\n";  // Output: 2 b
}
```

**24. Iterate Over a Map with a Filter**

```cpp
std::map<int, std::string> map = {{1, "one"}, {2, "two"}, {3, "three"}};

for (auto& [key, value] : map | std::views::filter([](const auto& pair) { return pair.second == "two"; })) {
    std::cout << key << " " << value << "\n";  // Output: 2 two
}
```

**25. Iterate Over a Set with a Filter**

```cpp
std::set<int> set = {1, 2, 3, 4, 5};

for (int num : set | std::views::filter([](int num) { return num % 2 == 0; })) {
    std::cout << num << " ";  // Output: 2 4
}
```

**26. Iterate Over a Range of Integers with a Transform**

```cpp
for (int i : std::ranges::iota_view(0, 10) | std::views::transform([](int i) { return i * i; })) {
    std::cout << i << " ";  // Output: 0 1 4 9 16 25 36 49 64 81
}
```

**27. Iterate Over a Range of Characters with a Transform**

```cpp
for (char c : std::ranges::iota_view('a', 'z' + 1) | std::views::transform([](char c) { return std::toupper(c); })) {
    std::cout << c << " ";  // Output: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
}
```

**28. Iterate Over a Range of Pairs with a Transform**

```cpp
std::vector<std::pair<int, char>> pairs = {{1, 'a'}, {2, 'b'}, {3, 'c'}};

for (auto& pair : pairs | std::views::transform([](const auto& pair) { return std::make_pair(pair.second, pair.first); })) {
    std::cout << pair.first << " " << pair.second << "\n";  // Output: a 1\nb 2\nc 3
}
```

**29. Iterate Over a Map with a Transform**

```cpp
std::map<int, std::string> map = {{1, "one"}, {2, "two"}, {3, "three"}};

for (auto& [key, value] : map | std::views::transform([](const auto& pair) { return std::make_pair(value, key); })) {
    std::cout << key << " " << value << "\n";  // Output: one 1\ntwo 2\nthree 3
}
```

**30. Iterate Over a Set with a Transform**

```cpp
std::set<int> set = {1, 2, 3, 4, 5};

```