Tips for incorporating an algorithm to identify whether a number contains 2 consecutive digits

Question

Tips for incorporating an algorithm to identify whether a number contains 2 consecutive digits

Looking to create a function that can determine if a number contains consecutive digits:

For example:

If the input is 11, it will return true
If the input is 21, it will return false
If the input is 323, it should return false because even though there are repeated numbers, they are not consecutive

Currently, I am converting the number into an array and iterating through it one by one to check for consecutive digits. However, this approach has a time complexity of O(n). If anyone has alternative solutions with better efficiency, please share.

Thank you!

javascript arrays algorithm

Answer 1

Answer №1

Consider an alternative approach that eliminates the need to convert the number into a string or array of numbers/characters. Here's how it works:

Start by setting a variable curr to -1.
Implement a loop with the condition while num > 0 and execute the following steps:

next_curr = num % 10
```
if next_curr == curr: return true
```
curr = next_curr
num = num / 10 (using integer division)

If the loop finishes, return false.

This algorithm operates in a single pass with time complexity of O(log n), where n represents the input number. The space complexity is O(1).

It's worth noting that while your initial algorithm also had a time complexity of O(log n), it required 2 passes and had a space complexity of O(log n).

While I haven't coded in JavaScript recently, below is a possible JS implementation of this algorithm:

function sameAdjacentDigits(num) {
    // Handle negative numbers and prevent potential issues when using Math.floor later on
    num = Math.abs(num)
    let curr = -1
    while (num > 0) {
        const nextCurr = num % 10
        if (nextCurr == curr) return true
        curr = nextCurr
        num = Math.floor(num / 10)
    }
    return false
}

Answer 2

Consider an alternative approach that eliminates the need to convert the number into a string or array of numbers/characters. Here's how it works:

Start by setting a variable curr to -1.
Implement a loop with the condition while num > 0 and execute the following steps:

next_curr = num % 10
```
if next_curr == curr: return true
```
curr = next_curr
num = num / 10 (using integer division)

If the loop finishes, return false.

This algorithm operates in a single pass with time complexity of O(log n), where n represents the input number. The space complexity is O(1).

It's worth noting that while your initial algorithm also had a time complexity of O(log n), it required 2 passes and had a space complexity of O(log n).

While I haven't coded in JavaScript recently, below is a possible JS implementation of this algorithm:

function sameAdjacentDigits(num) {
    // Handle negative numbers and prevent potential issues when using Math.floor later on
    num = Math.abs(num)
    let curr = -1
    while (num > 0) {
        const nextCurr = num % 10
        if (nextCurr == curr) return true
        curr = nextCurr
        num = Math.floor(num / 10)
    }
    return false
}

Answer 3

Answer №2

Implement regular expressions to identify patterns, then validate the results using a matcher

numbers_match = /(00|11|22|33|44|55|66|77|88|99)/;
numbers_match.match("11")

Visit this link for more information on using match in JavaScript strings

Answer 4

Implement regular expressions to identify patterns, then validate the results using a matcher

numbers_match = /(00|11|22|33|44|55|66|77|88|99)/;
numbers_match.match("11")

Visit this link for more information on using match in JavaScript strings

Answer 5

Answer №3

The simplest method to achieve this is through the use of regular expressions. Although the efficiency of the algorithm is not certain, a potential solution could be

/(\d)\1/

Answer 6

The simplest method to achieve this is through the use of regular expressions. Although the efficiency of the algorithm is not certain, a potential solution could be

/(\d)\1/

Answer 7

Answer №4

Based on the idea presented by @Tschallacka's response:

const values = [12,34,56];

const output = values.map(val=>{
  const check = val.toString().match(/(00|11|22|33|44|55|66|77|88|99)/);
  return check !== null;
})

console.log(output);

Answer 8

Based on the idea presented by @Tschallacka's response:

const values = [12,34,56];

const output = values.map(val=>{
  const check = val.toString().match(/(00|11|22|33|44|55|66|77|88|99)/);
  return check !== null;
})

console.log(output);

Tips for incorporating an algorithm to identify whether a number contains 2 consecutive digits

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

Update class name in React component based on state change

Tool to insert content into the initial subdirectory

Trouble with npm installation on Windows following node update

Transforming business entities into JSON format

Ways to transmit data from PHP to JavaScript

Issue with conflicting trigger events for clicking and watching sequences in input text boxes and checkboxes within an AngularJS application

Adding fields to all objects in an array within MongoDB

Dealing with forms in Next.js with TypeScript and server-side actions - Oops! Error: e._formData.get is not a recognized function

Remove the Prisma self-referencing relationship (one-to-many)

The jqgrid hidden grid is causing data duplication and the vertical scroll is covering up the information

Error: The property 'inputItem' is not recognized on type 'EventTarget' - Utilizing Semantic-Ui, React, and Typescript

Extracting data from a JSON file and displaying it using Angular

Retrieving information from a local JSON file in Vue.js using the jQuery $.getJSON() method

Is there a way to determine if the value of an array has not been defined?

Function in Typescript that accepts either a single object or an array of objects

Encountering an error message while starting up a Node Express server

The initial return value of $(document).height may be inaccurate, but is accurate upon recalculation

Is there a way to completely remove an element from the dom once the ajax call has returned

Do you think it's feasible to configure cookies for express-session to never expire?

Is it safe for me to assume that mobile browsers that have JavaScript enabled will also be able to