Plus One to Array Problem in Java

It is a very interesting problem frequently asked in interviews of top IT companies like Google, Amazon, TCS, Accenture, Adobe, Apple, Infosys, etc. By solving the problem, one wants to check the logical ability, critical thinking, and problem-solving skill of the interviewee. So, in this section, we are going to add (plus) one to an array problem in Java with different approaches and logic. Also, we will create Java programs for the same.

Problem Statement

In this problem, we have given an array in which each element represents a digit and the complete array represents a number. The digits are ordered from MSB to LSB in left to right order. Assume that there is no leading 0's in the number.

The task is to add 1 to the number and return the result in the form of an array of digits.

Let's understand it through examples.

Example

Input: arr = [2, 5, 9, 7]

Output: [2, 5, 9, 8]

It represents the number 2597. Add 1 to the most significant bit, we get 2598. The output will be [2, 5, 9, 8].

Let's see another example.

Input: arr = [9, 9]

Output: [1, 0, 0]

It represents the number 99. Add 1 to the most significant bit, we get 100. The output will be [1, 0, 0].

Solution to The Problem

Naive Approach

The simple approach is that first convert the array into a number, add one to it, and return the result in the form of an array. But the approach is not applicable to the large array. So, we will process each digit one by one.

Begin from the least significant bit and process each digit till the most significant bit.
If the current digit is smaller than 9, add 1 to the current digit and return the array else assign zero to the current digit.
If the last element is processed and it was also equal to 9, it means that all the digits were 9. So, we will increase the size of the array by one and assign 1 to the MSB.
Return the resultant array.

Plus One to Array Java Program

PlusOneArray.java

import java.util.Arrays; 
public class PlusOneArray
{
//function to add 1 to the array
public static int[] plusOne(int[] digits) 
{
int n = digits.length;
for(int i=n-1; i>=0; i--) 
{
if(digits[i] < 9) 
{
digits[i]++; 
return digits;
}
digits[i] = 0;
}
int[] newNumber = new int [n+1];
newNumber[0] = 1;
return newNumber;
}
//driver code
public static void main(String args[]) 
{
int [] arr = {6, 3, 8, 2}; 
//function calling
int[]ans=plusOne(arr); 
//prints the resultant array after adding 1 to MSB
System.out.println(Arrays.toString(ans));
}
}

Output:

[6, 3, 8, 3]

Using Vector

Another approach is using the vector. In this approach, we begin from the end of the vector. If the last element is 9, set it to 0, else exit from the loop.

If all digits are 9, set 1 at starting, else increment the element at the position where the loop stopped. Note that no carry, division, and modulo is required.

Let's implement the above approach in a Java program.

PlusOneExample1.java

import java.io.*;
import java.util.*;
public class PlusOneExample1
{
//function to add one to the array
static void plusOne(Vector<Integer> digits)
{
//initialize an index (digit of units)
int index= digits.size() - 1;
while (index >= 0 && digits.get(index) == 9)
{
//while the index is valid and the value at [index] == 9 set it as 0    
digits.set(index, 0);
//decement index by 1
index -= 1;
}
// if index < 0 (if all digits were 9)
if (index < 0)
{
//inserting 1 at the beginning of the vector 
digits.set(0, 1);
//adding an extra zero to the end of the vector 
digits.add(digits.size(),0);
}
//else increment the value at [index]
else
digits.set(index, digits.get(index) + 1);
}
//driver code
public static void main(String args[])
{
//creating an instance of the vector class and passing an array
Vector<Integer> digits = new Vector<Integer>(Arrays.asList(12, 45, 90, 34));
//function calling
plusOne(digits);
for (int digit : digits)
//prints the array after adding 1 to the array
System.out.print(digit + " ");
}
}

Output:

12 45 90 35

Let's see another approach.

In this approach, first, we reverse the given array. After that take a carry variable to store the carry. Iterate over the array from starting and add 1. Carry to the value of that array at that index.

Now check whether the value of that index is greater than equal to 9 or not. If yes, take the carry as the ten's value and the value at that index in the array will be the value present at the one place, else simply move on.

if digits[i]>9 then carry = digits[i]/10 and digits[i]%=10
if digits[i]<=9 then carry = 0

Repeat the above step until we reach the last element of the array. Note that if carry is not 0, simply add 1 to the array. At last, reverse the array, so that we can get the original array.

Let's implement the above approach in a Java program.

PlusOneExample2.java

import java.io.*;
import java.util.*;
public class PlusOneExample2
{
//function to add one to the array    
public static void plusOne(Vector<Integer> digits, int n)
{
//revers the given array so that we can begin traversing from back
Collections.reverse(digits);
//defining a variable to store carry
int carry = 0;
for(int i = 0; i < n; i++)
{
//initially carry is 0, it is the base case
if(i == 0)
digits.set(i, digits.get(i) + 1 + carry);
//if carry is not equal to zero, add it to the array element at that position
else if(carry != 0)
digits.set(i, digits.get(i) + carry);
//now to get carry, i.e. if digits[i]>9 we get the value at tens place in carry or else if digits[i]<9 carry will be 0
carry = digits.get(i) / 10;
//now if carry is not equal to 0, so at that index, we should keep the value present at the ones place so we do digits[i]%10
if(carry != 0)digits.set(i, digits.get(i) % 10);
}
//after doing all that if carry is still there which means one more element is needed to be added to the array
if(carry != 0)
digits.set(digits.size() - 1, carry);
//again, revere the array so that we can get the original array
Collections.reverse(digits);
}
//driver code
public static void main (String args[])
{
//creating an instance of the vector class and passing an array
Vector<Integer> digits = new Vector<Integer>(Arrays.asList(9, 9, 9, 9, 9));
//determines the size of the array
int n = digits.size();
//function calling
plusOne(digits, n);
for(int i = 0; i < n; i++)
{
//prints the array after adding 1 to the array    
System.out.print(digits.get(i) + " ");
}
}
}

Output: