davinci’s notebook » programming and technical issues

Old Help:Setup wiki

davinci — Sun, 24 Oct 2010 02:25:10 +0000

The content of this post used to live at http://stargrads.net/wiki/Help:Setup, and described how I had set up the software for this web site. I am archiving the contents of that page here for the reasons described below. It probably won’t interest anyone except for nerds.

I had originally intended to use MediaWiki to help me get out my writer’s block by using it to write my Ph.D. proposal live and online. However, since I have dropped out of the Ph.D. program, I haven’t really gone back to look at it. It turns out that MediaWiki is a magnet for spam, and I simply don’t have the time to revert edits when some bot inserts spam links into the wikis.

Another problem is that I had used WordPress^μ to give myself the flexibility of creating more than one blog on this web site. Since then, WordPress^μ has been merged into WordPress, so much of what is below is no longer relevant or necessary.

This is a record of everything I did to set up the software for stargrads.net, in case I need to install everything again, or to fix something that broke after an upgrade.

For help on how to use the software, see Help:Contents.

Blogs (WordPress^μ)

I am using the K2 theme for WordPress. This theme is designed so that the template files do not usually need to be edited. Most of my customisation is done through a stylesheet and using K2′s provided hooks. However, I did make three modifications to the template code in “theloop.php”:

I moved the permalink from the post title to just after it, and had it displayed as “[permalink]“.
I added a link to a post’s comments after each post.
I changed the code for the “Continue reading” link so that it expands/collapses the post using AJAX.

The stargrads.net banner and the loader for jsMath are included through “functions.php” by adding hooks for “template_body_top”.

One slight change to “header.php”: on line 52, I changed the string ” at ” to ” @ ” (this makes post titles show up as “post title @ davinci’s notebook” on the individual post pages).

Another change to “header.php”: I added links in the header to the RSS and Atom feeds of the comments.

The Continue Reading Link

The “Continue reading” link (which is normally displayed when WordPress encounters the tag) was changed so that it would display ellipses, followed by a new paragraph, before the link to the full post. This behaviour is overridden by the Ajaxified Expand Post NOW Plugin, for which see below.

The original code in “theloop.php” was:

, 'k2_domain'), the_title(, '', false))); ?>

This was changed to:

» [Continue reading %s]', 'k2_domain'), the_title(, , false))); ?>

The Ajaxified Expand Post NOW Plugin

In addition to the above, I activated the Ajaxified Expand Post NOW plugin. Note that this essentially overwrites the above changes. I made a number of customisations and modifications to the plugin:

\$aepnLoadingMsg = '… » [Fetching data ]';,
\$postLess = 'Collapse post';, and
\$postMore = 'Expand post';.

I also replaced the line \$content=preg_replace(...) and the following line with:
\$content=preg_replace('/(.*)/', (\$postLinkPrefix.'… » ['.\$postMore.']« ['.\$postLess.']'.\$postLinkPostfix.' [Permalink]'), \$content);

In the “getPost” function, I added the lines:

global $post;
\$post->ID = $id;

These were required to allow the footnotes plugin to create its anchors properly.

In the same function, I replaced the lines beginning \$content=explode(...) with:

\$content=explode(\$token,apply_filters('the_content',\$post_content),2); if (count(\$content)==2) { echo \$content[1]; }

This was needed so that plugins can apply filters to both parts of a text separated by the tag.

Finally, in the line gE('viewBox-'+postID).style.display = 'block';, I changed block to inline.

The above changes allow the post to be collapsed in the middle of a paragraph (or of a sentence, even).

There’s a slight bug in the integration of the The Ajaxified Expand Post NOW Plugin with jsMath. Currently, mathematical formulas after the tag do not get processed. To get around this, in posts where formulas appear after the tag but not before, an empty equation needs to be inserted before the tag to force jsMath to load. Furthermore, the plugin code needs to be edited to add these lines to the end of the “fetchDone” function:

jsMath.ConvertTeX('viewBox-'+postID); jsMath.Process('viewBox-'+postID);

Come to think of it, there’s probably nothing I can do about this. The reason is that if there are any error messages (jsMath is missing fonts, and so on), they have to be displayed at the top of the site. There’s no way this can happen if jsMath is loaded dynamically through Ajax when a post is expanded.

OpenID

~~The OpenID plugin has a bug which prevents trackbacks and pingbacks from working. See here for the fix.~~ This is fixed in the latest version.

WP-Syntax (GeSHi)

The WP-Syntax plugin needs to escape special characters. See here for the fix.

Move geshi to the common subdirectory, since it’s also used by MediaWiki. Change the line include_once("geshi/geshi.php") to include_once(getenv("DOCUMENT_ROOT") . "/common/geshi/geshi.php").

WP-reCAPTCHA

After setting the tab index in the options, the “comments.php” file has to be edited to change the tab index of the “Submit” button, so that the reCAPTCHA appears between the comment and the submit button.

Subscribe to Comments

The Subscribe to Comments plug-in likewise needs to be edited so that its checkbox appears just before the reCAPTCHA. The “comments.php” file needs to be edited to allow users to subscribe to comments even if they haven’t commented, by adding a call to show_subscription_checkbox(). I’ve also edited the plugin to insert some tab index information.

The plugin needs to be edited in a number of places to make it compatible with WordPress^μ, especially its concept of roles and capabilities. In particular, references to current_user_can('manage_options') should be changed to current_user_can('publish_posts') (to enable editors and blog posters who are not administrators to manage subscriptions). Also, SQL queries to SELECT comments need to have AND comment_type = '' added, so that pingbacks and trackbacks are ignored.

A minor cosmetic change: the “Return to the page you were viewing” link was changed so that it goes to the “#respond” anchor on that page.

Yet Another Related Posts Plugin

There’s a bug in version 3.0.13 of YARPP which adds slashes in front of quotation marks for several options on the options page. See here.

Sociable

The Sociable, YARPP, and AEPN plugins interact with each other in a bad way. Sociable and YARPP work together in single posts. However, when they are used together with AEPN, inside an expanded post (say, on the front page) the Sociable plugin interferes with the YARPP plugin so that the latter displays the wrong list of related posts.

I don’t know how to fix this, except to turn off the option to “Automatically display related posts”, and then adding a call to related_posts() to the K2 hook template_entry_foot.

