Project Euler #3

The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143 ?

Simply factorize the target number and select the maximum value from the factors.  Should be pretty simple.  It should be noted, however, that simply iterating through every number is not going to suffice, because a number can have two of the same factors.

For example, the number 28 has a prime factorization of 2, 2, and 7.  The fact that there are two 2’s in the factorization should be taken into account when writing your solution.

Project Euler #2

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, …

By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.

We are given our bounds in the problem,  1..4000000 , and we are to find and sum every even fibonacci number inside the given bounds.

To start off, we should define a function to generate a list of fibonacci numbers.  I opted for a recursive function, but this could easily be achieved using simple loops as well.

def fib(nums, maxNum):
    if not (nums[-1] >= maxNum):
        nums.append(nums[-1] + nums[-2])
        fib(nums, maxNum)
    return nums

With that function defined, the rest of the problem is simply iterating through the array of fibonacci numbers, testing if they are even, and adding them to a sum value.

Project Euler # 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.

This one is pretty simple from the get-go.  Simply iterate through numbers  1..999  and check if they are a multiple of 3 or 5.  If they are, add them to the total.

Creating an easy-use framework for Python applications

Recently I have been working on a framework for database driven Python applications.

Current code can be found here.

The idea here is to abstract the database work from the programming of the application.  Instead of writing a series of complex SQL commands to modify and migrate database tables, you can simply edit a single row in the `ApplicationData` or `DocumentDictionary` tables, and accomplish the work of a whole database migration with a simple `update` statement.

Data

All data is stored as JSON values, so if, for example, you would traditionally have a table like this:

point2d
id x-value y-value
1 0 0
2 1 1

With this framework, you would simple create an entry in the `DocumentDictionary` table for each of the columns, specifying the DocType, FieldName, and a few other things. Then, when creating a new Document of type `point2d`, the framework would create an entry in the `DocumentData` table, with the JSONData looking something like `{‘x-value’: 0, ‘y-value’: 0}`.

One of the downsides to using this system is that it adds computational overhead to database and data access. I believe that the ease-of-use justifies this, and the abstraction allows for more readable code overall.

Classes

Currently the framework provides a set of 4 classes to be used when programming.

  • framework.Framework(db = ‘/DB/application.sqlite’)
    • You’d instantiate this at the start of your application, optionally specifying your database location if it is different than the standard.
    • Stores all your important stuff in Memory, such as your current DocumentTypes, and currently open Docs
  • framework.Document()
    • Can be created anytime, by any object. Stores data in JSON, as seen in the DB structure.
    • Calling Document.commit() will write your Document to the database.  You should avoid doing this directly, because if Document().__dict__[“id”] already exists, you are going to overwrite it and lose your data.
  • framework.DocumentType()
    • Has two instance variables, one containing a string stating the DocType, the other being a list of framework.Field() s.
    • These are loaded from the database by Framework().loadDocTypes() , but you can create them yourself and write them to the database at will.  Please make sure that you do not overwrite anything important.
  • framework.Field()
    • Simply specifies a Field for use in a DocType
    • Corresponds to a typical Column in a database structure
    • Can be manually created and added to a DocType to create new “columns” in the database

Reddit Chrome Extension

I made a little extension for Google Chrome that allows you to quickly navigate to subreddits by simply typing “r”, followed by a space and the subreddit name in your address bar.

Code can be found here.

Install is simple.  Open Chrome, and type chrome://extensions into your address bar.  Enable developer mode, and select Load Unpacked Extension.  Select your local copy of the code, and you should be done.

Try it out!  Type “r all” in your address bar, and you should see “reddit.com/r/all” load up!

Simple AltCoin written in Python

In this day and age, nearly everyone has had some kind of exposure to cryptocurrencies.  Bitcoin has been massively popular over the past couple of years, and has sparked the creation of thousands of so called “Alt-Coins”.   Alt-Coins are essentially bitcoin clones that add new features, algorithms, etc to their codebase to allow for a broad spectrum of capabilities.

To the average coder though, the Bitcoin codebase is all but inaccessible.  The code behind Bitcoin is incredibly complex, and requires maintainers and contributors to be very familiar with the way that Bitcoin works and how the network operates.

This is where BasicCoin came in.  BasicCoin was created by Zack-bitcoin to simplify the code behind crypto-currencies.  BasicCoin uses a simple sha-256  hashing algorithm, and consists of just a few Python files.

From BasicCoin, I am developing MyCoin (the name is a work in progress.  I haven’t decided on a final name yet.).   The plan is to use the x11 mining algorithm for coin production, and the primary goal is just to keep the coin simple.  Progress can be tracked at the project github page.  Currently, only OSX is supported, due to syntax differences between OSX, Linux, and Windows.  For any suggestions, just submit an issue to the issue tracker, or submit a pull request!

Assembly development on a mac.

When I first got my mac, I had no idea how to continue working on my toy operating system.  After some research, I found a couple of effective ways to do assembly programming on the mac.

Option 1:

I recommend this method for learning basic assembly.  In combination with debug.com, dosbox provides a good safe environment for learning the basics.  A guy named Khoraski(on YouTube) has a really good series on how to do assembly programming in DEBUG.

Install dosbox.  Just use the .dmg file to install it to a default directory.

Next create a working directory to store all you dosbox programs and source files. Open up a terminal window, and type something along the lines of ‘mkdir ~/DOSPrograms’ to make a folder.

Now that you have a working directory, just download the debug.com file (try this site) and put it into the directory you created earlier(e.g. DOSPrograms).

The rest of this method is just  booting dosbox and using its built in commands.

Option 2:

This is another very safe way to practice Assembly, but provides a much broader toolset.

Download and install VirtualBox, and the latest Ubuntu .iso.

Install nasm via command line.

you should be good to go

Option 3:

Probably the most obvious option, you just install the tools directly into OSX and just program without the protection of a virtual machine.  Download Xcode, enable the command-line tools, and you should be ready to go.  Nasm, GCC, DD, VIM, and LD should be automatically installed and enabled.

 

I hope some of you found this helpful.  Options 2 and 3 are probably the two I would most recommend for serious Assembly development, seeing as Option 1 is severely limited in scope and utility.

TroopPress WordPress plugin

This wordpress plugin was made to allow troops to build wordpress websites, and have a clearly defined hierarchy of user roles.  Each role has its own permissions set, and (eventually) the permissions will be adjustable through the settings page.  Attached is an excel file with a list of the current permissions set.  There is no current release available, but there will be soon.  Current unreleased beta version is 0.2.4.

 

perms