博客 - 0</a><a href="http://www.donews.net/sayon1y">只说收藏</a>

金羊网 2005-12-10 13:34:28
作者：黄发有

不知道怎么搞得，baidu新闻聚合了这篇报道，但是却访问不了全文，所以只说通过proxy拿到了全文，转载至此，略去多图。请查看原文链接，
http://www.ycwb.com/gb/content/2005-12/10/content_1035491.htm
正文如下：

有很多文化时尚的流行，常常来得突兀，就像一场流行性感冒的大爆发，转眼间满街的人都头晕咳嗽流鼻涕。就像前些年的网恋，就像这一阵的博客（blog）。博客业内人士宣称这是个全民博客的时代，更有人将博客抬升到“第五媒体”的高度。“博客”是以网络日志和超文本链接作为基本构成要素的个人网页，其最诱人的承诺是媒体的源代码开放，在此基础上建立“零成本、零技术、零时差、零许可、零编辑”的个人意见平台。但是，源代码开放仅仅是一种技术上的可能性，舆论环境和法律规范下的种种传输协议(protoco)、标准和规则的重构，就像层层设防的防火墙一样，必然会削弱博客的冲击力与技术优势。

博客在中国第一步可谓自掘坟墓

为博客进入中国打头阵的是方兴东，他在2002年8月建立“博客中国”网站（2005年7月更名为“博客网”）；2003年，他与王俊秀合著的《博客：e时代的盗火者》为推动“人人博客”时代而摇旗呐喊。对于博客的过火的热情，使方兴东将博客描绘成了天堂，但在实际操作中却又剑走偏锋。2003年，博客中国之所以能在一夜之间红遍大江南北，得益于木子美狂贴《遗情书》，网民的蜂拥而入导致服务器瘫痪。更加有趣的是，方兴东居然投桃报李，让木子美“从良”，做了博客中国的市场经理。2004年竹影青瞳自毁前程的裸照风波，2005年流氓燕的“挺身而出”，颇有东施效颦的意味。博客在中国的历程，第一步就走歪了，真可谓自掘坟墓。从木子美到流氓燕，这些网络怪胎或公开展示自己的裸照，或恬不知耻地炫耀自己的性爱经历，丑态百出。以个人杂志、网络日记、网络文摘为主要形式的博客空间，浏览量与回复率最高的帖子几乎都与“性”有关，不是谈性文字就是美女图片。博客怎么成了垃圾工厂？

事实上，除了暴露个人隐私，“博客”还大有可为。在2005年7月7日的伦敦爆炸中，一位地铁乘客亚当·斯塔西用手机拍下了第一张现场照片，发送给主持一家博客网（moblog.co.uk）的朋友阿尔菲·丹恩，后者迅速发布了这张图片。转眼间，这张照片成了英国各大电视网竞相播放的画面。与此同时，一家由伦敦的救护车司机汤姆·雷纳德创办的个人博客网站“现实随机行动”也一举成名，它第一时间报道了系列爆炸案袭击地区的状况。颇有反讽色彩的是，中国的大多数博客网站都把精力用歪了。

网罗名人试图“从良”

或许正是意识到博客在中国的尴尬处境，国内第一门户网站新浪在2005年9月重拳出击，隆重推出新浪博客大赛。依托着新浪的品牌优势，新浪博客网罗织了一大批文化、娱乐与新闻界的名人为其捧场，后来居上，大有号令天下诸侯的霸气。仅作家而言，就有余华、余秋雨、陆天明、刘震云、虹影、张海迪、冯骥才、陈染、叶永烈、郭敬明、韩寒、海岩、棉棉、赵波等加盟。有趣的是，这些名人博客几乎都是挂羊头卖狗肉，只是拿出一些旧货来搪塞和敷衍网民。

余华算得上是最敬业的blogger，他除了在“文学随笔”、“音乐随笔”、“往事散文”、“国家印象”、“前言和后记”等栏目中贴出一些随笔之外，还开设了“互动”与“篝火论坛”等栏目，在博客上与读者进行交流。尽管更新率和点击率都很高，但这依然只是戴着“博客”面具的个人主页，“博客”这一面具掩饰了作家真正的表情，并以此达到某种诱惑甚至震慑的力量。尤其值得注意的是，这些个人博客上的网友评论显然是经过筛选和编辑的，我们只能看到谄媚的歌功颂德，根本看不到率真的质疑与尖锐的批评。倒是在南方网“南方社区·文心雕楼”开辟的“你认为余华这样的作家应该开博客吗？”的讨论区中，能看到一些网友的妙论，譬如“都市老农”认为：“余华，沦落的才子。大抵只有这个印象了。”“东方不亮”则认为：“阴谋论：炒作自己，为《兄弟》（下）准备。推测根据：网络是个好地方；一本书写得多好看，等续集等太久都要忘了，得让人惦记着。”

