# Program to delete Nth digit of a Number

Given a number num and a number n, the task is to delete this nth digit of the number num, from starting and from end.

Examples:

Input: num = 1234, n = 3
Output: num_after_deleting_from_starting = 124, num_after_deleting_from_end = 134

Input: num = 4516312, n = 2
Output: num_after_deleting_from_starting = 416312, num_after_deleting_from_end = 451632

Approach:

• To delete nth digit from starting:
1. Get the number and the nth digit to be deleted.
2. Count the number of digits
3. Loop number of digits time by counting it with a variable i.
4. If the i is equal to (number of digits – i), then skip, else add the ith digit as [ new_number = (new_number * 10) + ith_digit ].
• To delete nth digit from ending:
1. Get the number and the nth digit to be deleted.
2. Loop number of digits time by counting it with a variable i.
3. If the i is equal to (n), then skip, else add the ith digit as [ new_number = (new_number * 10) + ith_digit ].

Implementation:

 `// C++ implementation of above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to delete nth digit ` `// from starting ` `int` `deleteFromStart(``int` `num, ``int` `n) ` `{ ` ` `  `    ``// Get the number of digits ` `    ``int` `d = ``log10``(num) + 1; ` ` `  `    ``// Declare a variable ` `    ``// to form the reverse resultant number ` `    ``int` `rev_new_num = 0; ` ` `  `    ``// Loop with the number ` `    ``for` `(``int` `i = 0; num != 0; i++) { ` ` `  `        ``int` `digit = num % 10; ` `        ``num = num / 10; ` ` `  `        ``if` `(i == (d - n)) { ` `            ``continue``; ` `        ``} ` `        ``else` `{ ` ` `  `            ``rev_new_num = (rev_new_num * 10) + digit; ` `        ``} ` `    ``} ` ` `  `    ``// Declare a variable ` `    ``// to form the resultant number ` `    ``int` `new_num = 0; ` ` `  `    ``// Loop with the number ` `    ``for` `(``int` `i = 0; rev_new_num != 0; i++) { ` ` `  `        ``new_num = (new_num * 10) ` `                  ``+ (rev_new_num % 10); ` `        ``rev_new_num = rev_new_num / 10; ` `    ``} ` ` `  `    ``// Return the resultant number ` `    ``return` `new_num; ` `} ` ` `  `// Function to delete nth digit ` `// from ending ` `int` `deleteFromEnd(``int` `num, ``int` `n) ` `{ ` ` `  `    ``// Declare a variable ` `    ``// to form the reverse resultant number ` `    ``int` `rev_new_num = 0; ` ` `  `    ``// Loop with the number ` `    ``for` `(``int` `i = 1; num != 0; i++) { ` ` `  `        ``int` `digit = num % 10; ` `        ``num = num / 10; ` ` `  `        ``if` `(i == n) { ` `            ``continue``; ` `        ``} ` `        ``else` `{ ` ` `  `            ``rev_new_num = (rev_new_num * 10) + digit; ` `        ``} ` `    ``} ` ` `  `    ``// Declare a variable ` `    ``// to form the resultant number ` `    ``int` `new_num = 0; ` ` `  `    ``// Loop with the number ` `    ``for` `(``int` `i = 0; rev_new_num != 0; i++) { ` ` `  `        ``new_num = (new_num * 10) ` `                  ``+ (rev_new_num % 10); ` `        ``rev_new_num = rev_new_num / 10; ` `    ``} ` ` `  `    ``// Return the resultant number ` `    ``return` `new_num; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``// Get the number ` `    ``int` `num = 1234; ` `    ``cout << ``"Number: "` `<< num << endl; ` ` `  `    ``// Get the digit number to be deleted ` `    ``int` `n = 3; ` `    ``cout << ``"Digit to be deleted: "` `<< n << endl; ` ` `  `    ``// Remove the nth digit from starting ` `    ``cout << ``"Number after "` `<< n ` `         ``<< ``" digit deleted from starting: "` `         ``<< deleteFromStart(num, n) << endl; ` ` `  `    ``// Remove the nth digit from ending ` `    ``cout << ``"Number after "` `<< n ` `         ``<< ``" digit deleted from ending: "` `         ``<< deleteFromEnd(num, n) << endl; ` ` `  `    ``return` `0; ` `} `

 `// Java implementation of above approach ` ` `  ` `  `class` `GFG ` `{ ` `    ``// Function to delete nth digit ` `    ``// from starting ` `    ``static` `int` `deleteFromStart(``int` `num, ``int` `n) ` `    ``{ ` `     `  `        ``// Get the number of digits ` `        ``int` `d = (``int``)Math.log10(num) + ``1``; ` `     `  `        ``// Declare a variable ` `        ``// to form the reverse resultant number ` `        ``int` `rev_new_num = ``0``; ` `     `  `        ``// Loop with the number ` `        ``for` `(``int` `i = ``0``; num != ``0``; i++) { ` `     `  `            ``int` `digit = num % ``10``; ` `            ``num = num / ``10``; ` `     `  `            ``if` `(i == (d - n)) { ` `                ``continue``; ` `            ``} ` `            ``else` `{ ` `     `  `                ``rev_new_num = (rev_new_num * ``10``) + digit; ` `            ``} ` `        ``} ` `     `  `        ``// Declare a variable ` `        ``// to form the resultant number ` `        ``int` `new_num = ``0``; ` `     `  `        ``// Loop with the number ` `        ``for` `(``int` `i = ``0``; rev_new_num != ``0``; i++) { ` `     `  `            ``new_num = (new_num * ``10``) ` `                    ``+ (rev_new_num % ``10``); ` `            ``rev_new_num = rev_new_num / ``10``; ` `        ``} ` `     `  `        ``// Return the resultant number ` `        ``return` `new_num; ` `    ``} ` `     `  `    ``// Function to delete nth digit ` `    ``// from ending ` `    ``static` `int` `deleteFromEnd(``int` `num, ``int` `n) ` `    ``{ ` `     `  `        ``// Declare a variable ` `        ``// to form the reverse resultant number ` `        ``int` `rev_new_num = ``0``; ` `     `  `        ``// Loop with the number ` `        ``for` `(``int` `i = ``1``; num != ``0``; i++) { ` `     `  `            ``int` `digit = num % ``10``; ` `            ``num = num / ``10``; ` `     `  `            ``if` `(i == n) { ` `                ``continue``; ` `            ``} ` `            ``else` `{ ` `     `  `                ``rev_new_num = (rev_new_num * ``10``) + digit; ` `            ``} ` `        ``} ` `     `  `        ``// Declare a variable ` `        ``// to form the resultant number ` `        ``int` `new_num = ``0``; ` `     `  `        ``// Loop with the number ` `        ``for` `(``int` `i = ``0``; rev_new_num != ``0``; i++) { ` `     `  `            ``new_num = (new_num * ``10``) ` `                    ``+ (rev_new_num % ``10``); ` `            ``rev_new_num = rev_new_num / ``10``; ` `        ``} ` `     `  `        ``// Return the resultant number ` `        ``return` `new_num; ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `main(String []args) ` `    ``{ ` `     `  `        ``// Get the number ` `        ``int` `num = ``1234``; ` `        ``System.out.println(``"Number: "` `+ num ); ` `     `  `        ``// Get the digit number to be deleted ` `        ``int` `n = ``3``; ` `        ``System.out.println(``"Digit to be deleted: "` `+ n ); ` `     `  `        ``// Remove the nth digit from starting ` `        ``System.out.println(``"Number after "` `+ n ` `            ``+ ``" digit deleted from starting: "` `            ``+ deleteFromStart(num, n)); ` `     `  `        ``// Remove the nth digit from ending ` `        ``System.out.println( ``"Number after "` `+ n ` `            ``+ ``" digit deleted from ending: "` `            ``+ deleteFromEnd(num, n)); ` `     `  `         `  `    ``} ` ` `  `} ` ` `  `// This code is contributed by ihritik `

 `# Python3 implementation of above approach ` ` `  `# Function to delete nth digit ` `# from starting ` `import` `math; ` `def` `deleteFromStart(num, n): ` ` `  `    ``# Get the number of digits ` `    ``d ``=` `(math.log10(num) ``+` `1``); ` ` `  `    ``# Declare a variable to form  ` `    ``# the reverse resultant number ` `    ``rev_new_num ``=` `0``; ` ` `  `    ``# Loop with the number ` `    ``i ``=` `0``; ` `    ``while` `(num !``=` `0``): ` ` `  `        ``digit ``=` `num ``%` `10``; ` `        ``num ``=` `int``(num ``/` `10``); ` ` `  `        ``if` `(i !``=` `(``int``(d) ``-` `n)): ` `            ``rev_new_num ``=` `((rev_new_num ``*` `10``) ``+` `                                        ``digit); ` `        ``i ``+``=` `1``; ` ` `  `    ``# Declare a variable to form the ` `    ``# resultant number ` `    ``new_num ``=` `0``; ` ` `  `    ``# Loop with the number ` `    ``i ``=` `0``; ` `    ``while` `(rev_new_num !``=` `0``): ` ` `  `        ``new_num ``=` `((new_num ``*` `10``) ``+`  `                   ``(rev_new_num ``%` `10``)); ` `        ``rev_new_num ``=` `int``(rev_new_num ``/` `10``); ` `        ``i ``+``=` `1``; ` ` `  `    ``# Return the resultant number ` `    ``return` `new_num; ` ` `  `# Function to delete nth digit ` `# from ending ` `def` `deleteFromEnd(num, n): ` ` `  `    ``# Declare a variable to form  ` `    ``# the reverse resultant number ` `    ``rev_new_num ``=` `0``; ` ` `  `    ``# Loop with the number ` `    ``i ``=` `1``; ` `    ``while` `(num !``=` `0``): ` ` `  `        ``digit ``=` `num ``%` `10``; ` `        ``num ``=` `int``(num ``/` `10``); ` ` `  `        ``if` `(i !``=` `n): ` `            ``rev_new_num ``=` `((rev_new_num ``*` `10``) ``+` `                                        ``digit); ` `        ``i ``+``=` `1``; ` ` `  `    ``# Declare a variable ` `    ``# to form the resultant number ` `    ``new_num ``=` `0``; ` ` `  `    ``# Loop with the number ` `    ``i ``=` `0``; ` `    ``while` `(rev_new_num !``=` `0``): ` ` `  `        ``new_num ``=` `((new_num ``*` `10``) ``+`  `                   ``(rev_new_num ``%` `10``)); ` `        ``rev_new_num ``=` `int``(rev_new_num ``/` `10``); ` `        ``i ``+``=` `1``; ` ` `  `    ``# Return the resultant number ` `    ``return` `new_num; ` ` `  `# Driver code ` `# Get the number ` `num ``=` `1234``; ` `print``(``"Number:"``, num); ` ` `  `# Get the digit number to be deleted ` `n ``=` `3``; ` `print``(``"Digit to be deleted:"``, n); ` ` `  `# Remove the nth digit from starting ` `print``(``"Number after"``, n,  ` `      ``"digit deleted from starting:"``,  ` `            ``deleteFromStart(num, n)); ` ` `  `# Remove the nth digit from ending ` `print``(``"Number after"``, n,  ` `      ``"digit deleted from ending:"``,  ` `            ``deleteFromEnd(num, n)); ` ` `  `# This code is contributed by chandan_jnu `

 `// C# implementation of the above approach ` ` `  `using` `System; ` `class` `GFG ` `{ ` `    ``// Function to delete nth digit ` `    ``// from starting ` `    ``static` `int` `deleteFromStart(``int` `num, ``int` `n) ` `    ``{ ` `     `  `        ``// Get the number of digits ` `        ``int` `d = (``int``)Math.Log10(num) + 1; ` `     `  `        ``// Declare a variable ` `        ``// to form the reverse resultant number ` `        ``int` `rev_new_num = 0; ` `     `  `        ``// Loop with the number ` `        ``for` `(``int` `i = 0; num != 0; i++) { ` `     `  `            ``int` `digit = num % 10; ` `            ``num = num / 10; ` `     `  `            ``if` `(i == (d - n)) { ` `                ``continue``; ` `            ``} ` `            ``else` `{ ` `     `  `                ``rev_new_num = (rev_new_num * 10) + digit; ` `            ``} ` `        ``} ` `     `  `        ``// Declare a variable ` `        ``// to form the resultant number ` `        ``int` `new_num = 0; ` `     `  `        ``// Loop with the number ` `        ``for` `(``int` `i = 0; rev_new_num != 0; i++) { ` `     `  `            ``new_num = (new_num * 10) ` `                    ``+ (rev_new_num % 10); ` `            ``rev_new_num = rev_new_num / 10; ` `        ``} ` `     `  `        ``// Return the resultant number ` `        ``return` `new_num; ` `    ``} ` `     `  `    ``// Function to delete nth digit ` `    ``// from ending ` `    ``static` `int` `deleteFromEnd(``int` `num, ``int` `n) ` `    ``{ ` `     `  `        ``// Declare a variable ` `        ``// to form the reverse resultant number ` `        ``int` `rev_new_num = 0; ` `     `  `        ``// Loop with the number ` `        ``for` `(``int` `i = 1; num != 0; i++) { ` `     `  `            ``int` `digit = num % 10; ` `            ``num = num / 10; ` `     `  `            ``if` `(i == n) { ` `                ``continue``; ` `            ``} ` `            ``else` `{ ` `     `  `                ``rev_new_num = (rev_new_num * 10) + digit; ` `            ``} ` `        ``} ` `     `  `        ``// Declare a variable ` `        ``// to form the resultant number ` `        ``int` `new_num = 0; ` `     `  `        ``// Loop with the number ` `        ``for` `(``int` `i = 0; rev_new_num != 0; i++) { ` `     `  `            ``new_num = (new_num * 10) ` `                    ``+ (rev_new_num % 10); ` `            ``rev_new_num = rev_new_num / 10; ` `        ``} ` `     `  `        ``// Return the resultant number ` `        ``return` `new_num; ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `     `  `        ``// Get the number ` `        ``int` `num = 1234; ` `        ``Console.WriteLine(``"Number: "` `+ num ); ` `     `  `        ``// Get the digit number to be deleted ` `        ``int` `n = 3; ` `        ``Console.WriteLine(``"Digit to be deleted: "` `+ n ); ` `     `  `        ``// Remove the nth digit from starting ` `        ``Console.WriteLine(``"Number after "` `+ n ` `            ``+ ``" digit deleted from starting: "` `            ``+ deleteFromStart(num, n)); ` `     `  `        ``// Remove the nth digit from ending ` `        ``Console.WriteLine( ``"Number after "` `+ n ` `            ``+ ``" digit deleted from ending: "` `            ``+ deleteFromEnd(num, n)); ` `     `  `         `  `    ``} ` ` `  `} ` ` `  `// This code is contributed by ihritik `

 ` ` `// This code is contributed by jit_t. `

Output:
```Number: 1234
Digit to be deleted: 3
Number after 3 digit deleted from starting: 124
Number after 3 digit deleted from ending: 134
```

Another Approach: (To convert number into string)
Time complexity :O(1)

 `// C++ implementation to delete nth digit ` `// from starting with O(1) time complexity. ` `#include ` `using` `namespace` `std; ` ` `  `// function to delete nth number from starting ` `static` `string fromStart(string inp, ``int` `del)  ` `{ ` `    ``string inp1 = inp.substr(0, del - 1); ` `    ``string inp2 = inp.substr(del, inp.length()); ` `    ``return` `inp1 + inp2; ` `} ` ` `  `// function to delete nth number from ending ` `static` `string fromEnd(string inp, ``int` `del)  ` `{ ` `    ``string inp1 = inp.substr(0, inp.length() - del); ` `    ``string inp2 = inp.substr(inp.length() - del + 1,  ` `                                      ``inp.length()); ` `    ``return` `inp1 + inp2; ` `} ` ` `  `// Driver Code ` `int` `main()  ` `{ ` `    ``int` `in = 1234; ` `     `  `    ``// type cast input number to string ` `    ``stringstream ss; ` `    ``ss << in; ` `    ``string inp = ss.str(); ` `    ``int` `del = 3; ` `    ``cout << ``"num_after_deleting_from_starting "`  `         ``<< fromStart(inp, del) << endl; ` `    ``cout << ``"num_after_deleting_from_ending "` `         ``<< fromEnd(inp, del) << endl; ` `    ``return` `0; ` `} ` ` `  `// This code is contributed by chandan_jnu `

 `// Java implementation to delete nth digit ` `// from starting with O(1) time complexity. ` ` `  `public` `class` `DeleteN { ` ` `  `    ``public` `static` `void` `main(String args[]) { ` ` `  `        ``int` `in = ``1234``; ` `        ``// type cast input number to string ` `        ``String inp = Integer.toString(in); ` `        ``int` `del = ``3``; ` `        ``System.out.println(``"num_after_deleting_from_starting "` `+ fromStart(inp, del)); ` `        ``System.out.println(``"num_after_deleting_from_ending "` `+ fromEnd(inp, del)); ` `    ``} ` ` `  `    ``// function to delete nth number from starting ` `    ``static` `String fromStart(String inp, ``int` `del) { ` ` `  `        ``try` `{ ` `            ``String inp1 = inp.substring(``0``, del - ``1``); ` `            ``String inp2 = inp.substring(del, inp.length()); ` `            ``return` `inp1 + inp2; ` `        ``} ` ` `  `        ``catch` `(Exception e) { ` `            ``return` `"Check Input"``; ` `        ``} ` `    ``} ` ` `  `    ``// function to delete nth number from ending ` `    ``static` `String fromEnd(String inp, ``int` `del) { ` ` `  `        ``try` `{ ` `            ``String inp1 = inp.substring(``0``, inp.length() - del); ` `            ``String inp2 = inp.substring(inp.length() - del + ``1``, inp.length()); ` `            ``return` `inp1 + inp2; ` `        ``} ` ` `  `        ``catch` `(Exception e) { ` `            ``return` `"Check Input"``; ` `        ``} ` `    ``} ` ` `  `} `

 `# Python3 implementation to delete nth digit ` `# from starting with O(1) time complexity. ` ` `  `# function to del1ete nth number  ` `# from starting ` `def` `fromStart(inp, del11):  ` ` `  `    ``inp1 ``=` `inp[``0``:del1 ``-` `1``]; ` `    ``inp2 ``=` `inp[del1:``len``(inp)]; ` `    ``return` `inp1 ``+` `inp2; ` ` `  `# function to delete nth number  ` `# from ending ` `def` `fromEnd(inp, del1): ` `    ``inp1 ``=` `inp[``0``:``len``(inp) ``-` `del1]; ` `    ``inp2 ``=` `inp[``len``(inp) ``-` `del1 ``+` `1``:``len``(inp)]; ` `    ``return` `inp1 ``+` `inp2; ` ` `  `# Driver Code ` `in1 ``=` `1234``; ` ` `  `# type cast input number to string ` `inp ``=` `str``(in1); ` `del1 ``=` `3``; ` `print``(``"num_after_deleting_from_starting"``,  ` `                   ``fromStart(inp, del1)); ` `print``(``"num_after_deleting_from_ending"``,  ` `                   ``fromEnd(inp, del1)); ` ` `  `# This code is contributed by chandan_jnu `

 `// C# implementation to delete nth digit  ` `// from starting with O(1) time complexity.  ` `using` `System ; ` ` `  `public` `class` `DeleteN {  ` ` `  `    ``public` `static` `void` `Main() {  ` ` `  `        ``int` `num = 1234;  ` `         `  `        ``// type cast input number to string  ` `        ``string` `inp = Convert.ToString(num) ;  ` `        ``int` `del = 3;  ` `        ``Console.WriteLine(``"num_after_deleting_from_starting "`  `                            ``+ fromStart(inp, del));  ` `        ``Console.WriteLine(``"num_after_deleting_from_ending "`  `                            ``+ fromEnd(inp, del));  ` `    ``}  ` ` `  `    ``// function to delete nth number from starting  ` `    ``static` `String fromStart(``string` `inp, ``int` `del) {  ` ` `  `        ``try` `{  ` `            ``string` `inp1 = inp.Substring(0, del - 1);  ` `            ``string` `inp2 = inp.Substring(del, inp.Length - del);  ` `            ``return` `inp1 + inp2;  ` `        ``}  ` ` `  `        ``catch` `(Exception ) {  ` `            ``return` `"Check Input"``;  ` `        ``}  ` `    ``}  ` ` `  `    ``// function to delete nth number from ending  ` `    ``static` `String fromEnd(``string` `inp, ``int` `del) {  ` ` `  `        ``try` `{  ` `            ``string` `inp1 = inp.Substring(0, inp.Length - del);  ` `            ``string` `inp2 = inp.Substring(inp.Length - del + 1, del - 1);  ` `            ``return` `inp1 + inp2;  ` `        ``}  ` ` `  `        ``catch` `(Exception e) {  ` `            ``Console.WriteLine(e) ; ` `            ``return` `"Check Input"``;  ` `        ``}  ` `    ``}  ` `}  ` ` `  `// This code is contributed by Ryuga `

 ` `

Output:

```num_after_deleting_from_starting 124
num_after_deleting_from_ending 134```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :