为什么不以12月31日作为一年的开始？（如果别扭的话，可以把1月1日移到现在的12月31日）
或者为什么不以6月1日作为一年的开始？（如果别扭的话，可以把1月1日移到现在的6月1日）
或者为什么不以2月29日作为一年的开始？（如果别扭的话，可以把1月1日移到现在的2月29日）

如果以上的问题不能得以解答的话，那么元旦有什么意义呢？
干脆改名Resolution-Making Day算了。

如果说有人在上中这样的高中里语文、英语、物理、地理等这些大大小小的科目的作业几乎不做，这并不算太奇怪。
如果说有人在上中这样的高中里几乎不开夜车（除了写机器人报告），这并不算太奇怪。
如果说有人在上中这样的高中里几乎天天打三顿篮球（中午、下午、晚上），这并不算太奇怪。
。。。。。。
如果说有人在大学这样的环境里从不无故（或因飞雄的那些理由）缺课（排除瞒着这个人而上的课），这也不算太奇怪。
如果说有人在大学这样的环境里几乎都按时交作业，这也不算太奇怪。
如果说有人在大学这样的环境里把绝大多数的课余时间用来泡自修教室，这也不算太奇怪。
。。。。。。
但如果有人集以上诸条于一身。。。
还是有那么一点点的奇怪的。

这是我的生活吗？
太奇怪了。奇怪地就像办公室黑板上的“小鲍勃到此一游！！！”（因为没人会觉得这是小鲍勃写的）

这个冗长星期，我仿佛只有一天是1：30以前睡的，不为别的，只是在做作业。为什么会是这样呢？以下是我分析的原因：
学了数分！
不是因为做数分做到那么晚，而是因为学了数分以后，我就深深地爱上了五分钟之内就能想出做法的题目，导致我面对高等代数和工程图学等作业时欲罢不能，做了一道题还想再来一道，于是一不小心就到凌晨两点了。

而数分则要放在白天平心静气地做，典型的情况是：
一天中午，我花了两个小时，好不容易证出来 1 道题目，我的心情久久不能平静，高兴了良久。到了第二天中午，我又花了两个小时，结果做出来 -1 道题目（原来第二天中午我正准备往后做题的时候，忽然想重温一下上一道题目做出来时的喜悦，就看了一遍我的证法，不幸的是，我发现我做错了！）

一个月没打篮球：这是我的生活吗？
太奇怪了。奇怪地就像我这个奇怪的人：
为了不做作业和老师论战三百回合；
打篮球到熄灯后一小时之后和宿管据理力争以致宿管连检讨都不好意思问我讨；
从不说半个脏字；
没做作业不会说忘在寝室；
没车不会乱穿马路；
。。。。。。

坐在车站里等车，斜阳照在我脸上，我感觉自己处在存在与虚无之间，在一个异次元空间里，什么都不想，车水马龙与我无关，也没有积压的数分作业。

真是一种享受！

想起了这篇文章：

　　寂寞是一种清福。我在小小的书斋里，焚起一炉香，袅袅的一缕烟线笔直地上升，一直戳到顶棚，好像屋里的空气是绝对的静止，我的呼吸都没有搅动出一点波澜似的。我独自暗暗地望着那条烟线发怔。屋外庭院中的紫丁香还带着不少嫣红焦黄的叶子，枯叶乱枝的声响可以很清晰地听到，先是一小声清脆的折断声，然后是撞击着枝干的磕碰声，最后是落到空阶上的拍打声。这时节，我感到了寂寞。在这寂寞中我意识到了我自己的存在－－片刻的孤立的存在。这种境界并不太易得，与环境有关，更与心境有关。寂寞不一定要到深山大泽里去寻求，只要内心清净，随便在市廛里，陋巷里，都可以感觉到一种空灵悠逸的境界，所谓“心远地自偏”是也。在这种境界中，我们可以在想象中翱翔，跳出尘世的渣滓，与古人同游。所以我说，寂寞是一种清福。

　　在礼拜堂里我也有过同样的经验。在伟大庄严的教堂里，从彩色玻璃窗透进一股不很明亮的光线，沉重的琴声好像是把人的心都洗淘了一番似的，我感到了我自己的渺小。这渺小的感觉便是我意识到我自己存在的明证。因为平常连这一点点渺小之感都不会有的！

　　我的朋友肖丽先生卜居在广济寺里，据他告诉我，在最近一个夜晚，月光皎洁，天空如洗，他独自踱出僧房，立在大雄宝殿的石阶上，翘首四望，月色是那样的晶明，蓊郁的树是那样的静止，寺院是那样的肃穆，他忽然顿有所悟，悟到永恒，悟到自我的渺小，悟到四大皆空的境界。我相信一个人常有这样的经验，他的胸襟自然豁达寥廓。

　　但是寂寞的清福是不容易长久享受的。它只是一瞬间的存在。世界有太多的东西不时的提醒我们，提醒我们一件煞风景的事实：我们的两只脚是踏在地上的呀！一只苍蝇撞在玻璃窗上挣扎不出去，一声“老爷太太可怜可怜我这个瞎子吧”，都可以使我们从寂寞中间一头栽出去，栽到苦恼烦躁的漩涡里去。至于“催租吏”一类的东西打上门来，或是“石壕吏”之类的东西半夜捉人，其足以使人败兴生气，就更不待言了。这还是外界的感触，如果自己的内心先六根不净，随时都意马心猿，则虽处在最寂寞的境地里，他也是慌成一片，忙成一团，六神无主，暴跳如雷，他永远不得享受寂寞的清福。

　　如此说来，所谓寂寞不即是一种唯心论，一种逃避现实的现象吗？也可以说是。一个高韬隐遁的人，在从前的社会里还可以存在，而且还颇受人敬重，在现在的社会里是绝对的不可能。现在似乎只有两种类型的人了，一是在现实的泥溷中打转的人，一是偶然也从泥溷中昂起头来喘口气的人。寂寞便是供人喘息的几口新空气。喘几口气之后还得耐心地低头钻进泥溷里去。所以我对于能够昂首物外的举动并不愿再多苛责。逃避现实，如果现实真能逃避，吾寤寐以求之！

　　有过静坐经验的人该知道，最初努力把握着自己的心，叫它什么也不想，而是多么困难的事！那是强迫自己入于寂寞的手段，所谓参禅入定完全属于此类。我所赞美的寂寞，稍异于是。我所谓的寂寞，是随缘偶得，无需强求，一刹间的妙悟也不嫌短，失掉了也不必怅惘。但是我有一刻寂寞，我要好好地享受它。

如果没有你，我将在数分的无底深渊里坠落。

做了一个一百多行的很奇怪的环形链表数据结构，结果发现原来解了一道上中数学小测验里的填空题：

# include <iostream.h>
# include <stdlib.h>

struct node{
    int info;
    struct node *next;
};

typedef struct node NODE;

NODE * init();
void printOrdinal( int );
NODE * search_ptr( NODE *, NODE * );
void del( NODE *, NODE * );
int count( NODE * );

void main()
{
    int all = 30;
    int number = 9;
    int remain = 15;

    cout << "There are " << all << " People in all.\n" << "They will tell the numbers from 1 to " << number << ".\n" << remain << " people will survive.\n\n";
    int i, j;
    NODE * head, * ptr, * pnew, * phold;
    head = init();
    ptr = head;
    for ( i = 1; i <= all; ++i ){
        pnew = (NODE *)malloc( sizeof(NODE) );
        if ( pnew == NULL )
            cout << "malloc error!";
        ptr->next = pnew;
        ptr = ptr->next;
        ptr->info = i;
    }
    ptr->next = head;
    ptr = head->next;
    while ( count( head ) > remain ){
        for ( j = 1; j < number; ++j ){
            ptr = ptr->next;
            if ( ptr == head )
                ptr = ptr->next;
        }
        cout << "The   ";
        printOrdinal( ptr->info );
        cout << "\tman jumped into the sea!\n";
        phold = ptr->next;
        del( head, ptr );
        ptr = phold;
    }
    cout << endl;
    ptr = head->next;
    while ( ptr != head ){
        cout << "The   ";
        printOrdinal( ptr->info );
        cout << "\tman remained on board!\n";
        ptr = ptr->next;
    }
}

NODE * init()
{
    NODE * ptr;
    ptr = (NODE *)malloc( sizeof(NODE) );
    if (ptr == NULL)
        return ptr;
    ptr->info = 0;
    ptr->next = NULL;
    return ptr;
}

void del( NODE * head, NODE * ptr )
{
    NODE * ptrf;
    ptrf = search_ptr( head, ptr );
    ptrf->next = ptr->next;
    free( ptr );
}

void printOrdinal( int n )
{
    cout << n;
    n = n % 10;
    switch( n ){
    case 1:
        cout << " st";
        break;
    case 2:
        cout << " nd";
        break;
    case 3:
        cout << " rd";
        break;
    default:
        cout << " th";
        break;
    }
}

NODE * search_ptr( NODE * head, NODE * p0 )
{
    NODE * ptr = head;
    if ( ptr->next == p0 )
        return ptr;
    ptr = ptr->next;
    while ( ptr != head ){
        if ( ptr->next == p0 )
            return ptr;
        ptr = ptr->next;
    }
    return NULL;
}

int count( NODE * head )
{
    int i;
    NODE * ptr = head->next;
    for ( i = 0; ptr != head; ++i )
        ptr = ptr->next;
    return i;
}

终于明白人大选举是怎么一回事。

偌大的狗500教室坐满了人。
我前面的学生甲在用笔记本电脑玩NFS：most wanted；
我前面的学生乙在看；
我后面的学生丙：“这完全是选谁名字取得好嘛。”；
我后面的学生丁：“我决定了，我就点，点到的第一个人上面划大叉，第二个人上面划圈圈，最后剩下一个人没法点了，就按照圈和叉来点，点到什么就划什么。”（时间过去一分钟）“点好了，这个人人品最好，这个人其次，这个人最差。”

我这个弃权大王当然是弃权罗。

我不禁想起了高三的时候，有一次选优秀学生什么的，我正想履行我的弃权权，突然不知怎么的，被我们伟大的超级热爱数学的班长大人知道了，她硬是不允许，我也只能勉强在豆腐干（大小的纸上）上写上了我们伟大的超级热爱数学的班长大人的大名，谁知她还是不满意（因为好像一共要选五个），拿过我的笔，在我的选票上写上了我的名字之后直接把选票收上去了，直接导致了我的大名在计票过程中被写到了黑板上并且下面跟了一横！
我对此表示严重的抗议，我们伟大的超级热爱数学的班长大人严重的侵犯了我的选举自由权！
经过长时间的卧薪尝胆，我终于找到了申诉的机会。后来我们伟大的超级热爱数学的班长大人要入党，班主任找群众了解情况，群众一片赞美声。终于问到了我，我义愤填膺地（即使在场的人也许都没看出来）把这件事说了出来。谁知班主任却对我说的事例作了精辟的总结：“班长把机会让给同学们，非常好！”
我顿时晕倒。

哀叹民主法治意识之薄弱。

我深深地觉得弃权是一件非常好的事情。如果对一件事情没有倾向时，与其瞎选一个，还不如让有想法的人去决定，特别是选连听都没听说过的人大代表们。

# include <iostream.h>
# include <stdlib.h>
# include <string.h>

const int lines = 256;
const int chars = 256;
char bk[] = " ,.!?\"':;";

void input( char * [], int & );
void output( char * [], int );
void edit( char * [], int & );
void count( char * [], int );
void code( char * [], int );
void search( char * [], int );
void trans( char * [], int, void (*)( char * ) );
void EnpigLatinWord( char * );
void UnpigLatinWord( char * );
void printOrdinal( int );
void replace( char * &, char *, const char *, const char * );

void main()
{
    unsigned short s = 1;
    int line = 0;
    char * text[lines] = {NULL};

    cout << "Text Editor\n Ver.2\n";
    while ( s != 0 ){
        cout << "\n--- main menu ---\n* 1 -- new\t*\n* 2 -- print\t*\n* 3 -- edit\t*\n* 4 -- count\t*\n* 5 -- code\t*\n* 6 -- search\t*\n* 0 -- exit\t*\n-----------------\nselection:";
        cin >> s;
        cout << endl;
        switch( s ){
        case 1:
            input( text, line );
            break;
        case 2:
            output( text, line );
            break;
        case 3:
            edit( text, line );
            break;
        case 4:
            count( text, line );
            break;
        case 5:
            code( text, line );
            break;
        case 6:
            search( text, line );
            break;
        case 0:
            break;
        }
    }
    for ( int i = 0; i < line; ++i )
        free( text[i] );
}