余秋雨在博客上贴出的《中年人最可怕的是失去方寸》，只不过是《关于年龄》的摘录；刘震云坦率地说自己不懂博客，将博客改造成“文集”，每天贴出一章《温故一九四二》；虹影、陈染、赵波等“美女作家”比较自恋，照片比文字更能吸引网友的视线；海岩把博客布置成了新作和新剧的宣传阵地；郭敬明张贴的多为生活照和生活小记；韩寒贴出的是近期的赛车照片以及描述比赛心情的文字。这种自卖自夸的博客与众声喧哗的BBS相比，已经丧失了那种随意碰撞的活力和平等交流的自由。而且，这样的博客肯定无法持久，如果没什么好处，哪位名人愿意在这里浪费时间啊？除非给他们每人配一个秘书，负责维护他们的博客。由于网络的虚拟性，我难免萌生小人之心：名人博客的维护是否一开始就由别人代劳？

博客对于写作的冲击

博客对于写作的真正冲击，在于提供了一个无须准入许可的平台，是普通人自我宣泄自我表达的空间。但是，为博客写作披上“性”的外衣或罩上名人的光环，似乎都与博客所提供的美好蓝图背道而驰。中国的博客被改造成了中国特色的摊位，让袒胸露乳的女子和峨冠博带的名人轮番上阵，敲锣打鼓地赚吆喝。我感觉开办博客网站的人士有点像《皇帝的新衣》中的骗子，骗子说只有最愚蠢的人无法看到世界上最美丽、最神奇的布料和新衣，而经营博客者则说谁“不博了”谁就不时尚了，谁就是老土。

想起法国著名社会学家布厄迪尔在对话录《自由交流》中的一段话：“缺乏思想的老板和缺乏权力的记者或‘知识分子’按照时髦/不时髦、新潮/陈旧的标准来判断精神产品（而不是按照真实/虚假、独特/平庸、美/丑等等）。谁说杜梅泽尔关于印欧社会的某个论点是错误的，谁就必须拿出证据来，但是谁都可以只说它过时了，也就是不时髦了。而在巴黎，不时髦就等于直截了当地判死刑。”在这个追新逐异的年代，谁如果还在用狗熊掰棒子的故事来教导别人应当专注，谁就变成了出土文物。像狗熊这样一直在玉米地里转悠，掰一个扔一个，已经算得上是死心眼了，为什么不去摘点别的呢？

“见光死”的博客热情

博客业内人士总是故意把博客神秘化，给它遮上层层帷幕，在若明若暗的灯光的导引下，让好奇者穿行在黑暗的隧道之中，那些通过博客进行交流的人们一开始就像在黑夜中说话，又像那些被关押在地牢中相邻囚室的犯人，用相互敲击墙壁的方式来排遣寂寞。但正如一位网友所言：“就像你在黑夜中看到了一点光，你走啊走，找啊找，好一点的结果是你看到了一点烛光，带给你的是光明和温暖，但烛光也总有消逝的时候；不好的结果呢，很可能你最终看到的不过是坟场上方飘动的磷火。”幸运的是，在这个信息四通八达的年代，没有人能够遮蔽信息的光芒。当那些沉迷在博客迷宫中的网友们看穿了背后的那点小把戏，对于博客的热情就和网恋一样，“见光死”了。

网恋和流行性感冒一样，来无影去无踪，来得快去得也快。我想，博客也不例外。尽管国内著名的博客网站如博客网、新浪博客、天涯博客使出浑身解数，招徕点击，但是，该来的挡不住该走的也留不住。这种让人头脑发热发晕，让人激动得眼泪鼻涕一起下的时尚，就像一场浑浑噩噩的恋爱，“因为陌生而相爱，因为了解而分手”，当人们发现“不过如此”，头脑一清醒，高烧退了，就会奇怪自己怎么会这么草率地将真爱错投。

习惯于“狗眼看世界”的王朔在担任“文化在中国”网站的CAO（首席艺术官）时，接受某媒体的采访，其间谈到当时被大小媒体炒得火热的“网恋”，老王的态度简单到了极点：“人类对交流方式的愿望可以说是无孔不入，如果网络能作为一种手段，这有什么特别值得讨论的呢？这跟写信、打电话、大街上勾搭是一回事。”王朔的很多话都有故作惊人语与哗众取宠之嫌，但这席话却是一针见血。确实，网恋、博客与写信、打电话、大街上勾搭一样，都只是一种交流方式。

