function anagram(fir,sec){
    let fa = fir.split('')
    let sa = sec.split('')
    if(fa.length != sa.length){
        return 0
    }
    for(let e of fa){
        if(sa.includes(e)){
            let i = sa.indexOf(e)
            sa.splice(i,1)
        }
    }
    if(sa.length == 0){
        return 1
    }else{
        return 0
    }
}

 function anagram(str1, str2){
    
    return str1.split('').sort().join('') == str2.split('').sort().join('') ? 1 : 0;
}

 function anagram(a,b){
    a=a.split("").sort().join("")
    b=b.split("").sort().join("")
    if (a==b){
        return 1
    }
    else{
        return 0
    }
    
}

 function anagram(a, b) {
    let ma = a.split('').sort().join();
    let mb = b.split('').sort().join();
    return ma == mb;
}

 function permutate(word, start) {
    const length = word.length;
    let array = [];
    if (length - start === 1) array.push(word);
    for (let i = start; i < length; i++) {
        let swapped = swappedClone(word, i, start);
        array = array.concat(permutate(swapped, start + 1));
    }
    return array;
}

function swappedClone(word, i, j) {
    let clone = [...word];
    let temp = clone[i];
    clone[i] = clone[j];
    clone[j] = temp;
    return clone;
}

function anagram(wordA, wordB) {
    const bChars = Array.from(wordB);
    const permutations = permutate(Array.from(wordA), 0);
    for (let i = 0; i < permutations.length; i++)
        if (arraysEqual(permutations[i], bChars)) return 1;
    return 0;
}

function arraysEqual(a, b) {
    const lengthA = a.length;
    const lengthB = b.length;
    if (lengthA != lengthB) return false;
    for (let i = 0; i < lengthA; i++) {
        if (a[i] != b[i]) return false;
    }
    return true;
}

 function anagram(a, b) {
    let a_arr = a.split('');
    let b_arr = b.split('');
    console.log(b_arr);
    if(a_arr.length == b_arr.length){
        for(let each of a_arr){
            if(b_arr.indexOf(each) != -1){
                b_arr.splice(b_arr.indexOf(each), 1);
                console.log(b_arr);
            }
        }
        if (b_arr.length == 0){
            return 1;
        }else{
            return 0;
        }
    }else{
        return 0;
    }
}

 function anagram(s1, s2) {
    return s1.split('').sort().join() == s2.split('').sort().join();
}

 function anagram(a,b) {
    let arr = [...a], arr1 = [...b];
    let count = 0;
    arr.sort();
    arr1.sort();
    for (let i = 0; i < a.length; i++) {
        if (arr[i] === arr1[i])    
            count++
    }
    if (count === a.length)
        return 1;
    else 
        return 0;
}

 function anagram(a, b) {
    var c = a.split('');
    var d = b.split('');
    for (var i = 0; i < c.length; i++) {
        if(d.indexOf(c[i])!= -1) {
            d[d.indexOf(c[i])] = '-1';
        }
        else {
            return 0;
        }
    }
    for (i = 0; i < d.length; i++) {
        if(d[i] != '-1') {
            return 0;
        }
    }
    return 1;
}

 const anagram = (firstWord, secondWord) => (firstWord.split('').sort().join('') == secondWord.split('').sort().join(''))

 function anagram(a, b) {
        if (a.length != b.length) {
            return 0
        }
        arr1 = a.split("")
        arr2 = b.split("")
        let count = 0;

        for (let i = 0; i < arr1.length; i++) {
            for (let j = 0; j < arr2.length; j++) {
                if (arr1[i] == arr2[j]) {
                    count++;
                    arr2[j] = null;
                    j = arr2.length
                }
            }
        }

        if (count == a.length && count == b.length) {
            return 1
        }
        else return 0
    }

 function anagram(a,b){
let str1 = a.split('').sort().join('');
let str2 = b.split('').sort().join('');
if(str1 == str2)
{
    return 1;

}
else return 0
}

 function anagram(str1, str2){
    return (str1.split("").sort().join("") == str2.split("").sort().join("")) ? 1:0;
}

 function buildCharObject(str) {
  const charObj = {};
  str = str.toLowerCase().replace(/[^\w]/g);
  for (let char of str) {
    charObj[char] = charObj[char] + 1 || 1;
  }
  
  return charObj;
}

