const shuffle = ([...arr]) => {
  let m = arr.length;
  while (m) {
    const i = Math.floor(Math.random() * m--);
    [arr[m], arr[i]] = [arr[i], arr[m]];
  }
  return arr;
};

const foo = [1, 2, 3];
shuffle(foo); // [2, 3, 1], foo = [1, 2, 3]

const longestPalindrome = (s) => {
    if(s.length === 1) return s
    
    const odd = longestOddPalindrome(s)
    const even = longestEvenPalindrome(s)
    
    
    if(odd.length >= even.length) return odd
    if(even.length > odd.length) return even
};

const longestOddPalindrome = (s) => {    
    let longest = 0
    let longestSubStr = ""
    
    for(let i = 1; i < s.length; i++) {
        
        let currentLongest = 1
        let currentLongestSubStr = ""
        let left = i - 1
        let right = i + 1
        
        while(left >= 0 && right < s.length) {
            const leftLetter = s[left]
            const rightLetter = s[right]

            left--
            right++

            if(leftLetter === rightLetter) {
                currentLongest += 2
                currentLongestSubStr = s.slice(left+1, right)
            } else break
        }
        
                        
        if(currentLongest > longest) {
            if(currentLongestSubStr) longestSubStr = currentLongestSubStr 
            else longestSubStr = s[i]
            longest = currentLongest
        }
    }
    
    return longestSubStr
}

const longestEvenPalindrome = (s) => {    
    let longest = 0
    let longestSubStr = ""
    
    for(let i = 0; i < s.length - 1; i++) {
        if(s[i] !== s[i+1]) continue;
        
        let currentLongest = 2
        let currentLongestSubStr = ""
        let left = i - 1
        let right = i + 2
        
        while(left >= 0 && right < s.length) {
            const leftLetter = s[left]
            const rightLetter = s[right]

            left--
            right++
            
            if(leftLetter === rightLetter) {
                currentLongest += 2
                currentLongestSubStr = s.slice(left+1, right)
            } else break
        }
                
                
        if(currentLongest > longest) {
            if(currentLongestSubStr) longestSubStr = currentLongestSubStr
            else longestSubStr = s[i] + s[i+1]
    
            longest = currentLongest
        }
    }
    
    return longestSubStr
}
console.log(longestPalindrome("babad"))

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 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]

var d = new Date();
var d = new Date(milliseconds);
var d = new Date(dateString);
var d = new Date(year, month, day, hours, minutes, seconds, milliseconds);

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