const euclideanDistance = (a, b) =>
  Math.hypot(...Object.keys(a).map(k => b[k] - a[k]));
  
euclideanDistance([1, 1], [2, 3]); // ~2.2361
euclideanDistance([1, 1, 1], [2, 3, 2]); // ~2.4495

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());
}

const hammingDistance = (num1, num2) =>
  ((num1 ^ num2).toString(2).match(/1/g) || '').length;
  
hammingDistance(2, 3); // 1

const kMeans = (data, k = 1) => {
  const centroids = data.slice(0, k);
  const distances = Array.from({ length: data.length }, () =>
    Array.from({ length: k }, () => 0)
  );
  const classes = Array.from({ length: data.length }, () => -1);
  let itr = true;

  while (itr) {
    itr = false;

    for (let d in data) {
      for (let c = 0; c < k; c++) {
        distances[d][c] = Math.hypot(
          ...Object.keys(data[0]).map(key => data[d][key] - centroids[c][key])
        );
      }
      const m = distances[d].indexOf(Math.min(...distances[d]));
      if (classes[d] !== m) itr = true;
      classes[d] = m;
    }

    for (let c = 0; c < k; c++) {
      centroids[c] = Array.from({ length: data[0].length }, () => 0);
      const size = data.reduce((acc, _, d) => {
        if (classes[d] === c) {
          acc++;
          for (let i in data[0]) centroids[c][i] += data[d][i];
        }
        return acc;
      }, 0);
      for (let i in data[0]) {
        centroids[c][i] = parseFloat(Number(centroids[c][i] / size).toFixed(2));
      }
    }
  }

  return classes;
};
kMeans([[0, 0], [0, 1], [1, 3], [2, 0]], 2); // [0, 1, 1, 0]

const binomialCoefficient = (n, k) => {
  if (Number.isNaN(n) || Number.isNaN(k)) return NaN;
  if (k < 0 || k > n) return 0;
  if (k === 0 || k === n) return 1;
  if (k === 1 || k === n - 1) return n;
  if (n - k < k) k = n - k;
  let res = n;
  for (let j = 2; j <= k; j++) res *= (n - j + 1) / j;
  return Math.round(res);
};

binomialCoefficient(8, 2); // 28

import { createSlice } from "@reduxjs/toolkit";

const alert = createSlice({
	name: "alert",
	initialState: {
	msg: "",
	status: "",
	},
	reducers: {
	set_alert: (state, action) => {
	return {
	...state,
	msg: action.payload.msg,
	status: action.payload.status,
	};
	},
	clear_alert: (state, action) => {
	return {
	...state,
	msg: "",
	status: "",
	};
	},
	},
});

export default alert.reducer;

const { set_alert, clear_alert } = alert.actions;

export const setAlert = (msg, status) => dispatch => {
	dispatch(set_alert({ msg, status }));
	setTimeout(() => dispatch(clear_alert()), 4000);
};

export const clearAlert = () => dispatch => {
	dispatch(clear_alert());
};