A remove-last-digit pattern prints an integer, then repeatedly strips the rightmost digit with integer division by 10 until the value becomes zero.
Rule: while num != 0 → print num → num = num / 10
86523
8652
865
86
8 ← start = 86523Follows the hollow square border in Program 59; next is the growing reverse pattern in Program 61.
Use a while loop: print the current value, then divide by 10. Stop when num reaches 0.
| Method | Idea | Best for |
|---|---|---|
| while + divide by 10 | Print, then num /= 10 until zero | Learning, interviews, digit drills |
| abs for negatives | num = abs(num) before the loop | User input that may be negative |
while num is not 0:
print num
num = num / 10| Goal | Pattern |
|---|---|
| Loop condition | while (num != 0) |
| Print current | printf("%d\n", num); |
| Drop last digit | num = num / 10; or num /= 10; |
| Handle negatives | num = abs(num); (needs <stdlib.h>) |
| Line count | Equals the digit count of the starting number |
| API | Effect | Use for |
|---|---|---|
printf("%d", num) | Stays on the same line | Rare here — digits would glue together |
printf("%d\n", num) | Prints the value and ends the line | Each step of the pattern (WriteLine style) |
Unlike nested triangle patterns, each iteration needs its own newline — so %d\n combines Write + WriteLine in one call.
Change the starting number and the digit-removal pattern updates instantly — absolute value, up to 9 digits.
num = 86523Trace each print-then-divide step until the loop stops.
| Step | Prints | After / 10 |
|---|---|---|
| 1 | 86523 | 8652 |
| 2 | 8652 | 865 |
| 3 | 865 | 86 |
| 4 | 86 | 8 |
| 5 | 8 | 0 (loop ends) |
Five digits → five lines → O(d) time. Integer division truncates toward zero, so no floating-point is involved.
Three complete programs: fixed num = 86523, scanf input, and a compact num = 123 demo. Use View Output to reveal sample results.
num = 86523Hard-coded start — print, then divide by 10 until zero.
#include <stdio.h>
int main(void)
{
int num = 86523;
while (num != 0)
{
printf("%d\n", num);
num = num / 10;
}
return 0;
}1. Print first. Show the current num before changing it.
2. Divide by 10. Integer division drops the last digit — 86523 / 10 is 8652.
3. Stop at zero. When num becomes 0, while (num != 0) ends.
Read num with scanf, take absolute value, then run the same loop.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num;
printf("Enter a number: ");
if (scanf("%d", &num) != 1)
{
printf("Please enter a valid integer.\n");
return 1;
}
num = abs(num);
while (num != 0)
{
printf("%d\n", num);
num /= 10;
}
return 0;
}1. Prompt and validate. Check scanf before using num.
2. Absolutize. abs(num) keeps the digit-strip logic positive (and avoids sign quirks).
3. Same core. Print-then-divide matches Example 1 — only the source of num changes.
num = 123Three lines only — easy to dry-run on paper before larger demos.
#include <stdio.h>
int main(void)
{
int num = 123;
while (num != 0)
{
printf("%d\n", num);
num /= 10;
}
return 0;
}1. Three digits. 123 → 12 → 1 → 0 — three prints, then stop.
2. Trace on paper. Confirm you print before dividing; reverse that order and you miss the first line.
3. Scale up next. Once the small demo is clear, use Examples 1–2 for 86523 or user input.
Check these before calling the solution done.
If you divide before printing, the starting number never appears. Always print, then num /= 10.
while (num != 0) skips entirely when the start is already 0 — no lines are printed.
120 prints 120, then 12, then 1 — the trailing zero is not a separate line after division.
Without abs, negative starts print with a minus and still shrink toward zero — use abs when you want unsigned digit stripping.
If you forget \n, every value glues together on one line. Prefer printf("%d\n", num).
Validate scanf before the loop — a failed read leaves num uninitialized.
| Program | Time | Extra space |
|---|---|---|
| Fixed / input (Examples 1–2) | O(d) | O(1) |
| Compact num = 123 (Example 3) | O(d) | O(1) |
Each iteration removes one digit, so the loop runs d times for a d-digit start — linear in digit count, constant extra memory.
num, then num /= 10.while (num != 0) fits naturally./ 10 truncates — that is how the last digit disappears.O(d) time for d digits; O(1) extra space.One line: while (num != 0) { printf("%d\n", num); num /= 10; }
Each iteration prints the current number, then num = num / 10 drops the last digit using integer division — runtime is O(d) for d digits.
Continue by building a reverse number digit-by-digit with modulo and division.
12 people found this page helpful