Open In App

Add 1 to a given number

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

Write a program to add one to a given number. The use of operators like ‘+’, ‘-‘, ‘*’, ‘/’, ‘++’, ‘–‘ …etc are not allowed. 
Examples: 

Input:  12
Output: 13

Input:  6
Output: 7 

Method: Adding 1 to a given number by importing add function and without using +,- etc. 

C++




#include <iostream>
#include <functional>
using namespace std;
 
int main() {
    // input
    int n = 6;
 
    // adding 1 to a given number and print the output
    // one line solution
    std::function<int(int)> addOne = [](int x) -> int { return x + 1; };
    cout << addOne(n) << endl;
    return 0;
}


Java




import java.util.function.IntUnaryOperator;
 
public class AddOne {
  public static void main(String[] args) {
    // input
    int n = 6;
 
    // adding 1 to a given number and print the output
    // one line solution
    IntUnaryOperator addOne = x -> x + 1;
    System.out.println(addOne.applyAsInt(n));
  }
}


Python3




# Python code
# add 1 to a given number without using +
 
# importing add function
import operator 
#input
n=6
# adding 1 to a given number and print the output
# one line solution
print(operator.add(n,1))


C#




using System;
// C# equivalent
public class AddOne
{
    public static void Main(string[] args)
    {
        // input
        int n = 6;
 
        // adding 1 to a given number and print the output
        // one line solution
        System.Func<int, int> addOne = x => x + 1;
        System.Console.WriteLine(addOne(n));
    }
}


Javascript




// input
const n = 6;
 
// adding 1 to a given number and print the output
// one line solution
const addOne = (x) => x + 1;
console.log(addOne(n));


Output

7

Time Complexity: O(1)
Auxiliary Space: O(1)

Method 1 
To add 1 to a number x (say 0011000111), flip all the bits after the rightmost 0 bit (we get 0011000000). Finally, flip the rightmost 0 bit also (we get 0011001000) to get the answer. 
 

C++




// C++ code to add
// one to a given number
#include <bits/stdc++.h>
using namespace std;
 
int addOne(int x)
{
    int m = 1;
     
    // Flip all the set bits
    // until we find a 0
    while( x & m )
    {
        x = x ^ m;
        m <<= 1;
    }
     
    // flip the rightmost 0 bit
    x = x ^ m;
    return x;
}
 
/* Driver program to test above functions*/
int main()
{
    cout<<addOne(13);
    return 0;
}
 
// This code is contributed by rathbhupendra


C




// C++ code to add
// one to a given number
#include <stdio.h>
 
int addOne(int x)
{
    int m = 1;
     
    // Flip all the set bits
    // until we find a 0
    while( x & m )
    {
        x = x ^ m;
        m <<= 1;
    }
     
    // flip the rightmost 0 bit
    x = x ^ m;
    return x;
}
 
/* Driver program to test above functions*/
int main()
{
    printf("%d", addOne(13));
    getchar();
    return 0;
}


Java




// Java code to add
// one to a given number
import java.io.*;
class GFG {
 
    static int addOne(int x)
    {
        int m = 1;
         
        // Flip all the set bits
        // until we find a 0
        while( (int)(x & m) >= 1)
        {
            x = x ^ m;
            m <<= 1;
        }
     
        // flip the rightmost 0 bit
        x = x ^ m;
        return x;
    }
     
    /* Driver program to test above functions*/
    public static void main(String[] args)
    {
        System.out.println(addOne(13));
    }
}
 
// This code is contributed by prerna saini.


Python3




# Python3 code to add
# one to a given number
def addOne(x) :
     
    m = 1;
    # Flip all the set bits
    # until we find a 0
    while(x & m):
        x = x ^ m
        m <<= 1
     
    # flip the rightmost
    # 0 bit
    x = x ^ m
    return x
 
# Driver program
n = 13
print (addOne(n))
 
# This code is contributed by Prerna Saini.


C#




// C# code to add one
// to a given number
using System;
 
class GFG {
 