void input( char * text[], int & line )
{
    int len;
    char buffer[chars];

    cout << "( press \"Enter\" button to stop inputting )\n";
    cin.get();
    for ( line = 0; line < lines; line++ ){
        cout << line << ")\t";
        cin.getline( buffer, chars, '\n');
        if ( buffer[0] == '\0' )
            break;
        len = strlen( buffer ) + 1;
        text[line] = (char *)malloc( len * sizeof( char ) );
        if ( text[line] != NULL )
            strcpy( text[line], buffer );
        else{
            cout << "( malloc error! relaunching suggested. )";
            continue;
        }
    }
}


void output( char * text[], int line )
{
    int l, ps, p = 0;
    unsigned short s1 = 2;
    char s;

    cout << "Show by page? ( y / n )";
    cin >> s;
    if ( s == 'y' || s == 'Y' ){
        cout << "How many lines in a page?";
        cin >> l;
        if ( line % l == 0 )
            ps = line / l;
        else
            ps = line / l + 1;
        while ( s1 != 0 ){
            for ( int i = p * l; i < p * l + l; i++ )
                if ( i < line )
                    cout << i << ")\t" << text[i] << endl;
                else
                    cout << i << ")\t" << endl;
            if ( ps == 1 )
                cout << "    ( * ------------ ** ------------ ** 0--back * )";
            else if ( p == 0 )
                cout << "    ( * ------------ ** 2--page down ** 0--back * )";
            else if ( p == ps - 1 )
                cout << "    ( * 1--page up   ** ------------ ** 0--back * )";
            else
                cout << "    ( * 1--page up   ** 2--page down ** 0--back * )";
            cin >> s1;
            switch( s1 ){
            case 1:
                if ( p != 0 )
                    p--;
                break;
            case 2:
                if ( p != ps - 1 )
                    p++;
                break;
            case 0:
                break;
            }
        }
    }
    else{
        for ( int i = 0; i < line; i++ )
            cout << i << ")\t" << text[i] << endl;
    }
}

void edit( char * text[], int & line )
{
    unsigned short s = 1;
    int l, i, len;
    char buffer[chars];

    while ( s != 0 ){
        cout << "\n--- edit menu ---\n  1 -- insert\n  2 -- delete\n  3 -- replace\n  0 -- exit\n-----------------\nselection:";
        cin >> s;
        cout << endl;
        switch( s ){
        case 1:
            cout << "Which line to insert? ( from 0 to " << line << " )";
            cin >> l;
            for ( i = line - 1; i >= l; i-- )
                text[i + 1] = text[i];
            cout << l << ")\t";
            cin.get();
            cin.getline( buffer, chars, '\n');
            len = strlen( buffer );
            text[l] = (char * )malloc( len * sizeof ( char ) );
            if ( text[l] != NULL )
                strcpy( text[l], buffer );
            else
                cout << "( malloc error! relaunching suggested. )";
            line++;
            break;
        case 2:
            cout << "Which line to delete? ( from 0 to " << line - 1<< " )";
            cin >> l;
            free( text[l] );
            for ( i = l; i < line; i++ ){
                text[i] = text[i + 1];
            }
            text[line] = NULL;
            line--;
            break;
        case 3:
            cout << "Which line to change? ( from 0 to " << line - 1<< " )";
            cin >> l;
            free( text[l] );
            cout << l << ")\t";
            cin.get();
            cin.getline( buffer, chars, '\n');
            len = strlen( buffer );
            text[l] = (char * )malloc( len * sizeof ( char ) );
            if ( text[l] != NULL )
                strcpy( text[l], buffer );
            else
                cout << "( malloc error! relaunching suggested. )";
            break;
        }
    }
}

void count( char * text[], int line )
{
    int i, lChar = 0, lWord = 0, lline;
    char * ptok;
    char buffer[chars];

    cout << "Statistic:\t";

    for ( i = 0; i < line; ++i )
        lChar += strlen( text[i] );
    cout << lChar ;
    if ( lChar == 1 || lChar == 0 )
        cout << " character\n\t\t";
    else
        cout << " charactors\n\t\t";
   
    for ( i = 0; i < line; ++i ){
        strcpy( buffer, text[i] );
        ptok = strtok( buffer, bk );
        for ( lline = 0; ptok != NULL; ++lline )
            ptok = strtok( NULL, bk );
        lWord += lline;
    }
    cout << lWord ;
    if ( lWord == 1 || lWord == 0 )
        cout << " word\n";
    else
        cout << " words\n";
}

