Different Algorithms for 50-50 A/B Testing

We are running A/B tests on web app customers, given a customerId. Each customer will see different minor UX changes.
Trying to prevent usage of Feature Flags as its not currently setup yet in our system.

Initially we tried Even-Odd on CustomerId number, 50-50% ratio to test Feature 1. Example UserId 4 is even, 7 is odd.
However, when testing another Feature 2, doing Even-Odd 50-50% would make , Feature 1 Groups to have a matching group with Feature 2, as they both share Same algorithm.

What is another mathematical algorithm method, to run a hash or 50-50% algorithm , so I can differentiate?
We will have probably 10 Features to test, so need a way to add a parameter in the FeatureFlag Algorithm, and will track in a Document Table.

We are assigning groups with Javascript/Typescript btw.

Note: Groups should be steady and not random , eg Even-odd will give a consistent result.

In order to get consistent and non-random group assignments for each customer ID and feature number, you can consider groups using:

• Hashing + Modulus:

  We can make use of a simple hash function to distribute the customer IDs uniformly, then apply the modulus operation to divide them into groups.

  • we'll hash the customer ID together with the feature number.
  • The result is then modded by a large prime number to help ensure a uniform distribution.
  • After that, we use mod 2 to divide into two groups.

  function hashCode(customerId, featureNum) {
      const str = customerId.toString() + featureNum.toString();
      let hash = 0;
      for (let i = 0; i < str.length; i++) {
          const char = str.charCodeAt(i);
          hash = ((hash << 5) - hash) + char;
          hash |= 0; // Convert to 32bit integer
      }
      return hash;
  }
  
  function assignGroup(customerId, featureNum) {
      const largePrime = 15485863; // Just an example, choose any large prime number
      const hash = hashCode(customerId, featureNum);
      return ((hash % largePrime) % 2) === 0 ? 'A' : 'B';
  }
  

• Hashing, to distribute IDs more uniformly and consistently without such overlaps.

  function hashFunc(customerId, featureNum) {
    let str = customerId.toString() + featureNum.toString();
    let hash = 0;
    for (let i = 0; i < str.length; i++) {
      let char = str.charCodeAt(i);
      hash = ((hash << 5) - hash) + char; // This is a simple, commonly used hash function
      hash = hash & hash; // Convert to a 32-bit integer
    }
    return hash;
  }
  
  function assignGroup(customerId, featureNum) {
    return (hashFunc(customerId, featureNum) % 2) === 0 ? 'A' : 'B';
  }
  

• Sum of Digits, with the sum of digits of the customer ID and feature number, and using the result to divide customers into groups:

  function sumOfDigits(number) {
    let sum = 0;
    while (number) {
      sum += number % 10;
      number = Math.floor(number / 10);
    }
    return sum;
  }
  
  function assignGroup(customerId, featureNum) {
    return (sumOfDigits(customerId + featureNum) % 2) === 0 ? 'A' : 'B';
  }
  

Here is a simple solution:

  const getGroup = (user_id, feature_id) => {
    const power = Math.pow(2, feature_id + 1)
    const groupLimit = power / 2
    return (user_id % power) < groupLimit ? 'A' : 'B'
  }


  const userCount = 13
  const userIds = Array.from(Array(userCount).keys())

  console.log(`TEST FEATURE 0 ON ${userCount} USERS`)
  userIds.forEach(user_id => console.log(`user ${user_id}: ${getGroup(user_id, 0)}`))

  console.log(`TEST FEATURE 1 ON ${userCount} USERS`)
  userIds.forEach(user_id => console.log(`user ${user_id}: ${getGroup(user_id, 1)}`))

  console.log(`TEST FEATURE 2 ON ${userCount} USERS`)
  userIds.forEach(user_id => console.log(`user ${user_id}: ${getGroup(user_id, 2)}`))

Which gives: