├── adjacent_find_01.cpp
├── algorithms.cpp
├── any_of_01.cpp
├── binary_search_01.cpp
├── copy_01.cpp
├── copy_backward_01.cpp
├── copy_backward_02.cpp
├── copy_n_01.cpp
├── count_01.cpp
├── eual_range_01.cpp
├── find_01.cpp
├── find_end_01.cpp
├── find_end_03.cpp
├── find_first__of_01.cpp
├── find_if_01.cpp
├── for_each_n_01.cpp
├── generate_02.cpp
├── generate_03.cpp
├── heap_sort_01.cpp
├── in_place_merge_01.cpp
├── includes_01.cpp
├── includes_02.cpp
├── is_sorted_01.cpp
├── is_sorted_until_01.cpp
├── lexicographical_compare_three_way_01.cpp
├── lower_bound_01.cpp
├── merge_01.cpp
├── merge_02.cpp
├── min_01.cpp
├── mismatch_01.cpp
├── move_01.cpp
├── move_02.cpp
├── move_backward_01.cpp
├── n_th_element_01.cpp
├── next_permuttion_01.cpp
├── numeric
    ├── accumulate_01.cpp
    ├── accumulate_02.cpp
    ├── accumulate_03.cpp
    ├── accumulate_04.cpp
    ├── accumulate_05.cpp
    ├── adjacent_difference_01.cpp
    ├── adjacent_difference_02.cpp
    ├── adjacent_difference_03.cpp
    ├── exclusive_scan_01.cpp
    ├── gcd_01
    ├── inclusive_scan_01.cpp
    ├── inner_product_01.cpp
    ├── inner_product_02.cpp
    ├── inner_product_03.cpp
    ├── inner_product_04.cpp
    ├── inner_product_05.cpp
    ├── inner_product_06.cpp
    ├── iota_01.cpp
    ├── lcm_01.cpp
    ├── midpoint_01.cpp
    ├── partial_sum_01.cpp
    ├── partial_sum_02.cpp
    ├── partial_sum_03.cpp
    ├── partial_sum_04.cpp
    ├── reduce_01.cpp
    ├── reduce_02.cpp
    ├── reduce_03.cpp
    ├── transform_exclusive_scan_01.cpp
    ├── transform_inclusive_scan_01.cpp
    ├── transform_reduce_01.cpp
    ├── transform_reduce_02.cpp
    ├── transform_reduce_03.cpp
    ├── transform_reduce_04.cpp
    ├── transform_reduce_05.cpp
    └── transform_reduce_06.cpp
├── partial_sort_01.cpp
├── partial_sort_02.cpp
├── partition_01.cpp
├── reverse_01.cpp
├── reverse_02.cpp
├── rotate_01.cpp
├── sample_01.cpp
├── search_01.cpp
├── search_n_01.cpp
├── set_difference_01.cpp
├── set_intersection_01.cpp
├── set_union_01.cpp
├── shuffle_01.cpp
└── stable_partition_gather.cpp


/adjacent_find_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <algorithm>
 4 | 
 5 | int main() 
 6 | {
 7 |     std::vector<int> ivec = { 1, 4, 2, 3, 3, 5, 5, 6, 6, 6, 8, 10 };
 8 | 
 9 |     // Using adjacent_find to find the first pair of equal adjacent elements
10 |     if (const auto iter = std::adjacent_find(ivec.begin(), ivec.end()); iter != ivec.end()) {
11 |         std::cout << "First pair of equal adjacent elements: "
12 |             << *iter << " and " << *(iter + 1) << '\n';
13 |     }
14 |     else {
15 |         std::cout << "No equal adjacent elements found." << '\n';
16 |     }
17 | 
18 |     // Find the first pair of adjacent elements with a difference of 1
19 |     if (const auto iter = std::adjacent_find(ivec.begin(), ivec.end(),
20 |         [](int a, int b) { return (b - a) == 1; }); iter != ivec.end()) {
21 |         std::cout << "First pair of adjacent elements with a difference of 1: "
22 |             << *iter << " and " << *(iter + 1) << '\n';
23 |     }
24 |     else {
25 |         std::cout << "No adjacent elements with a difference of 1 found." << '\n';
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/algorithms.cpp:
--------------------------------------------------------------------------------
  1 | // all_of
  2 | template<class InIter, class UnPred>
  3 | bool all_of(InIter beg, InIter end, UnPred p);
  4 | 
  5 | // any_of
  6 | template<class InIter, class UnPred>
  7 | bool any_of(InIter beg, InIter end, UnPred p);
  8 | 
  9 | // none_of
 10 | template<class InIter, class UnPred>
 11 | bool none_of(InIter beg, InIter end, UnPred p);
 12 | 
 13 | // for_each
 14 | template<class InIter, class UFunc>
 15 | UFunc for_each(InIter beg, InIter end, UFunc f);
 16 | 
 17 | // for_each_n
 18 | template<class InIter, class Size, class UFunc>
 19 | UFunc for_each_n(InIter beg, Size n, UFunc f);
 20 | 
 21 | // count
 22 | template<class InIter, class T>
 23 | typename iterator_traits<InIter>::difference_type
 24 | count(InIter beg, InIter end, const T& val);
 25 | 
 26 | // count_if
 27 | template<class InIter, class UnPred>
 28 | typename iterator_traits<InIter>::difference_type
 29 | count_if(InIter beg, InIter end, UnPred p);
 30 | 
 31 | // mismatch
 32 | template<class InIter1, class InIter2>
 33 | std::pair<InIter1, InIter2> mismatch(InIter1 beg1, InIter1 end1, InIter2 beg2);
 34 | 
 35 | template<class InIter1, class InIter2, class BiPred>
 36 | std::pair<InIter1, InIter2>
 37 | mismatch(InIter1 beg1, InIter1 end1, InIter2 beg2, BiPred p);
 38 | 
 39 | // equal
 40 | template<class InIter1, class InIter2>
 41 | bool equal(InIter1 beg1, InIter1 end1, InIter2 beg2);
 42 | 
 43 | template<class InIter1, class InIter2, class BiPred>
 44 | bool equal(InIter1 beg1, InIter1 end1, InIter2 beg2, BiPred p);
 45 | 
 46 | template<class InIter1, class InIter2>
 47 | bool equal(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2);
 48 | 
 49 | template<class InIter1, class InIter2, class BiPred>
 50 | bool equal(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2, BiPred p);
 51 | 
 52 | // find
 53 | template<class InIter, class T>
 54 | InIter find(InIter beg, InIter end, const T& val);
 55 | 
 56 | // find_if
 57 | template<class InIter, class UnPred>
 58 | InIter find_if(InIter beg, InIter end, UnPred p);
 59 | 
 60 | // find_if_not
 61 | template<class InIter, class UnPred>
 62 | InIter find_if_not(InIter beg, InIter end, UnPred q);
 63 | 
 64 | // find_end
 65 | template<class ForIt1, class ForIt2>
 66 | ForIt1 find_end(ForIt1 beg1, ForIt1 end1, ForIt2 beg2, ForIt2 end2);
 67 | 
 68 | template<class ForIt1, class ForIt2, class BiPred>
 69 | ForIt1 find_end(ForIt1 beg1, ForIt1 end1, ForIt2 beg2, ForIt2 end2, BiPred p);
 70 | 
 71 | // find_first_of
 72 | template<class InIter, class ForIt>
 73 | InIter find_first_of(InIter beg, InIter end, ForIt s_beg, ForIt s_end);
 74 | 
 75 | template<class InIter, class ForIt, class BiPred>
 76 | InIter find_first_of(InIter beg, InIter end, ForIt s_beg, ForIt s_end, BiPred p);
 77 | 
 78 | // adjacent_find
 79 | template<class ForIt>
 80 | ForIt adjacent_find(ForIt beg, ForIt end);
 81 | 
 82 | template<class ForIt, class BiPred>
 83 | ForIt adjacent_find(ForIt beg, ForIt end, BiPred p);
 84 | 
 85 | // search
 86 | template<class ForIt1, class ForIt2>
 87 | ForIt1 search(ForIt1 beg1, ForIt1 end1, ForIt2 beg2, ForIt2 end2);
 88 | 
 89 | template<class ForIt1, class ForIt2, class BiPred>
 90 | ForIt1 search(ForIt1 beg1, ForIt1 end1, ForIt2 beg2, ForIt2 end2, BiPred p);
 91 | 
 92 | // search_n
 93 | template<class ForIt, class Size, class T>
 94 | ForIt search_n(ForIt beg, ForIt end, Size count, const T& val);
 95 | 
 96 | template<class ForIt, class Size, class T, class BiPred>
 97 | ForIt search_n(ForIt beg, ForIt end, Size count, const T& val, BiPred p);
 98 | 
 99 | // copy
100 | template<class InIter, class OutIter>
101 | OutIter copy(InIter beg, InIter end, OutIter d_first);
102 | 
103 | // copy_n
104 | template<class InIter, class Size, class OutIter>
105 | OutIter copy_n(InIter beg, Size count, OutIter result);
106 | 
107 | // copy_if
108 | template<class InIter, class OutIter, class UnPred>
109 | OutIter copy_if(InIter beg, InIter end, OutIter d_first, UnPred pred);
110 | 
111 | // copy_backward
112 | template<class BidIt1, class BidIt2>
113 | BidirIt2 copy_backward(BidIt1 beg, BidIt1 end, BidIt2 dest_last);
114 | 
115 | // move
116 | template<class InIter, class OutIter>
117 | OutIter move(InIter beg, InIter end, OutIter d_first);
118 | 
119 | // move_backward
120 | template<class BidIt1, class BidIt2>
121 | BidirIt2 copy_backward(BidIt1 beg, BidIt1 end, BidIt2 dest_last);
122 | 
123 | // swap
124 | template<class T>
125 | void swap(T& a, T& b);
126 | 
127 | // iter_swap
128 | template<class ForIt1, class ForIt2>
129 | void iter_swap(ForIt1 a, ForIt2 b);
130 | 
131 | // swap_ranges
132 | template<class ForIt1, class ForIt2>
133 | ForIt2 swap_ranges(ForIt1 beg1, ForIt1 end1, ForIt2 beg2);
134 | 
135 | // transform
136 | template<class InIter, class OutIter, class UnOp>
137 | OutIter transform(InIter beg1, InIter end1, OutIter d_first, UnOp unary_op);
138 | 
139 | template<class InIter1, class InIter2, class OutIter, class BinOp>
140 | OutIter transform(InIter1 beg1, InIter1 end1, InIter2 beg2, OutIter d_first, BinOp binary_op);
141 | 
142 | // replace
143 | template<class ForIt, class T>
144 | void replace(ForIt beg, ForIt end, const T& old_val, const T& new_val);
145 | 
146 | // replace_if
147 | template<class ForIt, class UnPred, class T>
148 | void replace_if(ForIt beg, ForIt end, UnPred p, const T& new_val);
149 | 
150 | // replace_copy
151 | template<class InIter, class OutIter, class T>
152 | OutIter replace_copy(InIter beg, InIter end, OutIter d_first, const T& old_val, const T& new_val);
153 | 
154 | // replace_copy_if
155 | template<class InIter, class OutIter, class UnPred, class T>
156 | OutIter replace_copy_if(InIter beg, InIter end, OutIter d_first, UnPred p, const T& new_val);
157 | 
158 | // fill
159 | template<class ForIt, class T>
160 | void fill(ForIt beg, ForIt end, const T& val);
161 | 
162 | // fill_n
163 | template<class OutIter, class Size, class T>
164 | OutIter fill_n(OutIter beg, Size count, const T& val);
165 | 
166 | // generate
167 | template<class ForIt, class Generator>
168 | void generate(ForIt beg, ForIt end, Generator g);
169 | 
170 | // generate_n
171 | template<class OutIter, class Size, class Generator>
172 | OutIter generate_n(OutIter beg, Size count, Generator g);
173 | 
174 | // remove
175 | template<class ForIt, class T>
176 | ForIt remove(ForIt beg, ForIt end, const T& val);
177 | 
178 | // remove_if
179 | template<class ForIt, class UnPred>
180 | ForIt remove_if(ForIt beg, ForIt end, UnPred p);
181 | 
182 | // remove_copy
183 | template<class InIter, class OutIter, class T>
184 | OutIter remove_copy(InIter beg, InIter end, OutIter d_first, const T& val);
185 | 
186 | // remove_copy_if
187 | template<class InIter, class OutIter, class UnPred>
188 | OutIter remove_copy_if(InIter beg, InIter end, OutIter d_first, UnPred p);
189 | 
190 | // unique
191 | template<class ForIt>
192 | ForIt unique(ForIt beg, ForIt end);
193 | 
194 | template<class ForIt, class BiPred>
195 | ForIt unique(ForIt beg, ForIt end, BiPred p);
196 | 
197 | // unique_copy
198 | template<class InIter, class OutIter>
199 | OutIter unique_copy(InIter beg, InIter end, OutIter d_first);
200 | 
201 | template<class InIter, class OutIter, class BiPred>
202 | OutIter unique_copy(InIter beg, InIter end, OutIter d_first, BiPred p);
203 | 
204 | // reverse
205 | template<class BidIter>
206 | void reverse(BidIter beg, BidIter end);
207 | 
208 | // reverse_copy
209 | template<class BidIter, class OutIter>
210 | OutIter reverse_copy(BidIter beg, BidIter end, OutIter d_first);
211 | 
212 | // rotate
213 | template<class ForIt>
214 | ForIt rotate(ForIt beg, ForIt n_first, ForIt end);
215 | 
216 | // rotate_copy
217 | template<class ForIt, class OutIter>
218 | OutIter rotate_copy(ForIt beg, ForIt n_first, ForIt end, OutIter d_first);
219 | 
220 | // shuffle
221 | template<class RanIt, class URBG>
222 | void shuffle(RanIt beg, RanIt end, URBG&& g);
223 | 
224 | // is_partitioned
225 | template<class InIter, class UnPred>
226 | bool is_partitioned(InIter beg, InIter end, UnPred p);
227 | 
228 | // partition
229 | template<class BidIter, class UnPred>
230 | BidIter partition(BidIter beg, BidIter end, UnPred p);
231 | 
232 | // stable_partition
233 | template<class BidIter, class UnPred>
234 | BidIter stable_partition(BidIter beg, BidIter end, UnPred p);
235 | 
236 | // partition_copy
237 | template<class InIter, class OutIter1, class OutIter2, class UnPred>
238 | std::pair<OutIter1, OutIter2>
239 | partition_copy(InIter beg, InIter end, OutIter1 d_first_true, OutIter2 d_first_false, UnPred p);
240 | 
241 | // partition_point
242 | template<class ForIt, class UnPred>
243 | ForIt partition_point(ForIt beg, ForIt end, UnPred p);
244 | 
245 | // sort
246 | template<class RanIt>
247 | void sort(RanIt beg, RanIt end);
248 | 
249 | template<class RanIt, class Compare>
250 | void sort(RanIt beg, RanIt end, Compare comp);
251 | 
252 | // stable_sort
253 | template<class RanIt>
254 | void stable_sort(RanIt beg, RanIt end);
255 | 
256 | template<class RanIt, class Compare>
257 | void stable_sort(RanIt beg, RanIt end, Compare comp);
258 | 
259 | // partial_sort
260 | template<class RanIt>
261 | void partial_sort(RanIt beg, RanIt middle, RanIt end);
262 | 
263 | template<class RanIt, class Compare>
264 | void partial_sort(RanIt beg, RanIt middle, RanIt end, Compare comp);
265 | 
266 | // partial_sort_copy
267 | template<class InIter, class RanIt>
268 | RanIt partial_sort_copy(InIter beg, InIter end, RanIt d_first, RanIt d_last);
269 | 
270 | template<class InIter, class RanIt, class Compare>
271 | RanIt partial_sort_copy(InIter beg, InIter end, RanIt d_first, RanIt d_last, Compare comp);
272 | 
273 | // nth_element
274 | template<class RanIt>
275 | void nth_element(RanIt beg, RanIt nth, RanIt end);
276 | 
277 | template<class RanIt, class Compare>
278 | void nth_element(RanIt beg, RanIt nth, RanIt end, Compare comp);
279 | 
280 | // is_sorted
281 | template<class ForIt>
282 | bool is_sorted(ForIt beg, ForIt end);
283 | 
284 | template<class ForIt, class Compare>
285 | bool is_sorted(ForIt beg, ForIt end, Compare comp);
286 | 
287 | // is_sorted_until
288 | template<class ForIt>
289 | ForIt is_sorted_until(ForIt beg, ForIt end);
290 | 
291 | template<class ForIt, class Compare>
292 | ForIt is_sorted_until(ForIt beg, ForIt end, Compare comp);
293 | 
294 | // lower_bound
295 | template<class ForIt, class T>
296 | ForIt lower_bound(ForIt beg, ForIt end, const T& val);
297 | 
298 | template<class ForIt, class T, class Compare>
299 | ForIt lower_bound(ForIt beg, ForIt end, const T& val, Compare comp);
300 | 
301 | // upper_bound
302 | template<class ForIt, class T>
303 | ForIt upper_bound(ForIt beg, ForIt end, const T& val);
304 | 
305 | template<class ForIt, class T, class Compare>
306 | ForIt upper_bound(ForIt beg, ForIt end, const T& val, Compare comp);
307 | 
308 | // binary_search
309 | template<class ForIt, class T>
310 | bool binary_search(ForIt beg, ForIt end, const T& val);
311 | 
312 | template<class ForIt, class T, class Compare>
313 | bool binary_search(ForIt beg, ForIt end, const T& val, Compare comp);
314 | 
315 | // equal_range
316 | template<class ForIt, class T>
317 | std::pair<ForIt, ForIt>
318 | equal_range(ForIt beg, ForIt end, const T& val);
319 | 
320 | template<class ForIt, class T, class Compare>
321 | std::pair<ForIt, ForIt>
322 | equal_range(ForIt beg, ForIt end, const T& val, Compare comp);
323 | 
324 | // merge
325 | template<class InIter1, class InIter2, class OutIter>
326 | OutIter merge(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2, OutIter d_first);
327 | 
328 | template<class InIter1, class InIter2, class OutIter, class Compare>
329 | OutIter merge(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2, OutIter d_first, Compare comp);
330 | 
331 | // inplace_merge
332 | template<class BidIter>
333 | void inplace_merge(BidIter beg, BidIter middle, BidIter end);
334 | 
335 | template<class BidIter, class Compare>
336 | void inplace_merge(BidIter beg, BidIter middle, BidIter end, Compare comp);
337 | 
338 | // includes
339 | template<class InIter1, class InIter2>
340 | bool includes(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2);
341 | 
342 | template<class InIter1, class InIter2, class Compare>
343 | bool includes(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2, Compare comp);
344 | 
345 | // set_union
346 | template<class InIter1, class InIter2, class OutIter>
347 | OutIter set_union(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2, OutIter d_first);
348 | 
349 | template<class InIter1, class InIter2, class OutIter, class Compare>
350 | OutIter set_union(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2, OutIter d_first, Compare comp);
351 | 
352 | // set_intersection
353 | template<class InIter1, class InIter2, class OutIter>
354 | OutIter set_intersection(InIter1 beg1, InIter1 end1,InIter2 beg2, InIter2 end2, OutIter d_first);
355 | 
356 | template<class InIter1, class InIter2, class OutIter, class Compare>
357 | OutIter set_intersection(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2, OutIter d_first, Compare comp);
358 | 
359 | // set_difference
360 | template<class InIter1, class InIter2, class OutIter>
361 | OutIter set_difference(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2, OutIter d_first);
362 | 
363 | template<class InIter1, class InIter2, class OutIter, class Compare>
364 | OutIter set_difference(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2, OutIter d_first, Compare comp);
365 | 
366 | // set_symmetric_difference
367 | template<class InIter1, class InIter2, class OutIter>
368 | OutIter set_symmetric_difference(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2, OutIter d_first);
369 | 
370 | template<class InIter1, class InIter2, class OutIter, class Compare>
371 | OutIter set_symmetric_difference(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2, OutIter d_first, Compare comp);
372 | 
373 | // make_heap
374 | template<class RanIt>
375 | void make_heap(RanIt beg, RanIt end);
376 | 
377 | template<class RanIt, class Compare>
378 | void make_heap(RanIt beg, RanIt end, Compare comp);
379 | 
380 | // push_heap
381 | template<class RanIt>
382 | void push_heap(RanIt beg, RanIt end);
383 | 
384 | template<class RanIt, class Compare>
385 | void push_heap(RanIt beg, RanIt end, Compare comp);
386 | 
387 | // pop_heap
388 | template<class RanIt>
389 | void pop_heap(RanIt beg, RanIt end);
390 | 
391 | template<class RanIt, class Compare>
392 | void pop_heap(RanIt beg, RanIt end, Compare comp);
393 | 
394 | // sort_heap
395 | template<class RanIt>
396 | void sort_heap(RanIt beg, RanIt end);
397 | 
398 | template<class RanIt, class Compare>
399 | void sort_heap(RanIt beg, RanIt end, Compare comp);
400 | 
401 | // is_heap
402 | template<class RanIt>
403 | bool is_heap(RanIt beg, RanIt end);
404 | 
405 | template<class RanIt, class Compare>
406 | bool is_heap(RanIt beg, RanIt end, Compare comp);
407 | 
408 | // is_heap_until
409 | template<class RanIt>
410 | RanIt is_heap_until(RanIt beg, RanIt end);
411 | 
412 | template<class RanIt, class Compare>
413 | RanIt is_heap_until(RanIt beg, RanIt end, Compare comp);
414 | 
415 | // min
416 | template<class T>
417 | const T& min(const T& a, const T& b);
418 | 
419 | template<class T, class Compare>
420 | const T& min(const T& a, const T& b, Compare comp);
421 | 
422 | template<class T>
423 | T min(std::initializer_list<T> ilist);
424 | 
425 | template<class T, class Compare>
426 | T min(std::initializer_list<T> ilist, Compare comp);
427 | 
428 | // max
429 | template<class T>
430 | const T& max(const T& a, const T& b);
431 | 
432 | template<class T, class Compare>
433 | const T& max(const T& a, const T& b, Compare comp);
434 | 
435 | template<class T>
436 | T max(std::initializer_list<T> ilist);
437 | 
438 | template<class T, class Compare>
439 | T max(std::initializer_list<T> ilist, Compare comp);
440 | 
441 | // minmax
442 | template<class T>
443 | std::pair<const T&, const T&> minmax(const T& a, const T& b);
444 | 
445 | template<class T, class Compare>
446 | std::pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
447 | 
448 | template<class T>
449 | std::pair<T, T> minmax(std::initializer_list<T> ilist);
450 | 
451 | template<class T, class Compare>
452 | std::pair<T, T> minmax(std::initializer_list<T> ilist, Compare comp);
453 | 
454 | // min_element
455 | template<class ForIt>
456 | ForIt min_element(ForIt beg, ForIt end);
457 | 
458 | template<class ForIt, class Compare>
459 | ForIt min_element(ForIt beg, ForIt end, Compare comp);
460 | 
461 | // max_element
462 | template<class ForIt>
463 | ForIt max_element(ForIt beg, ForIt end);
464 | 
465 | template<class ForIt, class Compare>
466 | ForIt max_element(ForIt beg, ForIt end, Compare comp);
467 | 
468 | // minmax_element
469 | template<class ForIt>
470 | std::pair<ForIt, ForIt>
471 | 
472 | minmax_element(ForIt beg, ForIt end);
473 | template<class ForIt, class Compare>
474 | 
475 | std::pair<ForIt, ForIt>
476 | minmax_element(ForIt beg, ForIt end, Compare comp);
477 | 
478 | // clamp
479 | template<class T>
480 | const T& clamp(const T& v, const T& lo, const T& hi);
481 | template<class T, class Compare>
482 | 
483 | const T& clamp(const T& v, const T& lo, const T& hi, Compare comp);
484 | 
485 | // lexicographical_compare
486 | template<class InIter1, class InIter2>
487 | bool lexicographical_compare(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2);
488 | 
489 | template<class InIter1, class InIter2, class Compare>
490 | bool lexicographical_compare(InIter1 beg1, InIter1 end1, InIter2 beg2, InIter2 end2, Compare comp);
491 | 
492 | // is_permutation
493 | template<class ForIt1, class ForIt2>
494 | bool is_permutation(ForIt1 beg1, ForIt1 end1, ForIt2 beg2);
495 | 
496 | template<class ForIt1, class ForIt2, class BiPred>
497 | bool is_permutation(ForIt1 beg1, ForIt1 end1, ForIt2 beg2, BiPred p);
498 | 
499 | template<class ForIt1, class ForIt2>
500 | bool is_permutation(ForIt1 beg1, ForIt1 end1, ForIt2 beg2, ForIt2 end2);
501 | 
502 | template<class ForIt1, class ForIt2, class BiPred>
503 | bool is_permutation(ForIt1 beg1, ForIt1 end1, ForIt2 beg2, ForIt2 end2, BiPred p);
504 | 
505 | // next_permutation
506 | template<class BidIter>
507 | bool next_permutation(BidIter beg, BidIter end);
508 | 
509 | template<class BidIter, class Compare>
510 | bool next_permutation(BidIter beg, BidIter end, Compare comp);
511 | 
512 | // prev_permutation
513 | template<class BidIter>
514 | bool prev_permutation(BidIter beg, BidIter end);
515 | 
516 | template<class BidIter, class Compare>
517 | bool prev_permutation(BidIter beg, BidIter end, Compare comp);
518 | 
519 | // accumulate
520 | template<class InIter, class T>
521 | T accumulate(InIter beg, InIter end, T init);
522 | 
523 | template<class InIter, class T, class BinOp>
524 | T accumulate(InIter beg, InIter end, T init, BinOp op);
525 | 
526 | // reduce
527 | template<class InIter>
528 | typename iterator_traits<InIter>::val_type
529 | reduce(InIter beg, InIter end);
530 | 
531 | template<class InIter, class T>
532 | T reduce(InIter beg, InIter end, T init);
533 | 
534 | template<class InIter, class T, class BinOp>
535 | T reduce(InIter beg, InIter end, T init, BinOp binary_op);
536 | 
537 | // inner_product
538 | template<class InIter1, class InIter2, class T>
539 | T inner_product(InIter1 beg1, InIter1 end1, InIter2 beg2, T init);
540 | 
541 | template<class InIter1, class InIter2, class T, class BinOp, class BinOp2>
542 | T inner_product(InIter1 beg1, InIter1 end1, InIter2 beg2, T init, BinOp op1, BinOp2 op2);
543 | 
544 | // adjacent_difference
545 | template<class InIter, class OutIter>
546 | OutIter adjacent_difference(InIter beg, InIter end, OutIter d_first);
547 | 
548 | template<class InIter, class OutIter, class BinOp>
549 | OutIter adjacent_difference(InIter beg, InIter end, OutIter d_first, BinOp op);
550 | 
551 | // partial_sum
552 | template<class InIter, class OutIter>
553 | OutIter partial_sum(InIter beg, InIter end, OutIter d_first);
554 | 
555 | template<class InIter, class OutIter, class BinOp>
556 | OutIter partial_sum(InIter beg, InIter end, OutIter d_first, BinOp op);
557 | 
558 | // exclusive_scan
559 | template<class InIter, class OutIter, class T>
560 | OutIter exclusive_scan(InIter beg, InIter end, OutIter d_first, T init);
561 | 
562 | template<class InIter, class OutIter, class T, class BinOp>
563 | OutIter exclusive_scan(InIter beg, InIter end, OutIter d_first, T init, BinOp binary_op);
564 | 
565 | // inclusive_scan
566 | template<class InIter, class OutIter>
567 | OutIter inclusive_scan(InIter beg, InIter end, OutIter d_first);
568 | 
569 | template<class InIter, class OutIter, class BinOp>
570 | OutIter inclusive_scan(InIter beg, InIter end, OutIter d_first, BinOp binary_op);
571 | 
572 | template<class InIter, class OutIter, class BinOp, class T>
573 | OutIter inclusive_scan(InIter beg, InIter end, OutIter d_first, BinOp binary_op, T init);
574 | 
575 | // transform_reduce
576 | template<class InIter1, class InIter2, class T>
577 | T transform_reduce(InIter1 beg1, InIter1 end1, InIter2 beg2, T init);
578 | 
579 | template<class InIter1, class InIter2, class T, class BinOp, class BinOp2>
580 | T transform_reduce(InIter1 beg1, InIter1 end1, InIter2 beg2, T init, BinOp binary_op1, BinOp2 binary_op2);
581 | 
582 | template<class InIter, class T, class UnOp, class BinOp>
583 | T transform_reduce(InIter beg, InIter end, T init, BinOp binary_op, UnOp unary_op);
584 | 
585 | // transform_exclusive_scan
586 | template<class InIter, class OutIter, class T, class BinOp, class UnOp>
587 | OutIter transform_exclusive_scan(InIter beg, InIter end, OutIter d_first, T init, BinOp binary_op, UnOp unary_op);
588 | 
589 | // transform_inclusive_scan
590 | template<class InIter, class OutIter, class BinOp, class UnOp>
591 | OutIter transform_inclusive_scan(InIter beg, InIter end, OutIter d_first, BinOp binary_op, UnOp unary_op);
592 | 
593 | template<class InIter, class OutIter, class BinOp, class UnOp, class T>
594 | OutIter transform_inclusive_scan(InIter beg, InIter end, OutIter d_first, BinOp binary_op, UnOp unary_op, T init);
595 | 
596 | // gcd
597 | template<class M, class N>
598 | constexpr std::common_type_t<M, N> gcd(M m, N n);
599 | 
600 | // lcm
601 | template<class M, class N>
602 | constexpr std::common_type_t<M, N> lcm(M m, N n);
603 | 
604 | // midpoint
605 | template<class T>
606 | constexpr T midpoint(T a, T b);
607 | 
608 | template<class T>
609 | constexpr T* midpoint(T* a, T* b);
610 | 
611 | // lerp
612 | template<class T>
613 | constexpr T lerp(T a, T b, T t);
614 | 
615 | 


--------------------------------------------------------------------------------
/any_of_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <iostream>
 3 | #include <algorithm>
 4 | 
 5 | int main()
 6 | {
 7 | 	std::vector<int> v{ 2, 6, 4, 0, 8, 10, 6 };
 8 | 
 9 | 	boolalpha(std::cout);
10 | 
11 | 	const auto is_even = [](int x) {return x % 2 == 0; };
12 | 
13 | 	std::cout << "any of :" << std::any_of(begin(v), end(v), is_even) << '\n';
14 | 	std::cout << "all of :" << std::all_of(begin(v), end(v), is_even) << '\n';
15 | 	std::cout << "none of :" << std::none_of(begin(v), end(v), is_even) << '\n';
16 | 
17 | 	v = {};
18 | 	std::cout << "for empty vector\n";
19 | 
20 | 	std::cout << "any of :" << std::any_of(begin(v), end(v), is_even) << '\n';
21 | 	std::cout << "all of :" << std::all_of(begin(v), end(v), is_even) << '\n';
22 | 	std::cout << "none of :" << std::none_of(begin(v), end(v), is_even) << '\n';
23 | }
24 | 


--------------------------------------------------------------------------------
/binary_search_01.cpp:
--------------------------------------------------------------------------------
 1 | // std::iota
 2 | // std::for_each
 3 | // std::binary_search
 4 | 
 5 | #include <vector>
 6 | #include <numeric>
 7 | #include <cstdlib>
 8 | #include <iostream>
 9 | #include <algorithm>
10 | 
11 | int main()
12 | {
13 | 	std::vector<int> ivec(100);
14 | 	std::iota(ivec.begin(), ivec.end(), 0);
15 | 
16 | 	while (ivec.size() != 40) {
17 | 		ivec.erase(ivec.begin() + rand() % ivec.size());
18 | 	}
19 | 
20 | 	std::for_each(ivec.begin(), ivec.end(), [](int i) {std::cout << i << ' '; });
21 | 		
22 | 	std::cout << "\nenter the searched value: ";
23 | 	int key;
24 | 	std::cin >> key;
25 | 
26 | 	std::cout <<
27 | 		(std::binary_search(ivec.begin(), ivec.end(), key) ? "found" : "not found");
28 | }
29 | 


--------------------------------------------------------------------------------
/copy_01.cpp:
--------------------------------------------------------------------------------
 1 | // std::copy
 2 | // std::copy_backward
 3 | 
 4 | #include <vector>
 5 | #include <algorithm>
 6 | #include <iostream>
 7 | #include <iterator>
 8 | 
 9 | int main()
10 | {
11 | 	const std::vector<int> source{ 10, 20, 30, 40, 50 };
12 | 	std::vector<int> dest(source.size() * 2);
13 | 
14 | 	copy_backward(source.begin(), source.end(), dest.end());
15 | 	copy(dest.begin(), dest.end(), std::ostream_iterator<int>{std::cout, " "});
16 | }
17 | 


--------------------------------------------------------------------------------
/copy_backward_01.cpp:
--------------------------------------------------------------------------------
1 | template< class BidIt1, class BidIt2 >
2 | BidIt2 copy_backward(BidIt1 beg, BidIt1 end, BidIt2 destend)
3 | {
4 |     while (beg != end) {
5 |         *(--destend) = *(--end);
6 |     }
7 |     return destend;
8 | }
9 | 


--------------------------------------------------------------------------------
/copy_backward_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <algorithm>
 2 | #include <iostream>
 3 | #include <vector>
 4 | 
 5 | int main()
 6 | {
 7 |     std::vector vsource{ 1, 3, 5, 7, 9};
 8 | 
 9 |     std::vector<int> vdest(7);
10 | 
11 |     std::copy_backward(vsource.begin(), vsource.end(), vdest.end());
12 | 
13 |     std::cout << "vdest: ";
14 |     for (int i : vdest)
15 |         std::cout << i << ' ';
16 |     std::cout << '\n';
17 | }
18 | 
19 | 


--------------------------------------------------------------------------------
/copy_n_01.cpp:
--------------------------------------------------------------------------------
 1 | // std::copy_n
 2 | 
 3 | #include <vector>
 4 | #include <list>
 5 | #include <algorithm>
 6 | #include <iterator>
 7 | #include <iostream>
 8 | 
 9 | int main()
10 | {
11 | 	std::vector ivec{ 1, 3, 5, 8, 7, 9, 2, 3};
12 | 	std::list<int> ilist;
13 | 	copy_n(ivec.begin(), 5, back_inserter(ilist));
14 | 
15 | 	std::cout << "ilist.size() = " << ilist.size() << '\n';
16 | 	copy(ilist.begin(), ilist.end(), std::ostream_iterator<int>{std::cout, " "});
17 | }
18 | 


--------------------------------------------------------------------------------
/count_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <iterator>
 2 | 
 3 | template<class InIter, class T = typename std::iterator_traits<InIter>::value_type>
 4 | typename std::iterator_traits<InIter>::difference_type
 5 | count(InIter beg, InIter end, const T& val)
 6 | {
 7 |     typename std::iterator_traits<InIter>::difference_type cnt{};
 8 | 
 9 |     while (beg != end) {
10 |         if (*beg == val)
11 |             ++cnt;
12 |         ++beg;
13 |     }
14 |     return cnt;
15 | }
16 | 


--------------------------------------------------------------------------------
/eual_range_01.cpp:
--------------------------------------------------------------------------------
 1 | //std::equal_range
 2 | 
 3 | #include <vector>
 4 | #include <algorithm>
 5 | #include <iterator>
 6 | #include <iostream>
 7 | 
 8 | int main()
 9 | {
10 | 	std::vector vec{ 2, 2, 2, 5, 5, 5, 7, 9, 9, 9, 9, 12, 12, 16, 35 };
11 | 	copy(begin(vec), end(vec), std::ostream_iterator<int>(std::cout, " "));
12 | 
13 | 	std::cout << "\nenter an integer: ";
14 |   int i;
15 | 	std::cin >> i;
16 | 
17 | 	auto [it_lower, it_upper] = equal_range(vec.begin(), vec.end(), i);
18 | 	std::cout << "distance for equal range : " << distance(it_lower, it_upper) << '\n';
19 | 	std::cout << "index for lowerbound : " << distance(vec.begin(), it_lower) << '\n';
20 | 	std::cout << "index for upperbound : " << distance(vec.begin(), it_upper) << '\n';
21 | }
22 | 


--------------------------------------------------------------------------------
/find_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <iostream>
 3 | #include <algorithm>
 4 | 
 5 | int main()
 6 | {
 7 | 	std::vector v{ 2, 7, 1, 4, 6, 8, 3, 2, 9, 1, 7, 6 };
 8 | 	std::cout << "enter the searched integer: ";
 9 | 	int key;
10 | 	std::cin >> key;
11 | 
12 | 	if (auto iter = find(begin(v), end(v), key); iter != v.end()) {
13 | 		std::cout << "found idx = " << iter - v.begin() << '\n';
14 | 	}
15 | 	else {
16 | 		std::cout << "not found\n";
17 | 	}
18 | }
19 | 


--------------------------------------------------------------------------------
/find_end_01.cpp:
--------------------------------------------------------------------------------
 1 | // std::search
 2 | // std::find_end
 3 | 
 4 | #include <vector>
 5 | #include <string>
 6 | #include <algorithm>
 7 | #include <iostream>
 8 | #include <iterator>
 9 | 
10 | int main()
11 | {
12 |     std::vector<std::string> svec{ "gul", "ali", "nur", "ece", "can", "ece", "ali", "nur", "ece", "tan" };
13 |     std::vector<int>::iterator result;
14 | 
15 |     const auto list = { "ali", "nur", "ece" };
16 | 
17 |     std::cout << "search with std::search\n";
18 |     if (auto iter = std::search(svec.begin(), svec.end(), list.begin(), list.end()); iter != svec.end()) {
19 |         std::cout << "found at index : " << distance(svec.begin(), iter) << '\n';
20 |     }
21 |     else {
22 |         std::cout << "not found\n";
23 |     }
24 | 
25 |     std::cout << "search with std::find_end\n";
26 |     if (auto iter = std::find_end(svec.begin(), svec.end(), list.begin(), list.end()); iter != svec.end()) {
27 |         std::cout << "found at index : " << distance(svec.begin(), iter) << '\n';
28 |     }
29 |     else {
30 |         std::cout << "not found\n";
31 |     }
32 | 
33 | }
34 | 


--------------------------------------------------------------------------------
/find_end_03.cpp:
--------------------------------------------------------------------------------
 1 | // quoted fom cppreference.com
 2 | 
 3 | #include <algorithm>
 4 | #include <array>
 5 | #include <cmath>
 6 | #include <iostream>
 7 | 
 8 | auto print_result = [](auto result, const auto& v)
 9 |     {
10 |         result == v.end()
11 |             ? std::cout << "Sequence not found\n"
12 |             : std::cout << "Last occurrence is at: " << std::distance(v.begin(), result)
13 |             << '\n';
14 |     };
15 | 
16 | int main()
17 | {
18 |     const auto v = { 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4 };
19 | 
20 |     for (auto const& x : { std::array{1, 2, 3}, {4, 5, 6} })
21 |     {
22 |         auto iter = std::find_end(v.begin(), v.end(), x.begin(), x.end()); // overload (1)
23 |         print_result(iter, v);
24 |     }
25 | 
26 |     for (auto const& x : { std::array{-1, -2, -3}, {-4, -5, -6} })
27 |     {
28 |         auto iter = std::find_end(v.begin(), v.end(), x.begin(), x.end(), // overload (3)
29 |             [](int x, int y)
30 |             {
31 |                 return std::abs(x) == std::abs(y);
32 |             });
33 |         print_result(iter, v);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/find_first__of_01.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | template<class InputIt, class ForwardIt>
 3 | InputIt find_first_of(InputIt first, InputIt last,
 4 |                       ForwardIt s_first, ForwardIt s_last);
 5 | 
 6 | 
 7 | template<class InputIt, class ForwardIt, class BinaryPredicate>
 8 | InputIt find_first_of(InputIt first, InputIt last,
 9 |                       ForwardIt s_first, ForwardIt s_last,
10 |                       BinaryPredicate p);
11 | 
12 | */ 
13 | 
14 | #include <algorithm>
15 | #include <vector>
16 | #include <iostream>
17 | 
18 | int main() 
19 | {
20 |     std::vector data = { 10, 20, 30, 40, 50 };
21 |     std::vector searched = { 25, 30, 45 };
22 | 
23 |     if (auto it = std::find_first_of(data.begin(), data.end(),
24 |         searched.begin(), searched.end()); it != data.end()) {
25 |         std::cout << "found : " << *it << '\n';
26 |     }
27 |     else {
28 |         std::cout << "not found\n";
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/find_if_01.cpp:
--------------------------------------------------------------------------------
 1 | // std::find_if
 2 | 
 3 | #include <vector>
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | 
 7 | int main()
 8 | {
 9 | 	std::vector v{ 2, 7, 1, 4, 6, 8, 26, 2, 9, 20, 1, 37, 6, 21};
10 | 
11 | 	int divisor;
12 | 	std::cout << "enter the divisor : ";
13 | 	std::cin >> divisor;
14 | 
15 | 	if (auto iter = std::find_if(cbegin(v), cend(v), [divisor](int x)
16 | 		{return x % divisor == 0; }); iter != v.end()) {
17 | 		std::cout << "found value is " << *iter << " idx is " << iter - v.begin() << '\n';
18 | 	}
19 | 	else {
20 | 		std::cout << "not found\n";
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/for_each_n_01.cpp:
--------------------------------------------------------------------------------
 1 | // for_each_n C++17
 2 | 
 3 | #include <algorithm>
 4 | #include <vector>
 5 | #include <iostream>
 6 | 
 7 | int main()
 8 | {
 9 | 	using ivec = std::vector<int>;
10 | 
11 | 	ivec vec{ 1, 3, 5, 9, 7, 0, 2, 4, 6, 8 };
12 | 
13 | 	const auto fprint = [](const ivec& vec) {
14 | 		for (const int i : vec) std::cout << i;
15 | 		std::cout << '\n';
16 | 		};
17 | 	fprint(vec);
18 | 	std::for_each_n(vec.begin(), 5, [](int& i) {--i; });
19 | 	fprint(vec);
20 | 	std::for_each_n(vec.rbegin(), 5, [](int& i) {++i; });
21 | 	fprint(vec);
22 | }
23 | 
24 | 


--------------------------------------------------------------------------------
/generate_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <list>
 2 | #include <algorithm>
 3 | #include <cstdlib>
 4 | #include <ctime>
 5 | #include <iostream>
 6 | 
 7 | void print_container(const auto& c)
 8 | {
 9 | 	for (const auto& elem : c)
10 | 		std::cout << elem << ' ';
11 | 	std::cout << '\n';
12 | }
13 | 
14 | int main()
15 | {
16 | 	std::list<int> ilist(20);
17 | 
18 | 	std::srand(static_cast<unsigned>(std::time(nullptr)));
19 | 	generate(ilist.begin(), ilist.end(), rand);
20 | 	print_container(ilist);
21 | 	generate(ilist.begin(), ilist.end(), [n = 2]()mutable {return n += 2; });
22 | 	print_container(ilist);
23 | }
24 | 


--------------------------------------------------------------------------------
/generate_03.cpp:
--------------------------------------------------------------------------------
 1 | // from cppreference.com
 2 | 
 3 | #include <algorithm>
 4 | #include <iostream>
 5 | #include <vector>
 6 |  
 7 | void println(std::string_view fmt, const auto& v)
 8 | {
 9 |     for (std::cout << fmt; const auto& e : v)
10 |         std::cout << e << ' ';
11 |     std::cout << '\n';
12 | };
13 |  
14 |  
15 | int f()
16 | {
17 |     static int i;
18 |     return ++i;
19 | }
20 |  
21 | int main()
22 | {
23 |     std::vector<int> v(5);
24 |  
25 |     std::generate(v.begin(), v.end(), f);
26 |     println("v: ", v);
27 |  
28 |     // Initialize with default values 0,1,2,3,4 from a lambda function
29 |     // Equivalent to std::iota(v.begin(), v.end(), 0);
30 |     std::generate(v.begin(), v.end(), [n = 0] () mutable { return n++; });
31 |     println("v: ", v);
32 | }
33 | 


--------------------------------------------------------------------------------
/heap_sort_01.cpp:
--------------------------------------------------------------------------------
1 | #include <algorithm>
2 | 
3 | template<typename RanIt, typename Comp>
4 | void heap_sort(RanIt first,  RanIt last, Comp cmp) 
5 | {
6 |     std::make_heap(first, last, cmp);
7 |     std::sort_heap(first, last, cmp);
8 | }
9 | 


--------------------------------------------------------------------------------
/in_place_merge_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <algorithm>
 4 | 
 5 | int main() 
 6 | {
 7 |     std::vector v = { 1, 3, 5, 7, 2, 4, 6, 8};
 8 | 
 9 |     std::inplace_merge(v.begin(), v.begin() + 4, v.end());
10 | 
11 |     for (int i : v) 
12 |         std::cout << i << ' ';  
13 | }
14 | 


--------------------------------------------------------------------------------
/includes_01.cpp:
--------------------------------------------------------------------------------
 1 | // std::generate
 2 | // std::sort
 3 | // std::copy
 4 | // std::includes
 5 | 
 6 | #include <cstdlib>
 7 | #include <ctime>
 8 | #include <vector>
 9 | #include <algorithm>
10 | #include <iostream>
11 | 
12 | int main()
13 | {
14 | 	std::srand(static_cast<unsigned>(std::time(nullptr)));
15 | 	std::vector<int> ivec(100);
16 | 	generate(ivec.begin(), ivec.end(), [] {return rand() % 1000; });
17 | 
18 | 	sort(ivec.begin(), ivec.end());
19 | 	copy(ivec.begin(), ivec.end(), std::ostream_iterator<int>(std::cout, " "));
20 | 	int x, y, z;
21 | 	std::cout << "\n\nenter 3 numbers in ascending order: ";
22 | 	std::cin >> x >> y >> z;
23 | 	auto list = { x, y, z };
24 | 	if (includes(ivec.begin(), ivec.end(), list.begin(), list.end()))
25 | 		std::cout << "found\n";
26 | 	else
27 | 		std::cout << "not found\n";
28 | }
29 | 


--------------------------------------------------------------------------------
/includes_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <set>
 3 | #include <algorithm>
 4 | #include <string>
 5 | 
 6 | int main() 
 7 | {
 8 |     std::set<std::string> perms = {"read", "write", "execute", "delete" };
 9 | 
10 |     const std::set<std::string> required1 = {"read", "write"};
11 | 
12 |     const std::set<std::string> required2 = {"read", "admin"};
13 | 
14 |     bool has_all1 = std::includes(perms.begin(), perms.end(), required1.begin(), required1.end());
15 | 
16 |     bool has_all2 = std::includes(perms.begin(), perms.end(), required2.begin(), required2.end());
17 | 
18 |     boolalpha(std::cout);
19 |     std::cout << "has_all1 : " << has_all1 << '\n';
20 |     std::cout << "has_all2 : " << has_all1 << '\n';
21 | }
22 | 
23 | 


--------------------------------------------------------------------------------
/is_sorted_01.cpp:
--------------------------------------------------------------------------------
 1 | //std::is_sorted
 2 | 
 3 | #include <vector>
 4 | #include <iostream>
 5 | #include <cmath>
 6 | #include <algorithm>
 7 | 
 8 | int main()
 9 | {
10 | 	std::vector v1{ 1, 3, 5, 8, 11, 14, 19};
11 | 	std::vector v2{ 12, 9, 8, 7, 3, 1, -1};
12 | 	std::vector v3{ 2, -3, 6, -9, -11, 13, -17};
13 | 
14 | 	boolalpha(std::cout);
15 | 
16 | 	std::cout << "is v1 sorted: " 
17 | 		<< is_sorted(v1.begin(), v1.end()) << '\n';
18 | 	
19 | 	std::cout << "is v2 sorted: " 
20 | 		<< is_sorted(v2.begin(), v2.end(), std::greater{}) << '\n';
21 | 	
22 | 	std::cout << "is v3 sorted: " 
23 | 		<< is_sorted(v3.begin(), v3.end(), 
24 | 			[](int x, int y) {
25 | 				return std::abs(x) < std::abs(y); }) << '\n';
26 | }
27 | 


--------------------------------------------------------------------------------
/is_sorted_until_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <iostream>
 3 | #include <algorithm>
 4 | 
 5 | int main()
 6 | {
 7 | 	std::vector v{ 1, 3, 5, 8, 7, 9, 2, 3};
 8 | 	
 9 | 	auto iter = std::is_sorted_until(v.begin(), v.end());
10 | 	std::cout << "sorted_range ends at idx " << 
11 | 		iter - v.begin() << '\n';
12 | 
13 | 	std::cout << "the first unsorted value is " << *iter << '\n';
14 | }
15 | 


--------------------------------------------------------------------------------
/lexicographical_compare_three_way_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <type_traits>
 3 | 
 4 | 
 5 | int main()
 6 | {
 7 |     std::vector a = { 1, 2, 3 };
 8 |     std::vector b = { 1, 2, 4 };
 9 | 
10 |     bool result = std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
11 |     auto ordering = std::lexicographical_compare_three_way(a.begin(), a.end(), b.begin(), b.end());
12 | 
13 |     static_assert(std::is_same_v<decltype(result), bool>);
14 |     static_assert(std::is_same_v<decltype(ordering), std::strong_ordering>);
15 | }
16 |     
17 | 


--------------------------------------------------------------------------------
/lower_bound_01.cpp:
--------------------------------------------------------------------------------
 1 | // std::copy
 2 | // std::lower_bound
 3 | // std::upper_bound
 4 | 
 5 | #include <vector>
 6 | #include <iterator>
 7 | #include <iostream>
 8 | 
 9 | int main()
10 | {
11 | 	std::vector<int> ivec{ 2, 5, 5, 7, 9, 9, 9, 9, 12, 12, 16, 35 };
12 | 	copy(begin(ivec), end(ivec), std::ostream_iterator<int>(std::cout, " "));
13 | 
14 | 	std::cout << "\nenter an integer: ";
15 | 	int ival;
16 | 	std::cin >> ival;
17 | 
18 | 	auto iter_lower = lower_bound(ivec.begin(), ivec.end(), ival);
19 | 	auto iter_upper = upper_bound(ivec.begin(), ivec.end(), ival);
20 | 
21 | 	std::cout << "distance for lower bound : " << distance(ivec.begin(), iter_lower) << '\n';
22 | 	std::cout << "distance for upper bound : " << distance(ivec.begin(), iter_upper) << '\n';
23 | 	std::cout << "distance for equal range " << distance(iter_lower, iter_upper) << '\n';
24 | 
25 | 	copy(iter_lower, iter_upper, std::ostream_iterator<int>(std::cout, " "));
26 | }
27 | 


--------------------------------------------------------------------------------
/merge_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <algorithm>
 3 | #include <vector>
 4 | 
 5 | int main() 
 6 | {
 7 |     std::vector x{ 1, 3, 5, 7 };
 8 |     std::vector y{ 2, 4, 6, 8 };
 9 |     std::vector<int> result(x.size() + y.size());
10 | 
11 |     std::merge(x.begin(), x.end(), y.begin(), y.end(), result.begin());
12 | 
13 |     for (int i : result)
14 |         std::cout << i << ' '; 
15 | }
16 | 


--------------------------------------------------------------------------------
/merge_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | // std::generate
 3 | // std::sort
 4 | // std::copy
 5 | // std::merge
 6 | 
 7 | #include <algorithm>
 8 | #include <random>
 9 | #include <iostream>
10 | 
11 | int main()
12 | {
13 | 	std::vector<int> x(10);
14 | 	std::vector<int> y(6);
15 | 	std::mt19937 eng{ std::random_device{}() };
16 | 	std::uniform_int_distribution dist{ 0, 1000 };
17 | 	generate(x.begin(), x.end(), [&eng, &dist] {return dist(eng); });
18 | 	generate(y.begin(), y.end(), [&eng, &dist] {return dist(eng); });
19 | 	sort(x.begin(), x.end());
20 | 	sort(y.begin(), y.end());
21 | 	std::cout << "x\n";
22 | 	copy(x.begin(), x.end(), std::ostream_iterator<int>{std::cout, " "});
23 | 	std::cout << "\ny\n";
24 | 	copy(y.begin(), y.end(), std::ostream_iterator<int>{std::cout, " "});
25 | 
26 | 	std::vector<int> mrg(x.size() + y.size());
27 | 	merge(x.begin(), x.end(), y.begin(), y.end(), mrg.begin());
28 | 	std::cout << "\nmrg\n";
29 | 	copy(mrg.begin(), mrg.end(), std::ostream_iterator<int>{std::cout, " "});
30 | }
31 | 


--------------------------------------------------------------------------------
/min_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <random>
 2 | #include <iostream>
 3 | #include <format>
 4 | #include <algorithm>
 5 | 
 6 | int main()
 7 | {
 8 | 	std::mt19937 eng{ std::random_device{}() };
 9 | 	std::uniform_int_distribution dist{ -999, 999 };
10 | 
11 | 	const int x = dist(eng);
12 | 	const int y = dist(eng);
13 | 	const int z = dist(eng);
14 | 	const int t = dist(eng);
15 | 
16 | 	std::cout << std::format("{} {} {} {}\n", x, y, z, t);
17 | 	std::cout << "min = " << std::min({ x, y, z, t }) << '\n';
18 | 	std::cout << "max = " << std::max({ x, y, z, t }) << '\n';
19 | 
20 | 	const auto fcomp = [](int x, int y) {
21 | 		return std::abs(x) < std::abs(y);
22 | 		};
23 | 
24 | 	std::cout << "\n";
25 | 
26 | 	std::cout << "min = " << std::min({ x, y, z, t }, fcomp) << '\n';
27 | 	std::cout << "max = " << std::max({ x, y, z, t }, fcomp) << '\n';
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/mismatch_01.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | 
 3 | namespace std {
 4 |     template<class InputIt1, class InputIt2>
 5 |     constexpr pair<InputIt1, InputIt2> mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2);
 6 | 
 7 |     template<class InputIt1, class InputIt2, class BinaryPredicate>
 8 |     constexpr pair<InputIt1, InputIt2> mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2,
 9 |                                                 BinaryPredicate p);
10 | }
11 | 
12 | */
13 | 


--------------------------------------------------------------------------------
/move_01.cpp:
--------------------------------------------------------------------------------
 1 | template <typename InIter, typename OutIter>
 2 | OutIter Move(InIter beg, InIter end, OutIter destbeg)
 3 | {
 4 | 	while (beg != end) {
 5 | 		*destbeg = std::move(*beg);
 6 | 		++beg;
 7 | 		++destbeg;
 8 | 	}
 9 | 
10 | 	return destbeg;
11 | }
12 | 


--------------------------------------------------------------------------------
/move_02.cpp:
--------------------------------------------------------------------------------
 1 | //std::copy
 2 | //std::move
 3 | 
 4 | #include <iostream>
 5 | #include <vector>
 6 | #include <algorithm>
 7 | 
 8 | class Myclass {
 9 | public:
10 | 	Myclass() = default;
11 | 
12 | 	Myclass& operator=(const Myclass&)
13 | 	{
14 | 		std::cout << "copy assignment\n";
15 | 		return *this;
16 | 	}
17 | 
18 | 	Myclass& operator=(Myclass&&)noexcept
19 | 	{
20 | 		std::cout << "move assignment\n";
21 | 		return *this;
22 | 	}
23 | };
24 | 
25 | int main()
26 | {
27 | 	std::vector<Myclass> vec_source(5);
28 | 	std::vector<Myclass> vec_dest(5);
29 | 
30 | 	copy(vec_source.begin(), vec_source.end(), vec_dest.begin());
31 | 	move(vec_source.begin(), vec_source.end(), vec_dest.begin());
32 | 
33 | }
34 | 


--------------------------------------------------------------------------------
/move_backward_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <memory>
 4 | #include <algorithm>
 5 | 
 6 | int main() 
 7 | {
 8 |     std::vector<std::unique_ptr<int>> vec;
 9 | 
10 |     for (int i = 0; i < 5; ++i)
11 |         vec.emplace_back(std::make_unique<int>(i));
12 | 
13 |     std::move_backward(vec.begin(), vec.begin() + 3, vec.end());
14 | 
15 |     for (const auto& ptr : vec) {
16 |         if (ptr)
17 |             std::cout << *ptr << " ";
18 |         else
19 |             std::cout << "empty ";
20 |     }
21 |     std::cout << '\n';
22 | }
23 | 


--------------------------------------------------------------------------------
/n_th_element_01.cpp:
--------------------------------------------------------------------------------
 1 | //std::generate_n
 2 | //std::nth_element
 3 | 
 4 | #include <vector>
 5 | #include <random>
 6 | #include <algorithm>
 7 | #include <iostream>
 8 | 
 9 | int main()
10 | {
11 | 	using namespace std;
12 | 
13 | 	constexpr int size = 10'000;
14 | 
15 | 	vector<int> ivec;
16 | 	ivec.reserve(size);
17 | 	mt19937 eng;
18 | 	uniform_int_distribution dist{ 0, 100'000 };
19 | 	generate_n(back_inserter(ivec), 10'000, [&] {return dist(eng); });
20 | 	nth_element(ivec.begin(), ivec.begin() + size / 2, ivec.end());
21 | 	//...
22 | 	cout << "median value is : " << ivec[size / 2];
23 | }
24 | 


--------------------------------------------------------------------------------
/next_permuttion_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <algorithm>
 3 | #include <iostream>
 4 | 
 5 | template <typename T>
 6 | void print_vec(const std::vector<T>& vec)
 7 | {
 8 | 	for (const auto& elem : vec)
 9 | 		std::cout << elem << ' ';
10 | 
11 | 	std::cout << '\n';
12 | }
13 | 
14 | int main()
15 | {
16 | 	std::vector vec{ 1, 2, 3};
17 | 	do {
18 | 		print_vec(vec);
19 | 	} while (std::next_permutation(vec.begin(), vec.end()));
20 | }
21 | 


--------------------------------------------------------------------------------
/numeric/accumulate_01.cpp:
--------------------------------------------------------------------------------
 1 | template<class InIter, class T>
 2 | constexpr // since C++20
 3 | T accumulate(InIter first, InIter last, T init)
 4 | {
 5 |     for (; first != last; ++first)
 6 |         init = std::move(init) + *first; // std::move since C++20
 7 | 
 8 |     return init;
 9 | }
10 | 


--------------------------------------------------------------------------------
/numeric/accumulate_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <numeric>
 3 | #include <algorithm>
 4 | #include <iostream>
 5 | #include <string>
 6 | 
 7 | 
 8 | int main()
 9 | {
10 | 	using namespace std::literals;
11 | 
12 | 	std::vector vec{ 2, 3, 7, 5, 9, 1, 6 };
13 | 	
14 | 	std::cout << std::accumulate(vec.begin(), vec.end(), 0) << '\n';
15 | 	std::cout << std::accumulate(vec.begin(), vec.end(), 100) << '\n';
16 | 
17 | 	std::vector<std::string> svec{ "Ali", "Ayse", "Nur", "Tan", "Ege", "Gul" };
18 | 	std::cout << std::accumulate(svec.begin(), svec.end(), ""s) << '\n';
19 | }
20 | 


--------------------------------------------------------------------------------
/numeric/accumulate_03.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <numeric>
 3 | #include <iostream>
 4 | #include <functional>
 5 | 
 6 | int main()
 7 | {
 8 |     std::vector vec{ 1, 2, 3, 4, 5};
 9 |     
10 |     std::cout << accumulate(vec.begin(), vec.end(), 1, std::multiplies<>{})
11 |         << '\n';
12 | }
13 | 


--------------------------------------------------------------------------------
/numeric/accumulate_04.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <numeric>
 3 | #include <iostream>
 4 | #include <functional>
 5 | 
 6 | int main()
 7 | {
 8 |     std::vector vec{ 1, 2, 3, 4, 5};
 9 |     
10 |     std::cout << accumulate(vec.begin(), vec.end(), 0, [](int x, int y) {return x + y * 2; })
11 |         << '\n';
12 | }
13 | 


--------------------------------------------------------------------------------
/numeric/accumulate_05.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <numeric>
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | #include <string>
 6 | 
 7 | int main()
 8 | {
 9 |     using namespace std::literals;
10 | 
11 |     std::vector<std::string> svec{ "ali", "mert", "nefes", "selim", "nur", "faruk" };
12 |     
13 |     std::cout << accumulate(svec.begin(), svec.end(), ""s, [](const std::string &s, std::string rs) 
14 |         {
15 |             std::reverse(rs.begin(), rs.end());
16 |             return s + rs;
17 |         })
18 |         << '\n';
19 | }
20 | 


--------------------------------------------------------------------------------
/numeric/adjacent_difference_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <iostream>
 4 | 
 5 | int main() 
 6 | {
 7 |     std::vector<int> vec{ 1,3,6,10 };
 8 |     std::vector<int> dest(vec.size());
 9 |     
10 |     std::adjacent_difference(vec.begin(), vec.end(), dest.begin()); // dest: 1, 2, 3, 4
11 |     
12 |     for (int x : dest) 
13 |         std::cout << x << ' ';
14 | }
15 | 


--------------------------------------------------------------------------------
/numeric/adjacent_difference_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <numeric>
 3 | #include <iostream>
 4 | 
 5 | int main()
 6 | {
 7 |     std::vector<int> original{ 1, 2, 3, 4, 5, 6 };   // input
 8 |     std::vector<int> cumulated(original.size());
 9 |     std::vector<int> recovered(original.size());
10 | 
11 |     std::partial_sum(original.begin(), original.end(), cumulated.begin());
12 |     
13 |     for (int x : cumulated)
14 |         std::cout << x << ' ';
15 | 
16 |     std::cout << '\n';
17 | 
18 |     std::adjacent_difference(cumulated.begin(), cumulated.end(), recovered.begin());
19 |     // recovered: 1, 2, 3, 4, 5, 6 (same as original)
20 | 
21 |     for (int x : recovered) 
22 |         std::cout << x << ' ';
23 | }
24 | 


--------------------------------------------------------------------------------
/numeric/adjacent_difference_03.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <iostream>
 4 | #include <algorithm> 
 5 | #include <print> 
 6 | 
 7 | int main() 
 8 | {
 9 |     std::vector<int> a{2, 4, 1, 7, 3};
10 | 
11 |     std::print("{}\n", a);
12 |     std::partial_sum(a.begin(), a.end(), a.begin());
13 |     std::print("{}\n", a);
14 |     std::adjacent_difference(a.begin(), a.end(), a.begin());
15 |     std::print("{}\n", a);
16 | }
17 | 


--------------------------------------------------------------------------------
/numeric/exclusive_scan_01.cpp:
--------------------------------------------------------------------------------
 1 | // exclusive_scan C++17
 2 | 
 3 | #include <numeric>
 4 | #include <vector>
 5 | #include <iostream>
 6 | 
 7 | int main() 
 8 | {
 9 |     std::vector<int> vec{ 1, 2, 3, 4 };
10 |     std::vector<int> dest(vec.size());
11 | 
12 |     std::exclusive_scan(vec.begin(), vec.end(), dest.begin(), 0); // out: 0,1,3,6
13 |         
14 |     for (int i : dest) 
15 |         std::cout << i << ' ';
16 | }
17 | 


--------------------------------------------------------------------------------
/numeric/gcd_01:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/numeric/inclusive_scan_01.cpp:
--------------------------------------------------------------------------------
 1 | // inclusive_scan C++17
 2 | 
 3 | #include <numeric>
 4 | #include <vector>
 5 | #include <iostream>
 6 | 
 7 | int main() 
 8 | {
 9 |     std::vector<int> vec{ 1, 2, 3, 4 };
10 |     std::vector<int> dest(vec.size());
11 | 
12 |     std::inclusive_scan(vec.begin(), vec.end(), dest.begin()); 
13 |         
14 |     for (int i : dest) 
15 |         std::cout << i << ' ';
16 | }
17 | 


--------------------------------------------------------------------------------
/numeric/inner_product_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <iostream>
 3 | #include <vector>
 4 | 
 5 | int main()
 6 | {
 7 | 	std::vector vec1{ 2, 5, 7, 6, 4 };
 8 | 	std::vector vec2{ 2, 1, 2, 7, 8 };
 9 | 	// 0 + 4 + 5 + 14 + 42 + 32
10 | 
11 | 	auto result = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
12 | 
13 | 	std::cout << "result = " << result << '\n';
14 | }
15 | 


--------------------------------------------------------------------------------
/numeric/inner_product_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <numeric>
 3 | #include <vector>
 4 | #include <functional>
 5 | 
 6 | int main()
 7 | {
 8 |     std::vector<int> x{ 2, 3, 1, 5, 6 };
 9 |     std::vector<int> y{ 1, 2, 4, 3, 5 };
10 |     //                  2  6  4  15 30
11 | 
12 |     //auto result = std::inner_product(x.begin(), x.end(), y.begin(), 0);
13 |     auto result = std::inner_product(x.begin(), x.end(), y.begin(), 0, std::plus<>{}, std::multiplies<>{});
14 |     std::cout << "Inner product of x and y: " << result << '\n';
15 | }
16 | 


--------------------------------------------------------------------------------
/numeric/inner_product_03.cpp:
--------------------------------------------------------------------------------
 1 | #include <functional>
 2 | #include <iostream>
 3 | #include <numeric>
 4 | #include <string>
 5 | 
 6 | int main()
 7 | {
 8 |     std::vector<std::string> v1{ "ali", "can", "ece", "ata", "gul", "tan", "eda", "naz" };
 9 |     std::vector<std::string> v2{ "nur", "tan", "ece", "ece", "gul", "tan", "naz", "eda" };
10 | 
11 |     int result = std::inner_product(v1.begin(), v1.end(), v2.begin(), 0, std::plus{}, std::equal_to{});
12 |     std::cout << "result = " << result << '\n';
13 | }
14 | 


--------------------------------------------------------------------------------
/numeric/inner_product_04.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <iostream>
 4 | #include <algorithm> 
 5 | 
 6 | int main() 
 7 | {
 8 |     std::vector<int> a{ 10, 40, 30, 13 };
 9 |     std::vector<int> b{ 20, 15, 35, 5};
10 | 
11 |     int result = std::inner_product(
12 |         a.begin(), a.end(), b.begin(), 0,
13 |         std::plus{},
14 |         [](int x, int y) { return std::min(x, y); }
15 |     );
16 | 
17 |     // min(10,20) + min(40,15) + min(30,35) + min(13, 5) = 10 + 15 + 30 + 5 = 60
18 |     std::cout << "min-sum: " << result << '\n';
19 | }
20 | 


--------------------------------------------------------------------------------
/numeric/inner_product_05.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <iostream>
 4 | 
 5 | int main() 
 6 | {
 7 |     std::vector<bool> a{ true, true, false, true };
 8 |     std::vector<bool> b{ true, false, false, true };
 9 | 
10 |     int result = std::inner_product(
11 |         a.begin(), a.end(), b.begin(), 0,
12 |         std::plus<>{},
13 |         [](bool x, bool y) { return x and y; }
14 |     );
15 | 
16 |     std::cout << "Logical AND count: " << result << '\n'; 
17 | }
18 | 


--------------------------------------------------------------------------------
/numeric/inner_product_06.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <cmath>
 4 | #include <iostream>
 5 | 
 6 | int main() 
 7 | {
 8 |     std::vector<int> real{ 90, 100, 80 };
 9 |     std::vector<int> pred{ 85, 110, 75 };
10 | 
11 |     double total_abs_diff = std::inner_product(
12 |         real.begin(), real.end(), pred.begin(), 0.0,
13 |         std::plus<>{},
14 |         [](int r, int p) { return std::abs(r - p); }
15 |     );
16 | 
17 |     std::cout << "Total absolute error: " << total_abs_diff << '\n'; // 5 + 10 + 5 = 20
18 | }
19 | 


--------------------------------------------------------------------------------
/numeric/iota_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <iostream>
 3 | 
 4 | template<typename ForIt, typename T>
 5 | constexpr void Iota(ForIt beg, ForIt end, T val)
 6 | {
 7 |     for (; beg != end; ++beg, ++val)
 8 |         *beg = val;
 9 | }
10 | 
11 | int main()
12 | {
13 |     std::vector<int> ivec(20);
14 |     Iota(ivec.begin(), ivec.end(), 10);
15 | 
16 |     for (const auto i : ivec)
17 |         std::cout << i << ' ';
18 | }
19 | 


--------------------------------------------------------------------------------
/numeric/lcm_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <iostream>
 3 | 
 4 | int main() 
 5 | {
 6 |     constexpr auto i1 = std::lcm(8, 12);
 7 |     constexpr auto i2 = std::lcm(-8, 12);
 8 |     constexpr auto i3 = std::lcm(12, -8);
 9 |     constexpr auto i4 = std::lcm(-12, -8);
10 | }
11 | 


--------------------------------------------------------------------------------
/numeric/midpoint_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <iostream>
 3 | 
 4 | int main() 
 5 | {
 6 |     int x = 1'000'000'000, y = 2'000'000'000;
 7 |     // (a + b)/2 overflows, midpoint has no overflow guarantee
 8 |     std::cout << std::midpoint(x, y) << '\n'; // 1500000000
 9 | }
10 | 


--------------------------------------------------------------------------------
/numeric/partial_sum_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <numeric>
 3 | #include <iostream>
 4 | 
 5 | int main()
 6 | {
 7 | 	std::vector svec{ 1, 3, 5, 7, 9, 11, 13, 15 };
 8 | 	std::vector<int> dvec(svec.size());
 9 | 
10 | 	partial_sum(svec.begin(), svec.end(), dvec.begin());
11 | 
12 | 	for (auto i : dvec)
13 | 		std::cout << i << ' ';
14 | }
15 | 


--------------------------------------------------------------------------------
/numeric/partial_sum_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <iostream>
 4 | #include <functional>
 5 | 
 6 | int main() 
 7 | {
 8 |     std::vector source{ 1, 3, 5, 7};
 9 |     std::vector<int> dest(source.size());
10 |     std::partial_sum(source.begin(), source.end(), dest.begin(), std::plus{});
11 |     
12 |     //std::partial_sum(source.begin(), source.end(), dest.begin(), std::multiplies{});
13 |     
14 |     //std::partial_sum(source.begin(), source.end(), dest.begin(), [](int x, int y) {
15 |         //return std::abs(x - y); });
16 | 
17 |     for (int i : dest) 
18 |         std::cout << i << ' ';
19 | }
20 | 


--------------------------------------------------------------------------------
/numeric/partial_sum_03.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <string>
 4 | #include <iostream>
 5 | 
 6 | int main() 
 7 | {
 8 |     std::vector<std::string> source{ "C", "+", "+", "20", " standard"};
 9 |     std::vector<std::string> dest(source.size());
10 | 
11 |     std::partial_sum(source.begin(), source.end(), dest.begin());
12 | 
13 |     for (const auto& s : dest)
14 |         std::cout << "[" << s << "] ";  
15 | }
16 | 


--------------------------------------------------------------------------------
/numeric/partial_sum_04.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <iostream>
 4 | 
 5 | int main() 
 6 | {
 7 |     std::vector<int> source{ 1, 2, 3, 4 };
 8 |     std::vector<int> dest1(source.size());
 9 |     std::vector<int> dest2(source.size());
10 | 
11 |     std::partial_sum(source.begin(), source.end(), dest1.begin());            // C++98
12 |     std::inclusive_scan(source.begin(), source.end(), dest2.begin());         // C++17
13 | 
14 |     for (int x : dest1) std::cout << x << " "; std::cout << '\n';
15 |     for (int x : dest2) std::cout << x << " "; std::cout << '\n';
16 |     }
17 | 


--------------------------------------------------------------------------------
/numeric/reduce_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <iostream>
 4 | 
 5 | int main() 
 6 | {
 7 |     std::vector<double> v{ 1.0, 2.0, 3.0, 4.0 };
 8 |     double result = std::reduce(v.begin(), v.end(), 0.0); // 10.0
 9 |     std::cout << result << '\n';
10 | }
11 | 


--------------------------------------------------------------------------------
/numeric/reduce_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <numeric>
 3 | #include <iostream>
 4 | 
 5 | int main()
 6 | {
 7 | 	std::vector ivec{ 1, 3, 5, 7, 9 };
 8 | 
 9 | 	auto x = reduce(ivec.begin(), ivec.end(), 0);
10 | 	auto y = reduce(ivec.begin(), ivec.end());
11 | 	auto z = reduce(ivec.begin(), ivec.end(), int{});
12 | 
13 | 	std::cout << "x = " << x << '\n';
14 | 	std::cout << "y = " << y << '\n';
15 | 	std::cout << "z = " << z << '\n';
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/numeric/reduce_03.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <string>
 4 | #include <iostream>
 5 | 
 6 | 
 7 | int main() 
 8 | {
 9 |     using namespace std::literals;
10 | 
11 |     std::vector<std::string> names{"nefes", "emine", "caner", "aytek", "tugra", "irfan"};
12 | 
13 |     auto s = std::reduce(names.begin(), names.end());
14 | 
15 |     std::cout << s << '\n';
16 | }
17 | 


--------------------------------------------------------------------------------
/numeric/transform_exclusive_scan_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <iostream>
 4 | 
 5 | int main() 
 6 | {
 7 |     std::vector<int> vec{ 1,2,3,4 };
 8 |     std::vector<int> dest(vec.size());
 9 |     
10 |     std::transform_exclusive_scan(
11 |         vec.begin(), vec.end(), dest.begin(), 0,
12 |         std::plus<>{},
13 |         [](int x) { return x * x; }  // map: square
14 |     ); 
15 | 
16 |     for (int x : dest) 
17 |         std::cout << x << ' ';
18 | }
19 | 


--------------------------------------------------------------------------------
/numeric/transform_inclusive_scan_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <iostream>
 4 | 
 5 | int main() 
 6 | {
 7 |     std::vector<int> vec{ 1, 2, 3, 4 }, dest(vec.size());
 8 |     std::transform_inclusive_scan(
 9 |         vec.begin(), vec.end(), dest.begin(),
10 |         std::plus<>{},
11 |         [](int i) { return 2 * i; } // map: double
12 |     ); // dest: 2,6,12,20
13 |     
14 |     for (int i : dest) 
15 |         std::cout << i << " ";
16 | }
17 | 


--------------------------------------------------------------------------------
/numeric/transform_reduce_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <numeric>
 3 | #include <iostream>
 4 | 
 5 | //T transform_reduce(Iter1 first1, Iter1 last1, Iter2 first2, T init);
 6 | 
 7 | int main()
 8 | {
 9 | 	std::vector a{ 1, 2, 3 };
10 | 	std::vector	b{ 4, 5, 6 };
11 | 
12 | 	int dot = std::transform_reduce(a.begin(), a.end(), b.begin(), 0);
13 | 	std::cout << "dot = " << dot << '\n';
14 | }
15 | 


--------------------------------------------------------------------------------
/numeric/transform_reduce_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <numeric>
 3 | #include <iostream>
 4 | 
 5 | // T transform_reduce(It1 f1, It1 l1, It2 f2, T init, BinaryOp1 reduce, BinaryOp2 transform);
 6 | 
 7 | int main()
 8 | {
 9 |     std::vector x{ 1, 2, 10, 5 };
10 |     std::vector y{ 2, 3,  4, 9 };
11 |     // (x[i] * y[i]) degerleri icin max
12 |     
13 |     int max_prod = 
14 |     std::transform_reduce(x.begin(), x.end(), 
15 |                         y.begin(),
16 |                         std::numeric_limits<int>::min(),
17 |                         [](int L, int R) { return std::max(L, R); },  // reduce
18 |                         std::multiplies<>{}// transform
19 |     );
20 |     std::cout << "max product = " << max_prod << '\n';
21 | }
22 | 


--------------------------------------------------------------------------------
/numeric/transform_reduce_03.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <numeric>
 3 | #include <iostream>
 4 | 
 5 | //    T transform_reduce(It1 first1, It1 last1, It2 first2, T init, BinaryOp1 reduce, BinaryOp2 transform);
 6 | 
 7 | int main()
 8 | {
 9 |     std::vector<int> x{ 1, 2, 10, 5 };
10 |     std::vector<int> y{ 2, 3,  4, 9 };
11 | 
12 |     int result = std::transform_reduce(
13 |         x.begin(), x.end(), y.begin(),
14 |         0,
15 |         std::plus<>{},                                  // reduce
16 |         [](int x, int y) { return std::abs(x - y); }    // transform
17 |     );
18 | 
19 |     std::cout << "result = " << result << '\n';
20 | }
21 | 


--------------------------------------------------------------------------------
/numeric/transform_reduce_04.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <numeric>
 3 | #include <iostream>
 4 | 
 5 | // T transform_reduce(Iter first, Iter last, T init, BinaryOp reduce, UnaryOp transform);
 6 | 
 7 | int main()
 8 | {
 9 |     std::vector vec{ 1, 2, 3, 4 };
10 | 
11 |     int sumsquare = std::transform_reduce(
12 |         vec.begin(), vec.end(),
13 |         0,
14 |         std::plus<>{},                 // reduce
15 |         [](int x) { return x * x; }    // transform
16 |     );
17 | 
18 |     std::cout << "sum of squares = " << sumsquare << '\n';
19 | }
20 | 


--------------------------------------------------------------------------------
/numeric/transform_reduce_05.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <string>
 4 | #include <iostream>
 5 | 
 6 | int main() 
 7 | {
 8 |     std::vector<std::string> words{ "C++", "STL", "transform_reduce" };
 9 | 
10 |     int len_sum = std::transform_reduce(
11 |         words.begin(), words.end(), 0,
12 |         std::plus<>{},
13 |         [](const std::string& s) { return s.length(); }
14 |     );
15 | 
16 |     std::cout << "total length: " << len_sum << '\n'; // 3 + 3+ 16 = 22
17 | }
18 | 


--------------------------------------------------------------------------------
/numeric/transform_reduce_06.cpp:
--------------------------------------------------------------------------------
 1 | #include <numeric>
 2 | #include <vector>
 3 | #include <string>
 4 | #include <iostream>
 5 | 
 6 | int main() 
 7 | {
 8 |     using namespace std::literals;
 9 | 
10 |     std::vector<std::string> names{"nefes", "emine", "caner", "aytek", "tugra", "irfan"};
11 | 
12 |     auto name = std::transform_reduce(
13 |         names.begin(), names.end(), ""s,
14 |         std::plus<>{},
15 |         [](const std::string& s) { return s.front(); }
16 |     );
17 | 
18 |     std::cout << "name : " << name << '\n';
19 | 
20 |     name = std::transform_reduce(
21 |         names.begin(), names.end(), ""s,
22 |         std::plus<>{},
23 |         [](const std::string& s) { return s.back(); }
24 |     );
25 | 
26 |     std::cout << "name : " << name << '\n';
27 | }
28 | 


--------------------------------------------------------------------------------
/partial_sort_01.cpp:
--------------------------------------------------------------------------------
 1 | //std::generate_n
 2 | //std::partial_sort
 3 | //std::copy
 4 | 
 5 | #include <vector>
 6 | #include <random>
 7 | #include <algorithm>
 8 | #include <iterator>
 9 | #include <iostream>
10 | 
11 | int main()
12 | {
13 | 	std::vector<int> ivec;
14 | 	ivec.reserve(10'000);
15 | 
16 | 	std::mt19937 eng{ std::random_device{}() };
17 | 	std::uniform_int_distribution dist{ 0, 100'000 };
18 | 	generate_n(back_inserter(ivec), 10'000, [&] {return dist(eng); });
19 | 
20 | 	partial_sort(ivec.begin(), ivec.begin() + 20, ivec.end());
21 | 	//partial_sort(ivec.begin(), ivec.begin() + 20, ivec.end(), std::greater{});
22 | 	
23 | 	copy(ivec.begin(), ivec.begin() + 10, std::ostream_iterator<int>{std::cout, "\n"});
24 | }
25 | 


--------------------------------------------------------------------------------
/partial_sort_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <algorithm>
 3 | #include <string>
 4 | #include "nutility.h"
 5 | 
 6 | int main()
 7 | {
 8 | 	using namespace std;
 9 | 
10 | 	constexpr size_t size{ 10'000u };
11 | 	constexpr size_t n = 10;
12 | 	vector<string> svec(size);
13 | 	
14 | 	generate(svec.begin(), svec.end(), 
15 | 		 [] {return random_name() + ' ' + random_surname(); });
16 | 	partial_sort(svec.begin(), svec.begin() + 10, svec.end());
17 | 
18 | 	for_each(svec.begin(), svec.begin() + 10, [](const string& s) {
19 | 		cout << s << '\n'; });
20 | }
21 | 


--------------------------------------------------------------------------------
/partition_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <algorithm> 
 4 | #include <iterator>
 5 | 
 6 | int main() 
 7 | {
 8 |     std::vector vec{ 5, 6, 1, 4, 3, 2, 1, 8, 5, 6, 7 };
 9 | 
10 |     auto partition_point = std::partition(vec.begin(), vec.end(), [](int x) {
11 |         return x % 2 == 0; });
12 | 
13 |     std::cout << "even numbers:\n";
14 |     std::copy(vec.begin(), partition_point, std::ostream_iterator<int>{std::cout, " "});
15 | 
16 |     std::cout << "\nodd numbers:\n";
17 |     std::copy(partition_point, vec.end(), std::ostream_iterator<int>{std::cout, " "});
18 | }
19 | 


--------------------------------------------------------------------------------
/reverse_01.cpp:
--------------------------------------------------------------------------------
 1 | // from cppreference.com
 2 | 
 3 | template<class BidirIt>
 4 | constexpr // since C++20
 5 | void reverse(BidirIt first, BidirIt last)
 6 | {
 7 |     using iter_cat = typename std::iterator_traits<BidirIt>::iterator_category;
 8 |  
 9 |     // Tag dispatch, e.g. calling reverse_impl(first, last, iter_cat()),
10 |     // can be used in C++14 and earlier modes.
11 |     if constexpr (std::is_base_of_v<std::random_access_iterator_tag, iter_cat>)
12 |     {
13 |         if (first == last)
14 |             return;
15 |  
16 |         for (--last; first < last; (void)++first, --last)
17 |             std::iter_swap(first, last);
18 |     }
19 |     else
20 |         while (first != last && first != --last)
21 |             std::iter_swap(first++, last);
22 | }
23 | 


--------------------------------------------------------------------------------
/reverse_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <algorithm>
 2 | #include <iostream>
 3 | #include <vector>
 4 | #include <list>
 5 | #include <string>
 6 | 
 7 | int main()
 8 | {
 9 |     const auto print = [](const auto& c) {
10 |         for (const auto& e : c)
11 |             std::cout << e << ' ';
12 |         std::cout.put('\n');
13 |         };
14 | 
15 |     std::vector vec{ 1, 4, 7, 9, 6, 5, 2, 8, 0, 3 };
16 |     print(vec);
17 |     reverse(vec.begin(), vec.end());
18 |     print(vec);
19 |     std::list lst{ 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 };
20 |     print(lst);
21 |     reverse(lst.begin(), lst.end());
22 |     print(lst);
23 | 
24 |     std::string name{ "bjarne stroustrup" };
25 |     print(name);
26 |     reverse(name.begin(), name.end());
27 |     print(name);
28 | }
29 | 
30 | 


--------------------------------------------------------------------------------
/rotate_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include <algorithm>
 3 | #include <iostream>
 4 | 
 5 | int main()
 6 | {
 7 | 	std::string s{ "necatiergin" };
 8 | 	std::cout << '|' << s << "|\n";
 9 | 	std::rotate(s.begin(), next(s.begin(), 6), s.end());
10 | 	std::cout << '|' << s << "|\n";
11 | }
12 | 
13 | 
14 | 


--------------------------------------------------------------------------------
/sample_01.cpp:
--------------------------------------------------------------------------------
 1 | // std::sample C++17
 2 | 
 3 | #include <string>
 4 | #include <iostream>
 5 | #include <random>
 6 | #include <iterator>
 7 | 
 8 | int main()
 9 | {
10 | 	std::string input{"0123456789"};
11 | 	std::cout << "enter the distance for the sample: ";
12 | 	int dist;
13 | 	std::cin >> dist;
14 | 
15 | 	std::mt19937 eng{ std::random_device{}()};
16 | 	std::string str{};
17 | 
18 | 	for (int i = 0; i < 10; ++i) {
19 | 		std::sample(input.begin(), input.end(), std::back_inserter(str), dist, eng);
20 | 		std::cout << str << '\n';
21 | 		str = {};
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/search_01.cpp:
--------------------------------------------------------------------------------
 1 | // std::search
 2 | // std::find_end
 3 | 
 4 | #include <vector>
 5 | #include <string>
 6 | #include <algorithm>
 7 | #include <iostream>
 8 | #include <iterator>
 9 | 
10 | int main()
11 | {
12 |     std::vector<std::string> svec{ "gul", "ali", "nur", "ece", "can", "ece", "ali", "nur", "ece", "tan" };
13 |     std::vector<int>::iterator result;
14 | 
15 |     const auto list = { "ali", "nur", "ece" };
16 | 
17 |     std::cout << "search with std::search\n";
18 |     if (auto iter = std::search(svec.begin(), svec.end(), list.begin(), list.end()); iter != svec.end()) {
19 |         std::cout << "found at index : " << distance(svec.begin(), iter) << '\n';
20 |     }
21 |     else {
22 |         std::cout << "not found\n";
23 |     }
24 | 
25 |     std::cout << "search with std::find_end\n";
26 |     if (auto iter = std::find_end(svec.begin(), svec.end(), list.begin(), list.end()); iter != svec.end()) {
27 |         std::cout << "found at index : " << distance(svec.begin(), iter) << '\n';
28 |     }
29 |     else {
30 |         std::cout << "not found\n";
31 |     }
32 | 
33 | }
34 | 


--------------------------------------------------------------------------------
/search_n_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <algorithm>
 4 | 
 5 | int main() 
 6 | {
 7 |     std::vector<int> ivec = { 1, 2, 2, 2, 3, 4, -4, 4, -4, 5, 6 };
 8 | 
 9 |     // Using search_n to find the first occurrence of 3 consecutive 2's
10 |     if (const auto iter = std::search_n(ivec.begin(), ivec.end(), 3, 2);
11 |         iter != ivec.end()) {
12 |             std::cout << "Found 3 consecutive 2's starting at position: "
13 |             << std::distance(ivec.begin(), iter) << '\n';
14 |     }
15 |     else {
16 |         std::cout << "No sequence of 3 consecutive 2's found." << '\n';
17 |     }
18 | 
19 |     // Using search_n with a custom predicate:
20 |     if (const auto iter = std::search_n(ivec.begin(), ivec.end(), 4, 4,
21 |         [](int x, int y) { return std::abs(x) == std::abs(y); });
22 |         iter != ivec.end()) {
23 |         std::cout << "Found 4 consecutive 4's starting at position: "
24 |             << std::distance(ivec.begin(), iter) << '\n';
25 |     }
26 |     else {
27 |         std::cout << "No sequence of 4 consecutive 4's found." << '\n';
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/set_difference_01.cpp:
--------------------------------------------------------------------------------
 1 | // std::copy
 2 | // std::set_difference
 3 | // std::set_symmetric_difference
 4 | 
 5 | #include <vector>
 6 | #include <string>
 7 | #include <iterator>
 8 | #include <algorithm>
 9 | #include <iostream>
10 | 
11 | int main()
12 | {
13 | 	std::vector x{ 2, 3, 3, 7, 7, 19, 23, 31, 37, 45, 45, 61 };
14 | 	std::vector y{ 2, 5, 7, 7, 9, 23, 32, 45, 57, 61, 63 };
15 | 
16 | 	std::ostream_iterator<int> ositer{ std::cout, " " };
17 | 	std::cout << "x\n";
18 | 	copy(x.begin(), x.end(), ositer);
19 | 	std::cout << "\ny\n";
20 | 	copy(y.begin(), y.end(), ositer);
21 | 	
22 | 	std::cout << "\nx - y\n";
23 | 	std::set_difference(x.begin(), x.end(),	y.begin(), y.end(), ositer);
24 | 	std::cout << "\ny - x\n";
25 | 	std::set_difference(y.begin(), y.end(),	x.begin(), x.end(), ositer);
26 | 	std::cout << "\n(x - y) U (y - x)\n";
27 | 	std::set_symmetric_difference(x.begin(), x.end(),	y.begin(), y.end(), ositer);
28 | }
29 | 


--------------------------------------------------------------------------------
/set_intersection_01.cpp:
--------------------------------------------------------------------------------
 1 | //std::set_intersection
 2 | 
 3 | #include <vector>
 4 | #include <string>
 5 | #include <iterator>
 6 | #include <algorithm>
 7 | #include <iostream>
 8 | 
 9 | 
10 | int main()
11 | {
12 | 	std::vector x{ 2, 3, 3, 7, 7, 19, 23, 31, 37, 45, 45, 61 };
13 | 	std::vector y{ 2, 5, 7, 7, 9, 23, 32, 45, 57, 61, 63 };
14 | 
15 | 	std::set_intersection(x.begin(), x.end(),
16 | 		y.begin(), y.end(), std::ostream_iterator<int>{std::cout, " "});
17 | }
18 | 


--------------------------------------------------------------------------------
/set_union_01.cpp:
--------------------------------------------------------------------------------
 1 | //std::set_union
 2 | 
 3 | #include <vector>
 4 | #include <string>
 5 | #include <iterator>
 6 | #include <algorithm>
 7 | #include <iostream>
 8 | 
 9 | int main()
10 | {
11 | 	std::vector x{ 2, 3, 3, 7, 7, 19, 23, 31, 37, 45, 45, 61 };
12 | 	std::vector y{ 2, 5, 7, 7, 9, 23, 32, 45, 57, 61, 63 };
13 | 
14 | 	std::set_union(x.begin(), x.end(),
15 | 		y.begin(), y.end(), std::ostream_iterator<int>{std::cout, " "});
16 | }
17 | 


--------------------------------------------------------------------------------
/shuffle_01.cpp:
--------------------------------------------------------------------------------
 1 | // std::shuffle C++11
 2 | 
 3 | #include <string>
 4 | #include <random>
 5 | #include <algorithm>
 6 | #include <iostream>
 7 | 
 8 | int main()
 9 | {
10 | 	std::string str{"necati ergin"};
11 | 	std::mt19937 eng{ std::random_device{}() };
12 | 	
13 | 	int count{};
14 | 
15 | 	while (count < 1000) {
16 | 		std::shuffle(str.begin(), str.end(), eng);
17 | 		if (const auto idx = str.find(' '); idx > 2 && idx < 9) {
18 | 			std::cout << str << '\n';
19 | 			++count;
20 | 		}
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/stable_partition_gather.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <random>
 4 | #include <algorithm>
 5 | #include <functional>
 6 | 
 7 | void print_container(const auto& c)
 8 | {
 9 | 	for (const auto& elem : c) {
10 | 		std::cout << elem << ' ';
11 | 	}
12 | 	std::cout << '\n';
13 | }
14 | 
15 | int main()
16 | {
17 | 	std::vector<int> ivec;
18 | 	ivec.reserve(40);
19 | 
20 | 	std::mt19937 eng{ std::random_device{}() };
21 | 	std::uniform_int_distribution dist{ 10, 99 };
22 | 
23 | 	std::generate_n(back_inserter(ivec), 40, [&eng, &dist] {return dist(eng); });
24 | 	print_container(ivec);
25 | 	std::cout << "enter the idx to gather: ";
26 | 	int idx;
27 | 	std::cin >> idx;
28 | 	const auto div5 = [](int i) {return i % 5 == 0; };
29 | 
30 | 	const auto iter = next(ivec.begin(), idx);
31 | 	const auto beg = std::stable_partition(ivec.begin(), iter, std::not_fn(div5));
32 | 	const auto end = std::stable_partition(iter, ivec.end(), div5);
33 | 	print_container(ivec);
34 | 
35 | 	for_each(beg, end, [](int i) {std::cout << i << ' '; });
36 | }
37 | 


--------------------------------------------------------------------------------