Generate all possible customer and account combinations - algorithm

Question

I am developing an application to store the relationship data of customers and accounts (w.r.t banking domain). Typically in banks a customer can have an account which is a sole account or have a joint account with another customer.
Eg 1: Customer C1 has a sole account A1.
Eg 2: Customer C1 and C2 have a joint account JA1 where C1 is primary holder and C2 is non-primary holder.
I am looking for an algorithm that will generate all possible combinations of relationships for a given number of customers and accounts.
For example: if the number of customers = 2 and number of accounts = 2, then the algorithm should generate the below entries.
Combination #1:
C1-A1-Primary
C1-A2-Primary
C2-A1-Non-Primary
C2-A2-Non-Primary
Combination #2:
C1-A1-Primary
C1-A2-Non-Primary
C2-A1-Non-Primary
C2-A2-Primary
Combination #3:
C1-A1-Non-Primary
C1-A2-Primary
C2-A1-Primary
C2-A2-Non-Primary
Combination #4:
C1-A1-Non-Primary
C1-A2-Non-Primary
C2-A1-Primary
C2-A2-Primary
Combination #5:
C1-A1-Sole
C1-A2-Primary
C2-A2-Non-Primary
Combination #6:
C1-A1-Sole
C1-A2-Non-Primary
C2-A2-Primary
Combination #7:
C1-A2-Sole
C1-A1-Primary
C2-A1-Non-Primary
Combination #8:
C1-A2-Sole
C1-A1-Non-Primary
C2-A1-Primary
Edit: This is not the complete list of combinations - but the algorithm is supposed to generate all those.

Answer 1

You have 2 problems to solve here:
Get all possible account types for N customers. You can do it like this:
const allAccounts = [];
for (let i = 1; i <= customersNumber; i++) {
allAccounts.push(C${i}-Sole);
for (let j = 1; j <= customersNumber; j++) {
if (i === j) continue;
allAccounts.push(C${i}-Primary C${j}-NonPrimary);
}
}
For 2 customers the result will be:
[
"C1-Sole",
"C1-Primary C2-NonPrimary",
"C2-Sole",
"C2-Primary C1-NonPrimary"
]
Get all possible combinations of length r (with repetitions) from this array. We want to exclude two types of combinations here:
ones that have 2 or more sole accounts for the same customer.
ones that are not connected (have no common customers, if I got you right)
// checks if two accounts are connected
function connected(customers1, customers2) {
return customers1.filter(cu => customers2.includes(cu)).length > 0;
}
// checks if acc1 and acc2 are the same Sole account
function sameSoleAccount(acc1, acc2) {
return acc1.type === 'Sole' && acc1 === acc2;
}
function printAccount(i, a) {
const c = a.customers;
return a.type === 'Sole' ? `${c[0]}-A${i}-Sole` : `${c[0]}-A${i}-Primary ${c[1]}-A${i}-NonPrimary`;
}
function combination(chosen, arr, index, r) {
if (index === r) {
const combination = chosen.map((c, i) => printAccount(i + 1, arr[c])).join(', ');
console.log(combination);
return;
}
for (let i = 0; i < arr.length; i++) {
if (chosen.length === 0 ||
chosen.some(ch => !sameSoleAccount(arr[ch], arr[i])
&& connected(arr[ch].customers, arr[i].customers))) {
const copy = chosen.slice();
copy[index] = i;
combination(copy, arr, index + 1, r);
}
}
}
function allPossibleCombinations(accountsNumber, customersNumber) {
const allAccounts = [];
for (let i = 1; i <= customersNumber; i++) {
allAccounts.push({customers: [`C${i}`], type: 'Sole'});
for (let j = 1; j <= customersNumber; j++) {
if (i === j) continue;
allAccounts.push({customers: [`C${i}`, `C${j}`], type: 'Joint'});
}
}
console.log(`All possible combinations for ${customersNumber} customers and ${accountsNumber} accounts: `);
combination([], allAccounts, 0, accountsNumber);
}
allPossibleCombinations(2, 2);

Answer 2

If you have limited relationship between accounts and customers:
1) create dict with:
dMapCustomer = {<nCustomerId>: [<nAccountId1>, <nAccountId2>]}
2) for each customer create all possible pairs, it is just
lCustomerPairs = [(nCustomerId, nAccountId1), (nCustomerId, nAccountId2), ...]
3) concat all pairs from step 2.
l = []
for nCustomer in lCustomer:
l += lCustomerPairs
If any account can be linked with any customer, then just:
lAccounts = [1,2,3]
lCustomers = [4,5,6]
list(product(lCustomers, lCustomers)) # all possible pairs of account and customer
Function product generates all possible pairs from two lists:
def product(l1, l2):
pools = [tuple(pool) for pool in [l1, l2]]
result = [[]]
for pool in pools:
result = [x+[y] for x in result for y in pool]
for prod in result:
yield tuple(prod)