241.md

<details open><summary>Info</summary><p>

* **Did you know about different ways of accessing C-style arrays by index?**

* http://eel.is/c++draft/dcl.array#def:array

</p></details><details open><summary>Example</summary><p>

```cpp
int main() {
  constexpr int array[] = {1, 2, 3};
  assert(2[array] == array[2]);
  assert(*(array+1) == array[1]);
}
```

> https://godbolt.org/z/5PnPzWvW8

</p></details><details open><summary>Puzzle</summary><p>

* **Can you implement `sum_n` which sums the first N numbers from the array using an altenative access syntax?**

```cpp
template<auto N>
/*TODO*/ auto sum_n(auto);

int main() {
  using namespace boost::ut;

  "sum_n"_test = [] {
    should("return 0 for empty array") = [] {
      constexpr int array[] = {};
      expect(constant<0 == sum_n<0>(array)>);
    };

    should("sum N first parameters") = [] {
      constexpr int array[] = {1, 2, 3};
      expect(constant<0 == sum_n<0>(array)>);
      expect(constant<1 == sum_n<1>(array)>);
      expect(constant<3 == sum_n<2>(array)>);
      expect(constant<6 == sum_n<3>(array)>);
    };
  };
}
```

> https://godbolt.org/z/5dMrTzGo7

</p></details><details><summary>Solutions</summary><p>

```cpp
template <auto N> constexpr auto sum_n(auto a) {
  std::decay_t<decltype(0 [a])> sum{};
  for (auto i = 0; i < N; ++i) {
    sum += i[a];
  }
  return sum;
}
```

> https://cpp-tip-of-the-week.godbolt.org/z/51fY56zdc

```cpp
template<auto N>
constexpr auto sum_n(auto arr) {
  return [&] <auto... Nth_of> (std::integer_sequence<int, Nth_of...>) {
    return (0 + ... + Nth_of[arr]);
  }(std::make_integer_sequence<int, N>{});
}
```

> https://godbolt.org/z/K9rcenjME

```cpp
template<auto N>
[[nodiscard]] constexpr auto sum_n(const auto array) {
    return [array]<auto... Is>(std::index_sequence<Is...>) {
        return (Is[array] + ... + 0);
    }(std::make_index_sequence<N>{});
}
```

> https://godbolt.org/z/cjo8MovY8

```cpp
template<auto N>
auto constexpr sum_n(auto arr) {
    double sum = 0;
    for(uint32_t i=0; i<N; i++)
        sum += *(arr+i);
    return sum;
}
```

> https://godbolt.org/z/Y6GxMMjx6

```cpp
template <auto I >
auto constexpr get_i(auto const & array)
{
    if constexpr (I % 3 == 0 )
        return array[I];
    else if constexpr (I % 3 == 1)
        return I[array];
    else
        return *(array + I );
}
template<auto N>
auto constexpr sum_n(auto const & array)
{
    return [&]<std::size_t ... Is>( std::index_sequence <Is...> const & )
    {
        return (get_i<Is>(array) + ... + 0 );
    }(std::make_index_sequence<N>());
}
```

> https://godbolt.org/z/cx4nfGhvz

```cpp
template <auto N>
constexpr auto sum_n(const auto& array) {
    return [&]<auto... Ith_index_of>(std::index_sequence<Ith_index_of...>) {
        return (0 + ... + Ith_index_of[array]);
    }(std::make_index_sequence<N>{});
}
```

> https://godbolt.org/z/d3Gcaq7Pn

```cpp
template<auto N>
[[nodiscard]] constexpr auto sum_n(const auto array) {
    return [array]<auto... Is>(std::index_sequence<Is...>) {
        return (Is[array] + ... + 0);
    }(std::make_index_sequence<N>{});
}
```

> https://godbolt.org/z/3nf6aKM4r