    static int addOne(int x)
    {
        int m = 1;
         
        // Flip all the set bits
        // until we find a 0
        while( (int)(x & m) == 1)
        {
            x = x ^ m;
            m <<= 1;
        }
     
        // flip the rightmost 0 bit
        x = x ^ m;
        return x;
    }
     
    // Driver code
    public static void Main()
    {
        Console.WriteLine(addOne(13));
    }
}
 
// This code is contributed by vt_m.


PHP




<?php
// PHP code to add
// one to a given number
 
 
function addOne($x)
{
    $m = 1;
     
    // Flip all the set bits
    // until we find a 0
    while( $x & $m )
    {
        $x = $x ^ $m;
        $m <<= 1;
    }
     
    // flip the rightmost 0 bit
    $x = $x ^ $m;
    return $x;
}
 
// Driver Code
echo addOne(13);
 
// This code is contributed by vt_m.
?>


Javascript




<script>
// JavaScript code to add
// one to a given number
 
function addOne( x) {
    let m = 1;
     
    // Flip all the set bits
    // until we find a 0
    while( x & m ) {
        x = x ^ m;
        m <<= 1;
    }
     
    // flip the rightmost 0 bit
    x = x ^ m;
    return x;
}
 
/* Driver program to test above functions*/
document.write(addOne(13));
</script>


Output

14

Time Complexity: O(log2n)
Auxiliary Space: O(1)

Method 2 
We know that the negative number is represented in 2’s complement form on most of the architectures. We have the following lemma hold for 2’s complement representation of signed numbers.
Say, x is numerical value of a number, then
~x = -(x+1) [ ~ is for bitwise complement ]
(x + 1) is due to the addition of 1 in 2’s complement conversion
To get (x + 1) apply negation once again. So, the final expression becomes (-(~x)). 

C++




#include <bits/stdc++.h>
using namespace std;
 
int addOne(int x)
{
    return (-(~x));
}
 
/* Driver code*/
int main()
{
    cout<<addOne(13);
    return 0;
}
 
 
// This code is contributed by rathbhupendra


C




#include<stdio.h>
 
int addOne(int x)
{
   return (-(~x));
}
 
/* Driver program to test above functions*/
int main()
{
  printf("%d", addOne(13));
  getchar();
  return 0;
}


Java




// Java code to Add 1 to a given number
import java.io.*;
class GFG
{
    static int addOne(int x)
    {
         return (-(~x));
    }
     
    // Driver program
    public static void main(String[] args)
    {
        System.out.printf("%d", addOne(13));
    }
}
 
// This code is contributed
// by Smitha Dinesh Semwal


Python3




# Python3 code to add 1 to a given number
 
def addOne(x):
    return (-(~x));
 
 
# Driver program
print(addOne(13))
 
# This code is contributed by Smitha Dinesh Semwal


C#




// C# code to Add 1
// to a given number
using System;
 
class GFG
{
    static int addOne(int x)
    {
        return (-(~x));
    }
     
    // Driver program
    public static void Main()
    {
        Console.WriteLine(addOne(13));
    }
}
 
// This code is contributed by vt_m.


PHP




<?php
// PHP Code to Add 1
// to a given number
 
function addOne($x)
{
return (-(~$x));
}
 
// Driver Code
echo addOne(13);
 
// This code is contributed by vt_m.
?>


Javascript




<script>
// JavaScript program for the above approach
function addOne(x)
{
    return (-(~x));
}
 
// Driver Code
    document.write(addOne(13));
 
// This code is contributed by susmitakundugoaldanga.
</script>


Output

14

Time Complexity: O(1)
Auxiliary Space: O(1)

Example : 

Assume the machine word length is one *nibble* for simplicity.
And x = 2 (0010),
~x = ~2 = 1101 (13 numerical)
-~x = -1101

Interpreting bits 1101 in 2’s complement form yields numerical value as -(2^4 – 13) = -3. Applying ‘-‘ on the result leaves 3. The same analogy holds for decrement. Note that this method works only if the numbers are stored in 2’s complement form.



Last Updated : 31 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads