misc-problem-solutions/include/forfun/array_concatenation.hpp at main · oboukli/misc-problem-solutions · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
// Copyright (c) Omar Boukli-Hacene. All rights reserved.
// Distributed under an MIT-style license that can be
// found in the LICENSE file.

// SPDX-License-Identifier: MIT

/// Problem sources:
/// https://leetcode.com/problems/concatenation-of-array/

#ifndef FORFUN_ARRAY_CONCATENATION_HPP_
#define FORFUN_ARRAY_CONCATENATION_HPP_

#include <algorithm>
#include <array>
#include <cstddef>
#include <iterator>

namespace forfun::array_concatenation {

namespace functional {

template <typename T, std::size_t Size>
constexpr auto concatenate(
    std::array<T, Size> const& src, std::array<T, 2UZ * Size>& dest
) noexcept -> void
{
    std::copy(src.cbegin(), src.cend(), dest.begin());
    std::copy(src.cbegin(), src.cend(), std::next(dest.begin(), Size));
}

} // namespace functional

namespace iterator_based {

template <typename T, std::size_t Size>
constexpr auto concatenate(
    std::array<T, Size> const& src, std::array<T, 2UZ * Size>& dest
) noexcept -> void
{
    for (std::size_t i{}; i < 2UZ; ++i)
    {
        auto iter{dest.begin()};
        std::advance(iter, Size * i);
        for (auto src_iter{src.cbegin()}; src_iter != src.cend(); ++src_iter)
        {
            *(iter++) = *src_iter;
        }
    }
}

} // namespace iterator_based

namespace iterator_based_double {

template <typename T, std::size_t Size>
constexpr auto concatenate(
    std::array<T, Size> const& src, std::array<T, 2UZ * Size>& dest
) noexcept -> void
{
    {
        auto iter{dest.begin()};
        for (auto src_iter{src.cbegin()}; src_iter != src.cend(); ++src_iter)
        {
            *(iter++) = *src_iter;
        }
    }
    {
        auto iter{std::next(dest.begin(), Size)};
        for (auto src_iter{src.cbegin()}; src_iter != src.cend(); ++src_iter)
        {
            *(iter++) = *src_iter;
        }
    }
}

} // namespace iterator_based_double

namespace iterator_unfolded {

template <typename T, std::size_t Size>
constexpr auto concatenate(
    std::array<T, Size> const& src, std::array<T, 2UZ * Size>& dest
) noexcept -> void
{
    auto dest1_iter{dest.begin()};
    auto dest2_iter{std::next(dest.begin(), Size)};
    for (auto src_iter{src.cbegin()}; src_iter != src.cend(); ++src_iter)
    {
        *(dest1_iter++) = *src_iter;
        *(dest2_iter++) = *src_iter;
    }
}

} // namespace iterator_unfolded

namespace nested_loops {

template <typename T, std::size_t Size>
constexpr auto concatenate(
    std::array<T, Size> const& src, std::array<T, 2UZ * Size>& dest
) noexcept -> void
{
    for (std::size_t i{}; i < 2UZ; ++i)
    {
#ifdef _MSC_VER
// Disable LOOP_BODY_NEVER_EXECUTED code analysis
#pragma warning(push)
#pragma warning(disable : 6294)
#endif // _MSC_VER
        for (std::size_t j{}; j < Size; ++j)
        {
            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
            dest[j + (i * Size)] = src[j];
        }
#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER
    }
}

} // namespace nested_loops

namespace semi_unfolded {

template <typename T, std::size_t Size>
constexpr auto concatenate(
    std::array<T, Size> const& src, std::array<T, 2UZ * Size>& dest
) noexcept -> void
{
#ifdef _MSC_VER
// Disable LOOP_BODY_NEVER_EXECUTED code analysis
#pragma warning(push)
#pragma warning(disable : 6294)
#endif // _MSC_VER
    for (std::size_t i{}; i < Size; ++i)
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
        dest[i] = src[i];
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
        dest[i + Size] = src[i];
    }
#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER
}

} // namespace semi_unfolded

} // namespace forfun::array_concatenation

#endif // FORFUN_ARRAY_CONCATENATION_HPP_