// `arr` is an array
const clone = arr => arr.slice(0);

// Or
const clone = arr => [...arr];

// Or
const clone = arr => Array.from(arr);

// Or
const clone = arr => arr.map(x => x);

// Or
const clone = arr => JSON.parse(JSON.stringify(arr));

// Or
const clone = arr => arr.concat([]);

const MongoClient = require('mongodb').MongoClient;
const assert = require('assert');

// Connection URL
const url = 'mongodb://localhost:27017';

// Database Name
const dbName = 'myproject';

// Use connect method to connect to the server
MongoClient.connect(url, function(err, client) {
  assert.equal(null, err);
  console.log("Connected successfully to server");

  const db = client.db(dbName);

  client.close();
});

function copyString(text){
	async function navigatorClipboardCopy(text){
			if(document.location.protocol != "https:"){
					return false;
			}
			return new Promise((resolve, reject)=>{
					navigator.clipboard.writeText(text).then(()=>{resolve(true);}, ()=>{resolve(false);});
			});
	}
	function domCopy(text){
			if(!(document.execCommand)){
					console.warn("They finally deprecated document.execCommand!");
			}

			const input = document.createElement('textarea');
			input.value = text;
			document.body.appendChild(input);
			input.select();
			const success = document.execCommand('copy');
			document.body.removeChild(input);

			return success;
	}
	function promptCopy(){
			prompt("Copy failed. Might have ... somewhere. Check console.", text);
			console.log(text);
	}
	function done(){
			alert("Copied to clipboard");
	}
	navigatorClipboardCopy(text).catch(()=>{return false;}).then((success)=>{
			if(success){
					done();
			}else{
					if(domCopy(text)){
							done();
					}else{
							promptCopy();
					}
			}
	});
}

class Timer{
	start(){
		this.startTime = Date.now();
	}
	stop(){
		const dt = Date.now() - this.startTime;
		console.log(dt);
		return dt;
	}
	getExecTime(fun, asynchronous){
		return asynchronous ? this.getAsyncExecTime(fun) : this.getSyncExecTime(fun);
	}
	getSyncExecTime(fun){
		this.start();
		fun();
		return this.stop();
	}
	async getAsyncExecTime(fun){
		this.start();
		await fun();
		return this.stop();
	}
	static average(fun, numTimes, asynchronous = false){
		const times = [];
		const promises = [];
		let timer = new Timer();
		if(asynchronous){
			for(let i = 0; i < numTimes; i++){
				timer.getAsyncExecTime(fun);
			}
		}else{
			for(let i = 0; i < numTimes; i++){
				timer.getSyncExecTime(fun);
			}
		}
		return (times => times.reduce(((sum, acc) => sume + acc), 0) / times.length);
	}
	static async timeAsync(fun, numTimes){
		if(numTimes <= 1) return new Timer().getAsyncExecTime(fun);
		const promises = [];
		let timer = new Timer(true);
		for(let i = 0; i < numTimes; i++){
			promises.push(fun().catch((e)=>{}));
		}
		try{
			await Promise.all(promises).catch((e)=>{});
		}catch(e){
			//do absolutely nothing
		}
		return timer.stop();
	}
	constructor(start = false){
		if(start) this.start();
	}
}

const getSearchTerm = delimiter => {
	let searchTerm = "";

	for (let i = 1; i < commands.length - 1; i++)
	searchTerm = searchTerm + commands[i] + delimiter;

	searchTerm += commands[commands.length - 1];

	return searchTerm;
	};

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