发表于 @ 2005年12月12日 11:20 AM | 评论 (2)

lexer

A lexer (lexical analyzer) is used in compilers to break input text into pieces called tokens.
In this problem you will be given a list of valid tokens.
For example: tokens = {"ab","aba","A"}
Given a list of valid tokens and an input string your lexer will work as follows:
1)
a) If the input doesn't begin with one of the valid tokens, remove the first character from the string.
b) If the input does begin with a valid token, determine the longest valid token the input starts with and remove it from the string.
The removed portion is considered CONSUMED.
2)
Repeat 1 until there are no characters left in the input.

The lexer is CASE-SENSITIVE so a token must exactly match the beginning of the string.

Given a list of valid tokens and an input string
your method will return a list containing the CONSUMED valid tokens in the order they were CONSUMED.

For example:
tokens = {"ab","aba","A"}
input = "ababbbaAab" "ab" and "aba"
are found at the beginning of the input but "aba" is longest so it is consumed.

Now: consumed = {"aba"} input = "bbbaAab"
There are no tokens that start with 'b' so the lexer will remove the first 3 characters from the string.

consumed = {"aba"} input = "aAab"
The 'a' doesn't match the token "A" due to CASE-SENSITIVITY.
The lexer removes the 'a' from the beginning of the string. consumed = {"aba"} input = "Aab"

The lexer consumes the "A" token. consumed = {"aba","A"} input = "ab"
Finally the lexer consumes the "ab" token and completes the process. consumed = {"aba","A","ab"}

input = ""
The returned list is {"aba","A","ab"}.

Create a class Lexer that contains the method tokenize, which takes a vector <string> tokens,
and a string input, and returns a vector <string> in the form specified above.
Definition

Class: Lexer
Method: tokenize
Parameters: vector <string>, string
Returns: vector <string>
Method signature: vector <string> tokenize(vector <string> tokens, string input)
(be sure your method is public)

Constraints
- tokens will contain between 0 and 50 elements inclusive
- Each element of tokens will have length between 1 and 50 inclusive
- Each element of tokens will only consist of letters (A-Z,a-z)
- input will have length between 0 and 50 inclusive
- input will only consist of letters (A-Z,a-z)
Examples
0)

{"ab","aba","A"}
"ababbbaAab"
Returns: { "aba",
"A",
"ab" }
Same as above
1)

{"a","a","aa","aaa","aaaa","aaaaa","aa"}
"aaaaaaaaaaaaaaaaaaaaaaaaa"
Returns: { "aaaaa",
"aaaaa",
"aaaaa",
"aaaaa",
"aaaaa" }
Make sure to use the longest valid starting token
2)

{"wow","wo","w"}
"awofwwofowwowowowwwooo"
Returns: { "wo",
"w",
"wo",
"w",
"wow",
"wow",
"w",
"wo" }

{"int","double","long","char","boolean","byte","float"}
"intlongdoublecharintintboolean"
Returns: { "int",
"long",
"double",
"char",
"int",
"int",
"boolean" }

{}
"Great"
Returns: { }
No valid tokens, so nothing is CONSUMED
5)

{"AbCd","dEfG","GhIj"}
"abCdEfGhIjAbCdEfGhIj"
Returns: { "dEfG",
"AbCd",
"GhIj" }

Remember CASE-SENSITIVITY

This problem statement is the exclusive and proprietary property of TopCoder, Inc.
Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited.
(c)2003, TopCoder, Inc. All rights reserved.
*/

/*
My Policy:
  1 对token进行排序，以长度作为依据，排成降序
  2 对输入数据循环查找tokens，从长到短；如果找到就进行输出；
  3 跳过找到的串，对后续的数据在应用相同的原则，继续进行处理；

#pragma warning ( disable: 4786)
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

class Lexer {
public:
static compare(const string &a, const string &b) {
  return a.length() > b.length();
}
vector <string> tokenize(vector <string> tokens, string input) {
  vector<string> result;
  if ( !tokens.size() ) {
   std::cerr << "No valid tokens, so nothing is CONSUMED" << std::endl;
   return result;
  }
  if ( input.length() == 0 ) {
   std::cerr << "Input data is emtpy, Needn't process" << std::endl;
   return result;
  }

  // 需要排序，并且需要按照字符串的长度以减序进行排序，
  // 这样下面就不需要进行特别的处理；
  // 否这，在出现长短两个串在同一个起始位置都匹配的时候，需要进行优先判断，
  // 以串长的为优先

  sort(tokens.begin(),tokens.end(),Lexer::compare);

  const char *p = input.c_str();

size_t pos=0;

size_t curpos=0;

  size_t minpos=0;
  int minidx=0;
  int len=input.length();

const char *pp=p;

  while(*p) {
   minpos=len;
   for(int i=0; i<tokens.size(); ++i ) {
    curpos=input.find(tokens[i],pos);
    if ( curpos != string::npos ) {
     if ( curpos < minpos ) {
      minpos = curpos;
      minidx = i;
     }
     /*
     // 如果前面不对tokens按照长度进行排序的话，需要下面的处理
     else if ( curpos == minpos ) {
      if ( tokens[i].length() > tokens[minidx].length() ) minidx = i;
     }
     */
    }
   }
   if ( minpos == len ) break;

   p   =pp + minpos + tokens[minidx].length();
   pos =minpos + tokens[minidx].length();
   result.push_back(tokens[minidx]);
  }

  return result;
}
};

