To uint, or not to uint

I like unsigned integers, always have. It’s more correct, concise and expressive, you get more (positive) space out of it and you’re preventing bugs by design. What’s not to love?


I’ve been nooking CLR via C# and it’s a fantastic read for anyone who wants to ‘get serious’ about .Net. The book’s so crammed full of good information it’s hard not to gush, but I digress.

I was nooking, you see, and I came across this recommendation:

“Use signed data types (such as Int32 and Int64 instead of unsigned numeric types such as UInt32 and UInt64) wherever possible.”

Say it aint so!

Jeffrey Richter continues:

“This allows the compiler to detect more overflow/underflow errors. In addition, various parts of the class library (such as Array’s and String’s Length properties) are hard-coded to return signed values, and less casting is required as you move these values around in your code.”

Casting is ugly, no argument there but I don’t care much about the overflow/underflow errors. I generally don’t enable overflow checking, there’s no political statement here, it’s just never come up.

And it still feels wrong for me to declare a value signed when I know that it shouldn’t be.

(Richter recommends enabling checking for debug builds, and disabling for release. Sound advice!)

But here’s real the kicker for me:

In addition, unsigned numeric types are not CLS-compliant.

Doh. I did a bit of searching to try and track down why it’s not part of the CLS, and I found that Brad Abrams expresses it best in this post:

“The general feeling among many of us is that the vast majority of programming is done with signed types. Whenever you switch to unsigned types you force a mental model switch (and an ugly cast). In the worst cast you build up a whole parallel world of APIs that take unsigned types. The value of avoiding the ‘< 0' check is not worth the inclusion of generics in the CLS"

Alright, I give in. I’m apparently in the minority, these guys are way smarter than I am, and it is easier, if not more concise. So it goes.

Goodbye for now uint, you’ll always hold a positive place in my heart.

Just like Weezer:

Picture Pages : Getting Started with Arduino!

It's alive!

It's alive!

I’ve finally gotten around to messing with Arduino, and it’s been a lot of fun! I picked up an “Experimentation Kit” from Adafruit and it contained everything I needed to get started, including a little booklet of circuit examples.

I don’t know that I’ve gained any programming insight from my experimentations, but I’d wager most developers would enjoy this sort of thing. It could make an excellent Christmas gift for that hard-to-buy-for geek in your family!

Project Euler: Problem 35 in Ruby

I used my prime generator from Problem 27 for this one. It would have been faster to build the rotation into my generator, but it ran fine without it.

Problem 35

How many circular primes are there below one million?

require 'prime_generator'

primer = 1_000_000

def is_rot_prime? primer, chars
	chars.size.times do |i|
		chars = { |i| chars[i - 1] }
		return false if !primer.is_prime?(chars.join("").to_i)

count = 0
primer.stack.each do |n|
	count += 1 if is_rot_prime? primer, n.to_s.split("")

# subtract 1 because "1" doesn't count
puts count - 1

Speaking of the rotation, the ruby array initialize methods and negative indexers make it a cinch to rotate. How cool is this?

chars = { |i| chars[i - 1] }

Project Euler: Problem 34 in Ruby

Practically every Project Euler problem benefits from memoization, however the issues I ran into with #34 had nothing to do with my algorithm.

The first hurdle was figuring out the upper bound. After scratching around in my notebook, I figured any number I would be looking for would have 7 digits or less. That gives us an upper bound of 9! * 7.

The second hurde took me much, much longer to figure out.

Here’s the secret: 0! = 1

I had taken it for granted that 0! would (of course!) be 0, and I had pre-filled my cache with the number 0. I went round, and round, and round, and round, and round, and round before figuring out (quite accidentally) my error.

It doesn’t make any sense to me, but you can’t argue with math!

Problem 34

Find the sum of all numbers which are equal to the sum of the factorial of their digits.

# cache the digit factorials
factorials = [1]
(1..9).each do |i|
	factorials.push(i * factorials.last)

result = 0
(3..2_540_160).each do |n|
	sum = n.to_s.split("").inject(0) do |sum,n|
		sum + factorials[n.to_i]
	result += n if n == sum
puts result

Runs in just under a minute 🙂

Project Euler : Problem 36 in Ruby

I’ve been ill today, but there’s no better medicine than an easy Project Euler problem! I tried doing some bitwise magic, but in the end my simplest solution proved the fastest as well.

Problem 36

Find the sum of all numbers, less than one million, which are palindromic in base 10 and base 2.

def palindrome? s
	s == s.reverse

sum = (1..1_000_000).inject(0) do |sum, n|
	sum += palindrome?(n.to_s) && palindrome?(n.to_s 2) ? n : 0

puts sum

Project Euler: Problem 33 in Ruby

It’s fugly, but it works. The hardest part was understanding the question. If the longer description didn’t say that there were exactly 4 fractions, I might have gone crazy.

For reals.

Problem 33

Discover all the fractions with an unorthodox cancelling method.

top, bottom = 1, 1

(10..98).each do |i|
	((i/10)..9).each do |jt|
		jt *= 10
		(1..9).each do |jo|
			j = jt + jo
			next if i >= j
			if i % 10 == j / 10 && i.to_f / j == (i / 10).to_f / (j % 10)
				top *= i
				bottom *= j

puts bottom / bottom.gcd(top)

Find the Longest Palindrome in a String

I recently discovered, and one of the more recent posts dealt with one of the greplin programming challenges. I figured since people were posting their code there, then it wouldn’t be too bad for me to post mine here!

Find the Longest Palindrome in a string:

I doubt this is an optimal solution, but I like how it works:

text = "FourscoreandsevenyearsagoourfaathersbroughtforthonthiscontainentanewnationconceivedinzLibertyanddedicatedtothepropositionthatallmenarecreatedequalNowweareengagedinagreahtcivilwartestingwhetherthatnaptionoranynartionsoconceivedandsodedicatedcanlongendureWeareqmetonagreatbattlefiemldoftzhatwarWehavecometodedicpateaportionofthatfieldasafinalrestingplaceforthosewhoheregavetheirlivesthatthatnationmightliveItisaltogetherfangandproperthatweshoulddothisButinalargersensewecannotdedicatewecannotconsecratewecannothallowthisgroundThebravelmenlivinganddeadwhostruggledherehaveconsecrateditfaraboveourpoorponwertoaddordetractTgheworldadswfilllittlenotlenorlongrememberwhatwesayherebutitcanneverforgetwhattheydidhereItisforusthelivingrathertobededicatedheretotheulnfinishedworkwhichtheywhofoughtherehavethusfarsonoblyadvancedItisratherforustobeherededicatedtothegreattdafskremainingbeforeusthatfromthesehonoreddeadwetakeincreaseddevotiontothatcauseforwhichtheygavethelastpfullmeasureofdevotionthatweherehighlyresolvethatthesedeadshallnothavediedinvainthatthisnationunsderGodshallhaveanewbirthoffreedomandthatgovernmentofthepeoplebythepeopleforthepeopleshallnotperishfromtheearth"

def find_longest_palindrome s1, size
	longest = ""

	s1.size.times do |start|
		break if start + size > s1.size
		s2 = s1[start, size].reverse
		if s1.include? s2
			return s2

	find_longest_palindrome s1, size - 1

puts find_longest_palindrome(text, text.length)

I found the site via this post, 10 puzzle websites to sharpen your programming skills. Now that the wedding’s over (pics soon!) I can’t wait to get back to a regular extracurricular programming schedule!