algorithm_mnemonics.txt

*algorithm_mnemonics.txt* Vim snippets to burst your productivity.

===============================================================================
MNEMONICS                                                 *algorithm_mnemonics*

  1. Mnemonics    ..........................    |algorithm_mnemonics_mnemonics|
    1.01. Containers    ...................    |algorithm_mnemonics_containers|
    1.02. Idioms    ...........................    |algorithm_mnemonics_idioms|
    1.03. Modifying    .....................    |algorithm_mnemonics_modifying|
    1.04. Mutating    .......................    |algorithm_mnemonics_mutating|
    1.05. Nonmodifying    ...............    |algorithm_mnemonics_nonmodifying|
    1.06. Numeric    .........................    |algorithm_mnemonics_numeric|
    1.07. Removing    .......................    |algorithm_mnemonics_removing|
    1.08. Sorted Ranges    .............    |algorithm_mnemonics_sorted_ranges|
    1.09. Sorting    .........................    |algorithm_mnemonics_sorting|
    1.10. Streams    .........................    |algorithm_mnemonics_streams|
    1.11. Strings    ..........................    |algorithm_mnemonics_string|
  2. Options    ..............................    |algorithm_mnemonics_options|
    2.1. const return    ................    |algorithm_mnemonics_const_return|
    2.2. lambda parameter    ........    |algorithm_mnemonics_lambda_parameter|

===============================================================================

1. Mnemonics                                    *algorithm_mnemonics_mnemonics*

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

1.01. Containers                                 *algorithm_mnemonics_containers*

'stv'                                              *algorithm_mnemonics_vector*
>
    std::vector<%\c> %\c
<
-------------------------------------------------------------------------------

1.02. Idioms                                       *algorithm_mnemonics_idioms*

'erm'                                               *algorithm_mnemonics_erase*
>
    %\m C%.erase(std::remove(std::begin(%\m C%), std::end(%\m C%), %\c), std::end(%\m C%));
<
-------------------------------------------------------------------------------

1.03. Modifying                                 *algorithm_mnemonics_modifying*

'cpb'                                       *algorithm_mnemonics_copy_backward*
>
    std::copy_backward(std::begin(%\m C%), std::end(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'cpi'                                             *algorithm_mnemonics_copy_if*
>
    std::copy_if(std::begin(%\m C%), std::end(%\m C%), std::begin(%\c),
    [](%\c) {
      %\c
    });
<
-------------------------------------------------------------------------------

'cpn'                                              *algorithm_mnemonics_copy_n*
>
    std::copy_n(std::begin(%\m C%), %\c, std::end(%\m C%));
<
-------------------------------------------------------------------------------

'cpy'                                                *algorithm_mnemonics_copy*
>
    std::copy(std::begin(%\m C%), std::end(%\m C%), std::begin(%\c));
<
-------------------------------------------------------------------------------

'fil'                                                *algorithm_mnemonics_fill*
>
    std::fill(std::begin(%\m C%), std::end(%\m C%), %\c);
<
-------------------------------------------------------------------------------

'fln'                                              *algorithm_mnemonics_fill_n*
>
    std::fill_n(std::begin(%\m C%), %\c, %\c);
<
-------------------------------------------------------------------------------

'gnn'                                          *algorithm_mnemonics_generate_n*
>
    std::generate_n(std::begin(%\m C%), %\c, [](%\c) {
      %\c
    });
<
-------------------------------------------------------------------------------

'gnr'                                            *algorithm_mnemonics_generate*
>
    std::generate(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
      %\c
    });
<
-------------------------------------------------------------------------------

'ita'                                               *algorithm_mnemonics_iota*
>
    std::iota(std::begin(%\m C%), std::end(%\m C%), %\c);
<
-------------------------------------------------------------------------------

'mov'                                                *algorithm_mnemonics_move*
>
    std::move(std::begin(%\m C%), std::end(%\m C%), std::begin(%\m C%));
<
-------------------------------------------------------------------------------

'mvb'                                       *algorithm_mnemonics_move_backward*
>
    std::move_backward(std::begin(%\m C%), std::end(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'rci'                                     *algorithm_mnemonics_replace_copy_if*
>
    std::replace_copy_if(std::begin(%\m C%), std::end(%\m C%),
      std::begin(%\m C%), [](%\c) {
      %\c
      }, %\c);
<
-------------------------------------------------------------------------------

'rpc'                                        *algorithm_mnemonics_replace_copy*
>
    std::replace_copy(std::begin(%\m C%), std::end(%\m C%), std::begin(%\m C%), %\c, %\c);
<
-------------------------------------------------------------------------------

'rpi'                                          *algorithm_mnemonics_replace_if*
>
    std::replace_if(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
    %\c
    }, %\c);
<
-------------------------------------------------------------------------------

'rpl'                                             *algorithm_mnemonics_replace*
>
    std::replace(std::begin(%\m C%), std::end(%\m C%), %\c, %\c);
<
-------------------------------------------------------------------------------

'swp'                                               *algorithm_mnemonics_swap*
>
    std::swap(%\m C%, %\c);
<
-------------------------------------------------------------------------------

'swr'                                         *algorithm_mnemonics_swap_ranges*
>
    std::swap_ranges(std::begin(%\m C%), std::end(%\m C%), std::begin(%\c));
<
-------------------------------------------------------------------------------

'tfm'                                           *algorithm_mnemonics_transform*
>
    std::transform(std::begin(%\m C%), std::end(%\m C%),
      std::begin(%\m C%), [](%\c) {
    %\c%
    });
<
-------------------------------------------------------------------------------

1.04. Mutating                                   *algorithm_mnemonics_mutating*

'nxp'                                    *algorithm_mnemonics_next_permutation*
>
    if (std::next_permutation(std::begin(%\m C%), std::end(%\m C%))) {
      %\c
    }
<
-------------------------------------------------------------------------------

'prp'                                    *algorithm_mnemonics_prev_permutation*
>
    if (std::prev_permutation(std::begin(%\m C%), std::end(%\m C%))) {
      %\c
    }
<
-------------------------------------------------------------------------------

'rtc'                                         *algorithm_mnemonics_rotate_copy*
>
    std::rotate_copy(std::begin(%\m C%), std::begin(%\c), std::end(%\m C%),
      std::begin(%\c));
<
-------------------------------------------------------------------------------

'rte'                                              *algorithm_mnemonics_rotate*
>
    std::rotate(std::begin(%\m C%), std::begin(%\c), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'rvc'                                        *algorithm_mnemonics_reverse_copy*
>
    std::reverse_copy(std::begin(%\m C%), std::end(%\m C%), std::begin(%\c));
<
-------------------------------------------------------------------------------

'rvr'                                             *algorithm_mnemonics_reverse*
>
    std::reverse(std::begin(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'shf'                                      *algorithm_mnemonics_random_shuffle*
>
    std::random_shuffle(std::begin(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

1.05. Nonmodifying                           *algorithm_mnemonics_nonmodifying*

'ajf'                                       *algorithm_mnemonics_adjacent_find*
>
    auto pos = std::adjacent_find(std::begin(%\m C%), std::end(%\m C%));
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'alo'                                              *algorithm_mnemonics_all_of*
>
    if (std::all_of(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
      %\c
    })) {
      %\c
    }
<
-------------------------------------------------------------------------------

'ano'                                              *algorithm_mnemonics_any_of*
>
    if (std::any_of(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
      %\c
    })) {
      %\c
    }
<
-------------------------------------------------------------------------------

'cni'                                            *algorithm_mnemonics_count_if*
>
    auto n = std::count_if(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
      %\c
    });
<
-------------------------------------------------------------------------------

'cnt'                                               *algorithm_mnemonics_count*
>
    auto n = std::count(std::begin(%\m C%), std::end(%\m C%), %\c);
<
-------------------------------------------------------------------------------

'eql'                                               *algorithm_mnemonics_equal*
>
    if (std::equal(std::begin(%\m C%), std::end(%\m C%), std::begin(%\c))) {
      %\c
    }
<
-------------------------------------------------------------------------------

'ffo'                                       *algorithm_mnemonics_find_first_of*
>
    auto pos = std::find_first_of(std::begin(%\m C%), std::end(%\m C%),
      std::begin(%\c), std::end(%\c));
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'fin'                                         *algorithm_mnemonics_find_if_not*
>
    auto pos = std::find_if_not(std::begin(%\m C%), std::end(%\m C%),[](%\c) {
      %\c
    });
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'fnd'                                                *algorithm_mnemonics_find*
>
    auto pos = std::find(std::begin(%\m C%), std::end(%\m C%), %\c);
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'fne'                                            *algorithm_mnemonics_find_end*
>
    auto pos = std::find_std::end(std::begin(%\m C%), std::end(%\m C%),
      std::begin(%\c), std::end(%\c));
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'fni'                                             *algorithm_mnemonics_find_if*
>
    auto pos = std::find_if(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
      %\c
    });
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'fre'                                            *algorithm_mnemonics_for_each*
>
    std::for_each(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
      %\c
    });
<
-------------------------------------------------------------------------------

'ihp'                                             *algorithm_mnemonics_is_heap*
>
    if (std::is_heap(std::begin(%\m C%), std::end(%\m C%))) {
      %\c
    }
<
-------------------------------------------------------------------------------

'ihu'                                       *algorithm_mnemonics_is_heap_until*
>
    auto pos = std::is_heap_until(std::begin(%\m C%), std::end(%\m C%));
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'ipr'                                      *algorithm_mnemonics_is_permutation*
>
    if (std::is_permutation(std::begin(%\m C%), std::end(%\m C%), std::begin(%\c))) {
      %\c
    }
<
-------------------------------------------------------------------------------

'ipt'                                      *algorithm_mnemonics_is_partitioned*
>
    if (std::is_partitioned(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
      %\c
      })) {
      %\c
    }
<
-------------------------------------------------------------------------------

'iss'                                           *algorithm_mnemonics_is_sorted*
>
    if (std::is_sorted(std::begin(%\m C%), std::end(%\m C%))) {
      %\c
    }
<
-------------------------------------------------------------------------------

'isu'                                     *algorithm_mnemonics_is_sorted_until*
>
    auto pos = std::is_sorted_until(std::begin(%\m C%), std::end(%\m C%));
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'lxc'                               *algorithm_mnemonics_lexigraphical_compare*
>
    if (std::lexigraphical_compare(std::begin(%\m C%), std::end(%\m C%),
      std::begin(%\c), std::end(%\c)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'mme'                                      *algorithm_mnemonics_minmax_element*
>
    auto minmax = std::minmax_element(std::begin(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'mne'                                         *algorithm_mnemonics_min_element*
>
    auto pos = std::min_element(std::begin(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'msm'                                            *algorithm_mnemonics_mismatch*
>
    auto values = std::mismatch(std::begin(%\m C%), std::end(%\m C%), std::begin(%\m C%));
    if (values.first == std::end(%\m C%)) {
      %\c
    } else {
      %\c
    }
<
-------------------------------------------------------------------------------

'mxe'                                         *algorithm_mnemonics_max_element*
>
    auto pos = std::max_element(std::begin(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'nno'                                             *algorithm_mnemonics_none_of*
>
    if (std::none_of(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
      %\c
    })) {
      %\c
    }
<
-------------------------------------------------------------------------------

'ppt'                                     *algorithm_mnemonics_partition_point*
>
    auto pos = std::partition_point(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
      %\c
    });
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'srh'                                              *algorithm_mnemonics_search*
>
    auto pos = std::search(std::begin(%\m C%), std::end(%\m C%),
      std::begin(%\c), std::end(%\c));
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'srn'                                            *algorithm_mnemonics_search_n*
>
    auto pos = std::search_n(std::begin(%\m C%), std::end(%\m C%),%\c,%\c);
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------


1.06. Numeric                                     *algorithm_mnemonics_numeric*

'acl'                                   *algorithm_mnemonics_accumulate_lambda*
>
    auto sum = std::accumulate(std::begin(%\m C%), std::end(%\m C%), 0, [](int total, %\c) {
      %\c
    });
<
-------------------------------------------------------------------------------

'acm'                                          *algorithm_mnemonics_accumulate*
>
    auto sum = std::accumulate(std::begin(%\m C%), std::end(%\m C%), 0);
<
-------------------------------------------------------------------------------

1.07. Removing                                   *algorithm_mnemonics_removing*

'rmc'                                         *algorithm_mnemonics_remove_copy*
>
    std::remove_copy(std::begin(%\m C%), std::end(%\m C%),
      std::begin(%\m C%), %\c);
<
-------------------------------------------------------------------------------

'rmf'                                      *algorithm_mnemonics_remove_copy_if*
>
    std::remove_copy_if(std::begin(%\m C%), std::end(%\m C%),
      std::begin(%\m C%), [](%\c) {
        %\c
    });
<
-------------------------------------------------------------------------------

'rmi'                                           *algorithm_mnemonics_remove_if*
>
    auto pos = std::remove_if(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
      %\c
    });
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'rmv'                                              *algorithm_mnemonics_remove*
>
    auto pos = std::remove(std::begin(%\m C%), std::end(%\m C%), %\c);
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'uqe'                                              *algorithm_mnemonics_unique*
>
    auto pos = std::unique(std::begin(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

1.08. Sorted Ranges                         *algorithm_mnemonics_sorted_ranges*

'bns'                                       *algorithm_mnemonics_binary_search*
>
    auto pos = std::binary_search(std::begin(%\m C%), std::end(%\m C%), %\c);
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'eqr'                                         *algorithm_mnemonics_equal_range*
>
    auto bounds = std::equal_range(std::begin(%\m C%), std::end(%\m C%), %\c);
<
-------------------------------------------------------------------------------

'erl'                                  *algorithm_mnemonics_equal_range_lambda*
>
    auto bounds = std::equal_range(std::begin(%\m C%), std::end(%\m C%), %\c,
      [](%\c,%\c) { %\c });
<
-------------------------------------------------------------------------------

'inc'                                            *algorithm_mnemonics_includes*
>
    if (std::includes(std::begin(%\m C%), std::end(%\m C%),
      std::begin(%\c), std::end(%\c))) {
        %\c
    }
<
-------------------------------------------------------------------------------

'ipm'                                       *algorithm_mnemonics_inplace_merge*
>
    std::inplace_merge(std::begin(%\m C%), std::end(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'lwb'                                         *algorithm_mnemonics_lower_bound*
>
    auto pos = std::lower_bound(std::begin(%\m C%), std::end(%\m C%), %\c);
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'mrg'                                               *algorithm_mnemonics_merge*
>
    std::merge(std::begin(%\m C%), std::end(%\m C%),
    std::begin(%\c), std::end(%\c), std::begin(%\c));
<
-------------------------------------------------------------------------------

'ssd'                            *algorithm_mnemonics_set_symmetric_difference*
>
    auto pos = std::set_symmetric_difference(std::begin(%\m C%),
      std::end(%\m C%), std::begin(%\c), std::end(%\c), std::begin(%\c));
<
-------------------------------------------------------------------------------

'std'                                      *algorithm_mnemonics_set_difference*
>
    auto pos = std::set_difference(std::begin(%\m C%), std::end(%\m C%),
      std::begin(%\c), std::end(%\c), std::begin(%\c));
<
-------------------------------------------------------------------------------

'stn'                                    *algorithm_mnemonics_set_intersection*
>
    auto pos = std::set_intersection(std::begin(%\m C%), std::end(%\m C%),
      std::begin(%\c), std::end(%\c), std::begin(%\c));
<
-------------------------------------------------------------------------------

'stu'                                           *algorithm_mnemonics_set_union*
>
    auto pos = std::set_union(std::begin(%\m C%), std::end(%\m C%),
      std::begin(%\c), std::end(%\c), std::begin(%\c));
<
-------------------------------------------------------------------------------

'ucp'                                         *algorithm_mnemonics_unique_copy*
>
    std::unique_copy(std::begin(%\m C%), std::end(%\m C%),
      std::ostream_iterator<string>(std::cout, "\n"));
<
-------------------------------------------------------------------------------

'upb'                                         *algorithm_mnemonics_upper_bound*
>
    auto pos = std::upper_bound(std::begin(%\m C%), std::end(%\m C%), %\c);
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

1.09. Sorting                                     *algorithm_mnemonics_sorting*

'mkh'                                           *algorithm_mnemonics_make_heap*
>
    std::make_heap(std::begin(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'nth'                                         *algorithm_mnemonics_nth_element*
>
    std::nth_element(std::begin(%\m C%), std::end(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'phh'                                           *algorithm_mnemonics_push_heap*
>
    std::push_heap(std::begin(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'pph'                                            *algorithm_mnemonics_pop_heap*
>
    std::pop_heap(std::begin(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'psc'                                   *algorithm_mnemonics_partial_sort_copy*
>
    std::partial_sort_copy(std::begin(%\m C%), std::end(%\m C%),
                      std::begin(%\c), std::end(%\c));
<
-------------------------------------------------------------------------------

'pst'                                        *algorithm_mnemonics_partial_sort*
>
    std::partial_sort(std::begin(%\m C%), std::end(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'ptc'                                      *algorithm_mnemonics_partition_copy*
>
    std::partition_copy(std::begin(%\m C%), std::end(%\m C%),
                      std::begin(%\c), std::end(%\c));
<
-------------------------------------------------------------------------------

'ptn'                                           *algorithm_mnemonics_partition*
>
    auto pos = std::partition(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
      %\c
    });
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'spt'                                    *algorithm_mnemonics_stable_partition*
>
    auto pos = std::stable_partition(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
      %\c});
    if (pos != std::end(%\m C%)) {
      %\c
    }
<
-------------------------------------------------------------------------------

'sth'                                           *algorithm_mnemonics_sort_heap*
>
    std::sort_heap(std::begin(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

'sts'                                         *algorithm_mnemonics_stable_sort*
>
    std::stable_sort(std::begin(%\m C%), std::end(%\m C%));
<
-------------------------------------------------------------------------------

1.10. Streams                                     *algorithm_mnemonics_streams*

'oit'                                           *algorithm_mnemonics_copy_cout*
>
    std::copy(std::begin(%\m C%), std::end(%\m C%), std::ostream_iterator<%\c>{
    %\istd::cout, "%\c"
    });
<
-------------------------------------------------------------------------------

'sti'                                                 *algorithm_mnemonics_cin*
>
    std::cin >>
<
-------------------------------------------------------------------------------

'sto'                                                *algorithm_mnemonics_cout*
>
    std::cout <<
<
-------------------------------------------------------------------------------

1.11. Strings                                      *algorithm_mnemonics_string*

'ltr'                                    *algorithm_mnemonics_string_trim_left*
>
    %\m C%.erase(0, %\m C%.find_first_not_of(" \t\n\r"));
<
-------------------------------------------------------------------------------

'lwr'                                        *algorithm_mnemonics_string_lower*
>
    std::transform(std::begin(%\m C%), std::end(%\m C%), std::begin(%\m C%), [](char c) {
    return std::tolower(c); });
<
-------------------------------------------------------------------------------

'trm'                                   *algorithm_mnemonics_string_trim_right*
>
    %\m C%.erase(%\m C%.find_last_not_of(" \t\n\r") + 1);
<
-------------------------------------------------------------------------------

'upr'                                        *algorithm_mnemonics_string_upper*
>
    std::transform(std::begin(%\m C%), std::end(%\m C%), std::begin(%\m C%), [](char c) {
    return std::toupper(c);
    });
    %\c
<
===============================================================================

2. Options                                        *algorithm_mnemonics_options*

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

'g:algorithm_mnemonics_const_return'       *g:algorithm_mnemonics_const_return*

Gives ability to add 'const type qualifier' to returning type.

Values:
  "None"  - don't add 'const'        => 'auto'
  "Left"  - add 'const' to the left  => 'const auto'
  "Right" - add 'const' to the right => 'auto const'
Default: >
  let g:algorithm_mnemonics_const_return = "Right"
<
-------------------------------------------------------------------------------

'g:algorithm_mnemonics_lambda_parameter' *algorithm_mnemonics_lambda_parameter*

Specifies how lambda parameter looks.

Values: string
Default: >
  let g:algorithm_mnemonics_lambda_parameter = "auto const value"
<
-------------------------------------------------------------------------------