I've got problem #2 in the bag.

Problem #2 goes like this:
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.

And my code goes as follows:
Haskell:

--fibinaci :: (Num a) => a -> a -> [a]
fibinaci a b
  | sum' > 4000000 = []
  | otherwise = sum' : fibinaci b sum'
  where sum' = a + b
 
problem2 = sum $ filter (even) (fibinaci 0 1)

#!/usr/bin/python
 
def fibinaci_list( in_list, input1, input2):
  flip = True
  while ( input1 + input2 < 4000000):
    if( flip == True):
      input1 = input1 + input2
      in_list.append(input1)
      flip = False
    else:
      input2 = input1 + input2
      in_list.append(input2)
      flip = True 
 
def even(n):
  if n % 2 == 0:
    return True
  else:
    return False
 
 
def main():
  first_list = []
  fibinaci_list(first_list, 0, 1)
  second_list = filter(even, first_list)
  print "%s" % (sum(second_list))
 
if __name__ == "__main__":
  main()

#!/usr/bin/perl
 
my $total = 0;
my $count1 = 0;
my $count2 = 1;
my $flip = 1;
 
while( $count2 + $count1 < 4000000)
{
  if ( $flip == 1)
  {
    $count1 += $count2;
    if ( $count1 % 2 == 0)
    {
      $total += $count1;
    }
    $flip = 0;
  }
  else
  {
    $count2 += $count1;
    if ( $count2 % 2 == 0)
    {
      $total += $count2;
    }
    $flip = 1;
  }
}
 
print $total;

Originally, I tried to copy the Python algorithm to Perl, using an array instead of a list. That didn't work. The program would always fail due to out of memory errors. To solve this problem I changed the program to work without using arrays and just took the whole fibinaci function out and put it into main.

As always, constructive comments for the code are welcomed.

So I'll admit it, I'm more than acceptably late to this party. OJ started working on these problems years ago, while I was still coding away on other stuff at school. Now that I'm not in school and needing a challenge I'm doing the best I can to tackle the problems at Project Euler. Since I'm also trying to pick up Haskell, this makes for a good way to learn the language. This isn't my first time using a Functional Programming language. But the last time I tried, it was forced upon me at school with inadequate assistance and the whole experience left a bad taste in my mouth. I'm glad that getting over the bad experience and learning something new at the same time.

I've started keeping a github repo with my solutions for the various problems. If anyone is interested in commenting on my code please do so. I welcome all constructive criticism.

To start this thing off; problem one reads,
“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.”

Being this one was simple. I coded it up in Haskell, Python, and Perl.
Haskell:

problem1 = sum $ filter (\x -> mod x 3 == 0 || mod x 5 == 0) [1..1000]
problem1' = sum $ filter (\x -> mod x 3 == 0 || mod x 5 == 0) [1..999]

#!/usr/bin/python
 
def threeorfive(n):
  if ( n % 3 == 0 or n % 5 == 0):
    return True
  else:
    return False
 
def main():
  first_list = range(1,1000)
  second_list = filter(threeorfive, first_list)
  print "%s" % (sum(second_list))
 
if __name__ == "__main__":
  main()

#!/usr/bin/perl
 
my $count = 0;
my $total = 0;
 
while ( $count < 1000)
{
  if ( $count % 3 == 0 or $count % 5 == 0)
  {
    $total += $count;
  }
 
  $count++;
}
 
print $total;

One thing that is nice about doing this in different languages, is that you get to become aware of the differences between some of those languages. For instance in Python the range function works a little differently than I expected. I was expecting an inclusive range function, one in which the 10 is included in the list. But that is now how Python's range works. It gives me 10 numbers, starting with 1, the end result is a list ending in 9. It's not a big deal and easily fixable, but just not something I was expecting. That is why the Haskell code has to functions in it. Just to verify that the Python code was correct.

I'll be posting more answers as I complete them. So expect to see some random posts with Euler solutions in them.

I'd just like to share with you these forty-seven lines of python code that amaze me. Not because they do anything special, but because they represent something that is pretty important to programming languages, modules, or libraries (depending on the language). Let's take a quick gander at the code:

#!/usr/bin/python
"""
#
# This is a simple script to grab the contents of a a website, 
# encoded into a MIME message, and email it
"""
import sys
import smtplib
import pycurl
from cStringIO import StringIO
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
 
data_buf = StringIO()
curl = pycurl.Curl()
 
# Setup pycurl to grab the data
curl.setopt(pycurl.URL, sys.argv[1])
curl.setopt(pycurl.WRITEFUNCTION, data_buf.write )
curl.perform()
curl.close()
 
# Begin creating email
#create html & text parts of the email
part1 = MIMEText(data_buf.getvalue(), 'html')
part2 = MIMEText(data_buf.getvalue(), 'text')
 
# next 5 lines put it all together
msg = MIMEMultipart('alternative')
msg['Subject'] = 'Website by Email'
 
msg.attach(part1)
msg.attach(part2)
 
# email away
# this code was copied from:
# <a href="http://www.mkyong.com/python/how-do-send-email-in-python-via-smtplib/<br />
#" title="http://www.mkyong.com/python/how-do-send-email-in-python-via-smtplib/<br />
#">http://www.mkyong.com/python/how-do-send-email-in-python-via-smtplib/<br />
#</a> Geshi keeps adding extra lines here, I'm not sure why
to = 'add_your_own'
gmail_user = 'add_your_own'
gmail_pwd = 'add_your_own'
smtpserver = smtplib.SMTP("smtp.gmail.com", 587)
smtpserver.ehlo()
smtpserver.starttls()
smtpserver.login(gmail_user, gmail_pwd)
smtpserver.sendmail(gmail_user, to, msg.as_string())
print 'done!'
smtpserver.quit()

This little script started out as a work assignment (which I have modified to make it more general). The task was to grab the contents of a particular website and email them. Not terribly complicated, but also not one I was thinking would be accomplished with twenty-eight lines of actual code.

Let's take a second to review which modules are being used above:

The code used by PycURL to grab the website, and deposit the data into the string.

StringIO module, to hold the contents of the website. (I wasn't able to get a regular string to work here. If you know how, please tell me.)

The MIME module for reformatting the website contents.

The SMTPlib module, for having all the code in it to properly communicate with a SMTP server, including TLS for encryption, to send said email through the web.

It wasn't until doing this project that I fully realized the importance of modules. It was these four modules that saved me uncountable hours of coding, testing, and debugging. Even if I had written out the functionality I needed from scratch, what I would have written would not have anywhere near the functionality that these other modules provided. In correlation to this, I wonder if there is some kind of connection between how popular a lanugage is and how easily extendable it is. I have no way to prove this of course, but both Perl & Python could be good examples (and also happen to be the languages I'm most familiar with). Both languages are popular, as shown by the normalized graph by langpop.com, and both are also extremely easy to add extra functionality to. The PycURL, CLyther, and PyCUDA modules are great cases in point. PycURL allows Python to tap into the CURL library. CLyther allows Python to use OpenCL, and PyCUDA allows Python to access the CUDA libraries. It makes my head hurt just to think about the amount of code that it would take to perform these same functions, if written from scratch.

After having this moment of realization, I find I am extremely grateful to all the programmers out there who put in their time to help create modules like these and to help them perform as well as they do. I tip my hat at you all.

For my current job I'm in charge of writing a script that requires a person to input their password and me being the semi-security conscious individual that I am knew that regular input for a script like this would be bad, as that would allow for over the shoulder (literally) view of someone's password. This is just unacceptable.

To solve this problem I hit the internets for a way to hide user input in Perl script. And in my travels I came across this old PERL FAQ site. I decided to try out the code and update it, throw it into a little dummy script. This is what I got (minus the dummy script):

sub get_password
{
  print "enter your password: ";
  system("stty -echo");
  chop(my $password=<>);
  print "\n";
  system("stty echo");
 
  return $password;
}

Saved it, ran it, and Holy Missing Characters Batman, it worked. So just as a mental exercise, I wanted to see if I could get it to emulate the password request when you run sudo, and I wrote this up in Python (because I need the practice):

#!/usr/bin/python
 
import os
import getpass
 
def get_password():
    #print "Please enter your password:"
    os.system("stty -echo")
    password = raw_input( getpass.getuser() + "'s password")
    os.system("stty echo")
    print "\n"
 
    return password
 
def main():
    local_password = get_password()
    print local_password
 
main()

And again... it worked. Of course I finally realized that the reason why it worked is because of the line "stty -echo". Taking that I typed it into a standard terminal and after hitting enter the results were the same. My terminal functioned normally, but without showing me the characters I was typing. After returning my terminal back to normal I decided to read a little more about stty. After digging through the man page for a little while I came across this argument which is an alias for echo:

[-]crterase
echo erase characters as backspace-space-backspace


Thus the reason why I couldn't see anything change is because my terminal is treating all characters I type on the screen as a three part sequence of non alphanumeric characters. Although I find this a little odd; I have to just go with the words of Bugs Bunny on this one, “I don't ask questions. I just have fun.”