000. Monchoka! Weekly Algos by your neighbourly scheme-r ;)

00 Palindrome Numbers.md

Prelude

Hi folks! This one took a while to post; but nevertheless, here we are!

Last week, Perserverance(a.k.a Percy) landed on Mars; which saw Linux on Mars! One small win(?) for Linux(?) \o/ \o/

Earlier this week, I picked up (again) "The Philosophy of Software Design by John Ousterhout" and I found myself nerding about it with some fellas at the office-- poor souls ;)!. The particularly interesting thing was the book's discussion of what our role is (as SWEs) wrt work; with an opinionated view that it all boils down to tackling "complexity". Without getting into much detail, I particularly found the books discussion of "causes of complexity" interesting: Dependencies and obscurity. For anyone getting into the field, I'd strongly recommend that read(albeit pore through it with a critical eye).

Last Week's Challenge

Issue 1: https://is.gd/HK0jFF

Mailing List discussion: https://is.gd/xrHZmY

If you get the bandwidth, hack at the problems at the submission links above-- It's a nice way to get comments on your code \m/\m/.

This Week's Challenge

Source: https://is.gd/HwTL9E

Given an integer as a function, test to see if it's a palindrome

Constraints: You may not cast the number to a string!

Examples:
Input: n = 9229
Output: True

input: n = 1234
Output: False

Post your answers here as comments.

Thanks for the submission! And it works. Here are a few (superficial) remarks from me:

Solution in python ```python

Would be nice if there was an "import math"...

class Solution:

No need for a class ey?

def isPalindrome(self, x: int) -> bool:

Normally in Python, I'd name functions in snake_case to stick to PEP8 ;)

# reverse then compare initial = x rev = 0

Trick for one liners like this is to have something like: ``` initial, rev = x, 0 ```

while x != 0: # Get the number in ones place # eg: 123 % 10 = 3 n = x % 10 # Make space in rev rev = rev * 10 # add n in the new space rev = rev + n

nitpick: rev *= 10 rev += n

# Delete the number in ones place # eg: 123 / 10 = 12 x = math.trunc(x / 10) if initial == rev: return True else: return False

For this, one return is good enough: ``` return initial == rev ```

…

-- Bonface M. K. D4F09EB110177E03C28E2FE1F5BBAE1E0392253F Humble GNU Emacs User / Bearer of scheme-y parens Curator: <https://upbookclub.com> / Twitter: @BonfaceKilz

fn rev_int(num: i32) -> i32 { let mut num = num; let mut rev = 0; while num != 0 { rev *= 10; rev += num % 10; num /= 10; }; rev } fn is_palindrome(n: i32) -> bool { n == rev_int(n) } ```

This looks succinct! :)

…

-- Bonface M. K. D4F09EB110177E03C28E2FE1F5BBAE1E0392253F Humble GNU Emacs User / Bearer of scheme-y parens Curator: <https://upbookclub.com> / Twitter: @BonfaceKilz

`
function isPalindrome(x: number): boolean {
let rev = 0;
let copy = x;

    while(copy > 0) {
        const rem = copy%10;
        rev = rem + (rev * 10);
        copy = Math.floor(copy/10);
    }
    return rev === x;

}
`

DMG <notifications@github.com> writes:

` function isPalindrome(x: number): boolean { let rev = 0; let copy = x; let round = 0; while(copy > 0) { const rem = copy%10; rev = rem + (rev * 10); copy = Math.floor(copy/10); round++; } return rev === x; } `

Typescript(And succinct)! This works. Thanks for the submission \o/\o/

…

-- Bonface M. K. D4F09EB110177E03C28E2FE1F5BBAE1E0392253F Humble GNU Emacs User / Bearer of scheme-y parens Curator: <https://upbookclub.com> / Twitter: @BonfaceKilz