function anagram(strA, strB) {
  const aCharObj = buildCharObject(strA);
  const bCharObj = buildCharObject(strB);
  
  if (Object.keys(aCharObj).length !== Object.keys(bCharObj).length) {
    return 0;
  }
  
  for (let char in aCharObj) {
    if (aCharObj[char] !== bCharObj[char]) {
      return 0;
    }
  }
  return 1;
}

 function anagram(str, d_str){
    let res = str.split('').sort().toString() == d_str.split('').sort().toString()
    return res;
}

 function anagram(a, b){
    if (a.toLowerCase().split('').sort().join() === b.toLowerCase().split('').sort().join()){
        return 1;
    } else {
        return 0;
    }
}

 let a = 'bagfd'
let b = 'gbfqsqa'
function anagram(a,b){
    let save = 0
    let arr = [];
    let arr1 = [];
    for (let i = 0; i != a.length && i != b.length; i++){
        arr.push(a[i])
        arr1.push(b[i])
    }
    arr.sort()
    arr1.sort()
    for(let i = 0; i != a.length && b.length; i++){
        if (arr1[i] == arr[i]){
            save++
        }
    }
    if (save == a.length && b.length){
        return 1
    }
    else {
        return 0
    }

}
console.log(anagram(a,b))

 function anagram(word1, word2) {
  let word1Chars = word1.split("").sort();
  let word2Chars = word2.split("").sort();
  return word1Chars.join("") === word2Chars.join("") ? 1 : 0;
}

 function anagram(a,b){ 
    if(a.length!=b.length){return 0;} 
    let A = a.split(''); 
    let B = b.split(''); 
    for(let i = 0;i< A.length;i++){ 
        for(let j = 0;j< B.length;j++){ 
            if(A[i]==B[j]){ 
                A[i]=' '; 
                B[j] = ' '; 
                i++; 
                j=-1; 
            } 
        } 
    } 
    let c = 0; 
    for(let i =0;i< A.length;i++){if(A[i]!=' '||B[i]!=' '){return 0;}} 
    return 1; 
}

 function anagram(a, b) {
    if (a.split("").sort().join("") == b.split("").sort().join(""))
    return 1;
    else return 0;
}

 function anagram(word1,word2){
    word1 = word1.split('').sort().join('');
    word2 = word2.split('').sort().join('');
    if (word1 == word2){
        return 1
    }
    else{
        return 0
    }
}

 function anagram ( a, b ) {
    let res = 0; 
    for (let i = 0; i < a.length; i++ ) {
        for ( let k = 0; k < b.length; k++ ) {
            if ( a [ i ] == b [ k ] ) 
            res = 1;
            else
            res = 0
        }
    }
    return res;
}

 function anagram(w1, w2) {
    for (let i = 0; i < w1.length; i++) {
        let index = w2.indexOf(w1[i]);
        if (index !== -1) w2 = w2.slice(0, index) + w2.slice(index + 1);
        else return 0; 
    }
    return 1;
}

 function anagram(a, b) {
    let prov = 0
    if (a==b){
        return 1
    }
    if (a.length == b.length){
        for (let i = 0; i            for (let t = 0; t                if (a[i]==b[t]){
                    prov++
                }
            }
        }
    if (prov == a.length){
        return 1
    }
    }
return 0
}

 function anagram(a, b)
{
    a = a.split('').sort().join('');
    b = b.split('').sort().join('');
    
    if (a == b)
        return 1;
    return 0;
}

 function anagram ( a, b ) {
    let res = 0; 
    for (let i = 0; i < a.length; i++ ) {
        for ( let k = 0; k < b.length; k++ ) {
            if ( a [ i ] == b [ k ] ) 
            res = 1;
            else
            res = 0
        }
    }
    return res;
}

 function anagram(w, v){
    w = w.split('').sort().join('');
    v = v.split('').sort().join('');
    if ( w == v) return 1;
    else return 0;
}

 function anagram(a, b) {
      if (a.split("").sort().join("") === b.split("").sort().join("")) //поділили рядок по символам, відсортували символи та з'єднали
        return 1; 
  return 0;
}

function anagram(w1, w2) {
    return w1.split("").sort().join("") == w2.split("").sort().join("");
}

 function anagram(word1, word2)
{
    w1 = word1.split('').sort().join('')
    w2 = word2.split('').sort().join('')
    if(w1==w2)
    {
    return 1
    }
    else
    {
        return 0
    }
}

 function anagram(a, b) {
    if(a.length != b.length)
        return 0;
    let l = { };
    for(let i = 0; i < a.length; ++i) {
        let n = a[i];
        if(!l[n])
            l[n] = 0;
        l[n] += 1;
    }
    for(let i = 0; i < b.length; ++i) {
        let n = b[i];
        if(!l[n] || l[n] == 0)
            return 0;
        l[n] -= 1;
    }
    for(let k in l) {
        if(l[k] != 0)
            return 0;
    }
    return 1;
}

 function anagram(s1, s2) {
    return s1.split('').sort().join() == s2.split('').sort().join();
}

 function anagram(a, b) {
    if(a.length != b.length){
    return 0;
    }
    return a.split('').sort().toString()==b.split('').sort().toString()? 1:0;
    
}

 function anagram(a, b){
    let arr1 = a.split('')
    let arr2 = b.split('')
    
    arr1.sort()
    arr2.sort()
    
    let str1 = arr1.join()
    let str2 = arr2.join()
    
    if (str1 == str2){
        return 1
    } else {
        return 0
    }
}

 function anagram(a, b){
    if(a.split('').sort().join('')==b.split('').sort().join('')){
    return 1;
    }
    else{
        return 0;
    }
}

 function anagram(a, b) {
    if (a.split("").sort().join("") == b.split("").sort().join("")) return (1); 
    else return (0);
}

 function anagram(a,b){
    a = a.split('').sort().join('');
    b = b.split('').sort().join('');
    if(a == b)
        return 1;
    return 0;
}

 function anagram(a, b) {
    if(a.length == b.length)
    {
        a = a.split('').sort();
        b = b.split('').sort();

        if(a.toString() == b.toString())
            return 1;
        else
            return 0;
    }
    else
        return 0;
}

 function anagram(a, b){
    let aa = a.split("");
    let bb = b.split("");
    aa.sort();
    bb.sort();
    console.log(aa);
    console.log(bb);
    a=aa.join("");
    b=bb.join("");
    return a==b;
}

 function anagram(a, b)
{
if ( a.split ('').sort().join('') !== b.split ('').sort().join('') )
{
return 0;
}
else
{
return 1;
}
}

 function anagram(A, B) {
    return A.split("").sort().join('')==B.split("").sort().join('')
}

 function anagram (firstWord, secondWord) {
  return (firstWord.split('').sort().join('') == secondWord.split('').sort().join(''))
}

 function anagram(str, str1) {
    if(str.length !== str1.length) 
     return 0;
  let s = str.split('').sort().join('');
  let s1 = str1.split('').sort().join('');
    if(s !== s1)
        return 0;
  return 1;
}

 function anagram(str1, str2){
    str1 = str1.split('').sort().join('');
    str2 = str2.split('').sort().join('');
    if( str1 == str2){
        return 1;
    }
    else{
        return 0;
    }
}

 function anagram(w1, w2){
    w1 = w1.split('')
    w2 = w2.split('')
    let isAnagram = true
    for(i of w1){
        if(!w2.includes(i) || w1.filter(x => x === i).length !== w2.filter(x => x === i).length){
            isAnagram = false
        }
    }
    if(isAnagram) return 1
    else return 0
}

 function permutate(word, start) {
    const length = word.length;
    let array = [];
    if (length - start === 1) array.push(word);
    for (let i = start; i < length; i++) {
        let swapped = swappedClone(word, i, start);
        array = array.concat(permutate(swapped, start + 1));
    }
    return array;
}

function swappedClone(word, i, j) {
    let clone = [...word];
    let temp = clone[i];
    clone[i] = clone[j];
    clone[j] = temp;
    return clone;
}

function anagram(wordA, wordB) {
    const bChars = Array.from(wordB);
    const permutations = permutate(Array.from(wordA), 0);
    for (let i = 0; i < permutations.length; i++)
        if (arraysEqual(permutations[i], bChars)) return 1;
    return 0;
}

function arraysEqual(a, b) {
    const lengthA = a.length;
    const lengthB = b.length;
    if (lengthA != lengthB) return false;
    for (let i = 0; i < lengthA; i++) {
        if (a[i] != b[i]) return false;
    }
    return true;
}

 function anagram(a, b) {
    let a1 = a.split('').sort().join('');
    let b1 = b.split('').sort().join('');
    if (a1 == b1)
    return 1;
    else 
    return 0;

}

 function anagram(a, b) {
    let y = a.split("").sort().join("");
    let z = b.split("").sort().join("");
    return ((z === y)? 1 : 0);
}

 function anagram(a, b){
    let result=0; 
    for (let i=0; i< a.length; i++){
        for (let k=0; k< b.length; k++ ){
            if (a[i]==b[k]){
                result=1;
            }
            else{
                result=0
            }
        }
    }
    return result;
    
}

 function anagram(a,b){
    return a.split('').sort().join('')==b.split('').sort().join('')?1:0 
}

 function anagram(a, b){
    a = a.split('');
    b = b.split('');
    let m = a.length;
        for (let i = 0; i < m; i++){
            m = a.length;
            let n = b.length;
            if (a[i] == b[0])
            {
                a.splice(i,1,);
                b.splice(0,1,);
            } 
            if (b.length < n){
                i = -1;
            }
    }
    if (b.length == 0)
    return 1;
    else return 0;
}

 function permutate(word, start) {
    const length = word.length;
    let array = [];
    if (length - start === 1) array.push(word);
    for (let i = start; i < length; i++) {
        let swapped = swappedClone(word, i, start);
        array = array.concat(permutate(swapped, start + 1));
    }
    return array;
}

function swappedClone(word, i, j) {
    let clone = [...word];
    let temp = clone[i];
    clone[i] = clone[j];
    clone[j] = temp;
    return clone;
}

function anagram(wordA, wordB) {
    const bChars = Array.from(wordB);
    const permutations = permutate(Array.from(wordA), 0);
    for (let i = 0; i < permutations.length; i++)
        if (arraysEqual(permutations[i], bChars)) return 1;
    return 0;
}