int main(int argc, char* argv[])
{
Lexer lex;
vector<string> result;
// Sample 0)
vector<string> tokens;
char *tk0[] = {"ab","aba","A"};
string str0="ababbbaAabC";
copy(tk0+0,tk0+3,std::back_inserter(tokens) );

std::cout << "input string\n";
std::cout << str0 << std::endl;
std::cout << "tokens: \n";
copy(tokens.begin(),tokens.end(), ostream_iterator<string>(cout, " "));
std::cout << std::endl;

result = lex.tokenize(tokens,str0);

copy(result.begin(), result.end() ,ostream_iterator<string>(cout, "\n"));
tokens.clear();
//-------------------------------------------------------------------------------//

// Sample 1)

char *tk1[]={"a","a","aa","aaa","aaaa","aaaaa","aa"};
string str1="aaaaaaaaaaaaaaaaaaaaaaaaa";

copy(tk1,tk1+7,std::back_inserter(tokens) );
std::cout << "input string\n";
std::cout << str1 << std::endl;
std::cout << "tokens: \n";
copy(tokens.begin(),tokens.end(), ostream_iterator<string>(cout, " "));
std::cout << std::endl;

result = lex.tokenize(tokens,str1);

copy(result.begin(), result.end() ,ostream_iterator<string>(cout, "\n"));
tokens.clear();
//-------------------------------------------------------------------------------//

// Sample 2)

char *tk2[]={"wow","wo","w"};
string str2="awofwwofowwowowowwwooo";

copy(tk2,tk2+3,std::back_inserter(tokens) );
std::cout << "input string\n";
std::cout << str2 << std::endl;
std::cout << "tokens: \n";
copy(tokens.begin(),tokens.end(), ostream_iterator<string>(cout, " "));
std::cout << std::endl;

result = lex.tokenize(tokens,str2);

copy(result.begin(), result.end() ,ostream_iterator<string>(cout, "\n"));
tokens.clear();
//-------------------------------------------------------------------------------//

// Sample 3)
char *tk3[]={"int","double","long","char","boolean","byte","float"};
string str3="intlongdoublecharintintboolean";

copy(tk3,tk3+7,std::back_inserter(tokens) );
std::cout << "input string\n";
std::cout << str3 << std::endl;
std::cout << "tokens: \n";
copy(tokens.begin(),tokens.end(), ostream_iterator<string>(cout, " "));
std::cout << std::endl;

result = lex.tokenize(tokens,str3);

copy(result.begin(), result.end() ,ostream_iterator<string>(cout, "\n"));
tokens.clear();
//-------------------------------------------------------------------------------//
// Sample 4)
// char *tk4[]={};
string str4="Great";

// copy(tk4,tk4+0,std::back_inserter(tokens) );
std::cout << "input string\n";
std::cout << str4 << std::endl;
std::cout << "tokens: \n";
copy(tokens.begin(),tokens.end(), ostream_iterator<string>(cout, " "));
std::cout << std::endl;

result = lex.tokenize(tokens,str4);

copy(result.begin(), result.end() ,ostream_iterator<string>(cout, "\n"));
tokens.clear();
//-------------------------------------------------------------------------------//
// Sample 5
char *tk5[]={"AbCd","dEfG","GhIj"};
string str5="abCdEfGhIjAbCdEfGhIj";

copy(tk5,tk5+3,std::back_inserter(tokens) );
std::cout << "input string\n";
std::cout << str5 << std::endl;
std::cout << "tokens: \n";
copy(tokens.begin(),tokens.end(), ostream_iterator<string>(cout, " "));
std::cout << std::endl;

result = lex.tokenize(tokens,str5);

copy(result.begin(), result.end() ,ostream_iterator<string>(cout, "\n"));
tokens.clear();
//-------------------------------------------------------------------------------//
return 0;
}

发表于 @ 2005年12月09日 9:12 AM | 评论 (0)