Asked about unique combinations

Author: BobSaidHi

include/CommonConfig.hpp

@@ -76,6 +76,10 @@ namespace LOAD {
      * like to create an array of all possible combinations of values in
      * PIN_VALUES_mOhms. (included some relevant lines of my own attempts as
      * context)
+     * @details Second Prompt: hanks, that seems to work perfectly! Could you
+     * add support for deduplicating the results? ie: a constexpr variable with
+     * the number of unique combinations, a consteval function to compute this,
+     * and a constexpr array of the deduplicated values?
      */
     namespace detail {
         // Sum of selected pins for a given bitmask
@@ -99,6 +103,61 @@ namespace LOAD {
 
             return {sum_for_mask(static_cast<uint_fast8_t>(Is), values)...};
         }
+
+        // --- helpers for deduplication ---
+
+        template <std::size_t N>
+        consteval etl::array<uint_fast16_t, N>
+        sorted_copy(const etl::array<uint_fast16_t, N> &input) {
+            auto result = input;
+            for (std::size_t i = 0; i < N; ++i) {
+                for (std::size_t j = i + 1; j < N; ++j) {
+                    if (result[j] < result[i]) {
+                        std::swap(result[i], result[j]);
+                    }
+                }
+            }
+            return result;
+        }
+
+        template <std::size_t N>
+        consteval std::size_t
+        count_unique(const etl::array<uint_fast16_t, N> &input) {
+            auto sorted = sorted_copy(input);
+            std::size_t count = 0;
+            bool first = true;
+            uint_fast16_t last = 0;
+
+            for (std::size_t i = 0; i < N; ++i) {
+                const auto v = sorted[i];
+                if (first || v != last) {
+                    ++count;
+                    last = v;
+                    first = false;
+                }
+            }
+            return count;
+        }
+
+        template <std::size_t InN, std::size_t OutN>
+        consteval etl::array<uint_fast16_t, OutN>
+        unique_sorted(const etl::array<uint_fast16_t, InN> &input) {
+            auto sorted = sorted_copy(input);
+            etl::array<uint_fast16_t, OutN> out{};
+            std::size_t out_i = 0;
+            bool first = true;
+            uint_fast16_t last = 0;
+
+            for (std::size_t i = 0; i < InN; ++i) {
+                const auto v = sorted[i];
+                if (first || v != last) {
+                    out[out_i++] = v;
+                    last = v;
+                    first = false;
+                }
+            }
+            return out;
+        }
     } // namespace detail
 
     /**
@@ -115,6 +174,19 @@ namespace LOAD {
     constexpr etl::array<uint_fast16_t, NUM_COMBINATIONS>
         ALL_COMBINATIONS_mOhms = getAllCombinations(PIN_VALUES_mOhms);
 
+    // number of unique combination values
+    constexpr std::size_t NUM_UNIQUE_COMBINATIONS =
+        detail::count_unique(ALL_COMBINATIONS_mOhms);
+
+    static_assert(NUM_UNIQUE_COMBINATIONS <= NUM_COMBINATIONS,
+                  "NUM_UNIQUE_COMBINATIONS must be <= NUM_COMBINATIONS");
+
+    // deduplicated, sorted combination values
+    constexpr etl::array<uint_fast16_t, NUM_UNIQUE_COMBINATIONS>
+        UNIQUE_COMBINATIONS_mOhms =
+            detail::unique_sorted<NUM_COMBINATIONS, NUM_UNIQUE_COMBINATIONS>(
+                ALL_COMBINATIONS_mOhms);
+
     // Pin 6 is connected by default in hardware
     constexpr uint_fast8_t INVERTED_PIN_INDEX = 5;
     constexpr uint8_t INVERTED_PIN_MASK = (1 << INVERTED_PIN_INDEX);