Let's first try to understand what is meant by symmetric difference. At its core, the symmetric difference is a mathematical operation that, when applied to arrays, reveals a unique set of elements. Specifically, it identifies those elements that are present in either one of the arrays but not in both. For example, for sets A = {1, 2, 3} and B = {2, 3, 4}, A △ B = {1, 4}.

This concept becomes more complex when extended beyond two arrays. Our goal today is to unravel this complexity and understand how to effectively find the symmetric difference across multiple arrays. So to evaluate an expression involving symmetric differences among three elements (A △ B △ C), you must complete one operation at a time. Thus, for sets A and B above, and C = {2, 3}, A △ B △ C = (A △ B) △ C = {1, 4} △ {2, 3} = {1, 2, 3, 4}. You have to understand clearly that we are not doing the comparison for all arrays at once.

Let's try to solve this problem with JavaScript. As inputs, there can be 2 or n number of arrays, and as output, we get the symmetric difference in one single array. The following is a solution to this problem. There can be much more efficient solutions to this problem. If you know a better solution please add a comment.

function sym() {
  const args = [...arguments];

  function symDiff(arrayOne, arrayTwo) {
    const result = [];

    arrayOne.forEach((item) => {
      if (arrayTwo.indexOf(item) < 0 && result.indexOf(item) < 0) {
        result.push(item);
      }
    });

    arrayTwo.forEach((item) => {
      if (arrayOne.indexOf(item) < 0 && result.indexOf(item) < 0) {
        result.push(item);
      }
    });

    return result;
  }

  return args.reduce(symDiff);
}


sym([1, 2, 3], [2, 3, 4], [2, 3])

The sym function is a JavaScript function designed to calculate the symmetric difference between multiple arrays. When the function is called, it takes any number of arrays as arguments. Initially, it converts these arguments into an actual array named args using the spread syntax, making it easier to manipulate them using array methods. Inside sym, there's a helper function named symDiff, which is responsible for computing the symmetric difference between two arrays at a time. This function works by iterating through each element of the first array, adding elements to a result array if they are not found in the second array and are not already in the result array. It then repeats this process for the second array. The result is an array of elements that are unique to each of the two arrays being compared.

The sym function then uses the reduce method on the args array. The reduce method applies the symDiff function across the args array, starting with the first two arrays and then consecutively applying the symmetric difference to the cumulative result and the next array in args. This approach allows the sym function to compute the symmetric difference across all provided arrays, resulting in a single array that represents the symmetric difference of all the input arrays.

Hopefully, this deep dive into its inner workings has provided clarity on how symmetric differences are calculated in JavaScript. If you have any questions or if there's a specific part of this process you'd like to discuss further, please feel free to leave a comment below. I'm always here to help and love engaging with readers about these fascinating programming concepts!

While I was working at Assetowl, a property management solutions company in Australia, I faced and solved a big problem that greatly improved how we brought data into our system.

When acquiring new customers we had to import their past data as a part of the onboarding process. Customers gave us inspection data in different formats, including PDF, Word, and Excel/CSV files for 100s properties they manage. In the onboarding process, this acts as a bottleneck because ~8 data entry operators had to do this manually. The variety of these data formats made the process of adding this data to our system slow and more likely to have mistakes. This was a huge challenge to make sales.

My main responsibility was to oversee data onboarding. I had to witness the difficulties and hurdles during this process. Top management had plans to implement a system to facilitate data onboarding but since Assetowl was a startup company top management did not have enough resources to invest in the onboarding system.

Solution

To tackle this challenge, I developed Python scripts, leveraging the capabilities of the Openpyxl library. This programming approach was aimed at converting data from CSV files into JSON files. JSON, or JavaScript Object Notation.

This technical solution significantly minimized the need for manual data entry. Automating the conversion process, not only saved time but also greatly reduced the possibility of errors. The code for these scripts is accessible on GitHub at this link: PDF-to-JSON.

Again a problem

Now I had JSON files ready to import into the system but there was an issue. Due to the inconsistency of customer-provided files, the JSON files were not 100% accurate. Even though JSON is humanly readable it was really hard to edit the JSON files.

Next solution

As a solution, I designed and developed a quality assurance web application using React, Typescript, and Redux. This application allowed users to upload above mentioned JSON files, make edits, and download the edited versions with ease, enhancing the overall data onboarding experience.

The source code is available on GitHub at this link: pcr-qa on GitHub. Additionally, a live demo of the application can be accessed at pcr-qa.netlify.app, providing a hands-on experience of its functionality.

With these solutions, data onboarding was 4X faster than manual data import. As a result of this increased efficiency, we were able to onboard more customers than ever before. The faster processing times allowed us to handle a larger volume of data without compromising on accuracy or quality. This was a significant step forward in meeting the growth of our clientele.