subgroups exercise using recursion

subgroups.spec.js

const _ = require("lodash");

function subgroups(elements) {
    if (elements.length == 1) {
        return [elements];
    }

    const drop = subgroups(_.drop(elements));
    const first = _.take(elements);
    const combined = [..._.map(drop, (i) => [...i, ...first]), ...[...drop, first]];

    return combined;
}

describe("subgroups", () => {
    _(_.range(2, 6))
        .map((n) => _.range(1, n))
        .each((inputElements) => {
            describe(`${inputElements}`, () => {
                let res;

                beforeAll(() => (res = subgroups(inputElements)));

                it("should ~2^n", () => expect(res.length).toBe((1 << inputElements.length) - 1));
                it("should unique", () => expect(_.uniq(res).length).toBe((1 << inputElements.length) - 1));
            });
        });
});

Nice! that's my solution too, recursion

I also started with the same stop condition as you: length === 1, but after I finished writing and started thinking that maybe the empty group should also be returned. Than I saw that if I change the stop condition to return the empty group, it also simplifies the combined calculation

My solution (and no lodash :))-

function subgroups(elements) {
    if (elements.length == 0) {
        return [[]];
    }

    const [first, ...rest] = elements
    const restSubgroups = subgroups(rest)
    const firstSubgroups =  restSubgroups.map(subgroup => [first, ...subgroup]) 

    return [...firstSubgroups, ...restSubgroups];
}

cool :)