## Playing with Digits of a Number: Tricks and Techniques

When solving problems on Codeforces or any other competitive programming platform, manipulating the digits of a number is a frequent requirement. Whether it's extracting digits, removing digits, or counting the number of digits, understanding these fundamental operations can save you time and help you avoid common pitfalls. In this blog entry, we'll discuss some useful tricks and provide code snippets to handle these tasks efficiently.

### Extracting Digits

Extracting digits from a number is a fundamental operation. The most common requirements are to get the last digit or to remove the last digit. Let's dive into how we can achieve these tasks.

#### Getting the Last Digit

To get the last digit of a number, simply take the remainder of the number when divided by 10. This can be done using the modulus operator `%`

.

**Code Example:**

```
int getLastDigit(int number) {
return number % 10;
}
```

**Explanation:**

- For a number
`n`

,`n % 10`

will give the last digit. For example,`123 % 10`

will give`3`

.

#### Removing the Last Digit

To remove the last digit of a number, perform integer division by 10. This can be done using the division operator `/`

.

**Code Example:**

```
int removeLastDigit(int number) {
return number / 10;
}
```

**Explanation:**

- For a number
`n`

,`n / 10`

will give the number with the last digit removed. For example,`123 / 10`

will give`12`

.

### Counting the Number of Digits

Counting the number of digits in a number can be done in various ways. One of the simplest and most efficient methods is using logarithms. Specifically, the base-10 logarithm can help us determine the number of digits in constant time.

#### Using Logarithms

The number of digits `d`

in a number `n`

can be calculated using the formula `d = floor(log10(n) + 1)`

.

**Code Example:**

```
#include <cmath> // For log10 and floor functions
int countDigits(int number) {
if (number == 0) return 1; // Special case for 0
return floor(log10(number) + 1);
}
```

**Explanation:**

- The
`log10(n)`

function returns the logarithm base 10 of`n`

. - Adding 1 and taking the floor of the result gives the number of digits.
- For example,
`log10(123)`

is approximately`2.0899`

, so`floor(2.0899 + 1)`

is`3`

.

#### Using a Loop

Alternatively, you can count the digits using a loop, which is more intuitive but less efficient for large numbers.

**Code Example:**

```
int countDigits(int number) {
int count = 0;
do {
number /= 10;
count++;
} while (number != 0);
return count;
}
```

**Explanation:**

- Divide the number by 10 repeatedly until it becomes 0, incrementing the count each time.
- This loop continues until all digits are processed.

### Putting It All Together

Here's a combined example that demonstrates these techniques in a single program.

```
#include <iostream>
#include <cmath>
using namespace std;
int getLastDigit(int number) {
return number % 10;
}
int removeLastDigit(int number) {
return number / 10;
}
int countDigits(int number) {
if (number == 0) return 1;
return floor(log10(number) + 1);
}
int main() {
int number;
cout << "Enter a number: ";
cin >> number;
cout << "Last digit: " << getLastDigit(number) << endl;
cout << "Number after removing the last digit: " << removeLastDigit(number) << endl;
cout << "Number of digits: " << countDigits(number) << endl;
return 0;
}
```

### Conclusion

Understanding how to manipulate the digits of a number is crucial for solving many competitive programming problems. By mastering the techniques to extract the last digit, remove the last digit, and count the number of digits, you'll be better equipped to handle a wide range of challenges. Happy coding!