I have previously written about how I learned ASP.NET MVC. It was primarily hands on learning but I did read a couple of ASP.NET MVC books along the way. The books I read dedicated a chapter or two to TDD and they certainly addressed the benefits of TDD and how MVC was designed with testability in mind, but TDD was merely an afterthought compared to, well, teaching one how to code the model, view and controller. This approach made some sense, and I learned a bunch about MVC from those books, but when it came to TDD the books were just a teaser and an opportunity missed.  But then I got lucky – Jonathan McCracken contacted me and asked if I’d review his book, Test-Drive ASP.NET MVC, and it was just what I needed to get over the TDD hump.

As the title suggests, Test-Drive ASP.NET MVC takes a different approach to learning MVC as it focuses on testing right from the very start. McCracken wastes no time and swiftly familiarizes us with the framework by building out a trivial Quote-O-Matic application and then dedicates the better part of his book to testing first – first by explaining TDD and then coding a full-featured Getting Organized application inspired by David Allen’s popular book, Getting Things Done. If you are a learn-by-example kind of coder (like me), you will instantly appreciate and enjoy McCracken’s style – its fast-moving, pragmatic and focused on only the most relevant information required to get you going with ASP.NET MVC and TDD.

The book continues with the test-first theme but McCracken moves away from the sample application and incorporates other practical skills like persisting models with NHibernate, leveraging Inversion of Control with the IControllerFactory and building a RESTful web service. What I most appreciated about this section was McCracken’s use of and praise for open source libraries like Rhino Mocks, SQLite and StructureMap (to name just a few) and productivity tools like ReSharper, Web Platform Installer and ASP.NET SQL Server Setup Wizard.  McCracken’s emphasis on real world, pragmatic development was clearly demonstrated in every tool choice, straight-forward code block and developer tip. Whether one is already familiar with the tools/tips or not, McCracken’s thought process is easily understood and appreciated.

The final section of the book walks the reader through security and deployment – everything from error handling and logging with ELMAH, to ASP.NET Health Monitoring, to using MSBuild with automated builds, to the deployment  of ASP.NET MVC to various web environments. These chapters, like those prior, offer enough information and explanation to simply help you get the job done. 

Do I believe Test-Drive ASP.NET MVC will turn you into an expert MVC developer overnight?  Well, no.  I don’t think any book can make that claim.  If that were possible, I think book list prices would skyrocket!  That said, Test-Drive ASP.NET MVC provides a solid foundation and a unique (and dare I say necessary) approach to learning ASP.NET MVC.  Along the way McCracken shares loads of very practical software development tips and references numerous tools and libraries. The bottom line is it’s a great ASP.NET MVC primer – if you’re new to ASP.NET MVC it’s just what you need to get started. 

Do I believe Test-Drive ASP.NET MVC will give you everything you need to start employing TDD in your everyday development?  Well, I used to think that learning TDD required a lot of practice and, if you’re lucky enough, the guidance of a mentor or coach.  I used to think that one couldn’t learn TDD from a book alone. Well, I’m still no pro, but I’m testing first now and Jonathan McCracken and his book, Test-Drive ASP.NET MVC, played a big part in making this happen.  If you are an MVC developer and a TDD newb, Test-Drive ASP.NET MVC is just the book for you.

As always, any feedback is welcome.

# Euler 20
# http://projecteuler.net/index.php?section=problems&id=20
# n! means n x (n - 1) x ... x 3 x 2 x 1
# Find the sum of digits in 100!
import time
start = time.time()

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

print sum([int(i) for i in str(factorial(100))])

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 19
# http://projecteuler.net/index.php?section=problems&id=19
# You are given the following information, but you may
# prefer to do some research for yourself.
#
# - 1 Jan 1900 was a Monday.
# - Thirty days has September,
#   April, June and November.
#   All the rest have thirty-one,
#   Saving February alone,
#   Which has twenty-eight, rain or shine.
#   And on leap years, twenty-nine.
# - A leap year occurs on any year evenly divisible by 4,
#   but not on a century unless it is divisible by 400.
#
# How many Sundays fell on the first of the month during
# the twentieth century (1 Jan 1901 to 31 Dec 2000)?
import time
start = time.time()

import datetime
sundays = 0

for y in range(1901,2001):
    for m in range(1,13):
        # monday == 0, sunday == 6
        if datetime.datetime(y,m,1).weekday() == 6:
            sundays += 1
print sundays

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 18
# http://projecteuler.net/index.php?section=problems&id=18
# By starting at the top of the triangle below and moving
# to adjacent numbers on the row below, the maximum total
# from top to bottom is 23.
#
# 3
# 7 4
# 2 4 6
# 8 5 9 3
#
# That is, 3 + 7 + 4 + 9 = 23.

# Find the maximum total from top to bottom of the triangle below:

# 75
# 95 64
# 17 47 82
# 18 35 87 10
# 20 04 82 47 65
# 19 01 23 75 03 34
# 88 02 77 73 07 63 67
# 99 65 04 28 06 16 70 92
# 41 41 26 56 83 40 80 70 33
# 41 48 72 33 47 32 37 16 94 29
# 53 71 44 65 25 43 91 52 97 51 14
# 70 11 33 28 77 73 17 78 39 68 17 57
# 91 71 52 38 17 14 91 43 58 50 27 29 48
# 63 66 04 68 89 53 67 30 73 16 69 87 40 31
# 04 62 98 27 23 09 70 98 73 93 38 53 60 04 23

# NOTE: As there are only 16384 routes, it is possible to solve
# this problem by trying every route. However, Problem 67, is the
# same challenge with a triangle containing one-hundred rows; it
# cannot be solved by brute force, and requires a clever method! ;o)
import time
start = time.time()

triangle = [
 [75],
 [95, 64],
 [17, 47, 82],
 [18, 35, 87, 10],
 [20, 04, 82, 47, 65],
 [19, 01, 23, 75, 03, 34],
 [88, 02, 77, 73, 07, 63, 67],
 [99, 65, 04, 28, 06, 16, 70, 92],
 [41, 41, 26, 56, 83, 40, 80, 70, 33],
 [41, 48, 72, 33, 47, 32, 37, 16, 94, 29],
 [53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14],
 [70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57],
 [91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48],
 [63, 66, 04, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31],
 [04, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 04, 23]]

# Loop through each row of the triangle starting at the base.
for a in range(len(triangle) - 1, -1, -1):
    for b in range(0, a):
        # Get the maximum value for adjacent cells in current row.
        # Update the cell which would be one step prior in the path
        # with the new total. For example, compare the first two
        # elements in row 15. Add the max of 04 and 62 to the first
        # position of row 14.This provides the max total from row 14
        # to 15 starting at the first position. Continue to work up
        # the triangle until the maximum total emerges at the
        # triangle's apex.
        triangle [a-1][b] += max(triangle [a][b], triangle [a][b+1])

print triangle [0][0]
print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 17
# http://projecteuler.net/index.php?section=problems&id=17
# If the numbers 1 to 5 are written out in words:
# one, two, three, four, five, then there are
# 3 + 3 + 5 + 4 + 4 = 19 letters used in total.
# If all the numbers from 1 to 1000 (one thousand)
# inclusive were written out in words, how many letters
# would be used?
#
# NOTE: Do not count spaces or hyphens. For example, 342
# (three hundred and forty-two) contains 23 letters and
# 115 (one hundred and fifteen) contains 20 letters. The
# use of "and" when writing out numbers is in compliance
# with British usage.
import time
start = time.time()

def to_word(n):
    h = { 1 : "one", 2 : "two", 3 : "three",
        4 : "four", 5 : "five", 6 : "six",
        7 : "seven", 8 : "eight", 9 : "nine",
        10 : "ten", 11 : "eleven", 12 : "twelve",
        13 : "thirteen", 14 : "fourteen", 15 : "fifteen",
        16 : "sixteen", 17 : "seventeen", 18 : "eighteen",
        19 : "nineteen", 20 : "twenty", 30 : "thirty",
        40 : "forty", 50 : "fifty", 60 : "sixty",
        70 : "seventy", 80 : "eighty", 90 : "ninety",
        100 : "hundred", 1000 : "thousand" }

    word = ""

    # Reverse the numbers so position (ones, tens,
    # hundreds,...) can be easily determined
    a = [int(x) for x in str(n)[::-1]]

    # Thousands position
    if (len(a) == 4 and a[3] != 0):
        # This can only be one thousand based
        # on the problem/method constraints
        word = h[a[3]] + " thousand "

    # Hundreds position
    if (len(a) >= 3 and a[2] != 0):
        word += h[a[2]] + " hundred"

        # Add "and" string if the tens or ones
        # position is occupied with a non-zero value.
        # Note: routine is broken up this way for [my] clarity.
        if (len(a) >= 2 and a[1] != 0):
            # catch 10 - 99
            word += " and"
        elif len(a) >= 1 and a[0] != 0:
            # catch 1 - 9
            word += " and"

    # Tens and ones position
    tens_position_value = 99
    if (len(a) >= 2 and a[1] != 0):
        # Calculate the tens position value per the
        # first and second element in array
        # e.g. (8 * 10) + 1 = 81
        tens_position_value = int(a[1]) * 10 + a[0]

        if tens_position_value <= 20:
            # If the tens position value is 20 or less
            # there's an entry in the hash. Use it and there's
            # no need to consider the ones position
            word += " " + h[tens_position_value]
        else:
            # Determine the tens position word by
            # dividing by 10 first. E.g. 8 * 10 = h[80]
            # We will pick up the ones position word later in
            # the next part of the routine
            word += " " + h[(a[1] * 10)]

    if (len(a) >= 1 and a[0] != 0 and tens_position_value > 20):
        # Deal with ones position where tens position is
        # greater than 20 or we have a single digit number
        word += " " + h[a[0]]

    # Trim the empty spaces off both ends of the string
    return word.replace(" ","")    

def to_word_length(n):
    return len(to_word(n))    

print sum([to_word_length(i) for i in xrange(1,1001)])

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 16
# http://projecteuler.net/index.php?section=problems&id=16
# 2^15 = 32768 and the sum of its digits is
# 3 + 2 + 7 + 6 + 8 = 26.
# What is the sum of the digits of the number 2^1000?
import time
start = time.time()

print sum([int(i) for i in str(2**1000)])

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 15
# http://projecteuler.net/index.php?section=problems&id=15
# Starting in the top left corner of a 2x2 grid, there
# are 6 routes (without backtracking) to the bottom right
# corner. How many routes are their in a 20x20 grid?
import time
start = time.time()

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

rows, cols = 20, 20
print factorial(rows+cols) / (factorial(rows) * factorial(cols))

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 14
# http://projecteuler.net/index.php?section=problems&id=14
# The following iterative sequence is defined for the set
# of positive integers:
# n ->  n/2 (n is even)
# n ->  3n + 1 (n is odd)
# Using the rule above and starting with 13, we generate
# the following sequence:
# 13  40  20  10  5  16  8  4  2  1
# It can be seen that this sequence (starting at 13 and
# finishing at 1) contains 10 terms. Although it has not
# been proved yet (Collatz Problem), it is thought that all
# starting numbers finish at 1. Which starting number,
# under one million, produces the longest chain?
# NOTE: Once the chain starts the terms are allowed to go
# above one million.
import time
start = time.time()

def collatz_length(n):
    # 0 and 1 return self as length
    if n <= 1: return n

    length = 1
    while (n != 1):
      if (n % 2 == 0):
        n /= 2
      else:
        n = 3*n + 1

      length += 1

    return length

starting_number, longest_chain = 1, 0

for x in xrange(1, 1000001):
    l = collatz_length(x)
    if l > longest_chain: starting_number, longest_chain = x, l 

print starting_number
print longest_chain

# Slow 31 seconds
print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 13
# http://projecteuler.net/index.php?section=problems&id=13
# Work out the first ten digits of the sum of the
# following one-hundred 50-digit numbers.
import time
start = time.time()

number_string = '\
37107287533902102798797998220837590246510135740250\
46376937677490009712648124896970078050417018260538\
74324986199524741059474233309513058123726617309629\
91942213363574161572522430563301811072406154908250\
23067588207539346171171980310421047513778063246676\
89261670696623633820136378418383684178734361726757\
28112879812849979408065481931592621691275889832738\
44274228917432520321923589422876796487670272189318\
47451445736001306439091167216856844588711603153276\
70386486105843025439939619828917593665686757934951\
62176457141856560629502157223196586755079324193331\
64906352462741904929101432445813822663347944758178\
92575867718337217661963751590579239728245598838407\
58203565325359399008402633568948830189458628227828\
80181199384826282014278194139940567587151170094390\
35398664372827112653829987240784473053190104293586\
86515506006295864861532075273371959191420517255829\
71693888707715466499115593487603532921714970056938\
54370070576826684624621495650076471787294438377604\
53282654108756828443191190634694037855217779295145\
36123272525000296071075082563815656710885258350721\
45876576172410976447339110607218265236877223636045\
17423706905851860660448207621209813287860733969412\
81142660418086830619328460811191061556940512689692\
51934325451728388641918047049293215058642563049483\
62467221648435076201727918039944693004732956340691\
15732444386908125794514089057706229429197107928209\
55037687525678773091862540744969844508330393682126\
18336384825330154686196124348767681297534375946515\
80386287592878490201521685554828717201219257766954\
78182833757993103614740356856449095527097864797581\
16726320100436897842553539920931837441497806860984\
48403098129077791799088218795327364475675590848030\
87086987551392711854517078544161852424320693150332\
59959406895756536782107074926966537676326235447210\
69793950679652694742597709739166693763042633987085\
41052684708299085211399427365734116182760315001271\
65378607361501080857009149939512557028198746004375\
35829035317434717326932123578154982629742552737307\
94953759765105305946966067683156574377167401875275\
88902802571733229619176668713819931811048770190271\
25267680276078003013678680992525463401061632866526\
36270218540497705585629946580636237993140746255962\
24074486908231174977792365466257246923322810917141\
91430288197103288597806669760892938638285025333403\
34413065578016127815921815005561868836468420090470\
23053081172816430487623791969842487255036638784583\
11487696932154902810424020138335124462181441773470\
63783299490636259666498587618221225225512486764533\
67720186971698544312419572409913959008952310058822\
95548255300263520781532296796249481641953868218774\
76085327132285723110424803456124867697064507995236\
37774242535411291684276865538926205024910326572967\
23701913275725675285653248258265463092207058596522\
29798860272258331913126375147341994889534765745501\
18495701454879288984856827726077713721403798879715\
38298203783031473527721580348144513491373226651381\
34829543829199918180278916522431027392251122869539\
40957953066405232632538044100059654939159879593635\
29746152185502371307642255121183693803580388584903\
41698116222072977186158236678424689157993532961922\
62467957194401269043877107275048102390895523597457\
23189706772547915061505504953922979530901129967519\
86188088225875314529584099251203829009407770775672\
11306739708304724483816533873502340845647058077308\
82959174767140363198008187129011875491310547126581\
97623331044818386269515456334926366572897563400500\
42846280183517070527831839425882145521227251250327\
55121603546981200581762165212827652751691296897789\
32238195734329339946437501907836945765883352399886\
75506164965184775180738168837861091527357929701337\
62177842752192623401942399639168044983993173312731\
32924185707147349566916674687634660915035914677504\
99518671430235219628894890102423325116913619626622\
73267460800591547471830798392868535206946944540724\
76841822524674417161514036427982273348055556214818\
97142617910342598647204516893989422179826088076852\
87783646182799346313767754307809363333018982642090\
10848802521674670883215120185883543223812876952786\
71329612474782464538636993009049310363619763878039\
62184073572399794223406235393808339651327408011116\
66627891981488087797941876876144230030984490851411\
60661826293682836764744779239180335110989069790714\
85786944089552990653640447425576083659976645795096\
66024396409905389607120198219976047599490197230297\
64913982680032973156037120041377903785566085089252\
16730939319872750275468906903707539413042652315011\
94809377245048795150954100921645863754710598436791\
78639167021187492431995700641917969777599028300699\
15368713711936614952811305876380278410754449733078\
40789923115535562561142322423255033685442488917353\
44889911501440648020369068063960672322193204149535\
41503128880339536053299340368006977710650566631954\
81234880673210146739058568557934581403627822703280\
82616570773948327592232845941706525094512325230608\
22918802058777319719839450180888072429661980811197\
77158542502016545090413245809786882778948721859617\
72107838435069186155435662884062257473692284509516\
20849603980134001723930671666823555245252804609722\
53503534226472524250874054075591789781264330331690'

total = 0

for i in xrange(0, 100 * 50 - 1, 50):
    total += int(number_string[i:i+49])         

print str(total)[:10]

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 12
# http://projecteuler.net/index.php?section=problems&id=12
# The sequence of triangle numbers is generated by adding
# the natural numbers. So the 7th triangle number would be
# 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms
# would be:
# 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
# Let us list the factors of the first seven triangle
# numbers:
#  1: 1
#  3: 1,3
#  6: 1,2,3,6
# 10: 1,2,5,10
# 15: 1,3,5,15
# 21: 1,3,7,21
# 28: 1,2,4,7,14,28
# We can see that 28 is the first triangle number to have
# over five divisors. What is the value of the first
# triangle number to have over five hundred divisors?
import time
start = time.time()

from math import sqrt

def divisor_count(x):
    count = 2 # itself and 1
    for i in xrange(2, int(sqrt(x)) + 1):
        if ((x % i) == 0):
            if (i != sqrt(x)): count += 2
            else: count += 1
    return count

def triangle_generator():
    i = 1
    while True:
        yield int(0.5 * i * (i + 1))
        i += 1

triangles = triangle_generator()

answer = 0
while True:
    num = triangles.next()
    if (divisor_count(num) >= 501):
        answer = num
        break;

print answer
print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 11
# http://projecteuler.net/index.php?section=problems&id=11
# What is the greatest product
# of four adjacent numbers in any direction (up, down, left,
# right, or diagonally) in the 20 x 20 grid?
import time
start = time.time()

grid = [\
[8,02,22,97,38,15,00,40,00,75,04,05,07,78,52,12,50,77,91,8],\
[49,49,99,40,17,81,18,57,60,87,17,40,98,43,69,48,04,56,62,00],\
[81,49,31,73,55,79,14,29,93,71,40,67,53,88,30,03,49,13,36,65],\
[52,70,95,23,04,60,11,42,69,24,68,56,01,32,56,71,37,02,36,91],\
[22,31,16,71,51,67,63,89,41,92,36,54,22,40,40,28,66,33,13,80],\
[24,47,32,60,99,03,45,02,44,75,33,53,78,36,84,20,35,17,12,50],\
[32,98,81,28,64,23,67,10,26,38,40,67,59,54,70,66,18,38,64,70],\
[67,26,20,68,02,62,12,20,95,63,94,39,63,8,40,91,66,49,94,21],\
[24,55,58,05,66,73,99,26,97,17,78,78,96,83,14,88,34,89,63,72],\
[21,36,23,9,75,00,76,44,20,45,35,14,00,61,33,97,34,31,33,95],\
[78,17,53,28,22,75,31,67,15,94,03,80,04,62,16,14,9,53,56,92],\
[16,39,05,42,96,35,31,47,55,58,88,24,00,17,54,24,36,29,85,57],\
[86,56,00,48,35,71,89,07,05,44,44,37,44,60,21,58,51,54,17,58],\
[19,80,81,68,05,94,47,69,28,73,92,13,86,52,17,77,04,89,55,40],\
[04,52,8,83,97,35,99,16,07,97,57,32,16,26,26,79,33,27,98,66],\
[88,36,68,87,57,62,20,72,03,46,33,67,46,55,12,32,63,93,53,69],\
[04,42,16,73,38,25,39,11,24,94,72,18,8,46,29,32,40,62,76,36],\
[20,69,36,41,72,30,23,88,34,62,99,69,82,67,59,85,74,04,36,16],\
[20,73,35,29,78,31,90,01,74,31,49,71,48,86,81,16,23,57,05,54],\
[01,70,54,71,83,51,54,69,16,92,33,48,61,43,52,01,89,19,67,48]]

# left and right
max, product = 0, 0
for x in range(0,17):
    for y in xrange(0,20):
        product = grid[y][x] * grid[y][x+1] * \
          grid[y][x+2] * grid[y][x+3]
        if product > max : max = product 

# up and down
for x in range(0,20):
    for y in xrange(0,17):
        product = grid[y][x] * grid[y+1][x] * \
          grid[y+2][x] * grid[y+3][x]
        if product > max : max = product

# diagonal right
for x in range(0,17):
    for y in xrange(0,17):
        product = grid[y][x] * grid[y+1][x+1] * \
          grid[y+2][x+2] * grid[y+3][x+3]
        if product > max: max = product 

# diagonal left
for x in range(0,17):
    for y in xrange(0,17):
        product = grid[y][x+3] * grid[y+1][x+2] * \
          grid[y+2][x+1] * grid[y+3][x]
        if product > max : max = product  

print max

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

I first attempted to solve this problem using the Ruby combinations libraries. That didn’t work out so well. With a second look at the problem, the provided formula ended up being just the thing to solve the problem effectively.

As always, any feedback is welcome.

# Euler 53
# http://projecteuler.net/index.php?section=problems&id=53
# There are exactly ten ways of selecting three from five,
# 12345: 123, 124, 125, 134, 135, 145, 234, 235, 245,
# and 345
# In combinatorics, we use the notation, 5C3 = 10.
# In general,
#
# nCr = n! / r!(n-r)!,where r <= n,
#              n! = n(n1)...321, and 0! = 1.
#
# It is not until n = 23, that a value exceeds
# one-million: 23C10 = 1144066.
# In general: nCr
# How many, not necessarily distinct, values of  nCr,
# for 1 <= n <= 100, are greater than one-million
timer_start = Time.now

# There's no factorial method in Ruby, I guess.
class Integer
  # http://rosettacode.org/wiki/Factorial#Ruby
  def factorial
    (1..self).reduce(1, :*)
  end
end

def combinations(n, r)
  n.factorial / (r.factorial * (n-r).factorial)
end

answer = 0

100.downto(3) do |c|
  (2).upto(c-1) { |r|
    answer += 1 if combinations(c, r) > 1_000_000
  }
end

puts answer

puts "Elapsed Time: #{(Time.now - timer_start)*1000} milliseconds"

Compared to Problem 51, this problem was a snap. Brute force and pretty quick…

As always, any feedback is welcome.

# Euler 52
# http://projecteuler.net/index.php?section=problems&id=52
# It can be seen that the number, 125874, and its double,
# 251748, contain exactly the same digits, but in a
# different order.
#
# Find the smallest positive integer, x, such that 2x, 3x,
# 4x, 5x, and 6x, contain the same digits.
timer_start = Time.now

def contains_same_digits?(n)
  value = (n*2).to_s.split(//).uniq.sort.join
  3.upto(6) do |i|
   return false if (n*i).to_s.split(//).uniq.sort.join != value
  end

  true
end

i = 100_000
answer = 0

while answer == 0
  answer = i if contains_same_digits?(i)
  i+=1
end

puts answer

puts "Elapsed Time: #{(Time.now - timer_start)*1000} milliseconds"

I know I started back up with Python this week, but I have three more Ruby solutions in the hopper and I wanted to share. For the record, Project Euler 51 was the second hardest Euler problem for me thus far. Yeah.

As always, any feedback is welcome.

# Euler 51
# http://projecteuler.net/index.php?section=problems&id=51
# By replacing the 1st digit of *3, it turns out that six
# of the nine possible values: 13, 23, 43, 53, 73, and 83,
# are all prime.
#
# By replacing the 3rd and 4th digits of 56**3 with the
# same digit, this 5-digit number is the first example
# having seven primes among the ten generated numbers,
# yielding the family: 56003, 56113, 56333, 56443,
# 56663, 56773, and 56993. Consequently 56003, being the
# first member of this family, is the smallest prime with
# this property.
#
# Find the smallest prime which, by replacing part of the
# number (not necessarily adjacent digits) with the same
# digit, is part of an eight prime value family.

timer_start = Time.now

require 'mathn'

def eight_prime_family(prime)

  0.upto(9) do |repeating_number|
    # Assume mask of 3 or more repeating numbers
    if prime.count(repeating_number.to_s) >= 3
      ctr = 1

      (repeating_number + 1).upto(9) do |replacement_number|
        family_candidate = prime.gsub(repeating_number.to_s,
          replacement_number.to_s)

        ctr += 1 if (family_candidate.to_i).prime?
      end

      return true if ctr >= 8
    end
  end

  false
end

# Wanted to loop through primes using Prime.each
# but it took too long to get to the starting value.
n = 9999
while n += 2
  next if !n.prime?
  break if eight_prime_family(n.to_s)
end

puts n
puts "Elapsed Time: #{(Time.now - timer_start)*1000} milliseconds"

As always, any feedback is welcome.

# Euler 10
# http://projecteuler.net/index.php?section=problems&id=10
# The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
# Find the sum of all the primes below two million.
import time
start = time.time()

def primes_to_max(max):
    primes, number = [2], 3        

    while number < max:
        isPrime = True
        for prime in primes:
            if number % prime == 0:
                isPrime = False
                break
            if (prime * prime > number):
                break
        if isPrime:
            primes.append(number)   

        number += 2                 

    return primes

primes = primes_to_max(2000000)
print sum(primes)

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 9
# http://projecteuler.net/index.php?section=problems&id=9
# A Pythagorean triplet is a set of three natural numbers,
# a  b  c, for which, # a2 + b2 = c2
# For example, 32 + 42 = 9 + 16 = 25 = 52.
# There exists exactly one Pythagorean triplet for which
# a + b + c = 1000. Find the product abc.
import time
start = time.time()

product = 0

def pythagorean_triplet():
    for a in range(1,501):
        for b in xrange(a+1,501):
          c = 1000 - a - b
          if (a*a + b*b == c*c):
            return a*b*c

print pythagorean_triplet()

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 8
# http://projecteuler.net/index.php?section=problems&id=8
# Find the greatest product of five consecutive digits
# in the following 1000-digit number
import time
start = time.time()

number = '\
73167176531330624919225119674426574742355349194934\
96983520312774506326239578318016984801869478851843\
85861560789112949495459501737958331952853208805511\
12540698747158523863050715693290963295227443043557\
66896648950445244523161731856403098711121722383113\
62229893423380308135336276614282806444486645238749\
30358907296290491560440772390713810515859307960866\
70172427121883998797908792274921901699720888093776\
65727333001053367881220235421809751254540594752243\
52584907711670556013604839586446706324415722155397\
53697817977846174064955149290862569321978468622482\
83972241375657056057490261407972968652414535100474\
82166370484403199890008895243450658541227588666881\
16427171479924442928230863465674813919123162824586\
17866458359124566529476545682848912883142607690042\
24219022671055626321111109370544217506941658960408\
07198403850962455444362981230987879927244284909188\
84580156166097919133875499200524063689912560717606\
05886116467109405077541002256983155200055935729725\
71636269561882670428252483600823257530420752963450'

max = 0
for i in xrange(0, len(number) - 5):
    nums = [int(x) for x in number[i:i+5]]
    val = reduce(lambda agg, x: agg*x, nums)
    if val > max: max = val

print max

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 7
# http://projecteuler.net/index.php?section=problems&id=7
# By listing the first six prime numbers: 2, 3, 5, 7,
# 11, and 13, we can see that the 6th prime is 13. What
# is the 10001st prime number?
import time
start = time.time()

def nthPrime(nth):
    primes = [2]
    number = 3          

    while len(primes) < nth:
        isPrime = True
        for prime in primes:
            if number % prime == 0:
                isPrime = False
                break
            if (prime * prime > number):
                break
        if isPrime:
            primes.append(number)
        number += 2                 

    return primes[nth - 1]

print nthPrime(10001)
print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 6
# http://projecteuler.net/index.php?section=problems&id=6
# Find the difference between the sum of the squares of
# the first one hundred natural numbers and the square
# of the sum.
import time
start = time.time()

square_of_sums = sum(range(1,101)) ** 2
sum_of_squares = reduce(lambda agg, i: agg+i**2, range(1,101))
print square_of_sums - sum_of_squares

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 5
# http://projecteuler.net/index.php?section=problems&id=5
# 2520 is the smallest number that can be divided by each
# of the numbers from 1 to 10 without any remainder.
# What is the smallest positive number that is evenly
# divisible by all of the numbers from 1 to 20?
import time
start = time.time()

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

def lcm(a, b):
    return a * b // gcd(a, b)

print reduce(lcm, range(1, 20))

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 4
# http://projecteuler.net/index.php?section=problems&id=4
# Find the largest palindrome made from the product of
# two 3-digit numbers. A palindromic number reads the
# same both ways. The largest palindrome made from the
# product of two 2-digit numbers is 9009 = 91 x 99.
# Find the largest palindrome made from the product of
# two 3-digit numbers.
import time
start = time.time()

def isPalindrome(s):
    return s == s[::-1]

max = 0
for i in xrange(100, 999):
    for j in xrange(i, 999):
        n = i * j;
        if (isPalindrome(str(n))):
            if (n > max): max = n

print max

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 3
# http://projecteuler.net/index.php?section=problems&id=3
# The prime factors of 13195 are 5, 7, 13 and 29.
# What is the largest prime factor of the number
# 600851475143?
import time
start = time.time()

def largest_prime_factor(n):
  max = n
  divisor = 2

  while (n >= divisor ** 2):
    if n % divisor == 0:
        max, n = n, n / divisor
    else:
        divisor += 1      

  return max

print largest_prime_factor(600851475143)

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 2
# http://projecteuler.net/index.php?section=problems&id=2
# Find the sum of all the even-valued terms in the
# Fibonacci sequence which do not exceed four million.
# Each new term in the Fibonacci sequence is generated
# by adding the previous two terms. By starting with 1
# and 2, the first 10 terms will be:
# 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
# Find the sum of all the even-valued terms in the
# sequence which do not exceed four million.
import time
start = time.time()

total = 0
previous = 0
i = 1

while i <= 4000000:
    if i % 2 == 0: total +=i

    # variable swapping removes the need for a temp variable
    i, previous = previous, previous + i

print total 

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

As always, any feedback is welcome.

# Euler 1
# http://projecteuler.net/index.php?section=problems&id=1
# If we list all the natural numbers below 10 that are
# multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of
# these multiples is 23. Find the sum of all the multiples
# of 3 or 5 below 1000.
import time
start = time.time()

print sum([x for x in range(1000) if x % 3== 0 or x % 5== 0]) 

print "Elapsed Time:", (time.time() - start) * 1000, "millisecs"
a=raw_input('Press return to continue')

# Also cool
def constraint(x):
    return x % 3 == 0 or x % 5 == 0

print sum(filter(constraint, range(1000)))

I really dig Ruby.  I really enjoy its dynamism and expressiveness and always-openness and it’s been the highlight of our coding club for me so far. But that’s just my take on the language.  I know a lot of coders who’s stomachs turn with the mere thought of Ruby.  They say it’s Ruby’s openness which has them feeling uneasy.  I’d say “write a bunch of tests and get over it,” but I figure there must be more to it than always open classes and possible method collisions. Yes, there’s something else to it alright. The folks who didn’t fall head over heals for Ruby are already in love with Python. 

You might remember that Python was the first language we tackled in our coding club.  My time with Python was okay but it didn’t feel as natural to me as Ruby.  But let’s say we started with Ruby and then moved onto Python.  Would I see Python in a different light right now.  Might I even prefer Python over Ruby?  I suppose it’s possible but it’s pretty tough to test that theory – unless we visit Python for a second time.

That’s right. The language club is going to focus on Python again and in my attempt to learn Python – yet again – in the open, I’ll be posting my solutions here just as I did for Ruby.  We don’t always have second chances so I going about this relearning with two primary goals in mind: 

First, I’m going to use IronPython and the IronPython tools which provide a Python code editor, a file-based project system, and an interactive Python interpreter, all inside Visual Studio 2010.  As a note, the IronPython tools are now part of the main IronPython installer which is Version 2.7 Alpha 1 (not the latest stable version, 2.6.1) and I’d be crazy not to use them. 

Second, I’d like to make sure I’m still learning Python without a complete MS skew so I’m going to run my code through Eclipse using the PyDev plugin as well.  Heck, I might use IDLE too. I already have this setup on my machine so it’s no big deal.

Okay, that’s it for now.  I worked on the first ten Euler problems last night and the solutions will be posted shortly.

Wish me luck.