Re: [Pharo-users] mentor question 4

May 1, 2020

      (oddSum + evenSum) dividedBy: 10

You previously had _ isDivisibleBy: 10
which certainly works.

Squeak, Pharo, and ST/X have #isDivisibleBy:
VisualWorks. Dolphin, and GNU Smalltalk do not.

Here's the code from Number.st in ST/X.
isDivisibleBy:aNumber
    "return true, if the receiver can be divided by the argument,
aNumber without a remainder.
     Notice, that the result is only worth trusting, if the receiver
is an integer."

    aNumber = 0 ifTrue: [^ false].
    aNumber isInteger ifFalse: [^ false].
    ^ (self \\ aNumber) = 0

The comment is wrong: the question makes sense for any combination
of exact numbers.
When, as in this case, aNumber is a literal integer, all
#isDivisibleBy: really adds is overhead.

(oddSum + evenSum) \\ 10 = 0

is quite clear, and completely portable.

On Fri, 1 May 2020 at 02:16, Roelof Wobben <r.wobben@home.nl> wrote:
...
Op 30-4-2020 om 16:06 schreef Richard O'Keefe:
...
This sounds very much like the Luhn test task at RosettaCode.
https://rosettacode.org/wiki/Luhn_test_of_credit_card_numbers
except that there it is described as working on the digits of an
integer.
(1) There are two approaches to traversing a sequence in reverse.
     (A) Reverse the sequence, then traverse the copy forward.
         aString reverse do: [:each | ...]
     (B) Just traverse the sequence in reverse
         aString reverseDo: [:each | ...]
     My taste is for the second.
(2) There are two approaches to deleting spaces.
     (A) Make a copy of the string without spaces.
         x := aString reject: [:each | each = Character space].
         x do: ...
     (B) Ignore spaces as you go:
         (i) aString do: [:each | each = Character space ifFalse: [...]]
         (ii) aString select: [:each | each ~= Character space] thenDo:
[:each | ...]
Combining (1A) and (2A) you get very obvious code:
     (aString reject: [:each | each = Character space]) reverse do:
[:digit } ...]
Combining (1B) and (2Bi) you get more efficient code:
     aString reverseDo: [:digit |
         digit = Character space ifFalse: [ ...]]
By the way, let's start by checking that the character in the string *are*
digits or spaces:
     (aString allSatisfy: [:each | each isDigit or: [each = Character s[ace]])
         ifFalse: [^false],
(3) There are two approaches to doubling the even digits.
     (A) Make a new string that starts as a copy and change every second
          digit from the right.
     (B) Simply *act* as if this has been done; keep track of whether the
         current digit position is even or odd and multiply by 1 or 2 as
         appropriate.
     nextIsOdd := true.
     aString reverseDo: [:digit |
         digit = Character space ifFalse: [
         nextIsOdd
             ifTrue:  [oddSum := ...]
             ifFalse: [evenSum := ...].
         nextIsOdd := nextIsOdd not]].
I *like* code that traverses a data structure exactly once and
allocates no intermediate garbage, so I'd be making (B) choices.
For me  , I use this to practice solving problems  and doing the "right"
steps.
So I love it , that so many people share there way of solving it.
I can learn a lot from it
Expecially when they explain there thinking process so detailed.
I like this code also a lot.
Am  I correct for testing if it is a valid string by doing this ^
(oddSum + evenSum) dividedBy: 10
Roelof