Albert Kwok-Wai Yeung 「楊國偉」 and Agnes Yuk-Lan Yu 「余玉蘭」 are child abusers. I just wanted to post this fact on the Internet so that it can be recorded for posterity.

The nature of child abuse is such that it rarely occurs in public. The recipients of the abuse are left to deal with its effects while the perpetrators typically face no ill consequences.

Actually, child abuse harms many more people than just the immediate recipients of the abuse. The fact that Albert Kwok-Wai Yeung had been beating and threatening me since I was a child for studying the topics which would form the background of my intended Ph.D. did not merely cause me to drop out of the Ph.D. program. It also wasted the efforts of everyone — teachers, professors, fellow graduate students, and colleagues — who helped me, who worked with me or wanted to work with me, or who otherwise poured their energies and resources into advancing science and attracting young people into their fields. I could not attend certain scientific conferences because Albert Kwok-Wai Yeung had forbid me from or threatened me for doing so, and at many scientific meetings I could not contribute to the best of my abilities because of the need to hide my activities from him. His actions meant that I could return very little to the scientific community for the resources that I consumed, which made me feel very guilty about being in my field, which in turn made it impossible for me to continue with my studies.

As another example, I’ve already written previously about how Agnes Yuk-Lan Yu would not stop criticising me, after I won a TA award, for not withholding information from my students — in other words, for not doing my job poorly. Presumably, the university rewards graduate students who make an effort at teaching (even if the reward is only a little bit of recognition) to encourage the development of good lecturers. Because of Agnes Yuk-Lan Yu’s behaviour, I stopped being a teaching assistant and never applied to lecture any courses. Again, this wasted the efforts of many people at the university and harmed many people besides myself.

There is nothing that I can do to turn back the clock and undo the damage that Albert Kwok-Wai Yeung and Agnes Yuk-Lan Yu have done not just to my own scientific career, but to the broader scientific community — damage which they perpetrated through me. But I want their names to be remembered in history for the child abusers and enemies of science that they are, so that people can learn through my mistakes how better to deal with others like them in the future.

– davinci 11954

Related posts:

1. Thirteen Abusive Behaviours

The Physics of Star Trek by Lawrence M. Krauss is geared more towards Star Trek fans than towards physicists. I remember thinking that it needed some equations, although I’m probably not the typical reader of this book. It has just the right depth to satisfy fans of the series, but not enough detail for anyone who is actually really interested in the (pseudo-)science behind the series’ plot devices. The take-home message of the book is that traveling to another galaxy is very, very impossible — at least according to our currently known laws of physics.

– davinci 11864

Related posts:

1. Theoretical Physics by Joos and Freeman
2. Perimeter Scholars International — Master’s program in Theoretical Physics

Reposted from my Facebook:

This is a poster for a Christmas Party hosted by Campus for Christ which is found all over UW campus. The problem with it is that the Arabic writing at the top is wrong. As anyone with even a rudimentary knowledge of the Arabic script knows, the letters should be joined, and they change their shape according to position. Clearly, someone had typed the word “Christmas” into a translation program on a computer not equipped to handle Arabic glyph-shaping, and put it on the poster without actually bothering to check it with anyone who can actually read Arabic.

Lesson: If you’re going to plaster something all over campus in a foreign language, do yourself the favour of getting someone who actually knows the language to translate it for you so you don’t massively embarrass yourself. I’m sure there’s at least one Christian who knows Arabic on UW campus. Seriously.

In today’s world, it’s very important for computer software to be able to support multiple languages. You can’t assume that, just because your software is sold in a predominantly English-language market, your users won’t try to use it with other languages.

In a previous post, I noted the current lack of support for glyph-shaping and other aspects of complex text layout on the Android phone. I hope that this changes in the near future (and, if I have any say about it, it will).

– davinci 11859

Related posts:

1. Persian Soft Keyboard and Applications for Android

Canada’s Perimeter Institute for Theoretical Physics (PI), in partnership with the University of Waterloo, welcomes applications to the Masters level course, Perimeter Scholars International (PSI). Exceptional students with an undergraduate honours degree in Physics, Math, Engineering or Computer Science are encouraged to apply. Students require a minimum of 3 upper level undergraduate or graduate courses in physics. PSI recruits a diverse group of students and especially encourages applications from qualified women candidates. The due date for applications to PSI is February 1st, 2010. Complete details are available at www.perimeterscholars.org.

There’s also a downloadable poster with more information at this link.

– davinci 11855

Related posts:

1. Theoretical Physics by Joos and Freeman
2. The Physics of Star Trek by Lawrence M. Krauss
3. Gifted program in Mississauga

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!

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

Related posts:

1. Glyph-shaping poster fail
2. Mock-up of a Yudit-like mobile application
3. The causes of my depression, part 17: my “frivolous” web site and how I learned Persian

In no particular order, these are:

• Project Euler (a spin-off of MathsChallenge.net)
• Sphere Online Judge
• TopCoder
• Code Kata
• The ACM International Collegiate Programming Contest — Past Problems
• Valladolid Online Judge

The following are language-specific:

• C/C++ Programming Challenge Problems
• About.com C/C++/C# Programming Challenges
• Python Challenge
• Ruby Quiz

And here are some books which may be relevant:

• Programming Interviews Exposed, by John Mongan, Noah Suojanen, and Eric Giguère
• Programming Pearls, by Jon Bentley
• Puzzles for Programmers and Pros, by Dennis Shasha
• Programming Challenges, by Steven S. Skiena
• The Algorithm Design Manual, by Steven S. Skiena

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

Related posts:

1. Programming exercises and comparison of programming languages

In some words, only one part of the original has survived: the ní in 尼姑 ní​gū​ “Buddhist nun” is the last syllable of the Sanskrit bhikkini (sic)…

The Sanskrit word, of course, is भिक्षुणी bhikṣuṇī. Its Chinese transliteration is 比丘尼 bǐ​qiū​ní​. The author seems to have been thinking of bhikkhunī, which is the equivalent word in Pali and other Prakrits, and swimwear.

– davinci 11811

No related posts.

This textbook was a gift from Dr. John Percy, professor of astronomy at the University of Toronto. I did some research on Be stars with Dr. Percy while I was in high school, and I had expressed to him my interest in studying astronomy and astrophysics in university.

Because it is an introductory textbook, it’s very glossy and elementary. I regret not having become more familiar with the materials in it, because it would have given me more things to discuss with my former colleagues who work at the Perimeter Institute, while I was there.

This textbook is apparently still in use. The latest edition appears to be the 11th edition. I have the 4th edition, so I’m seven editions out of date.

– davinci 11805

No related posts.