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.
#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;
} |
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));
}
} |
# 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 ))
|
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));
}
} |
// 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)); |
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++ 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++ 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 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 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# 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 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. ?> |
<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> |
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)).
#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 |
#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 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 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# 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 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. ?> |
<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> |
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.