function arraysEqual(a, b) {
    const lengthA = a.length;
    const lengthB = b.length;
    if (lengthA != lengthB) return false;
    for (let i = 0; i < lengthA; i++) {
        if (a[i] != b[i]) return false;
    }
    return true;
}

 function anagram(str1, str2) {
    for (let i1 of str1) {
        let index = str2.indexOf(i1)
        str2 = str2.slice(0, index) + str2.slice(index + 1)
    }
    
    return str2 === "" ? 1 : 0;
}

 function anagram(a, b)
{
    let s1 = ""; let str1 = [];
    let s2 = ""; let str2 = [];
    for (let i = 0; i < a.length; i++)
        str1.push(a[i]);
    for (let j = 0; j < b.length; j++)
        str2.push(b[j]);
    str1 = str1.sort();
    str2 = str2.sort();
    for (let i = 0; i < str1.length; i++)
        s1 += str1[i];
    for (let j = 0; j < str2.length; j++)
        s2 += str2[j];
    if (s1 == s2) return 1;
    else return 0;
}

 function anagram(a,b){
    let a1 = a.split('').sort().join('');
    let b1 = b.split('').sort().join('');
    if (a1 == b1)
    return 1;
    else 
    return 0;

}

 function anagram(a, b)
{
if(a.length != b.length)
return 0
a=a.split("").sort()
b=b.split("").sort()
for(let i = a.length - 1; i>=0; i--)
if(a[i]!=b[i])
return 0
return 1
}

 function anagram(str1, str2) {
    let anagramArray = [];
    anagramArray.push(str1);
    anagramArray.push(str2);
    let res = 0;
    if (anagramArray == 0 || anagramArray.length == 1) {
        res = 0;
    } else {
        for (let i = 0; i < anagramArray.length; i++) {
            let firstWord = anagramArray[0].split("").sort().join("");
            if (anagramArray[i].split("").sort().join("") == firstWord) {
                res = 1;
            } else {
                res = 0;
            }
        }
    }
    return res;
}

 function anagram(a,b)
{
    a = a.split("").sort().join("");
    b = b.split("").sort().join("");
    
    if(a === b)
        return 1;

    return 0;
}

 function anagram(a, b){
    let j = a.split("").sort()
    let r = b.split("").sort()
    k = 0
    if (JSON.stringify(j) == JSON.stringify(r)){
        k = 1
    }
    return k
    
}

 function anagram(a, b) {
    let arrA = Array.from(a).sort();
    let arrB = Array.from(b).sort();
    let equals = arrA.every((val, index) => val === arrB[index]);
    return equals ? 1 : 0;
}

 function anagram(s1, s2) {
    return s1.split('').sort().join() == s2.split('').sort().join();
}

 function anagram(a, b){
    if (a.toLowerCase().split('').sort().join() === b.toLowerCase().split('').sort().join()){
        return 1;
    } else {
        return 0;
    }
}

 function anagram(s1, s2) {
    return s1.split('').sort().join() == s2.split('').sort().join();
}

 function anagram(zx, xc) {
    if (zx.length != xc.length) return +false;
    xc = xc.split('')
    for (let char in zx) {
        let n = xc.indexOf(zx[char]);
        if (n>=0) {
            xc.splice(n, 1);
        } else {
            return +false
        }
    }
    return +true
}

 function anagram(a, b){
    a = a.split('').sort().join('');
    b = b.split('').sort().join('');
    
    if (a == b) return 1;
    else return 0;
}

 function anagram(a, b) {
    let n1 = a.split('').sort().join()
    let n2 = b.split('').sort().join()
    if (n1 === n2) return 1
    return 0
}

 function anagram(str1,str2) {
    return str1.split('').sort().join('')==str2.split('').sort().join('')
}

 function anagram(a,b) {
    let k = 1;
    let alf = a.split('').sort().join();
    let alf2 = b.split('').sort().join();
    if (alf == alf2) k = 1;
    else k = 0;
    return k;
}

 function anagram(x,y) {
    x = x.split('').sort().join('');
    y = y.split('').sort().join('');
    if ( x == y ) {
        return 1;
    }
    else {
        return 0;
    }
}

 function anagram(a, b) {
    let n = a.split('').sort().join('');
    let m = b.split('').sort().join('');
    if(n === m){
        return 1;
    } else{
        return 0;
    }
   
   
}
//

 function anagram(a, b){
    a = a.split("").sort().join("");
    b = b.split("").sort().join("");

    if(a == b)
        return true
    return false
}

 function anagram(a, b) {
    if(a.length == b.length)
    {
        a = a.split('').sort();
        b = b.split('').sort();

        if(a.toString() == b.toString())
            return 1;
        else
            return 0;
    }
    else
        return 0;
}

 function anagram(a, b)
{
    a = a.split('').sort().join('');
    b = b.split('').sort().join('');
    
    if (a == b) return 1;
    else return 0;
}

 function anagram(a, b) {
    if (a.split('').sort().join('') == b.split('').sort().join('')) return 1; else return 0;
}

 function anagram(s1, s2)
{
    let a1 = s1.split('');
    let a2 = s2.split('');
    
    for( i = 0; i < a1.length; i++)
    {
        if(a2.indexOf(a1[i]) != -1)
        {
            a2[a2.indexOf(a1[i])] = '-1';
        }
        else
            return 0;
    }
    
    for(i = 0; i < a2.length; i++)
    {
        if(a2[i] != '-1')
            return 0;
    }
    
    return 1;
}

 function anagram(a, b) {
    let aa = a.split('');
    let bb = b.split('');
    let l = aa.length;
    let res = 0;
    if(aa.length != bb.length){
        return 0;
    }else{
    for(let i = 0; i < l; i++){
        for(let j = 0; j < l; j++){
            if(aa[0] == bb[j]){
                aa.splice(0, 1);
                bb.splice(j, 1);
                j = l;
                res++;
            }
        }
    }
    if(res == l){
        return 1;
    }else {
        return 0;
    }
  }
}

 function anagram(a,b){
    if(a.length!=b.length){return 0;}
    let A = a.split('');
    let B = b.split('');
    for(let i = 0;i< A.length;i++){
        for(let j = 0;j< B.length;j++){
            if(A[i]==B[j]){
                A[i]=' ';
                B[j] = ' ';
                i++;
                j=-1;
            }
        }
    }
    let c = 0;
    for(let i =0;i< A.length;i++){if(A[i]!=' '||B[i]!=' '){return 0;}}
    return 1;
}

 function anagram(w1,w2){
    if (w1.split('').sort().join('')==w2.split('').sort().join('')) return 1;
    return 0;
}

 function anagram(a,b) {
    let mass1 = a.split('').sort().join('');
    let mass2 = b.split('').sort().join('');
    if (mass1 == mass2) return 1;
    else return 0;
    
}

 function anagram(a, b) {
    let c = a.split('').sort().join('');
    let d = b.split('').sort().join('');
    if(c!=d)
    return 0;
    else
    return 1;
}

 function anagram(word1,word2){
    let splittedWord1 = word1.toString().split('')
    let splittedWord2 = word2.toString().split('')
    let obj1 = {}
    let obj2 = {}
    for (let i of splittedWord1){
        if (obj1[i]){
            obj1[i]++;
        }
        else{
            obj1[i] = 1
        }
    }
    for (let i of splittedWord2){
        if (obj2[i]){
            obj2[i]++;
        }
        else{
            obj2[i] = 1
        }
    }
    if (Object.keys(obj1).length == Object.keys(obj2).length){
        for( let i of splittedWord1){
            if (obj1[i] != obj2[i]){
                return 0
            }
        }
    }
    return 1
}

 function anagram(string1, string2){
    if(string1.split("").sort().join("") == string2.split("").sort().join("")){
        return 1;
    }else{
        return 0;
    }
}

 function permutate(word, start) {
    const length = word.length;
    let array = [];
    if (length - start === 1) array.push(word);
    for (let i = start; i < length; i++) {
        let swapped = swappedClone(word, i, start);
        array = array.concat(permutate(swapped, start + 1));
    }
    return array;
}

function swappedClone(word, i, j) {
    let clone = [...word];
    let temp = clone[i];
    clone[i] = clone[j];
    clone[j] = temp;
    return clone;
}

function anagram(wordA, wordB) {
    const bChars = Array.from(wordB);
    const permutations = permutate(Array.from(wordA), 0);
    for (let i = 0; i < permutations.length; i++)
        if (arraysEqual(permutations[i], bChars)) return 1;
    return 0;
}

function arraysEqual(a, b) {
    const lengthA = a.length;
    const lengthB = b.length;
    if (lengthA != lengthB) return false;
    for (let i = 0; i < lengthA; i++) {
        if (a[i] != b[i]) return false;
    }
    return true;
}

 function anagram(s1, s2){
    let a1=s1.split('');
    let a2=s2.split('');
    
    for(let i=0; i< a1.length; i++)
    {
        if(a2.indexOf(a1[i])!=-1){
            a2[a2.indexOf(a1[i])]='-1';
        }
        else{
          return 0;
        }
    }
    for(i=0; i< a2.length; i++){
        if(a2[i]!='-1')
            return 0;
    }
    return 1;
}

 const buildCharObject = str => {
  const charObj = {}
  for(let char of str.replace(/[^\w]/g).toLowerCase()) {
    charObj[char] = charObj[char] + 1 || 1
  }
  return charObj
}
 