void code( char * text[], int line )
{
    unsigned short s = 1;

    cout << "\nNotice:\tThe encoding process will encode the english word\n\tcomposed of at least 2 characters,\n\twhile other characters will remain what they are before encoding.\n\tUncoding what is not encoded by the editor is not recommended.\n";
    while ( s != 0 ){
        cout << "\n--- code menu ---\n  1 -- encode\n  2 -- uncode\n  0 -- exit\n-----------------\nselection:";
        cin >> s;
        cout << endl;
        switch( s ){
        case 1:
            trans( text, line, EnpigLatinWord );
            break;
        case 2:
            trans( text, line, UnpigLatinWord );
            break;
        }
        if ( s == 1 || s == 2 )
            cout << "Process Finished!\nYou may go back to the main menu to print so as to see the result.\n";
    }
}

void trans( char * text[], int line, void (*pig)( char * ) )
{
    int i, l;
    char buffer[chars], buffer3[chars], bf[chars];
    char * ptok, * ptr, * buffer2 = bf;

    // buffer  is for toking
    // buffer2 is for saving the things between the tokens
    // buffer3 is the new string

    for ( i = 0; i < line; ++i ){
        strcpy( buffer, text[i] );
        buffer2 = bf;
        strcpy( buffer2, text[i] );
        *buffer3 = NULL;
        ptok = strtok( buffer, bk );
        while ( ptok != NULL ){
            l = strlen( ptok );
            ptr = strchr( buffer2, *ptok );                   
            *ptr = NULL;
            strcat( buffer3, buffer2 );
            *ptr = *ptok;
            buffer2 = ptr + l;
            ++l;
            ptr = (char *)malloc( ( l + 5 ) * sizeof( char ) );
            if ( ptr != NULL )
                strcpy( ptr, ptok );
            else{
                cout << "( malloc error! relaunching suggested. )";
                break;
            }
            (*pig)( ptr );
            strcat( buffer3, ptr );
            free( ptr );
            ptok = strtok( NULL, bk );
        }
        strcat( buffer3, buffer2 );
        free( text[i] );
        l = strlen( buffer3 ) + 1;
        text[i] = (char *)malloc( l * sizeof( char ) );
        if ( text[i] != NULL )
            strcpy( text[i], buffer3 );
        else{
            cout << "( malloc error! relaunching suggested. )";
            break;
        }
    }
}

void EnpigLatinWord( char * word )    // ABC -> BCAay
{
    char * ptr = word;
    char a = *word;
    int k = 0;

    while ( *ptr != NULL ){
        if ( !( int(*ptr) >= 65 && int(*ptr) <= 90 || int(*ptr) >= 97 && int(*ptr) <= 122 ) )
            return;    //not english characters
        ++k;
        ++ptr;
    }
    if ( k == 1 )
        return;    //only one character
    ptr = word;
    while ( *ptr != NULL ){
        *ptr = *( ptr + 1 );
        ++ptr;
    }
    --ptr;
    *ptr = a;
    ++ptr;
    *ptr = 'a';
    ++ptr;
    *ptr = 'y';
    ++ptr;
    *ptr = NULL;
}

void UnpigLatinWord( char * word )
{
    char * ptr = word;
    char a;

    ptr = word;
    while ( *ptr != NULL )
        ++ptr;
    --ptr;
    if ( *ptr != 'y' || ptr == word )
        return;
    --ptr;
    if ( *ptr != 'a' || ptr == word )
        return;
    *ptr = NULL;
    --ptr;
    if ( ptr == word )
        return;
    a = *ptr;
    while ( ptr > word ){
        *ptr = *( ptr - 1 );
        --ptr;
    }
    *ptr = a;
}

