Locate and retrieve the item that appears most often in a given array

Question

Locate and retrieve the item that appears most often in a given array

In order to determine the mode of an array consisting of integer numbers only, I must create a function named findMode. If the array is empty, the function should return 0. Otherwise, it should return the element that occurs most frequently in the array. In case there are multiple modes, the smallest value among them should be returned. To achieve this, I need to generate a new array to keep track of how many times each number appears in the input array.

Here is the initial implementation:

import { print } from "....";

export let main = async () => {
    let input = [2, 1, 1, 2, 1, 0]
    print(mode(input))

};

export let findMode = (b: number[]): number => {
    let newArr: number[] = []; /** An intermediate array created to store count */
    if (b.length === 0) {
        return 0;
    for (let i = 0; i < b.length; i++) {


};
main();

The expected/actual results are as follows:

If the array is [2,1,1,2,1,0], the expected result is 1. When inspecting the array with counts, newArr[1,3,2] should be printed. This signifies that element 0 appears once, element 1 appears thrice, and element 2 appears twice. The maximum occurrence corresponds to index 1 in the intermediate array, leading to the mode being 1.

For arrays like [0,0,0,1,1,2,1,1], [4,4,7,4,0,7], [-4,-4,-1,3,5], [1,1,2,3,2], and [10,10,10,20,20,30], the expected modes are 1, 4, -4, 1, and 10 respectively. In cases where there are multiple modes, the smallest one should always be selected.

arrays typescript for-loop return mode

Answer 1

Answer №1

Do you think a solution like this would be effective?

const calculateMode = (numbers: number[]): number => {
    // Array to store values and their counts
    const counts: Array<{ value: number, count: number }> = [];

    if (!numbers || !numbers.length) {
        return 0;
    }

    for (let i = 0; i < numbers.length; i++) {
        const val = numbers[i];
        const count = counts.find(count => count.value === val);

        if (count) {
            count.count++;
        } else {
            counts.push({ value: val, count: 1 });
        }
    }

    const mode = counts.sort((c1, c2) => c2.count - c1.count)[0];

    const largestNumber = counts.sort((c1, c2) => c2.value - c1.value)[0];
    let newArr = new Array(largestNumber);
    newArr = newArr.map((val, i) => {
        const count = counts.find(count => count.value === i);
        if (count) {
            return count.count;
        } else {
            return 0;
        }
    });
};

Answer 2

Do you think a solution like this would be effective?

const calculateMode = (numbers: number[]): number => {
    // Array to store values and their counts
    const counts: Array<{ value: number, count: number }> = [];

    if (!numbers || !numbers.length) {
        return 0;
    }

    for (let i = 0; i < numbers.length; i++) {
        const val = numbers[i];
        const count = counts.find(count => count.value === val);

        if (count) {
            count.count++;
        } else {
            counts.push({ value: val, count: 1 });
        }
    }

    const mode = counts.sort((c1, c2) => c2.count - c1.count)[0];

    const largestNumber = counts.sort((c1, c2) => c2.value - c1.value)[0];
    let newArr = new Array(largestNumber);
    newArr = newArr.map((val, i) => {
        const count = counts.find(count => count.value === i);
        if (count) {
            return count.count;
        } else {
            return 0;
        }
    });
};

Answer 3

Answer №2

To solve this problem and get the desired result, you can utilize the Array#reduce method along with an additional object to keep track of counts.

export let findMode = (b: number[]): number => {
  // Object to store count of each element
  // Initialized with '0' with a count of 0 as default value
  let ref = {
    '0': 0
  };

  return b.reduce((value, num) => {
    // Set count to 0 if not defined
    ref[num] = ref[num] || 0;

    // Increase count for current element
    ref[num]++;
    
    // If the count of the current element is greater than the previous one
    // Return the current element
    if (ref[num] > ref[value]) {
      return num;
      
    // If counts are equal, return the smaller value
    } else if (ref[num] === ref[value]) {
      return num < value ? num : value;
    }
    
    // Otherwise, return the previous value
    return value;
    
    // Initialize the initial value as 0 (default)
  }, 0);
};

let findMode = b => {

  let ref = {
    '0': 0
  };

  return b.reduce((value, num) => {
    ref[num] = ref[num] || 0;
    ref[num]++;
    if (ref[num] > ref[value]) {
      return num;
    } else if (ref[num] === ref[value]) {
      return num < value ? num : value;
    }
    return value;
  }, 0);
};


[
  [2, 1, 1, 2, 1, 0],
  [1, 3, 2],
  [0, 0, 0, 1, 1, 2, 1, 1],
  [4, 4, 7, 4, 0, 7],
  [-4, -4, -1, 3, 5],
  [1, 1, 2, 3, 2],
  [10, 10, 10, 20, 20, 30]
].forEach(v => console.log(findMode(v)))

Answer 4

To solve this problem and get the desired result, you can utilize the Array#reduce method along with an additional object to keep track of counts.

export let findMode = (b: number[]): number => {
  // Object to store count of each element
  // Initialized with '0' with a count of 0 as default value
  let ref = {
    '0': 0
  };

  return b.reduce((value, num) => {
    // Set count to 0 if not defined
    ref[num] = ref[num] || 0;

    // Increase count for current element
    ref[num]++;
    
    // If the count of the current element is greater than the previous one
    // Return the current element
    if (ref[num] > ref[value]) {
      return num;
      
    // If counts are equal, return the smaller value
    } else if (ref[num] === ref[value]) {
      return num < value ? num : value;
    }
    
    // Otherwise, return the previous value
    return value;
    
    // Initialize the initial value as 0 (default)
  }, 0);
};

let findMode = b => {

  let ref = {
    '0': 0
  };

  return b.reduce((value, num) => {
    ref[num] = ref[num] || 0;
    ref[num]++;
    if (ref[num] > ref[value]) {
      return num;
    } else if (ref[num] === ref[value]) {
      return num < value ? num : value;
    }
    return value;
  }, 0);
};


[
  [2, 1, 1, 2, 1, 0],
  [1, 3, 2],
  [0, 0, 0, 1, 1, 2, 1, 1],
  [4, 4, 7, 4, 0, 7],
  [-4, -4, -1, 3, 5],
  [1, 1, 2, 3, 2],
  [10, 10, 10, 20, 20, 30]
].forEach(v => console.log(findMode(v)))

Locate and retrieve the item that appears most often in a given array

Answer №1

Answer №2

Similar questions

Activate function on Ctrl + K in a React TypeScript project

Creating an enumeration within a class

Encountering a problem while compiling the Next.js app

Ways to disperse items within another item

What is the best way to create an interface that only allows keys to be a combination of values from a specific property found within each object of an array?

Obtain a byte array from an AngularJs controller

Assigning a Value to a Dropdown Menu in Angular

Exploring the Worldwide Influence of TypeScript, React, and Material-UI

"Encountering a glitch in the Typescript/Node API where Express routes

Expanding form fields dynamically with AngularJS

Angular 10 introduces a new approach to handling concurrency called "forkJoin"

Changing an object into an array for saving and transforming it back to an array for usage in JavaScript

The instanceof operator does not recognize the value as an instance and is returning false, even though it

What are the steps to splitting an array into separate integer and string arrays?

What methods are available to prevent redundant types in Typescript?

Troubleshooting: Imported Variable in Angular 2+ Throwing Module Not Found Error

Incorporating a unique variant with Tailwind called "

What is the significance of incorporating 'Actions' as data within the Redux framework?

Declaring properties for an interface

Manipulate the 'i' variable within a for loop using JavaScript, JQuery, and JSON to modify an attribute