K2 Rolling Archives

In the “themes/k2/js/k2.functions.js” file, change the “smartPosition” function to the following:

/* Fix the position of an element when it is about to be scrolled off-screen */
function smartPosition(obj) {

       if ( jQuery.browser.msie && parseInt(jQuery.browser.version, 10) = jQuery(obj).offset().top) {
                       jQuery('body').addClass('smartposition');
                       rollingarchives.style.left = '' + (345 - document.documentElement.scrollLeft) + 'px';
               } else {
                       jQuery('body').removeClass('smartposition');
                       rollingarchives.style.left = '0px';
               }
       });

};

The value of 345 was determined experimentally. There’s probably a better (cleaner) way to do this!

Kses hack

The tags “ref”, “references”, and “wikindx” had to be allowed through a so-called “kses hack”, so that footnotes and citations would work.

I had to edit the “wp-includes/kses.php” file to include “market” as an allowed protocol, to allow links to Android Market.

Incompatible plugins

Some plugins written for WordPress may be incompatible with WordPress^μ. In some cases, it may be impossible to update the plugin’s options. A hack to get around this is to comment out any “check_admin_referer” lines in the plugin, change the options, and then uncomment those lines.

Wiki (MediaWiki)

Major changes to the skin, obviously. The original settings for the sidebar were:

SEARCH
navigation
- mainpage|mainpage-description
- portal-url|portal
- currentevents-url|currentevents
- recentchanges-url|recentchanges
- randompage-url|randompage
- helppage|help
TOOLBOX
LANGUAGES

Note that to edit the sidebar, just edit the special wiki page MediaWiki:Sidebar.

The CSS for the site is found at MediaWiki:Common.css.

Forums (bbPress)

In the “header.php” file, add the line “” to load jsMath.

Bibliography (Wikindx)

To write the name of the software, use “Wikindx“, which shows up as
Wikindx.

Calendar (WebCalendar)

These pertain to WebCalendar 1.20.

There’s a bug that prevents WebCalendar from display pages with untimed events if using PHP 5.2.8 and up. Typically the web server returns a zero-sized reply. See this post for the fix.

There’s another bug that prevents user/group selection pages from displaying with the error “Program Error: No Form Specified”. See here for the fix.

Equations (jsMath)

The following code was inserted into the header files of the templates for this web site:

To get equations to display correctly in {{sc|W|IKINDX}}, curly brackets have to be escaped correctly. Replace each “{” with “{{}” and each “}” with “{}}”.

When updating, don’t forget to save the customised macros and the installed fonts.

See above for a slight bug with the Ajaxified Expand Post NOW Plugin in regards to jsMath.

Web Analytics (piwik)

When upgrading piwik, pay special attention to the config and tmp subdirectories, especially their permission settings.

There are plugins available for WordPress and MediaWiki, but for now, the piwik code is just going into the template.

– davinci

Programming exercise: interweaved strings

davinci — Sun, 22 Nov 2009 01:45:33 +0000

I don’t quite remember where I saw this problem, but I’m sure it’s appeared in a number of places. Given two strings $s$ and $t$, determine whether a string $u$ is formed by interweaving $s$ and $t$. That is, determine whether $u$ can be formed by taking the first few characters of (say) $s$, followed by the first few characters of $t$, then the next few characters of $s$, and so on. For example, the string “abccdcxey” can be formed by interweaving “abcde” with “ccxy”.

I took way too long thinking about how to set up the problem than I should have. In the end, I decided to quickly write up a solution that is easy to code, even if it may not be optimal. The solution uses an $(m+1) \times (n+1)$ table, with indices starting from $0$, where the $(i,j)$ entry is a boolean value indicating whether it’s possible to form the $(i+j)$-character prefix of $u$ from the first $i$ characters of $s$ and the first $j$ characters of $t$.

Let $m$ and $n$ be the lengths of $s$ and $t$, respectively. Assume that $u$ is of length $m+n$. (This can be easily checked and handled at the beginning.) The function that determines whether $u$ is formed by interweaving $s$ and $t$ is as follows:

bool interweave(char *s, int m, char *t, int n, char *u) {
    bool **table = new_table(m+1, n+1);    
    table[0][0] = true;
 
    for( int row = 0; row &lt; m+1; row++ ) {
        for( int col = 0; col &lt; n+1; col++ ) {
            if( table[row][col] ) {
                if( row != m ) {
                    table[row+1][col] = (s[row] == u[row+col]);
                }
                if( col != n ) {
                    table[row][col+1] = (t[col] == u[row+col]);
                }
            }
        }
    }
 
    bool result = table[m][n];
    delete table;
    return result;
}

When programming on the whiteboard, it’s important not to get bogged down in details. In the above, I’ve assumed the existence of a function new_table(rows,cols) which returns a two-dimensional array of bools, of the requested number of rows and columns, with all entries initialised to false. This is simple enough to implement that I hope the interviewer won’t actually ask me to write it out during the interview, but in case I have to do so, here it is:

bool **new_table(int rows, int cols) {
    bool **table = new bool*[rows];
    for( int i = 0; i &lt; rows; i++ ) {
        table[i] = new bool[cols];
        for( int j = 0; j &lt; cols; j++ ) {
            table[i][j] = false;
        }
    }
    return table;
}

The algorithm runs in time $O(m \times n)$ and also takes that much space. I wasn’t really satisfied with this solution because it doesn’t make use of the fact that the same prefix of $u$ can be formed by interweaving prefixes of $s$ and $t$ in different ways. For example, “abcc” can be formed by interweaving “abc” and “c” in two different ways. Now, the above algorithm doesn’t perform redundant calculations, but only because we’re sweeping the table row-by-row in an orderly fashion.

One can, of course, contrive values for which most of the table actually needs to be visited, but for most values of $s$ and $t$, if one or more paths from the upper left corner to the lower right corner of the table exists, the only entries of the table that need to be visited are likely to be very close to these paths. It makes sense therefore to keep track of which entries in the table are actually necessary to visit.

The following code is closer to the algorithm I have in mind:

bool interweave(char *s, int m, char *t, int n, char *u) {
    queue q = new queue(m+1,n+1);
    q.enqueue(0,0);
 
    bool result = false;
 
    while( !q.empty() ) {
        int row, col;
        q.dequeue(&amp;row, &amp;col);
 
        if( ( row == m ) &amp;&amp; ( col == n ) ) {
            result = true;
            break;
        }
 
        if( ( row != m ) &amp;&amp; ( s[row] == u[row+col] ) &amp;&amp; !q.marked(row+1,col) ) {
            q.enqueue(row+1,col);
        }
        if( ( col != n ) &amp;&amp; (t[col] == u[row+col] ) &amp;&amp; !q.marked(row,col+1) ) {
            q.enqueue(row,col+1);
        }
    }
 
    delete queue;
    return result;
}

In the above, I’ve assumed the existence of a queue class that allows me to enqueue and dequeue pairs of integers consisting of a row and a column. A row-column pair is enqueued only if it corresponds to a prefix of $u$ that can be formed by interweaving a prefix of $s$ and a prefix of $t$. Furthermore, the queue class also keeps track of whether a pair has ever been enqueued. The marked function returns true if that’s the case, and false otherwise. It can do this either using a two-dimensional array, as before, or it can use a fancier structure that trades off time for savings in space.

If a two-dimensional array is used, the algorithm will still require $O(m \times n)$ time just to initialise it. However, the main loop in the interweave function will be $O(m+n)$ for inputs for which there is little overlap or repetition in the input strings.

– davinci 11848

Programming exercise: red-white-blue sorting

davinci — Fri, 20 Nov 2009 20:52:38 +0000

I’ve been practising coding on the whiteboard for job interviews. This is very different than coding in front of a computer which has a keyboard, a monitor, and a nice editing program that allows you to correct your mistakes and type repetitive text very quickly. I’m trying to keep my programs simple and short, and writing in a C-like pseudocode.

This exercise comes from Skiena’s The Algorithm Design Manual^[1].

You are given an array $A$ of $n$ elements, each of which is one of red, white, or blue. The only permitted operations on $A$ are to examine an item at position $i$ using Examine(i), and to swap two items at positions $i$ and $j$ using Swap(i,j). The problem is to sort the elements as efficiently as possible, such that the elements are in the order red, followed by white, then finally blue.

The trick to coding on a whiteboard is to first draw some simple visual examples, and use them to talk your interviewer (or yourself) through how the algorithm is supposed to work, before writing down any actual code. It’s very important that you have the algorithm you want to code before you start coding, because any editing other than very minor changes is basically impossible on a whiteboard.

The first thing to notice is that we can do better than the standard $O(n\log n)$ sorting algorithms, since the number of different values for the elements is a small constant. My first thought was to make one pass of the array to count the number of red, white, and blue elements, one more pass to put all the red elements in front, and a final pass to put the white elements before the blue ones. While this algorithm is linear time, which is asymptotically the best you can do, with a little thought and a little bookkeeping, it’s possible to do everything in just one pass of the array.

The idea is as follows. Keep two “pointers”, say $r$ and $b$, which begin at the front and back respectively, and which keep track of the places where the next red and blue elements should go. Now sweep the array from front to back.

If the current position has a blue element, swap it to position $b$. Now, we decrement $b$, but we don’t advance the position of the sweep yet, because we might have just swapped in another blue element. This rule ensures that there are no blue elements behind us (i.e., towards the front of the array).

Dealing with a red element is a bit trickier, since both the $r$ pointer and the sweep’s position are advancing. If we’re at the same position as the $r$ pointer, there’s a contiguous block of red elements behind us, and we can simply increment $r$ and move on to the next position. If we’re ahead of the $r$ pointer, we can swap the red element to that position, and increment $r$. Note that we can only ever swap in a white element, since we’ve guaranteed that there are no blue elements behind us, and $r$ is always beyond the continguous block of known red elements at the front.

Finally, if the current position has a white element, we can just skip over it. If it’s in the wrong position, it’ll be dealt with later when we encounter the red element it needs to be swapped with.

The loop terminates when our sweep hits the contiguous block of blue elements at the back of $A$, i.e., when $pos > b$. For simplicity, we assume that $n \geq 1$ (which we can always check for before we begin).

This is the algorithm I came up with on the whiteboard:

int r, b, pos;
 
r = 0; b = n-1;
while(Examine(r) == 'R') { r++; }
while(Examine(b) == 'B') { b--; }
 
pos = r;
 
while( pos &lt;= b ) {
    char val = Examine(pos);
    if( val == 'B' ) {
        Swap(b, pos);
        b--;
    } else if( val == 'R' ) {
        if( r &lt; pos ) {
            Swap(r, pos);
        } else {
            pos++;
        }
        r++;
    } else if( val == 'W' ) {
        pos++;
    }
}

I’ve assumed that Examine(i) returns one of 'R', 'W', or 'B'. The $pos$ variable keeps track of the position as I sweep the array from front to back. The two initial loops skip over any red elements at the front and any blue elements at the back of the array (these are not strictly necessary, but make things a bit faster in some cases). Each element is examined exactly once, for a total run time of $n$, making this the most efficient algorithm possible.

– davinci 11847

Persian Soft Keyboard and Applications for Android

davinci — Mon, 16 Nov 2009 06:34:28 +0000

Update (July 25, 2010): Please read this before posting a comment, sending me an e-mail, or giving the software a rating on the Android Market. Also, note that the remarks below pertain to Android 2.2 and below, and may become obsolete in the future.

About the keyboard:

The app is a keyboard. Please do not say that “it doesn’t work” because “I see only squares”. A keyboard does not help you to render fonts or shape glyphs. This software is meant only for people who can already display Persian on their phones, but have no means of input. With that being said, I understand that many people who are looking for an input method for Persian are also looking for a way to display it. Just don’t confuse the two functionalities. (For information on how to display Persian, read on to the next section below.)
There is nothing sinister about the warning that the software may see sensitive information such as passwords and credit card numbers. It can see anything you type when it is the active keyboard — and so can every other soft keyboard. It does not do anything with this information except to use it to guess what you’re typing. If you don’t want your password or credit card number to be read by the app, just switch to the default Android keyboard when you need to type something secret. (Unless, of course, your password is actually in Persian.)
On most devices, you have to enable an input method after it’s installed by going into Settings, and to switch input methods you hold the trackball or long-tap with your finger in a text input field. These depend on the operating system, and are not things that I can change.

On installing a font and rooting your phone:

To display Persian on Android, it is not sufficient just to install a font. You also need to get the system to join the glyphs and to display them in right-to-left order.
To install a font, you will need to root your phone. Instructions can be found by using a search engine.
If you are unable to follow the instructions yourself, or cannot find someone who is physically present to take you through the steps, it is unlikely that anyone can help you online. It’s not a trivial task in most cases, and nobody wants to be responsible for accidentally bricking your phone. I will try to help, but please understand that your request is non-trivial. Furthermore, please see the remark above about it not being sufficient just to install a font. Even after a font is installed, there is still a lot of work to do to display Persian on Android. If you do not understand how to root a phone yourself, you will very likely not understand how to go through the rest of the process either.

About displaying Persian on your phone:

FarsiTel has just announced a Persianised version of Android. If you have a newer Android (2.1 and up) and want a completely Persian ROM, start your investigations there. Note that this solution includes a keyboard also (and it is a different one from mine).
You can also try Arabic Android for displaying Persian. Yes, it’s designed for Arabic, but it works for Persian also. You may have to pay to obtain right-to-left functionality. Look for the “Arabic Android” app in the market once you have the appropriate image from the site installed.
There is an app on the Android Market called “Persian Browser” that will enable font-shaping in the web browser only. If your browser displays Perso-Arabic glyphs but don’t join them or display them right-to-left, you can download this app to fix the problem.
To use these ROMs/apps, you may need to root your phone and/or install fonts. See the section above.
Disclaimer: I am not involved with these projects, and (to my knowledge) neither is my employer.

And, finally, I cannot make any comments about the state of official support for Persian on Android due to the terms of my employment. This is my personal web site, and is unaffiliated with my employer. Anything I write here about Persian support on Android reflects my personal opinion only.

The original post (from Nov. 16, 2009) follows.

I recently got a new smart phone — an Android-powered HTC Dream. As I wrote in a previous post, one of the first applications that I always look for is a multilingual dictionary, or at the very least a way to enter input in languages other than English.

It took me almost no time to write up a Persian Soft Keyboard, which I have put on the Android Market. (If you’re viewing this page on an Android device, you can download the application directly by clicking this link.)

Because Android is open source, it was remarkably easy to learn how to use the SDK. Unfortunately, despite this, there are a number of design decisions which make it difficult to enable Android devices for the Persian language (or many other languages). For one thing, it is impossible for the average user to install a new font, and the default fonts that ship with most Android phones don’t cover character sets outside of the Latin-based alphabets. For another, built-in support for complex text layout is very incomplete, and that includes the bidirectional text display and glyph-shaping which are essential for properly rendering Persian text.

I can understand the decision to leave these features out, since space is limited on most Android devices. However, this means that users who use languages other than English end up having to go to a lot of trouble to get these languages to work, such as downloading versions of applications capable of handling their specific language. It would have been much simpler if the base Android system had been packaged with a font that covered the Unicode characters for the most common languages in the world and applications that were aware of how to lay out their writing systems.

As things are, even with a Persian font installed, most applications still don’t display Persian text properly because of directionality and glyph-shaping problems. I’ve included an option for the Persian Soft Keyboard to output Unicode presentation forms, i.e., glyphs which are already shaped and joined. Even though this option does not comply with the Unicode standard, it allows readable Persian text to be entered into and sent through the default SMS application, for example. (Whether the recipient will be able to read the message at the other end is another issue.)

Currently, I’m bundling a simple note pad and a translator application with the Persian Soft Keyboard package. At the moment, the available note pad applications can’t handle right-to-left text, and the available translators don’t do glyph-shaping correctly. I hope that more Android software authors make their applications aware of languages other than English, because I don’t really want to support or maintain applications which are redundant.

– davinci 11843

The causes of my depression, part 17: my “frivolous” web site and how I learned Persian

Lists of programming exercises

davinci — Mon, 19 Oct 2009 03:34:52 +0000

I’ve collected a number of web sites with lists of programming exercises, which I’m going through for practice.

In no particular order, these are:

The following are language-specific:

And here are some books which may be relevant:

Since the exercises are judged, I probably won’t be posting solutions here. My accounts on Project Euler, Sphere Online Judge, and TopCoder are all “dlyongemallo”.

– davinci 11814

Programming exercises and comparison of programming languages

Programming exercise: permutations of a string

davinci — Thu, 08 Oct 2009 17:57:07 +0000

The problem is to implement a function that outputs all possible permutations of the characters in a string. Unlike combinations, two permutations are considered distinct if they contain the same characters, but in a different order. Also, for the purposes of this exercise, each occurrence of a repeated character is considered to be a distinct character. That is, if the input is “aaa”, the output should be six repetitions of “aaa”. The permutations may be output in any order.

This exercise, like the previous one on combinations of a string, is from the book Programming Interviews Exposed by John Mongan and Noah Suojanen^[1].

For a string of length $n$, there are $n! = n \times (n-1) \times (n-2) \times \cdots \times 1$ permutations. It’s fairly easy to see how these arise. A permutation may begin with any of the $n$ characters. Having fixed this first character, the second one may be chosen from the remaining $(n – 1)$ characters. And so on.

The recursive structure of the problem is then obvious. To compute the permutations of a string of $n$ characters, first cycle through the characters in the string. For each character, remove it from the string, compute the permutations of the remaining $(n – 1)$ characters, and then prepend the previously removed character to each of the resulting permutations. The base case is the empty string, whose only permutation is itself.

The problem stipulates that each occurrence of a repeated character is to be treated as a distinct character. Consider the input string “aba”. When dealing with the first “a”, the program should remove it, compute the permutations of “ba” (which are “ba” and “ab”), and then prepend “a” to those permutations (resulting in “aba” and “aab”). However, when dealing with the second occurrence of “a”, the program should remove that “a”, and compute the permutations of the remaining string, “ab”. This seems to cause some difficulty, as it will mean that our program has to distinguish between the removal of the first “a” and the removal of the second “a”. Note, however, that the permutations of “ab” are the same as the permutations of “ba” (though they might be output in a different order). A little thought shows that any time we need to remove a character, we can always just remove its first occurrence, since the permutations of the resulting characters will be the same regardless of which occurrence we remove.

To begin with, we need a function to remove the first occurrence of an item from a list. This is basically an exercise from “Scheme 101″:

(define (remove-once the-item the-list)
    (cond ((null? the-list) '())
          ((equal? the-item (car the-list)) (cdr the-list))
          (else (cons (car the-list) (remove-once the-item (cdr the-list))))
    )
)

The heart of our solution will be a function called permute. Given an empty set, it returns a set containing only the empty set. Otherwise, it calls itself recursively. The outline looks like this:

(define (permute the-list)
    (if (null? the-list) '(())
        (...)
    )
)

What goes into the (...) above? We can build this up from the inside out. We know that there is a recursive call to permute, but with the selected character removed (ignoring for the moment how we select this character):

(permute (remove-once the-selected the-list))

The selected character should be prepended to each of the resulting permutations:

(map (lambda (the-rest) (cons the-selected the-rest))
    (permute (remove-once the-selected the-list)))

Each of the characters should become the selected character in turn:

(map (lambda (the-selected) 
    (map (lambda (the-rest) (cons the-selected the-rest))
        (permute (remove-once the-selected the-list)))) 
                 the-list)

Running the above code on the input '(a b c d e) will result in something like '( (a-perms) (b-perms) (c-perms) (d-perms) (e-perms) ), where x-perms are permutations beginning with the letter x. This list of lists of permutations should be flattened by applying append. The rest of the program in Scheme is then:

(define (permute the-list)
    (if (null? the-list) '(())
        (apply append
            (map (lambda (the-selected) 
                         (map (lambda (the-rest) (cons the-selected the-rest))
                              (permute (remove-once the-selected the-list)))) 
                 the-list)
        )
    )
)
 
(define (permutations the-string)
    (map (lambda (s) (apply string s))
        (permute (string-&gt;list the-string)))
)
 
(define test-input "abcde")
(display (permutations test-input))

Because we need to output $n!$ permutations (note that the factorial grows faster than the exponential function), it’s probably a good idea in most cases not to keep the permutations in memory, but rather to print them out as they are generated.

The following Python program uses logic similar to the above Scheme program, but prints out each permutation right away. The only difference in the logic is that, because the Python program uses strings and indices into strings, it distinguishes between each occurrence of a repeated character:

def print_permutations(input_string):
 
    def print_permutations_helper(set_of_chars, output_string):
        if set_of_chars == "":
            print output_string,
        else:
            for index, char in enumerate(set_of_chars):
                print_permutations_helper(
                    set_of_chars[:index]+set_of_chars[index+1:], 
                    output_string + char)
 
    print_permutations_helper(input_string, "")
 
test_input = "abcde"
print_permutations(test_input)

One can manipulate sets, lists, or strings in C++ using STL classes, but it’s probably much faster to just use a boolean array to keep track of which letters have been “removed” from use. The following C++ program produces the same output as the above Python program:

#include<iostream>
#include<string.h>
using namespace std;
 
void print_permutations_helper(char *input, char *output, bool *used,
    int len, int depth)
{
    // At the current depth, cycle through all the letters.
    for( int i = 0; i &lt; len; i++ ) {
 
        // If the letter hasn't been used yet, use it.
        if( !used[i] ) {
            output[depth] = input[i];
 
            if( depth == len - 1 ) {
                cout &lt;&lt; output &lt;&lt; " ";
            } else {
                used[i] = true;
                print_permutations_helper(input, output, used, len, depth+1);
                used[i] = false;
            }
        }
    }
}
 
void print_permutations(char *input) 
{
    // Allocate a new character buffer to hold the output, and also
    // an array of flags for keeping track of which letters have
    // already been used.  (Assume that this always succeeds, or
    // that error handling is taken care of elsewhere.)
    int len = strlen(input);
    char *output = new char[len+1];
    output[len] = '\ 0';
    bool *used = new bool[len+1];
 
    // Initialise all the letters as unused.
    for( int i = 0; i &lt; len; i++ ) {
        used[i] = false;
    }
 
    // Recursively print the permutations. 
    print_permutations_helper(input, output, used, len, 0);
    cout &lt;&lt; endl;
 
    // Free the memory.    
    delete output;
    delete used;
}
 
int main()
{
    char test_input[] = "abcde";
    print_permutations(test_input);
}

As with the previous exercise on combinations of a string, this exercise also demonstrates how the typical approach to solving a problem will differ depending on whether Scheme or C++ (or some other language) is used. One can postulate a version of the Sapir-Whorf hypothesis for programming languages, that the language used to tackle a problem has an effect on the way in which it is solved.

– davinci 11804

Programming exercise: combinations of a string

davinci — Wed, 07 Oct 2009 18:13:27 +0000

The problem is to implement a function that outputs all possible combinations of the characters in a string (with length ranging from one to the length of the string). Unlike permutations, two combinations are considered to be the same if they contain the same characters, but in a different order. Another way to define the problem is to find the power set of the characters of the string (excluding the empty set).

Like the previous exercise, this one is also from the book Programming Interviews Exposed by John Mongan and Noah Suojanen^[1].

To begin with, let’s consider an example. What are the combinations of the string “abcde”? Since the ordering of the letters within the combinations don’t matter, let’s keep the letters in the same order as in the original string. Also, for now, let’s include the empty string as one of the combinations, for simplicity. Then it’s clear that there are $2^{5} = 32$ combinations, since each of the $5$ letters can be either included or excluded. (For an input string of length $n$, there will be $2^{n}$ combinations, including the empty string.)

The letter “a” will be included in half of the combinations, and excluded in the other half. (Of course, this is also true of each of the other letters.) In fact, those combinations that exclude “a” are just the combinations of the string “bcde”, and those that include “a” are exactly these same combinations, but prefixed with “a”. This gives an obvious recursive solution to the problem.

Expressed in Scheme, the program looks like this:

(define (power-set the-set)
    (if (null? the-set) '(())
        (let ( (power-set-of-subset (power-set (cdr the-set))) 
               (prepend-excluded (lambda (subset) (cons (car the-set) subset))) )
             (append
                power-set-of-subset
                (map prepend-excluded power-set-of-subset) 
             ) 
        )
    )
)
 
(define (combinations the-string)
    (map (lambda (s) (apply string s)) 
         (cdr (power-set (string-&gt;list the-string))) )
)
 
(define test-input "abcde")
(display (combinations test-input))

The combinations function just converts the input string to a list of letters, applies power-set to the list, and converts the result back into a list of strings. (The empty set is excluded by applying cdr, since it is the first item in the list returned by power-set by design.)

The power-set function is pretty straightforward. It computes the power set of the subset that excludes the first letter (with a recursive call), then returns a set consisting of the elements of this power set along with these elements prepended with the excluded letter. The base case is slightly tricky: the power set of the empty set is not the empty set, but a set containing only the empty set.

(Aside: I wish that the higher-order functions map and fold/reduce had better names — especially “map”, a word that is used for just too many things.)

The same program can be written in Python as follows:

def combinations(input_string):
 
    def combinations_helper(set_of_chars):
        if set_of_chars == "":
            return [""]
        else:
            combinations_of_subset = combinations_helper(set_of_chars[1:])
            combinations_of_subset.extend(
                map( lambda t: set_of_chars[0] + t, combinations_of_subset)
            )
        return combinations_of_subset
 
    return combinations_helper(input_string)[1:]
 
test_input = "abcde"
print combinations(test_input)

The Python program uses string manipulation operations (string slicing, concatenation) instead of treating the input as a list as the Scheme program does. The idea, however, is exactly the same.

There are probably more efficient ways to write these programs in these languages. In particular, the conversions between strings and lists (in Scheme) and the string manipulation operations (in Python) may be expensive.

What I like about the idea behind the above programs is that the result of the computation for the combinations excluding a character are re-used when computing the combinations including it. This saves on a lot of recursive calls.

The “obvious” solution to the same problem in C++ is the following:

#include<iostream>
#include<string.h>
using namespace std;
 
void print_combinations_helper(char *input, char *output, 
    int len, int depth, int start)
{
    // The variable depth holds the recursion depth, or, equivalently, 
    // the index into the output string of the character that's being
    // generated.  The variable start is the index of the first of
    // the still available letters.
 
    // At the current depth, cycle through the still available letters.
    for( int i = start; i &lt; len; i++ ) {
        output[depth] = input[i];
        print_combinations_helper(input, output, len, depth+1, i+1);
    }
    output[depth] = '\ 0';
    cout &lt;&lt; output &lt;&lt; endl;
}
 
void print_combinations(char *input) 
{
    // Allocate a new character buffer to hold the output.  (Assume 
    // that this always succeeds, or that error handling is being
    // taken care of elsewhere.)
    int len = strlen(input);
    char *output = new char[len+1];
 
    // Recursively print the combinations, starting with the first
    // character.
    print_combinations_helper(input, output, len, 0, 0);
 
    // Free the memory for the output buffer.
    delete output;
}
 
int main() 
{
    char test_input[] = "abcde";
    print_combinations(test_input);
}

The above program actually also prints out the empty string as one of the combinations, but this can be easily fixed by an if clause, or by relocating the cout statement (lines 18–19) inside the loop (at line 16, and substituting depth+1 for depth). The reason that I didn’t write the program that way is because then the combinations would have been output in a very different order compared to the above Scheme/Python programs. (The way it’s written now, the output is actually in exactly the reverse order, but that’s good enough for comparison purposes.)

While the recursive function is called only $n+1$ times in the Scheme/Python programs (once for each character and once more for the empty set), the C++ program makes a total of $2^{n}$ calls to the recursive helper function. On the other hand, while the Scheme/Python programs have to keep $2^{n}$ items in memory (each of which is $O(n)$ in size), the C++ program prints each combination as soon as it has been computed and thus uses only $O(n)$ memory.

Personally, I prefer the solution used in the Scheme program because I find it conceptually much more elegant. It would also be preferably if recursive function calls are expensive for some reason. However, the solution used in the C++ program is better if memory is limited, or if the combinations do not need to be retained in memory after they have been printed.

Of course, one can write the first program in C++ or the second one in Scheme, but the point is that the two solutions are, in some sense, the more “natural” ones for their respective languages.

– davinci 11803

Programming exercise: maximum value in integer array, part 1

davinci — Wed, 30 Sep 2009 06:32:20 +0000

This exercise is just a little bit more substantial than the last one — but not by very much. Given an array of $n$ non-negative integers, find the maximum value in the array, or return $-1$ if the array is empty. Obviously, the use of any built-in maximum-finding function is forbidden. While the problem is almost trivial, it does illustrate how each language works with array or vector data types, as well as how it handles iteration.

This exercise, like some of the other ones that I will also be going through, is from the book Programming Interviews Exposed by John Mongan and Noah Suojanen^[1].

For consistency, let’s assume that the array for which we’re trying to find the maximum value is $\{6, 3, 8, 7, 1, 2, 0, 9, 4, 5\}$. Let’s also assume for simplicity that $n$ is given, that we don’t have to check for errors (the input is a list of non-negative integers as promised), and that we can write $-1$ for the error return code. (In production code, we would of course define a named constant such as ARRAY_EMPTY_ERROR, or use some other form of error-handling such as exceptions.)

Let’s begin with C. The code is pretty straightforward, except that I had to remind myself to declare the loop counter $i$ outside of the loop. (Declaring it in the loop initialisation is not allowed in standards prior to C99.) It’s also a lot harder to code on paper than it is on a keyboard (my handwriting is terrible, due to atrophy). Here’s the program in C:

#include<stdio.h>
 
int arraymax(int array[], int n) {
    int currentMax;
    int i;
 
    if( n&lt;= 0) { return -1; }
 
    currentMax = array[0];
    for( i = 1; i &lt; n; i++ ) {
        if( array[i] &gt; currentMax ) {
            currentMax = array[i];
        }
    }
 
    return currentMax;
}
 
int main(int argc, char *argv[])
{
    int testinput[] = { 6, 3, 8, 7, 1, 2, 0, 9, 4, 5 };
    printf("max = %d\n", arraymax(testinput, 10));
}

I could, of course, have written the exact same program in C++, but to make things interesting, I’m going to use the STL vector class:

#include<iostream>
#include<vector>
 
using namespace std;
 
int vectormax(vector&lt;int&gt; vec)
{
    int currentMax;
 
    if( vec.empty() ) {
        return -1;
    }
 
    currentMax = vec[0];
    for( int i = 1; i &lt; vec.size(); i++ ) {
        if( vec[i] &gt; currentMax ) {
            currentMax = vec[i];
        }
    }
 
    return currentMax;
}
 
int main()
{
    int values[] = { 6, 3, 8, 7, 1, 2, 0, 9, 4, 5 };
    vector&lt;int&gt; testinput(values, values+10);
    cout &lt;&lt; "max = " &lt;&lt; vectormax(testinput) &lt;&lt; endl;
}

The only tricky part was I had to look up how to initialise a vector without looping through the values and using push_back. The code above calls the iteration constructor, using the trick that an int array in C++ is just a pointer to its first element, and the fact that pointers are iterators.

Apparently, in the proposed c++0x standard, it will be possible to initialise a vector using a static array like this:

26
27

    // Use the initialiser list constructor.
    vector&lt;int&gt; testinput = { 6, 3, 8, 7, 1, 2, 0, 9, 4, 5 };

In the program above, I’ve used indices as if the vector were just a regular array. The preferred way to access vector elements in C++ is to use iterators. This means replacing lines 14–15 with the following:

    vector&lt;int&gt;::iterator vi = vec.begin();
    for( currentMax = *vi++; vi != vec.end(); vi++ ) {
        if( *vi &gt; currentMax ) {
            currentMax = *vi;
        }
    }

I had to think a little bit about the loop initialisation condition, currentMax = *vi++. The iterator is dereferenced before it is incremented, which is the desired behaviour.

There are a number of differences between the C# and C/C++ programs. First, there’s the foreach statement, which makes for nicer-looking loops. Then there’s the fact that the array type specifier [] must appear before the variable name, rather than after. Here’s the code:

using System;
 
public class ArrayMax {
    public static int arraymax(int[] array)
    {
        if( array.Length == 0 ) {
            return -1;
        }
 
        int currentMax = array[0];
        foreach( int value in array ) {
            if( value &gt; currentMax ) {
                currentMax = value;
            }
        }
 
        return currentMax;
    }
 
    public static void Main() {
        int[] testinput = { 6, 3, 8, 7, 1, 2, 0, 9, 4, 5 };
        Console.WriteLine("max = {0}\n", arraymax(testinput));
    }
}

I had to remember to make the arraymax function static so that it can be called without instantiating the ArrayMax class.

The Java code is essentially identical to the C# code, mutatis mutandis:

public class ArrayMax {
    public static int arraymax( int[] array ) 
    { 
        if( array.length == 0 ) {
            return -1;
        }
 
        int currentMax = array[0];
        for( int i = 1; i &lt; array.length; i++ ) {
            if( array[i] &gt; currentMax ) {
                currentMax = array[i];
            }
        }
 
        return currentMax;
    }
 
    public static void main( String args[]) {
        int testinput[] = { 6, 3, 8, 7, 1, 2, 0, 9, 4, 5 };
        System.out.println("max = " + arraymax(testinput) + "\n");
    }
}

Beginning in J2SE v1.5/5.0^[2], Java introduced a “for each” loop, and so lines 9–13 above should be replaced with this:

        for( int value : array ) {
            if( value &gt; currentMax ) {
                currentMax = value;
            }
        }

Now that we’ve gotten the standard general-purpose imperative and object-oriented (i.e., “C-like”) languages out of the way, it’s time for some fun(ctional programming).

Of course, Lisp and Scheme already have a max function defined to get the maximum value in a list of integers, but as mentioned before, its use is forbidden to us. Nevertheless, the solution to the given problem in these languages is still very simple. How can we express the function that returns the maximum value of a list of integers? One way to do it is to express it as the folding (or reducing) of the list with a function that compares two integer values and returns the larger one. Expressed in Lisp, this function is:

1	(defun larger (x y) (if (> x y) x y))

The rest of the Lisp program easily follows:

(defun list-max (intlist) 
    (if (null intlist) -1
          (reduce #'larger intlist)
     ))
 
(setq intlist '( 6 3 8 7 1 2 0 9 4 5 ))
(format t "max = ~D" (list-max intlist))

(Incidentally, it’s because of things like #', which is called the sharp-quote, that some people don’t like Lisp.)

The Scheme program is essentially identical:

(define (listmax intlist) 
    (if (null? intlist) -1
          (let ( (larger (lambda (x y) (if (&gt; x y) x y)) ) )
            (fold larger (car intlist) (cdr intlist)))
    )
)
 
(define intlist '( 6 3 8 7 1 2 0 9 4 5 ))
(display "max = ")
(display (listmax intlist))

The Python code is also very similar:

def listmax(intlist):
    if intlist == []:
        return -1
    else: 
        return reduce( lambda x, y : x if x &gt; y else y, intlist)
 
testinput = [ 6, 3, 8, 7, 1, 2, 0, 9, 4, 5 ]
print "max =", listmax(testinput)

I really like the Python code. It combines the simplicity of the fold idea used in Lisp/Scheme with the clarity of an ALGOL-like syntax.

I should mention that another way of expressing the function that returns the maximum value in a list of integers is as a recursive function that returns the only element in a list of size one, and returns the larger of the first element and the result of the function applied to the rest of the list for a list of size two or more. However, unless the program is written using tail recursion, and one is using a compiler that optimises tail-recursive calls, the stack will grow with the size of the list, so this solution is not as good as the one using fold/reduce.

I was originally also going to write the program in the remaining languages listed in the previous post, but I’ve spent far too much time already on this exercise, and I’d like to move on to some more difficult ones. And besides, the program in the other functional languages will be very similar except for syntax, and there’s almost no point in coding a “maximum integer value in an array” function in the mathematical languages, since an optimised version of such a function is already built into them. I may return to this exercise later with additional languages, so I’ll append “part 1″ to the title of this post.

– davinci 11796

Programming exercise: Hello, world!

davinci — Sun, 27 Sep 2009 16:22:50 +0000

As a preliminary exercise to jog my memory, here is the obligatory “Hello, world!” program in a variety of languages. On the one hand, the programs do nothing except output a string, and so don’t illustrate very much about the respective languages. On the other hand, the simplicity of the task does illustrate the difference between languages that allow you to begin coding right away versus those that require a considerable amount of setting up (importing libraries, declaring classes, etc.) before you even have a functioning program.

To be consistent, the programs will all output “Hello, world!”, followed by the newline character.

First up, of course, is C:

#include<stdio.h>
int main(int argc, char *argv[]) {
    printf("Hello, world!\n");
}

C++ is similar, except that iostream is used instead of stdio:

#include<iostream>
using namespace std;
int main() {
    cout &lt;&lt; "Hello, world!" &lt;&lt; endl;
}

Java requires that a class be defined:

class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, world!\n");
    }
}

C# looks like a mixture of C and Java:

using System;
public class HelloWorld {
    public static void Main() {
        Console.WriteLine("Hello, world!\n");
    }
}

In an interview situation, I doubt that I would use C# or Java, unless explicitly asked. It wastes too much time to set up the classes. Also, when writing code on a whiteboard or on paper, the shallower your indentation level, the better, because you don’t want to use up space unnecessarily, and you’ll have to move things around when you’re asked to add to or modify the code.

In Perl, this program is just one line:

1	print "Hello, world!\n";

The program is almost the same in Python:

1	print "Hello, world!\n"

The only difference is that the statement in Python does not need to end in a semicolon (although it is legal, it is superfluous). In Python 3 and above, print is a function:

1	print("Hello, world!\n")

In Ruby:

1	puts "Hello, world!\n"

In Common Lisp:

1	(format t "Hello, world!~%")

I’ll probably not be able to remember the format operators on the spot (e.g., “~%” instead of the much more common “\n” for “newline”).

In Scheme:

1 2	(display "Hello, world!") (newline)

In Prolog:

1	write('Hello, world!'), nl.

In Haskell:

1	putStrLn("Hello, world!")

Note that putStrLn already appends a newline character.

In Standard ML:

1	print("Hello, world!\n");

In the Linux shell (e.g., bash):

1	echo 'Hello, world!'

The echo command outputs a trailing newline.

And now, for some mathematical languages. In Matlab:

1	fprintf("Hello, world!\n");

In Octave (the above Matlab program will also work):

1	printf("Hello, world!\n");

In Maple:

1	print(`Hello, world!\n`);

In Mathematica:

1	Print["Hello, world!\n"]

I suppose that, in the mathematical languages, rather than print “Hello, world!” to the display, a true “Hello, world!” program would assign that value to a string, and then evaluate the string (to itself).

In an interview situation, I’ll probably use C/C++, because that’s the general-purpose programming language that I have the most experience with. However, I think that Python is actually a better language for quickly mocking up working programs on the spot, so I’m going to practise using Python some more.

– davinci 11793

Programming exercises and comparison of programming languages

davinci — Sat, 26 Sep 2009 18:15:14 +0000

I started programming when I was eight years old. The first programming language I learned was Basic, followed very shortly by C and 8086 assembly language. During elementary school, I was also exposed to Pascal and Logo. I ignored Pascal because it seemed to me that anything I could do in it I could already do with C, and although I had some fun with Logo’s turtle graphics, I didn’t take it very seriously. At the time, I didn’t appreciate its connection with Lisp and other “serious” programming languages.

The computer science courses in my high school were taught through Turing, a situation which nobody liked. Some of my classmates already knew how to program, mostly in Basic or Pascal. Knowledge of C was considered somewhat elite. I bought cheap (student or home) editions of both Microsoft and Borland development tools. I made some money doing miscellaneous jobs, mostly using C++, which was my favourite language during those years and for the first several years of university. Some of these jobs involved updating legacy code written in Fortran, which I had to learn to read. I also had some small exposure to Lisp through AutoCAD, but not very much. I did, on the other hand, write a lot of Visual Basic and Visual Basic for Applications (VBA) code for Microsoft Office.

I learned a lot of web programming in my first year of undergraduate studies, because it was a hot topic at the time, and also because the university provided free web space. This meant HTML, Java, JavaScript, VBScript, and Perl (because of the many CGI programs written in that language). A little bit later I also learned PHP, which was relatively new at the time. In school, I also learned hardware description languages such as SPICE and VHDL. Because the university’s systems were run on Unix (and, later, GNU/Linux), I also learned shell scripting. (Of course, I already knew how to write batch files for DOS/Windows, but that hardly counts as a programming language.)

In the third year of university, I was finally properly introduced to Scheme and Lisp. Unfortunately, I was in an environment that wasn’t very supportive of the study of those languages. My fellow engineering classmates were used to C/C++ or Java (or more generally, imperative programming), and many mocked the (to them) bizarre syntax of Scheme and the λ-calculus. However, I appreciated that there were things I could easily do in Scheme or Lisp that would be difficult — or even impossible — to do in C/C++ and Java. I thought that it was unfortunate that no one had explained the rationale behind Lisp to me earlier, even though I had already been exposed to Lisp on multiple occasions before then. I think that Lisp is a better introductory language for teaching computer programming than C, because it seems to me that Lisp programmers can easily learn C, whereas people who have gotten used to C have a difficult time learning Lisp.

Because I was in an engineering program, during my upper undergraduate years I wrote a lot of programs in Matlab, in addition to programming in C/C++. This continued throughout my first postgraduate degree, which was in electrical engineering, at the University of Toronto.

When I came to the University of Waterloo for a second postgraduate degree, this time in computer science, I joined the Programming Languages Lab. I was also a teaching assistant for several programming courses, including CS442/642, the university’s upper year/graduate-level Principles of Programming Languages course. Needless to say, I learned many, many programming languages during this period, in a large variety of programming paradigms.

For my quantum computing research for the past several years, I have been using mostly Maple and Mathematica, in addition to Matlab. Because of this, I may have gotten rusty with my programming skills in the more general-purpose (i.e., non-mathematical) languages. Because I’m interviewing for software engineering jobs, I need to brush up on these skills.

I’ve collected some programming exercises from various places, and in this series of posts, I’m going to do these exercises in a variety of languages, for practice. I’ll also comment on the suitability of the various languages to different tasks and compare them with one another.

– davinci 11792