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 express = require('express')
const app = express()
const port = 3000

app.get('/', (req, res) => {
  res.send('Hello World!')
})

app.listen(port, () => {
  console.log(`Example app listening on port ${port}`)
})

const nums = [1, 2, 3];
const strs = Array.from('est');

nums.push(6);
nums.push(4, 9);
strs.unshift('t');

nums.length;                     // 6
nums[nums.length - 1];           // 9
strs[0];                         // 't'
strs[2];                         // 's'

nums.slice(1, 3);                // [2, 3]
nums.map(n => n * 2);            // [2, 4, 6, 12, 8, 18]
nums.filter(n => n % 2 === 0);   // [2, 6, 4]
nums.reduce((a, n) => a + n, 0); // 25

strs.reverse();                  // ['t', 's', 'e', 't']
strs.join('');                   // 'test'

const nums = new Set([1, 2, 3]);

nums.add(4);
nums.add(1);
nums.add(5);
nums.add(4);

nums.size;                       // 5
nums.has(4);                     // true

nums.delete(4);
nums.has(4);                     // false

[...nums];                       // [1, 2, 3, 5]

nums.clear();
nums.size;                       // 0

const items = new Map([
  [1, { name: 'John' }],
  [2, { name: 'Mary' }]
]);

items.set(4, { name: 'Alan' });
items.set(2, { name: 'Jeff' });

items.size;                      // 3
items.has(4);                    // true
items.get(2);                    // { name: 'Jeff' }

items.delete(2);
items.size;                      // 2

[...items.keys()];               // [1, 4]
[...items.values()];             // [{ name: 'John' }, { name: 'Alan' }]

items.clear();
items.size;                      // 0

//Upvotes comments according to a regex pattern. I tried it out on https://www.reddit.com/r/VALORANT/comments/ne74n4/please_admire_this_clip_precise_gunplay_btw/
//Known bugs:
	//If a comment was already upvoted, it gets downvoted
	//For some reason, it has around a 50-70% success rate. The case insensitive bit works, but I think some of the query selector stuff gets changed. Still, 50% is good

let comments = document.getElementsByClassName("_3tw__eCCe7j-epNCKGXUKk"); //Comment class
let commentsToUpvote = [];
const regexToMatch = /wtf/gi;
for(let comment of comments){
	let text = comment.querySelector("._1qeIAgB0cPwnLhDF9XSiJM"); //Comment content class
	if(text == undefined){
	continue;
	}
	text = text.textContent;
	if(regexToMatch.test(text)){
	console.log(text);
	commentsToUpvote.push(comment);
	}
}
function upvote(comment){
	console.log(comment.querySelector(".icon-upvote")); //Just showing you what it's doing
	comment.querySelector(".icon-upvote").click();
}
function slowRecurse(){
	let comment = commentsToUpvote.pop(); //It's gonna go bottom to top but whatever
	if(comment != undefined){
	upvote(comment);
	setTimeout(slowRecurse,500);
	}
}
slowRecurse();

questions = Array.from(document.querySelectorAll(".multiple-choice-question"));
async function hackRadio(question){
	if(question.querySelector(".question-chevron").getAttribute("aria-label") == "Question completed") return;
	let answerChoices = question.querySelectorAll(".zb-radio-button");
	async function guess(answerChoice){
		answerChoice.querySelector("label").click();
	}
	let pause = 0;
	for(let answerChoice of answerChoices){
		setTimeout(()=>{guess(answerChoice)},pause);	//No need to check given that it will record the correct answer anyways.
		pause += 1000;
	}
}
for(let question of questions){
	hackRadio(question);
}
questions = Array.from(document.querySelectorAll(".short-answer-question"));
async function hackShortAnswer(question){
	if(question.querySelector(".question-chevron").getAttribute("aria-label") == "Question completed") return;
	question.querySelector("textarea").value = question.querySelector(".forfeit-answer").textContent;
	//question.querySelector(".check-button").click(); They are smart bastards
}
for(let question of questions){
	const showAnswerButton = question.querySelector(".show-answer-button");
	showAnswerButton.click();
	showAnswerButton.click();
	hackShortAnswer(question);
}

const bucketSort = (arr, size = 5) => {
  const min = Math.min(...arr);
  const max = Math.max(...arr);
  const buckets = Array.from(
    { length: Math.floor((max - min) / size) + 1 },
    () => []
  );
  arr.forEach(val => {
    buckets[Math.floor((val - min) / size)].push(val);
  });
  return buckets.reduce((acc, b) => [...acc, ...b.sort((a, b) => a - b)], []);
};

bucketSort([6, 3, 4, 1]); // [1, 3, 4, 6]