-
Notifications
You must be signed in to change notification settings - Fork 73
/
Copy path286.md
134 lines (109 loc) · 8.64 KB
/
286.md
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
<details open><summary>Info</summary><p>
* **Did you know that Circle supports Python's extended slice syntax for variadic packs?**
* https://docs.python.org/2.3/whatsnew/section-slices.html
* https://github.com/seanbaxter/circle/blob/master/comprehension/README.md
</p></details><details open><summary>Example</summary><p>
```cpp
auto foo(auto... ts) {
// syntax: ...[start:stop:step]
std::cout << ts...[0] << '\n'; // prints first element
((std::cout << ts...[0:2]), ...) << '\n'; // prints frist two elemetns
((std::cout << ts...[::2]), ...) << '\n'; // prints every second
((std::cout << ts...[::-1]), ...) << '\n'; // prints in reverse
}
int main() {
foo(1, 2, 3, 4);
}
```
> https://circle.godbolt.org/z/Pj7E5cPe1
</p></details><details open><summary>Puzzle</summary><p>
* **Can you add missing extened slice expressions on variadic packs to match the requirements?**
```cpp
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3)); // identity
static_assert(std::tuple{2} == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3)); // second
static_assert(std::tuple{3} == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1} == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3} == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4} == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6} == [](auto... ts) { return std::tuple{/*TODO*/}; }(1, 2, 3, 4, 5, 6)); // second half
```
> https://circle.godbolt.org/z/33P78nG7e
</p></details><details><summary>Solutions</summary><p>
```cpp
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3)); // identity
static_assert(std::tuple{2} == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3} == [](auto... ts) { return std::tuple{ts...[2]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1} == [](auto... ts) { return std::tuple{ts...[::-1] ...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3} == [](auto... ts) { return std::tuple{ts...[1:3] ...}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4} == [](auto... ts) { return std::tuple{ts...[1::2] ...}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...[0:sizeof...(ts)/2] ...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6} == [](auto... ts) { return std::tuple{ts...[sizeof...(ts)/2:] ...}; }(1, 2, 3, 4, 5, 6)); // second half
```
> https://circle.godbolt.org/z/Gn8WETGMY
```cpp
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3)); // identity
static_assert(std::tuple{2} == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3} == [](auto... ts) { return std::tuple{ts...[-1]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1} == [](auto... ts) { return std::tuple{ts...[::-1]...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3} == [](auto... ts) { return std::tuple{ts...[-3:]...}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4} == [](auto... ts) { return std::tuple{ts...[1::2]...}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...[:sizeof...(ts)/2]...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6} == [](auto... ts) { return std::tuple{ts...[sizeof...(ts)/2:]...}; }(1, 2, 3, 4, 5, 6)); // second half
```
> https://circle.godbolt.org/z/7b3f5T7bf
```cpp
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3)); // identity
static_assert(std::tuple{2} == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3} == [](auto... ts) { return std::tuple{ts...[-1]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1} == [](auto... ts) { return std::tuple{ts...[::-1]...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3} == [](auto... ts) { return std::tuple{ts...[-3:-1:1]...}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4} == [](auto... ts) { return std::tuple{ts...[1::2]...}; }(1, 2, 3, 4)); // evens
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...[:sizeof...(ts)/2:]...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6} == [](auto... ts) { return std::tuple{ts...[sizeof...(ts)/2::]...}; }(1, 2, 3, 4, 5, 6)); // second half
```
> https://circle.godbolt.org/z/fEdn1G6r7
```cpp
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3)); // identity
static_assert(std::tuple{2} == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3} == [](auto... ts) { return std::tuple{ts...[-1]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1} == [](auto... ts) { return std::tuple{ts...[::-1]...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3} == [](auto... ts) { return std::tuple{ts...[-3:]... /*[-2:]*/}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4} == [](auto... ts) { return std::tuple{ts...[1::2]...}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...[:sizeof...(ts)/2]...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6} == [](auto... ts) { return std::tuple{ts...[sizeof...(ts)/2:]...}; }(1, 2, 3, 4, 5, 6)); // second half
```
> https://circle.godbolt.org/z/rvh4YGnx6
```cpp
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3)); // identity
static_assert(std::tuple{2} == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3} == [](auto... ts) { return std::tuple{ts...[-1]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1} == [](auto... ts) { return std::tuple{ts...[::-1]...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3} == [](auto... ts) { return std::tuple{ts...[1:3]...}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4} == [](auto... ts) { return std::tuple{ts...[1::2]...}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...[:sizeof...(ts) / 2]...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6} == [](auto... ts) { return std::tuple{ts...[sizeof...(ts) / 2:]...}; }(1, 2, 3, 4, 5, 6)); // second half
```
> https://circle.godbolt.org/z/qxbbWv4o1
```cpp
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3)); // identity
static_assert(std::tuple{2} == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3} == [](auto... ts) { return std::tuple{ts...[-1]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1} == [](auto... ts) { return std::tuple{ts...[::-1]...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3} == [](auto... ts) { return std::tuple{ts...[1:]...}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4} == [](auto... ts) { return std::tuple{ts...[1::2]...}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...[:3]...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6} == [](auto... ts) { return std::tuple{ts...[3:]...}; }(1, 2, 3, 4, 5, 6)); // second half
```
> https://circle.godbolt.org/z/sW7hccoE7
```cpp
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...}; }(1, 2, 3)); // identity
static_assert(std::tuple{2} == [](auto... ts) { return std::tuple{ts...[1]}; }(1, 2, 3)); // second
static_assert(std::tuple{3} == [](auto... ts) { return std::tuple{ts...[-1]}; }(1, 2, 3)); // last
static_assert(std::tuple{3, 2, 1} == [](auto... ts) { return std::tuple{ts...[::-1]...}; }(1, 2, 3)); // reverse
static_assert(std::tuple{2, 3} == [](auto... ts) { return std::tuple{ts...[-3:]...}; }(1, 2, 3)); // last two
static_assert(std::tuple{2, 4} == [](auto... ts) { return std::tuple{ts...[1::2]...}; }(1, 2, 3, 4)); // odds
static_assert(std::tuple{1, 2, 3} == [](auto... ts) { return std::tuple{ts...[0:3]...}; }(1, 2, 3, 4, 5, 6)); // first half
static_assert(std::tuple{4, 5, 6} == [](auto... ts) { return std::tuple{ts...[3:]...}; }(1, 2, 3, 4, 5, 6)); // second half
```
> https://circle.godbolt.org/z/7cnWsP5Mq