void search( char * text[], int line )
{
    unsigned short s = 1, s1;
    int i, j, m, n, k, dl, nt, d, l;
    char a[chars], b[chars];
    char * ptr;
    int nl[lines] = {0}, post[lines][chars] = {0};

    while ( s != 0 ){
        cout << "\n-- search menu --\n  1 -- search\n  2 -- and replace\n  0 -- exit\n-----------------\nselection:";
        cin >> s;
        cout << endl;
        switch( s ){
        case 1:    //search
            cout << "The contents for search:\n";
            cin >> a;
            nt = 0;
            for ( i = 0; i < line; ++i ){
                ptr = strstr( text[i], a );
                for ( j = 0; ptr != NULL; ++j )
                    ptr = strstr( ( ptr + strlen( a ) ), a );
                nl[i] = j;
                nt += j;
            }
            cout << endl << nt << " matching contents found\n";
            if ( nt != 0 )
                for ( i = 0; i < line; ++i )
                    if ( nl[i] != 0 )
                        cout << nl[i] << " in line (" << i << ")\n";
            l = strlen( a );
            for ( i = 0; i < l + 1; ++i )
                a[i] = 0;
            break;
        case 2:    //search and replace
            cout << "The contents for search:\n";
            cin >> a;
            cout << "Replaced by:\n";
            cin >> b;
            dl = strlen( b ) - strlen( a );
            nt = 0;
            //search the text and locate all matching contents
            for ( i = 0; i < line; ++i ){
                ptr = strstr( text[i], a );
                for ( j = 0; ptr != NULL; ++j ){
                    post[i][j + 1] = ptr - text[i];
                    ptr = strstr( ( ptr + strlen( a ) ), a );
                }
                nl[i] = j;
                nt += j;
            }
            cout << endl << nt << " matching contents found\n";
            d = 0;
            for ( i = 0; i < line; ++i ){
                s1 = 1;
                if ( nl[i] != 0 )
                    cout << endl << i << ")\t" << text[i] << endl;
                for ( j = 1; j <= nl[i]; ++j ){
                    cout << "\n    ( 1--replace ** 2--next ** 3--replace all ** 0--cancel )\n"
                        << "action on the ";
                    printOrdinal( j );
                    cout << " found in line (" << i << "):";
                    cin >> s1;
                    if ( s1 == 0 )
                        break;                   
                    else if ( s1 == 3 ){    //replace all from the present location
                        //replace the rest matching contents in this line
                        for ( m = j; m <= nl[i]; ++m ){
                            replace( text[i], text[i] + post[i][m], a, b );
                            for ( n = m + 1; n <= nl[i]; ++n )
                                post[i][n] += dl;
                        }
                        //replace matching contents in the rest lines
                        for ( m = i + 1; m < line; ++m ){
                            for ( n = 1; n <= nl[m]; ++n ){
                                replace( text[m], text[m] + post[m][n], a, b );
                                for ( k = n + 1; k <= nl[i]; ++k )
                                    post[m][k] += dl;                       
                            }
                        }
                        ++d;    //to mark that the text has been changed
                        break;
                    }
                    else if ( s1 == 1 ){    //replace
                        replace( text[i], text[i] + post[i][j], a, b );
                        for ( m = j + 1; m <= nl[i]; ++m )
                            post[i][m] += dl;
                        ++d;
                    }
                }
                if ( s1 == 0 || s1 == 3 )    //'cancel' or 'replace all' selected
                    break;
            }
            if ( d != 0 )
                cout << "\nProcess Finished!\nYou may go back to the main menu to print so as to see the result.\n";
            l = strlen( a );
            for ( i = 0; i < l + 1; ++i )    //zero string a
                a[i] = 0;
            l = strlen( b );
            for ( i = 0; i < l + 1; ++i )    //zero string b
                b[i] = 0;
            break;
        }
    }
}

void printOrdinal( int n )
{
    cout << n;
    n = n % 10;
    switch( n ){
    case 1:
        cout << " st";
        break;
    case 2:
        cout << " nd";
        break;
    case 3:
        cout << " rd";
        break;
    default:
        cout << " th";
        break;
    }
}

void replace( char * & text, char * ptr, const char * a, const char * b )
{
    char buffer[chars] = {0};
    char * p;
    int len, l;

    *ptr = NULL;
    strcpy( buffer, text );
    *ptr = *a;
    strcat( buffer, b );
    l = strlen( buffer );
    p = ptr + strlen( a );
    strcat( buffer, p );
    len = strlen( buffer ) + 1;
    free( text );
    text = (char *)malloc( len * sizeof( char ) );
    if ( text != NULL )
        strcpy( text, buffer );
    else
        cout << "( malloc error! relaunching suggested. )";
}

