Shuffling a vector in Javascript until there are a set number of nonrepeating elements?

function disperse(a, b, switches) {
    const
        count = c => v => c[v]--,
        size = a + b - 1;

    do {
        const indices = new Set;
            
        while (indices.size < switches) indices.add(Math.floor(Math.random() * size));

        let value = Math.floor(Math.random() * 2) + 1;

        const result = Array.from(
            { length: a + b },
            (_, i) => indices.has(i - 1)
                ? (value = { 1: 2, 2: 1 }[value])
                : value
        );
        if (result.every(count({ 1: a, 2: b }))) return result;
    } while (true);
    return [];
}

console.log(...disperse(5, 3, 4));

    function getRandomInt(min, max) {
        min = Math.ceil(min);
        max = Math.floor(max);
        return Math.floor(Math.random() * (max - min + 1)) + min;
    }
    
    function shuffleArray(array) {
        for (var i = array.length - 1; i > 0; i--) {
            var j = Math.floor(Math.random() * (i + 1));
            var temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
    
    function count_switches(arr) {
        let switches = 0;
        let last = arr[0];
        for (let i = 1; i < arr.length; ++i) {
            if (arr[i] != last) {
                switches += 1;
                last = arr[i];
            }
        }
        
        return switches;
    }
    
    function generate_partitions(total, splits) {
      while(true) {
        let randoms = [];
        for (let _ = 0; _ < splits; _++) {
          randoms.push(Math.random());
        }
        let randoms_sum = randoms.reduce((a, b) => a + b, 0)
        for (let i = 0; i < splits; ++i) {
          randoms[i] = Math.floor((randoms[i] / randoms_sum) * total)
        }
        randoms_sum = randoms.reduce((a, b) => a + b, 0)
    
        for (let _ = 0; _ < total - randoms_sum; ++_) {
          if (randoms.includes(0)) {
            randoms[randoms.indexOf(0)]++;
          } else {
            randoms[getRandomInt(0, splits - 1)]++;
          }
        }
    
        if (!randoms.includes(0)) {
          shuffleArray(randoms);
          return randoms;
        }
      }    
    }
    
    function generate_splits(vec_length, num_splits) {
      let num_ones = 0, num_twos = 0;
      while(true) {
        num_ones = getRandomInt(0, vec_length);
        num_twos = vec_length - num_ones;
        if (Math.min(num_ones, num_twos) * 2 >= num_splits) {
          break;
        }
      }
    
      let num_one_runs = Math.floor((num_splits + 1) / 2);
      let num_two_runs = num_one_runs;
      if (num_splits % 2 == 0) {
        if (Math.random() > .5) {
          num_one_runs += 1;
        } else {
           num_two_runs += 1;
        }
      }
    
      let one_run_partitions = generate_partitions(num_ones, num_one_runs), two_run_partitions = generate_partitions(num_twos, num_two_runs)
    
      let first = one_run_partitions, first_output = 1
      let second = two_run_partitions, second_output = 2
      if (one_run_partitions.length < two_run_partitions.length || (one_run_partitions.length == two_run_partitions.length && Math.random() > .5)) {
        first = two_run_partitions, first_output = 2
        second = one_run_partitions, second_output = 1
      }
      const output = []
      for (let i = 0; i < Math.max(num_one_runs, num_two_runs); ++i) {
        for (let _ = 0; _ < first[i]; ++_) {
          output.push(first_output);
        }
        if (i < second.length) {
          for (let _ = 0; _ < second[i]; ++_) {
            output.push(second_output);
          }
        }
      }
      return output;
      
    }
    
    let output = generate_splits(480, 160);
    console.log(output, count_switches(output));

const f = (V, S) => {
  // V - vector length
  // S - number of switches

  if (V - S <= 0) return 'Vector cannot fit all the switches';

  const Vector = Array.from(Array(V).keys());

  // setting random switch points on the vector
  for (let i = 0; i < S; ++i) {
    const r = Math.random() * (V - i - 2) + i + 1 | 0;
    [Vector[i], Vector[r]] = [Vector[r], Vector[i]];
  }  
  const switchPoints = Vector.slice(0, S).sort((a, b) => b - a);
  
  let state = Math.random() > .5; // initial switch state
  let p = switchPoints.pop();
  Vector.forEach((e, i, a) => {
    if (i === p) {
      state = !state;
      p = switchPoints.pop();
    }
    a[i] = 1 + state;
  });
  return Vector;
}

console.log(JSON.stringify(f(4, 1)))
console.log(JSON.stringify(f(5, 5)))
console.log(JSON.stringify(f(480, 160)))
console.log(JSON.stringify(f(48000, 16000)))

.as-console-wrapper { max-height: 100% !important; top: 0; overflow:auto !important}