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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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 < m+1; row++ ) {
        for( int col = 0; col < 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:

1
2
3
4
5
6
7
8
9
10

bool **new_table(int rows, int cols) {
    bool **table = new bool*[rows];
    for( int i = 0; i < rows; i++ ) {
        table[i] = new bool[cols];
        for( int j = 0; j < 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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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(&row, &col);
 
        if( ( row == m ) && ( col == n ) ) {
            result = true;
            break;
        }
 
        if( ( row != m ) && ( s[row] == u[row+col] ) && !q.marked(row+1,col) ) {
            q.enqueue(row+1,col);
        }
        if( ( col != n ) && (t[col] == u[row+col] ) && !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

Related posts:

1. Programming exercise: permutations of a string
2. Programming exercise: combinations of a string
3. Programming exercise: red-white-blue sorting

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

int r, b, pos;
 
r = 0; b = n-1;
while(Examine(r) == 'R') { r++; }
while(Examine(b) == 'B') { b--; }
 
pos = r;
 
while( pos <= b ) {
    char val = Examine(pos);
    if( val == 'B' ) {
        Swap(b, pos);
        b--;
    } else if( val == 'R' ) {
        if( r < 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

Related posts:

1. Programming exercise: interweaved strings
2. Programming exercise: maximum value in integer array, part 1
3. Programming exercise: Hello, world!

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″:

1
2
3
4
5
6

(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:

8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

(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->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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

#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 < len; i++ ) {
 
        // If the letter hasn't been used yet, use it.
        if( !used[i] ) {
            output[depth] = input[i];
 
            if( depth == len - 1 ) {
                cout << output << " ";
            } 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 < len; i++ ) {
        used[i] = false;
    }
 
    // Recursively print the permutations. 
    print_permutations_helper(input, output, used, len, 0);
    cout << 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

Related posts:

1. Programming exercise: combinations of a string
2. Programming exercise: Hello, world!
3. Programming exercise: maximum value in integer array, part 1

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

(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->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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#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 < len; i++ ) {
        output[depth] = input[i];
        print_combinations_helper(input, output, len, depth+1, i+1);
    }
    output[depth] = '\ 0';
    cout << output << 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

Related posts:

1. Programming exercise: permutations of a string
2. Programming exercise: Hello, world!
3. Programming exercise: maximum value in integer array, part 1

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include<stdio.h>
 
int arraymax(int array[], int n) {
    int currentMax;
    int i;
 
    if( n<= 0) { return -1; }
 
    currentMax = array[0];
    for( i = 1; i < n; i++ ) {
        if( array[i] > 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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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

14
15
16
17
18
19

    vector<int>::iterator vi = vec.begin();
    for( currentMax = *vi++; vi != vec.end(); vi++ ) {
        if( *vi > 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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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 > 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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class ArrayMax {
    public static int arraymax( int[] array ) 
    { 
        if( array.length == 0 ) {
            return -1;
        }
 
        int currentMax = array[0];
        for( int i = 1; i < array.length; i++ ) {
            if( array[i] > 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:

9
10
11
12
13

        for( int value : array ) {
            if( value > 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:

2
3
4
5
6
7
8

(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:

1
2
3
4
5
6
7
8
9
10

(define (listmax intlist) 
    (if (null? intlist) -1
          (let ( (larger (lambda (x y) (if (> 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:

1
2
3
4
5
6
7
8

def listmax(intlist):
    if intlist == []:
        return -1
    else: 
        return reduce( lambda x, y : x if x > 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

Related posts:

1. Programming exercise: Hello, world!
2. Programming exercise: permutations of a string
3. Programming exercise: combinations of a string

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

First up, of course, is C:

1
2
3
4

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

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

1
2
3
4
5

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

Java requires that a class be defined:

1
2
3
4
5

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

C# looks like a mixture of C and Java:

1
2
3
4
5
6

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

Related posts:

1. Programming exercise: maximum value in integer array, part 1
2. Programming exercise: combinations of a string
3. Programming exercise: permutations of a string

I recently threw out several boxes of old computer programming software and books, because they were obsolete, and I didn’t know anyone who wanted them. For nostalgia’s sake, I took photos of the stuff I threw out. It’s such a pity that commercial software and the associated books become outdated so quickly.

I’m reposting the photos here since they do belong, in a way, in this series of posts on the books that I’ve owned throughout my life.

From left to right, the following pictures show:

1. the books that came with Borland C++ v5;
2. the books that came with Borland C++Builder v1 and v3;
3. some books on C, Prolog, and InterBase;
4. two books on C++Builder;
5. more books on Borland C++, and a few other topics.

I don’t have very much to say about the books that came with the Borland products, other than that I never used them very much, since pretty much the same content was also available through the Windows help system. I have to wonder if anyone ever referred to their paper copies of these volumes, or if these were included merely to justify the prices. On the other hand, the OWL reference posters were both useful and aesthetically pleasing.

As for the other books, they served their purpose. I learned what I needed to from them at the time, but now they’re obsolete and are basically completely useless (except maybe to hobbyists who build or refurbish old computers for fun).

The following three pictures aren’t of books, but are related to the above:

1. the box that Borland C++ v4 came in — unfortunately, I did not take a picture of the books inside, but it was full of them;
2. I did, however, take a picture of the 22 floppy disks;
3. Adobe Acrobat v4.

– davinci 11770

Related posts:

1. Programming exercises and comparison of programming languages
2. A life in books
3. Object Oriented Turing

I often end up using a program called Yudit, a Unicode editor written by Gáspár Sinai, even on a system that has native integrated support for multiple input methods, because it’s available on a wide range of systems and I’m familiar with the input methods bundled with it. For example, even though the same input method is supposedly available on both Microsoft Windows and through SCIM, there may be slight differences in the keyboard layouts that can result in typos if one is not careful.

It seems that the majority of wireless handheld devices ship with only one input method. Yudit does not appear to run on any of the major mobile operating systems, but it would be overkill anyway, since people aren’t likely to want to edit entire Unicode documents on their cell phones. On the other hand, it would be useful to be able to switch input methods, even if only to type a few words into an e-mail, or to look something up in an online dictionary.

In adapting input methods designed for personal computers to cellphones, one immediately runs into the problem that what would have been a single keystroke on a full-sized keyboard becomes a key combination or a series of taps on a keypad. With the predictive text systems used on some cellphones, one also runs into the problem of textonyms.

I wanted to see if I could port some of Yudit’s input methods to a mobile environment, so I ignored these problems for the moment and assumed, for the sake of simplicity, that the device had a full-sized keyboard. I also decided to write a Java MIDlet, because these can be run on a number of different mobile platforms. (Yudit itself is written in C++.)

Even this simplified version of the problem turned out not to be so easy. I tried using the TextField and TextBox classes in the javax.microedition.lcdui package, and while I was able to capture the user’s input and replace it with the appropriate Unicode, neither class handled bidirectional text very well.

I tried mixing the Chinese-CJ (Cangjie), Devanagari, and Farsi input methods (used for entering Chinese, Hindi, and Persian text, respectively), and the result was that my little program became very confused. On some emulated devices, the left and right arrow keys would move the cursor left and right, respectively, while within the Persian text; but on others, the effects of these keys were reversed, as were the effects of the backspace and delete keys.

It would probably take a lot more work to get any of these input methods working properly, but this was only a first attempt, which I wanted to document in case anyone else wanted to try something similar. Also, it’s possible that I would have been more successful if I had used UI libraries specific to a company or manufacturer, such as RIM’s net.rim.device.api.ui package, rather than the generic (and hence not as powerful) javax.microedition.lcdui package.

I’ve included several screenshots of what my little experiment looks like when run on Sun’s Java ME SDK mobile emulator with a generic device, as well as on RIM’s BlackBerry emulator with two different devices. The Devanagari did not render at all on the emulated BlackBerry devices. There were also some small layout problems, which I didn’t fix since this was only supposed to be a quick experiment.

Screenshots of experiment on Sun’s generic emulated mobile phone:

Screenshots of experiment on RIM’s emulated BlackBerry Curve 8300:

Screenshots of experiment on RIM’s emulated BlackBerry Tour 9630:

Considering the size of the mobile device markets in China, India, and the Middle East, getting different input methods to work in a mobile environment is an important (and potentially financially rewarding) problem to tackle.

– davinci

Related posts:

1. Persian Soft Keyboard and Applications for Android