Thread: Dissecting numbers

int num = 123;

Now print out what num/10 is, and what num%10 is

Originally Posted by jmajeremy

Thanks alot C+/-, your algorithm works perfectly!

It is too complex
Using Salem's advice you can bring it to:

Code:

Digit1 = A / 100
Digit2 = (A %100) / 10
Digit3 = A %10

for example

Eh, robatino, I think you should initialise i to 2, not 3.

EDIT:
No, I saw it wrongly: it does work, since you have a post-decrement. But that is, frankly, a hack that will confuse people, just as it confused me. I think it is easier to understand at a glance the more common idiom:

Code:

for (int i = 2; i >= 0; --i) {
    digit[i] = tmp % 10;
    tmp /= 10;
}

In this particular case efficiency isn't an issue, but if one works with large loops, it's the most concise and efficient way to loop from n-1 to 0.

Precisely: efficiency is not the issue here, but your version affects clarity, and so we can quote the maxim that premature optimisation is the root of all evil.

Concerning efficiency: I am no expert in this area, but I doubt your version is measurably more efficient anyway. The normal idiom compares with zero, enters the loop body, and then decrements. Your version implicitly compares with zero, decrements, and then enters the loop body.

Clarity depends on what one is used to - the usual idiom for copying C-style strings

Code:

  while (*s++ = *t++) ;

is in my opinion much more cryptic, but it gets commonly used anyway (Kernighan and Ritchie actually recommend it!). As for efficiency, the comparison with zero is probably more efficient in my case, since as I understand it comparisons like <= require a subtraction, as opposed to != which is just a bitwise comparison. Your version can't use !=, since it needs to allow 0 as a possible value (although it could if the loop went up instead of down), and also has to use a signed integral type as the loop variable, which halves the maximum range of the loop (although again this isn't necessary if the loop goes up).

Edit: Sorry, actually your version _could_ use != but only as "i != -1".

Code:

for (int i=3; i--;)

Problem with the above pattern that on the first glance it is read as
for (int i=3; i>0 ; i--) due to standard usage of the for loop
only on the third glance the code is read as it is written... And this makes it hard to understand and possible source of bugs when someone comes to modify it...

If I had to write something like that I'll go on the laserlight's solution or:

Code:

for (int i=3; i>0;) 
{
   i--;
   etc
}

But of course if the code is not supposed to be maintained - it is not an issue...

Clarity depends on what one is used to

I agree. In this case, your version is not what people would be used to, and considering that jmajeremy needed help for such a relatively trivial problem, it is reasonable to expect that jmajeremy lacks experience in C++, and possibly computer programming in general. As such, it makes sense to give examples that are along common lines, especially since the usual idiom is more general (loop from some high index to some low index).

As for efficiency, the comparison with zero is probably more efficient in my case, since as I understand it comparisons like <= require a subtraction, as opposed to != which is just a bitwise comparison.

It is possible to do a bitwise comparison to test for such inequalities, of course. Anyway, the compiler may well be able to optimise the code such that it performs no worse than your version.

and also has to use a signed integral type as the loop variable, which halves the maximum range of the loop (although again this isn't necessary if the loop goes up).

True, but that does not matter at all here. Even for a 400-bit integer an 8-bit signed char as the loop index would be good enough (though also a little strange, heh).