Odd Occurrences In Array exercise from Codility (JavaScript/NodeJS)

OddOccurrencesInArray.js

/**
 * Finds element without a pair in an unsorted array of integers
 * @param {array} A
 * @return {int} element without a pair
 */
function solution(A) {
    let result = 0;
  
    for (let element of A) {
        // Apply Bitwise XOR to the current and next element
        result ^= element
    }

    return result
}


// =======================
// SLOW
// =======================
function slowSolution(A) {
    // Convert the array to a map with element as a key and number of occurrences as a value
    // Example: { '3': 2, '7': 1, '9': 4 }
    let map = A.reduce((map, obj) => {
        map[obj] = ++map[obj] || 1
        return map
    }, {})
    
    // Then filter the map by checking if the key's value is equal to 1
    // Returns array with key
    let filteredArr = Object.keys(map).filter(el => map[el] === 1)
    
    return  +filteredArr[0] || null
}

would you like to explain line result ^= element? im not familiar with ^= operator

@radityaarya ^ is a XOR operator which means if the similar ( 0 or 1) bit will occur at the same position it will produce 0 ( i.e., false ) if otherwise non similar then it will produce 1 ( i.e., true).

This is my version for this exercise

function solution(A) {
    let map = {};
    for(var i = 0; i < A.length; i++) {;
        map[A[i]] = ++map[A[i]] || 1;
    }
    for(properties in map) {
        if(map[properties] % 2 != 0) return parseInt(properties);
    }
}

Correct solution with O(n) complexity

function solution(A) {
    let map = A.reduce((map, obj) => {
        map[obj] = ++map[obj] || 1
        return map
    }, {})
    
    let filteredArr = Object.keys(map).filter(el => map[el] %2)
    return  +filteredArr[0] 
}

@RomaSto

Just want to know how is your solution better from @Edengb? Using filter which will also going to iterate through the array. !!

And what difference you both provide from the initial solution as slowSolution?

Please elaborate either of you. Thanks

Fast and understandable 🤯 solution.

function solution(A) {
  A = A.sort();

  let val = A[A.length - 1];
  for (let i = 0; i < (A.length - 1) / 2; i++) {
    if (A[i * 2] !== A[i * 2 + 1]) {
      val = A[i * 2];
      break;
    }
  }
  return val;
}

@k0ff33 I can't figure out how Bitwise XOR operator does work.
@RomaSto It is still O(N**2).