Fun with Modulo, Leap Years! and Unicode Hell (ruby program pt. 5)

Unicode Hell
This is cool. I innocently picked a simple problem (reversing text) to learn the Ruby programming language. I got more than I bargained for. Turns out that Unicode is supposed to be handled on the upcoming (since 5 years ago) Ruby 2.0.... great. So I'll have to implement an ad-hoc solution on my own. Part of the problem is that there are so many ways to encode text in bytes. And the other is that there doesn't seem to be a simple standard. The first problem is that Unicode text can be part of multiple character sets with different lengths. The most common UTF-16 should solve my program's problems but will trip up with weird characters in very obscure languages like say Cree. The second problem is how do you figure out which character set is a text in? I'm stumped for now.

Leap Years!
If you read my post on modulo you know I'm very excited about learning about this new programming operation and its use in jargon. (I'll have the protein burger! That's a normal burger modulo bun.) But right after that, I was trying to calculate a quick way to determine if a year is a leap year. So I looked up in Wikipedia and found out that they have a small program that tells you and it uses modulo! I was psyched. I read it and understood it right away.

Here is the pseudo-code from Wikipedia:

My leap year Ruby Program

if year modulo 400 is 0
       then is_leap_year
else if year modulo 100 is 0
       then not_leap_year
else if year modulo 4 is 0
       then is_leap_year
else 
       not_leap_year

Notice that if a year divides by 100 but not 400, it is not a leap year. Kinda tricky, huh? All this so March 21 can be around spring equinox.

Here is my program:
I tried to write it as close to the pseudo-code as I could. Notice how similar they are. But mine is code. It runs. By the way, elsif is a contraction of else if; I could have written it either way. (Elsif sounds like an elven maiden name, right?) The stuff below the yellow highlight gets text from the user, chops off the last end-of-line character or return. Converts the input to an integer, (a very important step that I missed originally) and out puts the result.

Now what I want to do is make it a method call that works after a period. So you can go year.leap? and get true if it's a leap year, false if it's not and nil if it's a string.

Fun with Modulo
All this is fun really got me thinking about one of pet peeves about the way math is explained. I hear (I used it above) "If a year divides by 100 but not 400, it's not a leap year." Well that's hogwash; any year will be divisible by 400. Take the non-leap year 1000 (Y1K!). Divide 1000/400 and get 2½. Oh the horror! The world goes crazy! A fraction! A decimal! (2.5) What are we to do?? Talk about confusing for a kid (or an adult preparing for the GRE).

Well now I know how to say this concept without doing some weird mathematical impossibility. If a year modulo 100 is 0 but modulo 400 is not, it's not a leap year. It just sits down, proper and still, and doesn't go around gallivanting, jumping and leaping about like that year 2K.

ps. Y1K was a leap year, because the calendar calculation I'm using is from the Gregorian Calendar, created in 1500's. But people forget how they were in their youth and judge the next generation harshly nonetheless...