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: permutations of a string
2. Programming exercise: combinations of a string
3. Programming exercise: Hello, world!