// There are n rings and each ring is either red, green, or blue. The rings are distributed across ten rods labeled from 0 to 9.

// You are given a string rings of length 2n that describes the n rings that are placed onto the rods. Every two characters in rings forms a color-position pair that is used to describe each ring where:

// The first character of the ith pair denotes the ith ring's color ('R', 'G', 'B').
// The second character of the ith pair denotes the rod that the ith ring is placed on ('0' to '9').
// For example, "R3G2B1" describes n == 3 rings: a red ring placed onto the rod labeled 3, a green ring placed onto the rod labeled 2, and a blue ring placed onto the rod labeled 1.

// Return the number of rods that have all three colors of rings on them.


let rings = "B0B6G0R6R0R6G9";
var countPoints = function(rings) {
    
    let sum = 0;
    
	// Always 10 Rods
    for (let i = 0; i < 10; i++) {
        if (rings.includes(`B${i}`) && rings.includes(`G${i}`) && rings.includes(`R${i}`)) {
            sum+=1;
        }
    }
    
    return sum;
    
};

console.log(countPoints(rings));

console.log("hello world")

const unzipWith = (arr, fn) =>
  arr
    .reduce(
      (acc, val) => (val.forEach((v, i) => acc[i].push(v)), acc),
      Array.from({
        length: Math.max(...arr.map(x => x.length))
      }).map(x => [])
    )
    .map(val => fn(...val));
unzipWith(
  [
    [1, 10, 100],
    [2, 20, 200],
  ],
  (...args) => args.reduce((acc, v) => acc + v, 0)
);
// [3, 30, 300]

const insertionSort = arr =>
  arr.reduce((acc, x) => {
    if (!acc.length) return [x];
    acc.some((y, j) => {
      if (x <= y) {
        acc.splice(j, 0, x);
        return true;
      }
      if (x > y && j === acc.length - 1) {
        acc.splice(j + 1, 0, x);
        return true;
      }
      return false;
    });
    return acc;
  }, []);
  
insertionSort([6, 3, 4, 1]); // [1, 3, 4, 6]

function printHeap(heap, index, level) {
    if (index >= heap.length) {
        return;
    }
    console.log("  ".repeat(level) + heap[index]);
    printHeap(heap, 2 * index + 1, level + 1);
    printHeap(heap, 2 * index + 2, level + 1);
}

//You can call this function by passing in the heap array and the index of the root node, which is typically 0, and level = 0.

let heap = [3, 8, 7, 15, 17, 30, 35, 2, 4, 5, 9];
printHeap(heap,0,0)

class SequentialQueue{	//if you want it to go backwards, too bad
	next(){
		return this.i++;
	}
	constructor(start = 0){
		this.i = start;
	}
}
const que = new SequentialQueue(0);
for(let i = 0; i < 10; i++){
	console.log(que.next());
}