From what I gather, a wireframe is just that a wire-frame. It should purely consist of a layout, with the possibility of some actual production CSS in the page. The articles suggested that there are two main ways to do this:

1. Create a page for each "flow" of your application.
2. Create one page with a "stacked flow" of your application.

Basically, a flow is the various screens/interfaces that the end-user will be presented with. They give a nice "login" example (one which I actually made one of my own as well) with a "stacked flow" wireframe. You can see my example of that here. Comments are welcome, but keep in mind:

1. I'm not a graphic designer
2. This is my first crack at this
3. It's 2am... and I'm making wireframes...

Needless to say, that's kind of how I feel at the moment. The actual prototype, which I plan on using YUI for will probably come out tomorrow or sometime next week.

The reason I actually went through and made a wireframe, is because I'm attempting to get some sort of side project going for myself (yet again...) so I can play around with some new things. These things being YUI; as mentioned above, Python; which I've been somewhat getting into and web frameworks - namely Pylons. So tonight at least I got some wireframes done for the login, the next step will be to learn some YUI and get some fake data going for the prototype.

Lastly, I (possibly re)learned some interesting things today regarding CSS. As you can see in the source for my wireframes, I'm actually using display: table. Insane! I've never actually used that, ever. I initially had a pretty descent layout, but when looking at it on my Nokia N800, it looked completely borked! So the only way was to make div's within my login box actually span set percentage widths.

Now you're probably saying, whoa! Just set a width on that puppy and your good to go. Wrong! Since I wanted somewhat "tabular" data, consisting of two rows, and two colums. Each row being 100% the width of the box and each column being 50% of the row, there was no way to do that using pure css and not using tables. This is for two reasons:

1. Div elements are initially set as display: block. This means there is a line break before and after the element. So there's no way to have two "columns" side by side.
2. Inline elements (or elements set to display:inline!) do line up side by side; however!, they will only take on as much width as they need, and don't respond to width: styles. They may use the width attribute in some browsers, but not what I was testing it in (FireFox 2).

So I came across an article talking about using display: table. And really, it couldn't be simpler. Parent element needs to be set as display: table. The children of that needs to be set as display: table-row. And the children of the rows need to be set to display: table-cell. The only downside, is there is absolutely no support for colspan or rowspan in css or the markup. Even if they did work, it looks like the CSS for those will be depricated in CSS 3 and replaced by some other multi-row/column attribute.

So all in all, a night of learning pylons, which I'm really starting to like. And hopefully I'll keep cranking out these wireframes/prototypes and get good enough at them so I can actually use them in my daily work. And although I'm posting more now... I hope I don't make a habit of posting at 2:30am : (. Next time I'll hopefully have some stuff on prototypes to discuss.

All in all this post is just me wanting to try out maemo-wordpy. And yup! This is posted from my new internet tablet!

Trying other various methods I still came up short with the result being about 176 seconds at best. To optimize my program I was mainly looking for some information on how prime numbers might be related to bits/bytes to see if I could perhaps try some bitwise operations to speed things up. In doing so, I came across an article suggesting that having an array of bits (essentially a long char) with each char representing a number in an array from 0 to x; x being the limit. Once this array was created, simply just iterate from 0 to the square root of your limit, and mark all multiples of any primes found on your way. Makes sense - and this greatly cuts down on all the harsh prime calculating going on in the background.

As I'm still learning python, I figured I'd try the next best thing and just make an array of boolean variables. This way I can just check to see if they're true/false. After adapting my program to do this -  having a representative array as opposed to an array of actual values, the finished product was able to find the answer in 2 to 3 seconds. Awesome.

Code is posted below. Sooner or later I'm hoping these problems will force me into creating more of an OO type program. But for the time being I'm being pretty lame and writing everything procedurally. As always, comments/criticism is welcome!

Problem 10

Calculate the sum of all the primes below one million.

#!/usr/bin/python#function to find if a number is prime

def is_prime(n):

#check found prime numbers first

  global primes

  for prime in primes:

    if(n%prime == 0):

      return False

  return True

#function to mark prime numbers

def mark_primes(n):

  global numbers

  x = 2

  while(x*n < 1000000):

    if(numbers[x*n]):

      numbers[x*n] = False

    x += 1

#initialize vars

total   = 0

numbers = []

primes  = []

#initially set everything to true

for x in xrange(0, 1000000):

  numbers.append(True)

#we know 0 and 1 are false

numbers[0] = False

numbers[1] = False

#start with multiples of primes from 2 to 1000 (sqrt 1,000,000)

for x in xrange(2, 1000):

#if prime, add to prime pool and mark it and it's multiples

  if(is_prime(x)):

    primes.append(x)

    mark_primes(x)

#calculate the final sum

for x in xrange(0, len(numbers)):

  if(numbers[x]):

    total += x

print "Total: ", total

So I guess I should start with saying I'll be using/learning Python for all of my problems. Not a terribly hard choice as I'm already pretty familiar with Perl and PHP which seem to be somewhat similar to Python. Anyways, if anyone else wants to get in on the fun. Feel free to do so and post links to your own blogs/solutions or simply just put them here! I plan on using these solutions as an excuse to actually get posting more on here. So, we'll see how that goes. I may also have to make some sort of hiding script so solutions aren't completely revealed to those that want to accomplish everything on their own. Without further adieu - the first 3 problems and my solutions.

Problem 1

Add all the natural numbers below 1000 that are multiples of 3 or 5.

A simple brute force script - nothing really too elegant.

#!/usr/bin/python
total = 0;
for n in range(1, 1000):
  if n%3 == 0 or n%5 == 0:
    total += n

print total

Problem 2

Find the sum of all the even-valued terms in the Fibonacci sequence which do not exceed one million.

Another brute force script - nothing fancy.

#!/usr/bin/python
f1    = 0
f2    = 1
total = 0;

while (f1+f2) < 1000000:
  tmp = f1 + f2
  if tmp%2 == 0:
    total += tmp
  f1 = f2
  f2 = tmp

print total

Problem 3

Find the largest prime factor of 317584931803.

This problem was the first one that actually posed some thought. Given the example "The prime factors of 13195 are 5, 7, 13 and 29.", as well as doing some research; prime factors are just prime numbers that all multiply into the initial number given. Rather than explaining, I'll just let the code speak for itself.

#!/usr/bin/python
limit = 317584931803

#function to find if a number is prime
def is_prime(n) :
  test  = 2
  while (test <= n/2):
    if(n%test == 0):
      return False
    else:
      test += 1
  return True

primes  = []  #holds prime factors
num = 2       #starting point

#loop through all possibilities until we hit the limit
while (num <= limit):

  #assume it's not a multiple of any prime numbers
  is_multiple = False
  add = 1

  #check already known primes
  for prime in primes:
    #check to see if it's a multiple of a prime number
    if(num%prime == 0):
      is_multiple = True

  #if it's not a multiple and it devides into our current limit
  if(not is_multiple and limit%num == 0):

    #actually check to see if it's prime
    if(is_prime(num)):

      #it is! don't increment our current number yet
      #until it's not a factor of our limit
      add = 0

      #add to our array, and re-calculate the new limit
      primes.append(num)
      limit = limit/num

  #incriment to the next number
  num += add

#print our results
print primes

So, all in all these seem like some pretty alright challenges. I've already got my roomate doing them (Java) and I wouldn't be surprised if a few other friends (on or off the blogroll) would get interested as well. I'd also be very interested to hear from some of the veteran pyCoders on things they would've done different, or some key aspects of the language that I'm missing. I quickly found out already that the following code results in an overflow - hence why i'm using the while loop as opposed to a for x in y loop. As always, comments, criticism and randomness is welcome!

for x in range(2, 317584931803):
  #creates array with 317584931803 variables! yikes!

Any better ways to loop through that without having to do a while loop?

Today I also ended up setting up my webfaction account with a few friends of mine. We mainly decided to move there because of dreamhost's policy against long running processes. Don't get me wrong! Dreamhost is a dream hosting company with super cheap plans with tons of storage and bandwidth. But myself and some of my friends have taken quite an interest in learning python as of late. It seems a lot of their web frameworks (mainly pylons and django) involve running some sort of python WSGI "middleware" to communicate between webservers and the actual web applications. At any rate, this was a nightmare to try and get running properly dreamhost. Webfaction seems to be more than python friendly, so we'll see how it goes!