关于上次那个坐垫上的露水的问题，我深深地觉得，是个很好的科普题材。于是我决定把这个选题卖给中央十台，我帮他们脚本也搞定了，我觉得很符合他们的风格。如下：

有一天，sjtu的小gu早晨起床到楼下那自行车，忽然发现了一个奇怪的现象。
（飘忽不定的镜头）（紧张的音乐）
车棚里的自行车坐垫上居然没有露水！！！！！！！！！！！！
爱开动小脑筋的小gu同学于是纳闷了。好好的，外面自行车坐垫上都有露水，为什么唯独车棚里的车没有露水呢？？？？？？？？！！！！！！！！

（进广告）

小gu同学顿时愣住了，为什么车棚里的车上就是没露水呢？？？？？？？？！！！！！！！！！
第二天，记者来到了发生诡异的“没露水事件”的诡异的地方sjtu
（记者和小gu见面的镜头）
过了一天的早晨，记者随小gu来到了发生诡异事件的车棚。
果然没露水！！！！！
（记者仔细调查现场）
这样的事情太奇怪了，记者决定第二天天还没亮再来调查。
于是，在一个月黑风高的凌晨，记者和小gu来到了车棚前。
（月亮的镜头）
可是，没露水事件早就又一次发生了。那么，此次调查会无功而返吗？？？？？？？大家的努力都白费了吗？？？？？

（进广告）

正当大家灰心丧气的时候，小gu同学忽然看见天上的一颗星星。
（小gu看天与天空镜头切换）
会不会是那个星球上的外星人搞的鬼呢？？？？？？？！！！！！！！
这个想法顿时让大家看到了希望。
如果真的是外星人造成的，
（紧张诡异的音乐）（天空与自行车坐垫镜头切换）
那么，那些外星人究竟为什么要制造这样的现象呢？？？
他们又是用何种手段制造这一系列诡异的“没露水事件”的呢？？？
有没有人看见过他们，甚至看见他们制造“没露水事件”呢？？？
那些外星人又是从什么星球来的呢？？？
他们是乘什么来到地球的呢？？？
他们的目的又是什么呢？？？
他们会对人类造成伤害吗？？？
他们长成什么样？？？
他们是谁？？？？？？？？！！！！！！！！

（进广告）

带着这么多问题，我们来到了“国家空间物理研究所”，找到了XXX所长。我们请教了他，这一系列“没露水事件”会不会是由外星人造成的。XXX所长欣然接受了我们的提问。
XXX所长：鉴于现在还没有确切的证据表明有外星人来过地球，“没露水事件”由外星人造成的可能性不大。
大家的心顿时凉了半截，好不容易找到的线索就这样没了。
（记者和小gu灰心丧气状）（悲伤的音乐）
难道这次调查又将以失败告终吗？？？？！！！！
难道“没露水事件”将成为一个千古之谜吗？？？？！！！！
如果是这样的话，这将成为人类历史上的一大悲哀！！！！！
（悲壮的音乐）

（进广告）

正当大家陷入迷茫之中时，有一个神秘人物进入了记者的视线，他的名字叫“（没有名称）”，他主动要求加入这个调查的行列。
（没有名称）：露水的凝结，是因为气温降低，达到露点。此时也易成雾，而雾滴是可能下落的。放在车棚内的，下落的雾少。另一方面，车棚内温度稍高（除非空气流动很快），凝露少。对于座垫而言，直接凝结的露水并不多（石头、铁等，导热率较高的物体凝结多），雾的作用更明显。
到底是不是这样呢？？？？？？
（没有名称）的话可不可信呢？？？？？？
（（没有名称）用坚毅的目光看着自行车坐垫）
记者就此进行了多方的走访：
中国科学院物理研究所所长YYY：这样的说法还是有一定的道理的。
国家气象局首席预报员ZZZ：确实可以这样理解。
就此，这个困扰了记者多日的难题得到了圆满的解决。

为什么这么长时间不更新呢？是个谜。

我只知道这次要狂更新。