function anagram (a, b){
  const aCharObject = buildCharObject(a)
  const bCharObject = buildCharObject(b)
 
  if(Object.keys(aCharObject).length !== Object.keys(bCharObject).length) {
    return false
  }
  for(let char in aCharObject) {
    if(aCharObject[char] !== bCharObject[char]) {
      return 0
    }
  }
  return a
}

 function anagram(a, b) {
  var h = a.length;
  a = a.split("");
  b = b.split("");
    let gold = 0;
    if(a.length==b.length){
    for(let i = 0; i < a.length; i++){
       while(a.includes(b[i])){
         a.splice(a.indexOf(b[i]), 1)
         b.splice(i, 1)
         gold++}

    }
   }

    if(gold==h){
        gold = 1}else
        {gold = 0}
  
    
    return gold;
}

 function anagram(w1, w2) {
    ww1 = w1.split('').sort().join('')
    ww2 = w2.split('').sort().join('')
    if (ww1 == ww2)
    return 1
    else
    return 0
}

 function anagram(word1,word2){
    let splittedWord1 = word1.toString().split('')
    let splittedWord2 = word2.toString().split('')
    let a1 = {}
    let a2 = {}
    for (let i of splittedWord1) {
        if (a1[i]){
            a1[i]++;
        }
        else{
            a1[i] = 1
        } 
    }
    for (let i of splittedWord2){
        if (a2[i]){
            a2[i]++;
    }
        else{ 
            a2[i] = 1
        }    
    }
    if (Object.keys(a1).length == Object.keys(a2).length){
        for( let i of splittedWord1){
            if (a1[i] != a2[i]){
                return 0 
            }
        }
    }
    return 1
}

 function anagram(a, b)
    {
        if(a.length == b.length)
        {
            let arr1 = [];
            let arr2 = [];
            for(let i = 0; i < a.length; i++)
            {
                arr1.push(a[i]);
                arr2.push(b[i]);
            }
            arr1.sort();
            arr2.sort();
            for(let i = 0; i < arr1.length; i++)
            {
               if( arr1[i] != arr2[i])
                {
                    return 0;
                } 
            }
            return 1;
        }
        else
        {
            return 0;
        }
    }

 function anagram(word1, word2) {
  let word1Sorted = word1.split("").sort().join("");
  let word2Sorted = word2.split("").sort().join("");
  if (word1Sorted === word2Sorted) {
    return 1;
  } else {
    return 0;
  }
}

 function anagram(a, b){
    let la = a.length;
    let lb = b.length;
    if(la !== lb){
       return 0;
    }
    let str1 = a.split('').sort().join('');
    let str2 = b.split('').sort().join('');
    if(str1 === str2){
       return 1;
    } 
    else{ 
       return 0;
    }
 }

 function anagram(a, b) {
return a.toLowerCase().split("").sort().join("") == b.toLowerCase().split("").sort().join("")
}

 function anagram(str1, str2){
    if(str1.length == str2.length){
        if(str1.split('').sort().join('') == str2.split('').sort().join('')) return 1;
        else return 0;
    }
    else return 0;
}

 function anagram(v1, v2){
    let arr_v1 = v1.split("").sort();
    let arr_v2 = v2.split("").sort();
    if(arr_v1.length == arr_v2.length){
    for (let i =0;i< arr_v1.length;i++){
        if (arr_v1[i]!=arr_v2[i]){
            return 0
        }
            
        
    }
}
    else{
        return 0
    }
    return 1
}

 function anagram(word, word2)
{
    let arr = word.split('').sort();
    let arr2 = word2.split('').sort();
    if(arr.length!=arr2.length) return 0;
    for(i=0;i< arr.length;i++)
    {
        if(arr[i]!=arr2[i]) return 0;
    }
    return 1;
}

 function anagram(a, b)
{
    a = a.split('').sort().join('');
    b = b.split('').sort().join('');
    
    if (a == b) return 1;
    else return 0;
}

 function anagram(s1,s2){
    if(s1.length != s2.length) return 0
    let s1Sort = s1.split('').sort().join('');
    let s2Sort = s2.split('').sort().join('');
    return (s1Sort == s2Sort)? 1:0
}

 function anagram(a, b) {
    a=a.split('').sort().join('');
    b=b.split('').sort().join('');
    
    if(a==b)
        return 1;
    else return 0;
}

 function anagram(s1, s2) {
    return s1.split('').sort().join() == s2.split('').sort().join();
}

 function anagram(word1, word2){
    if(word1.split('').sort().join('') === word2.split('').sort().join('')){
        return 1;
    }
    else
    {
        return 0;
    }
}

 function anagram(a, b) {
    let arr1 = Array.from(a).sort();
    let arr2 = Array.from(b).sort();
    for(let i = 0; i < arr1.length; i++){
        if(!(arr1[i] === arr2[i])){
            return 0;
        }
    }
    if(arr1.length !== arr2.length)
        return 0;
    return 1;
}

 function anagram(string1, string2){
    string1.toLowerCase()
    string2.toLowerCase()
    let array1 = []
    let array2 = []
    let answer
    for (let i = 0; i < string1.length; i++){
        array1.push(string1.charAt(i))
        array2.push(string2.charAt(i))
    }
    array1.sort()
    array2.sort()
    for (let j = 0; j < array1.length; j++){
      if (array1[j] == array2[j])
        answer = 1
      else{
        answer = 0
        break
      }
    }
    return answer
}

 function anagram(a, b)
{
    let arr1 = a.split('');
    let arr2 = b.split('');
    arr1 = arr1.sort().join('');
    arr2 = arr2.sort().join('');
    if(arr1 == arr2)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

 function anagram(m,n){
    let result = 0;
    for( let i = 0; i< m.length ; i++){
        for(let k = 0; k < n.length; k++){
         if ( m[i] == n[k]){
             result = m;
         }  
         else {
             result = 0;
         }
        }
    }
    return result
}