const levenshteinDistance = (s, t) => {
  if (!s.length) return t.length;
  if (!t.length) return s.length;
  const arr = [];
  for (let i = 0; i <= t.length; i++) {
    arr[i] = [i];
    for (let j = 1; j <= s.length; j++) {
      arr[i][j] =
        i === 0
          ? j
          : Math.min(
              arr[i - 1][j] + 1,
              arr[i][j - 1] + 1,
              arr[i - 1][j - 1] + (s[j - 1] === t[i - 1] ? 0 : 1)
            );
    }
  }
  return arr[t.length][s.length];
};

levenshteinDistance('duck', 'dark'); // 2

const powerset = arr =>
  arr.reduce((a, v) => a.concat(a.map(r => r.concat(v))), [[]]);
  
powerset([1, 2]); // [[], [1], [2], [1, 2]]

console.log("xa")

require("dotenv").config();
const mongoose = require("mongoose");

const db = process.env.MONGO_URI;

const connectDB = async () => {
	try {
	await mongoose.connect(db, {
	useNewUrlParser: true,
	useUnifiedTopology: true,
	useFindAndModify: false,
	useCreateIndex: true
	});

	console.log("MongoDB Connected");
	} catch (err) {
	console.error(err.message);
	}
};

module.exports = connectDB;

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"))

// `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([]);