emu in blogjava

<script>
var m=1000000000;//000;

function choices(decree)
{
    var i,j,n=1;
    var arrSum=new Array(26);//最后一个字母在每个位置的总合
    for(j=0;j<arrSum.length;++j)arrSum[j]=0;
    for(i=1;i<=decree.length;++i)
    {
        var tmpSum=new Array(26);
        for(j=0;j<26;++j)tmpSum[j]=0;

        if('A'==decree.charAt(i-1))
        {
            if(1==i)
            {
                arrSum[0]=1;
            }
            else
            {
                n=0;
                for(j=i-1;j>=0;--j)//向前分散，如123->6530
                {
                    n+=arrSum[j];
                    tmpSum[j]=n;
                }
                n = 0
                for(j=0;j<=i;++j)
                {//保存到arrSum
                    arrSum[j]=tmpSum[j];
                    n+=arrSum[j];
                }

            }
        }
        else
        {
            if(1==i)
            {
                arrSum[1]=1;
            }
            else
            {
                n=0;
                for(j=0;j<i;++j)//向后分散，如123->0136
                {
                    n+=arrSum[j];
                    tmpSum[j+1]=n;
                }
                n = 0
                for(j=0;j<=i;++j)
                {//保存到arrSum
                    arrSum[j]=tmpSum[j];
                    n+=arrSum[j];
                }
            }
        }
        document.write(decree.substr(0,i),"=",n,"<br>");
        //if(n>m)return -1;
    }

    return n;
}
document.write("BAA","=",choices("BAA"),"<br>");
document.write("AAAA","=",choices("AAAA"),"<br>");
document.write("BABABABABABABABABABABABAB","=",choices("BABABABABABABABABABABABAB"),"<br>");
</script>

这道比较难，emu写了程序穷举了各种可能性输出后，手工分析了一番数据才终于找到规律。呕血中……


public class Alphabet {
public static void main(String[] args) {
Alphabet a = new Alphabet();
String[] data = new String[]{"BAABABBAABBBAAB:-1","AABBABABABABBA:520259727",
"BAABABAAABBBAAB:969740563","AAABABABABABBA:294939658"};
for (int i = 0; i < data.length; i++) {
String[] sample = data[ i ].split(":");
String decree = sample[0];
int choices = Integer.parseInt(sample[1]);
assertEquals(a.choices(decree), choices);
}
System.out.println("all passed!");
}

private static void assertEquals(int a, int b) {
if (a != b)
throw new RuntimeException("assert failed!! Expected " + b +
" but got " + a);
}

public int choices(String decree) {
int[] oldPosList = new int[3];
int timesCount = 1;
oldPosList[decree.startsWith("A")?1:2]=1;
for (int i = 2; i <= decree.length(); i++) {
timesCount = 0;
int[] newPosList = new int[i + 2];
char ch = decree.charAt(i - 1);
if (ch == 'A') {
for (int j = 1; j <= i; j++) {
int times = oldPosList[j];
if (i < decree.length())
for (int k = 1; k <= j; k++) newPosList[k] += times;
timesCount += j*times;
}
} else {
for (int j = 1; j <= i; j++) {
int times = oldPosList[j];
if (i < decree.length())
for (int k = j + 1; k <= i + 1; k++) newPosList[k] += times;
timesCount += (i-j+1)*times;
}
}
oldPosList = newPosList;
if (timesCount > 1000000000) return -1;
}
return timesCount;
}
}

用了一些高深的数学原理，不过对“th+=e/n;”能否把闸值修正到曲线线的定点，我有一点怀疑。

<SCRIPT LANGUAGE="JavaScript">
<!--
function minErr(s,c)
{
for(var th=2;th<50;++th)
{
var e = 0,n=0;
for(var i=0;i<s.length;++i)
{
if(c.charAt(i )!=(s[i]>=th?"C":"N"))
{
++n;
e+=(s[i]-th);
}
}
if(e<=0)
{
th+=e/n;
break;
}
}
e = 0;
for(var i=0;i<s.length;++i)
{
if(c.charAt(i )!=(s[i]>=th?"C":"N"))
{
e+=(s[i]-th)*(s[i]-th);
}
}
return e/s.length;
}

//-->
</SCRIPT>

我估计均方差是一条类似抛物线的曲线（有一个顶点或者一个平的顶部），用二分法收敛到曲线的顶点上。但是由于计算机二进制计算精度限制的原因，实际收敛到的地方可能和顶点有微小的偏差（比如0.1,0.2,0.3,0.4用二进制表示都是循环小数，因此用二分法如果不做特别处理就收敛不到这些点上）。

---

public class MSQErr {
public static void main(String[] args) {
MSQErr err = new MSQErr();
assertEquals(err.minErr(new int[] {3, 3, 1, 8}, "NNNC"), 0);
assertEquals(err.minErr(new int[] {5, 2, 3, 6}, "CCNC"), 0.125);
assertEquals(err.minErr(new int[] {5, 2, 3, 6, 2}, "CCNCN"), 0.1);
assertEquals(err.minErr(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20},
"NNNCNNNCNNNCNCCCCCCC"), 2.34);
System.out.println("all pass");
}

private static void assertEquals(double a, double b) {
if (a != b)
throw new RuntimeException("assert failed!! Expected " + b +
" but got " + a);
}

public double minErr(int[] score, String cancerous) {
double max = 0, min = 1000;
for (int i = 0; i < score.length; i++) {
int s = score[ i ];
if (s > max)
max = s;
if (s < min)
min = s;
}
double mid = (max + min) / 2;
double d1 = 1, d2 = 2;
while (d1 != d2) {
d1 = getErr(score, cancerous, mid);
d2 = getErr(score, cancerous, mid + (max - min) / 1000000000);
if (d1 > d2)
min = mid;
else
max = mid;
mid = (max + min) / 2;
}
return Math.floor(d1 * 1000000000) / 1000000000;
}

public double getErr(int[] score, String cancerous, double threshold) {
double result = 0;
for (int i = 0; i < score.length; i++) {
double d = score[ i ] - threshold;
char c = cancerous.charAt(i);
if (d > 0 && c == 'N' || d < 0 && c == 'C') {
result += d * d;
}
}
return result / score.length;
}
}

---

对它的正确性没有充分验证过，因为
d2 = getErr(score, cancerous, mid + (max - min) / 1000000000);
我只是想知道向x轴正方向走一小步看看抛物线的走向是向上还是向下。如果这一小步恰好跨过了抛物线顶点的话对方向的判断有可能就是错的，不过这样的事件发生的概率实在是太小了。
参数验证没有做，如果给错误参数的话，有可能抛异常（cancerous串太短的话），也有可能忽略错误的数据（cancerous太长或者不完全由N和C构成）。题目中没有明确的提出应该怎么处理这样的数据，由它去吧。

赶上秋水无恨第一次的解法了，时间复杂度o(1)。

public class HouseParty {
public static void main(String[] args) {
HouseParty hp = new HouseParty();
//hp.maxArea(3,0,0);
long startBy = System.currentTimeMillis();
System.out.println("(8, 0, 0):"+hp.maxArea(8, 0, 0));
System.out.println("(7, 0, 1):"+hp.maxArea(7, 0, 1));
System.out.println("(9, 8, 2):"+hp.maxArea(9, 8, 2));
System.out.println("(6, 23, 13):"+hp.maxArea(6, 23, 13));
System.out.println("(16, 0, 4):"+hp.maxArea(16, 0, 4));
System.out.println("(16, 2, 1):"+hp.maxArea(16, 2, 1));
System.out.println("(16, 4, 4):"+hp.maxArea(16, 4, 4));
System.out.println("(1024, 324, 4):"+hp.maxArea(1024, 324, 4));
System.out.println("(9, 0, 3):"+hp.maxArea(9, 0, 3));
System.out.println("time used:" + (System.currentTimeMillis() - startBy));
}
public int maxArea(int numReg, int numWin, int numDoor) {
int width = 0;
int length = 0;
if (numDoor>4) numDoor =4;
if (numReg<6) return 0;
if (numDoor<1) return 0;
if (numReg+numWin+numDoor<8) return 0;
if (numDoor>1) {
width = 1;
length = 3;
numReg -= 6;
numDoor -= 2;
}else if (numWin>1){
width = 1;
length = 3;
numReg -= 6;
numDoor -= 1;
numWin -= 1;
}else{
width = 1;
length = 3;
numReg -= 7;
numDoor -= 1;
}
if (numDoor >=2 && numReg>=2){
if (width<length) width += 2; else length += 2;
numDoor -= 2;
numReg -= 2;
}

if (numWin >=2 && numReg>=2){
int n = Math.min(numWin,numReg)/2;
int m = n/2; n -= m;
if (width<length) {
width += n*2;
length += m*2;
} else{
width += m*2;
length += n*2;
}
numWin -= 2*(n+m);
numReg -= 2*(n+m);
}

if (numDoor >=1 && numWin >=1 && numReg>=2){
if (width<length) width += 2; else length += 2;
numWin -= 1;
numDoor -= 1;
numReg -= 2;
}
if ((numDoor >=1 || numWin >=1) && numReg>=3){
if (width<length) width += 2; else length += 2;
numReg -= 3;
}
if (numReg>=2){
int n = numReg/2;
int m = n/2; n -= m;
if (width<length) {
width += n;
length += m;
} else{
width += m;
length += n;
}
}
return width*length*16;
}
}

这次时间复杂度降到了o〔n)，结果也正确了，从代码可以看得清思路。


public class HouseParty {
    public static void main(String[] args) {
        HouseParty hp = new HouseParty();
        long startBy = System.currentTimeMillis();
        System.out.println("(50,50,50):" + hp.maxArea(50, 50, 50));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("(8, 0, 0):" + hp.maxArea(8, 0, 0));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("(8, 1, 1):" + hp.maxArea(8, 1, 1));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("(7, 0, 1):" + hp.maxArea(7, 0, 1));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("(9, 8, 2):" + hp.maxArea(9, 8, 2));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("(6, 23, 13):" + hp.maxArea(6, 23, 13));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("(16, 0, 4):" + hp.maxArea(16, 0, 4));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("(16, 2, 1):" + hp.maxArea(16, 2, 1));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("(16, 4, 4):" + hp.maxArea(16, 4, 4));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("(9, 0, 3):" + hp.maxArea(9, 0, 3));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("(8, 0, 4):" + hp.maxArea(8, 0, 4));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("(9, 1, 2):" + hp.maxArea(9, 1, 2));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("(9, 2, 1):" + hp.maxArea(9, 2, 1));
        System.out.println("biggest room:" + hp.biggestRoom);
        System.out.println("time used:" + (System.currentTimeMillis() - startBy));

    }

    public Room biggestRoom;
    public int maxArea(int numReg, int numWin, int numDoor) {
        biggestRoom = null;
        if (numReg < 6)
            return 0;
        if (numDoor < 1)
            return 0;
        if (numReg + numWin + numDoor < 8)
            return 0;
        Room initialRoom = null;
        if (numDoor > 1) {
            initialRoom = new Room("RDR", "R", "RDR", "R");
            numReg -= 6;
            numDoor -= 2;
        } else if (numWin > 0) {
            initialRoom = new Room("RDR", "R", "RWR", "R");
            numReg -= 6;
            numDoor -= 1;
            numWin -= 1;
        } else {
            initialRoom = new Room("RDR", "R", "RRR", "R");
            numReg -= 7;
            numDoor -= 1;
        }

        if (numDoor >= 2 && numReg >= 2) {
            initialRoom.appendWalls("DR", "DR");
            numDoor -= 2;
            numReg -= 2;
        } else if (numDoor >= 1) {
            if (numWin >= 1 && numReg >= 2) {
                initialRoom.appendWalls("DR", "WR");
                numWin -= 1;
                numDoor -= 1;
                numReg -= 2;
            } else if (numReg >= 3) {
                initialRoom.appendWalls("DR", "RR");
                numDoor -= 1;
                numReg -= 3;
            }
        }

        while (numWin >= 2 && numReg >= 2) {
            initialRoom.appendWalls("WR", "WR");
            numWin -= 2;
            numReg -= 2;
        }
        if (numWin >= 1 && numReg >= 3) {
            initialRoom.appendWalls("WR", "RR");
            numWin -= 1;
            numReg -= 3;
        } while (numReg >= 2) {
            initialRoom.appendWalls("R", "R");
            numReg -= 2;
        }
        biggestRoom = initialRoom;
        return initialRoom.getArea() * 16;
    }


    private class Room {
        StringBuffer east, south, west, north;
        public Room(String east, String south, String west, String north) {
            this.east = new StringBuffer(east);
            this.south = new StringBuffer(south);
            this.west = new StringBuffer(west);
            this.north = new StringBuffer(north);
        }

        public int getArea() {
            return east.length() * south.length();
        }

        public String toString() {
            return "east:" + east + "\tsouth:" + south + "\twest:" + west +
                    "\tnorth:" + north;
        }

        public void appendWalls(String w1, String w2) {
            if (east.length() < south.length()) {
                east.append(w1);
                west.append(w2);
            } else {
                south.append(w1);
                north.append(w2);
            }
        }
    }
}

<script>
function Int(n){return Math.floor(n)};
function min(n,m){return Math.min(n,m)};
function maxArea(numReg,numWin,numDoor){
 if(numDoor<1 || numReg<4 )
  return 0;
 var l,x=1,y=1;//x,y表示长和宽
 if(numDoor>4)numDoor=4;numReg-=4;
 var nUsed=min(numReg,numDoor+numWin);//用的门窗的总合
 
 if(nUsed%2)//如果是1或3，则补足2的倍数
 if(numReg-1>nUsed){//如果墙够用来代替门窗
  if((0==(numReg%2))&&(1==(nUsed%4))&&(nUsed>1))--nUsed;else//(12,4,1)bug
  {numReg-=1;++nUsed;}//则多用一个门窗
 }else --nUsed;//若不够,则少用一个门窗

 if(nUsed==0)return 0;//(5,5,5)bug

 if(l=Int(nUsed/4))//先添加到四面
 {
  x+=l*2;y+=l*2;//2=一个门窗加一个墙
  numReg-=l*4;nUsed%=4;//每面都要用墙,故*4
 }
 if(nUsed==2)
 {
  numReg-=2;//减去和门窗对应的墙
  x+=2;//先添加给一边,因为目前两边还一样长
  if(numReg>=2){numReg-=2;y+=1;}//如果墙有多余的,先给另一边加1,尽量相同
 }

 if(l=Int(numReg/4))//先添加到四面
 {
  x+=l;y+=l;//这时只加了一个墙
  numReg-=l*4;//但一样每面都要用墙,故*4
 }
 if(numReg>1)//多出来的分两边
 {
  numReg-=2;//只有一面加墙
  if(x>y)y+=1;else x+=1;
 }
 return x*y*16;
}

document.write("8,0,0=",maxArea(8,0,0), "<br>");
document.write("8,0,1=",maxArea(8,0,1), "<br>");
document.write("9,8,2=",maxArea(9,8,2), "<br>");
document.write("6,23,13=",maxArea(6,23,13), "<br>");
</script>

穷举法。其中用了3进制代替多重循环遍历。时间复杂度超过题目要求，失败！


import java.util.*;

public class HouseParty {
public static void main(String[] args) {
HouseParty hp = new HouseParty();
//hp.maxArea(3,0,0);
long startBy = System.currentTimeMillis();
/*
System.out.println(hp.maxArea(7, 0, 1));
System.out.println("biggest room:" + hp.biggestRoom);
System.out.println(hp.maxArea(9, 8, 2));
System.out.println("biggest room:" + hp.biggestRoom);
System.out.println(hp.maxArea(6, 23, 13));
System.out.println("biggest room:" + hp.biggestRoom);
*/
System.out.println("(16, 0, 4):"+hp.maxArea(16, 0, 4));
System.out.println("biggest room:" + hp.biggestRoom);
System.out.println("(16, 2, 1):"+hp.maxArea(16, 2, 1));
System.out.println("biggest room:" + hp.biggestRoom);
System.out.println("(16, 4, 4):"+hp.maxArea(16, 4, 4));
System.out.println("biggest room:" + hp.biggestRoom);
System.out.println("time used:" + (System.currentTimeMillis() - startBy));
}

private int numReg, numWin, numDoor;
private int REG = 0, WIN = 1, DOOR = 2;
private Room biggestRoom = null;
public int maxArea(int numReg, int numWin, int numDoor) {
if (numDoor == 0)
return 0;
if (numReg < 4)
return 0;
if (numDoor > 4)
numDoor = 4;
if (numWin > numReg / 2)
numWin = numReg / 2;
this.numReg = numReg;
this.numWin = numWin;
this.numDoor = numDoor;
ArrayList possibleWalls = getPossibleWals(numReg / 2 , numWin,1);
int result = getMaxArea(possibleWalls);
return result * 16;
}

private ArrayList getPossibleWals(int numReg, int numWin, int numDoor) {
ArrayList result = new ArrayList();
if (numWin > numReg / 2 - 1)
numWin = numReg / 2 - 1;
if (numDoor > 1)
numDoor = 1;
int wallMaxLength = numReg + numWin + numDoor;
for (int wallLength = 1; wallLength < wallMaxLength; wallLength++) {
for (int i = 0, n = new Double(Math.pow(3, wallLength)).intValue();
i < n; i++) { //这样穷举的效率很低，应用递归检查
Wall wall = new Wall();
wall.wall = new int[wallLength];
int tmp = i;
for (int j = 0; j < wallLength; j++) {
wall.wall[j] = tmp % 3;
tmp = tmp / 3;
}
if (wall.checkRule()) {
result.add(wall);
}
}
}
return result;
}

private int getMaxArea(ArrayList possibleWalls) {
int wallCount = possibleWalls.size();
int result = 0;
for (int iWallEast = 0; iWallEast < wallCount; iWallEast++) {
Wall east = (Wall) possibleWalls.get(iWallEast);
for (int iWallWest = 0; iWallWest < wallCount; iWallWest++) {
Wall west = (Wall) possibleWalls.get(iWallWest);
if (east.wall.length != west.wall.length)
continue;
if (east.wall.length != west.wall.length)
continue;
if (east.getRegCount() + west.getRegCount() > numReg)
continue;
if (east.getWinCount() + west.getWinCount() > numWin)
continue;
if (east.getDoorCount() + west.getDoorCount() > numDoor)
continue;
for (int iWallSouth = 0; iWallSouth < wallCount; iWallSouth++) {
Wall south = (Wall) possibleWalls.get(iWallSouth);
if (east.getRegCount() + west.getRegCount() +
south.getRegCount() > numReg)
continue;
if (east.getWinCount() + west.getWinCount() +
south.getWinCount() > numWin)
continue;
if (east.getDoorCount() + west.getDoorCount() +
south.getDoorCount() > numDoor)
continue;
for (int iWallNorth = 0; iWallNorth < wallCount; iWallNorth++) {
Wall north = (Wall) possibleWalls.get(iWallNorth);
if (south.wall.length != north.wall.length)
continue;
if (east.getRegCount() + west.getRegCount() +
south.getRegCount() + north.getRegCount() > numReg)
continue;
if (east.getWinCount() + west.getWinCount() +
south.getWinCount() + north.getWinCount() > numWin)
continue;
if (east.getDoorCount() + west.getDoorCount() +
south.getDoorCount() + north.getDoorCount() >
numDoor)
continue;
if (east.getDoorCount() + west.getDoorCount() +
south.getDoorCount() + north.getDoorCount() < 1)
continue;
Room room = new Room(east, south, west, north);
if (room.getArea() > result) {
result = room.getArea();
biggestRoom = room;
}
}
}
}
}
return result;
}

private class Wall {
public int[] wall;
public int[] combinationCount;
public int getRegCount() {
return combinationCount[REG];
}

public int getWinCount() {
return combinationCount[WIN];
}

public int getDoorCount() {
return combinationCount[DOOR];
}

public String toString() {
char[] tmp = new char[] {'R', 'W', 'D'};
String result = "";
for (int i = 0; i < wall.length; i++)
result += tmp[wall[ i ]];
return result;

}

public boolean checkRule(){
this.combinationCount = new int[3];
if (wall[0] == DOOR)
return false;
if (wall[wall.length - 1] == DOOR)
return false;
if (wall[0] == WIN)
return false;
if (wall[wall.length - 1] == WIN)
return false;
for (int i = 0, n = wall.length; i < n; i++)
if (wall[ i ] == WIN && (wall[i - 1] != REG || wall[i + 1] != REG))
return false;
else
combinationCount[wall[ i ]]++;
if (getRegCount() < 1)
return false;
if (getRegCount() > numReg)
return false;
if (getWinCount() > numWin)
return false;
if (getDoorCount() > numDoor)
return false;
if (getDoorCount() > 1)
return false;
return true;
}
}


private class Room {
Wall east, south, west, north;
public Room(Wall east, Wall south, Wall west, Wall north) {
this.east = east;
this.south = south;
this.west = west;
this.north = north;
}

public int getArea() {
if (east.wall.length != west.wall.length)
return 0;
if (south.wall.length != north.wall.length)
return 0;
if (east.getRegCount() + west.getRegCount() + south.getRegCount() +
north.getRegCount() > numReg)
return 0;
if (east.getWinCount() + west.getWinCount() + south.getWinCount() +
north.getWinCount() > numWin)
return 0;
if (east.getDoorCount() + west.getDoorCount() + south.getDoorCount() +
north.getDoorCount() > numDoor)
return 0;
if (east.getDoorCount() + west.getDoorCount() + south.getDoorCount() +
north.getDoorCount() < 1)
return 0;
return east.wall.length * south.wall.length;

}

public String toString() {
return "east:" + east + "\tsouth:" + south + "\twest:" + west +
"\tnorth:" + north;
}
}
}

>>import Java.util.Hashtable;

Java这个包是楼主自己写的吧？我只知道有个java.util.Hashtable

>>Map allDrivers =; 这也能编译通过？

不只jboss和eclipse是免费的，java也是免费的，但是我们都还在靠java混饭吃呢，这倒没什么不妥。

从来没有人证明过不可能有银弹，这也不是问题。目标过于远大？这更不成其为问题了。

剩下的问题我认为才是真正的问题。普元再强，你能强得过微软去？windows上面的软件大半不是微软出品的，用java开发的软件也大半不是sun出品的，可是普元上面的构件却基本上是普元出品的。虽然我们自己也可以开发构建，但是这不是一个开放的标准，我们如果这样做了自己的利益得不到保障，谁会去这样做呢？所以普元这个封闭的标准造成了他只能闭门造车，想帮他忙丰富他的构件库的人都无从下手。普元开发能力再强能开发出来多少种构件呢？

我觉得普元想做大，唯一的出路就是吧开发和应用环境都免费开放，最好干脆开源，并免费开放目前的大多数可以通用化的构件，在他的主导下创建并维护一个社群，让每个人都可以用EOS获取自己的利益，然后他可以以定制构件和生产出售在EOS平台上的软件来盈利。

如果他不这样做，我相信他的竞争对手迟早也会这么做。事实上，如果我是个没有生存压力的自由程序员，我现在也许已经在这么做了。

在他转向开放之前，我没有办法再看好他。

题目真够难的，一个钟头完成3道题的，都是些什么人啊！？

找到原因了，原来每次竞赛的竞赛平台版本都不同的，我下的Competition Arena 是google在2月的竞赛平台，它视图去连的2月竞赛服务器，难怪死的很难看。

指的是 http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5103041">http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5103041

jira在3.1的时候这样声明：
JDK 1.5 has a bug that prevents JIRA from processing mail correctly. Until the issue is resolved, JIRA does not support JDK 1.5. We recommend you use JDK 1.4.x but it is possible to continue with JDK 1.5 by restarting the server with option \'-Dallow.jdk.1.5=true\'. You can find the JDK bug at http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5103041">http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5103041

哈哈，jdk1.5是大势所趋，jira犟了几天终于还是投降了。

不懂就不要瞎掺和！

要证明徐业林的“无偏二极管”就是永动机不用照方舟和何院士，我就可以。所谓第二类永动机就是指可以依靠单一热源做功的热机，“无偏二极管”从空气中获得热量来输出电流，因此就是第二类永动机。

其实所谓的“无偏二极管”和最原始的第二类永动机原型（从空气或者海水中获得热量来做功的热机）并无二致。任振球（中国气象科学研究院研究员）　陈其翔（北京联合大学教授）　孙文鹏（核工业北京地质研究院研究员）　李世辉（总参工程兵第四设计研究院高级工程师）这几个《无偏二极管不是“永动机”》的作者应该好好学习一下热力学和再发表他们的高论。他们提出的“热力学第二定律成立必须满足的严格的限定条件”和在原始的第二类永动机原型上同样适用，他们应该先回顾一下历史上其他的第二类永动机失败的原因再反思他们的高论能否成立。(http://www.gmw.cn/01gmrb/2005-04/21/content_219445.htm)

想不出什么情形下需要用到。

王俊28日进仓
作者： Administrator
2005-07-29
王俊28日下午进仓，预计将在无菌仓内化疗10日左右，之后进行骨髓移植手术。

王俊妹妹王燚从工行和招行帐户中取款12万元，与其他8万元一起作为手术押金交纳给北大医院。王燚在10日后也将住院1-2日作移植。届时将由王俊的其他亲属负责照顾。

目前暂定于在术后一周(8月15日左右)结束募捐活动。据悉在术后7-10日即可得知手术成功与否。让我们祝福王俊吧~ 这20天，你要加油哦~

技术在人脑子里面啊。

我们有一组同事一个多月前开始做一个示范项目，公司的原目的是在项目中积累一些通用的模块和框架，可是就我现在看来，他们一群人都扑上去赶进度了，通用性？还是下回再说吧。

也许换种方式和框架，可重用性能得到一些提高？也许我们应该多关注一下soa了？

我读计算机纯粹是个误会，高考报的全部院校的第一志愿都是填的物理专业，第二才是计算机，跟别人反着来的，想着实在读不成物理了读计算机也将就，谁知道最后还真的读不成物理了跑去读计算机，可惜了一个大好物理人才。

你手头的好东东还真多

java的正则没怎么玩过，jscript中的特殊字符有以下11个。

$ 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 \$。
( ) 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)。
* 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。
+ 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。
. 匹配除换行符 \n之外的任何单字符。要匹配 .，请使用 \。
[ 标记一个中括号表达式的开始。要匹配 [，请使用 \[。
? 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?。
\ 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配 "("。
^ 匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^。
{ 标记限定符表达式的开始。要匹配 {，请使用 \{。
| 指明两项之间的一个选择。要匹配 |，请使用 \|。

>>这还不是我理想的java，只要是Object赋值，都要可以：
>>MyClass myobj = obj0:

其实在动态类型里面应该是在对任何变量赋任何值的时候都
myobj = obj0:

或者
var myobj = obj0:

最次的也是
Object myobj = obj0:

如果还限定MyClass 那就还是强类型语言了。

2个多月过去了，不知道楼主有什么进展？

我觉得于组件技术的要害首先是组件基础设施，包括主要的运行框架，组件的接口和协议。这个设计要先做好了，在它的基础上开发组件才有成功的希望。直接创建组件库的作用是不大的。所以按照我的理解，你的论文题目首先是关于组件基础设施的。

《业务构件工厂》(http://www.csdn.net/primeton/download/factory.rar)不知道楼主有没有看过？

在深圳，做过程序员，开过公司，有过非常好的朋友，也有过不怎么样的，住过黄木岗那么烂的房子，也在梅林水库边上最舒服的房子里住过，过过非常开心的日子，不开心的日子也有过，吃过山天和巴蜀风，也曾穷的开不起饭，绝色的网友mm也见过，恐龙当然也见过，还见过csdn上的绝顶高手，淘过美国村的各种小玩意儿，在大梅沙游过泳，在南山顶吹过清新的海风，太多太多的回忆难以忘怀。

现在进来这么难啊？我原来申请好像是自动受理的，刚申请就自动开通了。

>>>>map裡面放值可以進一步控制類型，比如什麼key只能放什麼類型的value.
>>泛型不是已經能實現了嗎!?

呵呵Dennis 看混了。什么key只能放什么类型的value是不大可能被支持的。现实应用中的key的可能性是无穷多的，即使相同的key在不同的应用中也有不同的含义，而且一个key在一个容器里面只能对应一个对象，所以从语言层面上在key和value之间建立这样的关联是无法想像的，goldrain只是在钻牛角尖而已。

>>>>编译当然不去能排除所以错误，但是所有能够在编译期排除的错误都没有理由留到调试的时候去发现
>>代价难道是增加一门语言的复杂度？
你可以选择的，多接受一个语言概念，少一些犯错误的可能性，或者相反。我想任何一个做过中等以上规模项目的人都知道怎么选择的代价更大。

>>现在的动态类型语言如python连变量的类型都不用定义了，
>>而且还不是一样那么多的追随者，一样做大型的项目，
>>甚至很多人都已经开始怀疑我们到底要强类型还是弱类型，
>>要编译语言还是脚本语言了。java却一意孤行，在复杂的道路上越走越远...这么发展下去，再出个java6.0,7.0,不知到又会增加怎样的功能，但结果是显然的:java将越来越复杂！

java6就会支持至少3种动态语言了，如果你高兴还有很多开源项目会帮你支持更多的。但是弱类型和脚本语言也有它的代价。没有编译期类型检查的支持，做大的软件项目和负责的应用是不可想像的。而且脚本语言的运行效率暂时也不可能像jvm的运行效率这样芝麻开花节节高。反编译一个groovy脚本编译成的class文件来读一读你就会看到，动态类型造成了多大的代价。而当前摩尔定律正在面临失效……

>>语言究竟要简单还是要复杂？没有泛型前的我们真的很需要泛型么？

没有人喜欢复杂的语言的，但是怎么样才是真正的简单是个值得思考的问题。泛型在我看来恰恰让语言更简单了。我们不用自己去做烦琐的类型检查而同时也不用担心我们api的调用者往我们容器里面乱放东西了，更不要说节省我们没有作类型检查而费尽心思去调试程序找出错误调用的代价。

>>而5.0加入的泛型就显得多余，java控制了变量的类型还不够，还想通吃List,Map中的类型控制。本来List,Map只要对象就能放进去，加道控制不是自己给自己设卡么。有几个开发会犯这种错误……

不是这样的。5.0没有通吃List，Map中的类型控制，他只是提供了泛型这个手段，没有强制你一定要转到泛型上。

>>有几个开发会犯这种错误，就算设错了类型，这种错误到运行期让它抛出就是了，没必要对原本简单的语法大作文章，你难道想在编译期就排除所有错误么

如果你的包将发布给你不知道的人使用，你就要对他们有可能范的错误尽可能做好准备而不是一相情愿的相信没几个开发者会犯错误。这中错误在编译期发现和运行期发现处理的代价相差是非常巨大的。编译当然不去能排除所以错误，但是所有能够在编译期排除的错误都没有理由留到调试的时候去发现（很多时候甚至调试时都发现不了）。

>>本标签只支持jdk1.5,及其通过jndi获得数据库连接！！

wow!一个标签还要处理数据库连接，还要获得sql语句，和底层绑定的太多，实用倒实用了，通用性呢？

原来也想过做相同的东西，但是关键问题没有想通。其实displaytag的开发者倒也未必没想过这个问题，但是可能要找一个漂亮简单通用的解决方案真的不大容易吧。

如果一次不把全部数据交给displaytag去分页，那么在翻页的时候就要重新进行查询，那么displaytag就不得不和数据访问部分绑定，这样标签就没有办法通用化了。

我很有兴趣的是大明白的displaytagpro怎么解决翻页的时候重新查询呢？

就是demo里面的displaytagpro.jar文件对吗？怎么不提供原码？

我现在在成都发展，一时间还回不了深圳，天天盼啊。
那天听说google有卫星地图，赶快就上去看了深圳了，看到以前工作学习过的那些地方，不禁感慨。

我们搞的技术好像差不多。一直在关注你的blog。

晓得在深圳，深圳哪里啊？我在深圳也住过2年，搬过10次家 :-P

>>很多Java框架是帮我们省去很多繁杂的操作，解决我们实际开发中共同遇到的问题的，关键是你能不能理解到这个共同的实际问题是什么

好！

买在哪里啊？

嘻嘻，这篇随笔居然上了七月的程序员杂志。

突然想起一个问题，假如热力学箭头反转而心理学箭头不反转，那么我们其实没有办法分别现在的宇宙是在膨胀还是收缩……也许我们现在的前进方向根本就是反的呢？

与时间穿梭有关的一个话题是时间反演：在遥远的未来，宇宙膨胀结束后继以收缩，时间箭头反转（热力学箭头会反转，但是心理学箭头也会吗？存疑），一切开始反演，我们腐烂的尸体也重新变得新鲜，然后心脏又开始跳动，反演我们的一生之后钻回妈妈肚子里面结束这一生（我的天啊！），至少物理学上是没有矛盾的。

不过现在的天文观测表明宇宙继续在加速膨胀（而不是减速），因此很可能我们不会再回来。

还有虫洞，我想物理学最终不会容许破坏因果关系的现在出现的……不过也难说，量子逻辑这么古怪的怪胎毕竟都诞生了，说不定有一天新的“虫洞逻辑”也会出现呢？

王俊近况及募捐情况报告
作者： Administrator
2005-07-22
7月18日，王俊由于牙齿发炎，拔了一颗牙。另由于医院无菌仓被其他病人占用，尚无法预约。因此还需要休养一段时间才能够预定手术时间。目前王俊打算再次回家休养。

7月19日，《竞报》采访了王俊，登载报道：博客总动员拯救程序员王俊，日前已在人民网等媒体转载。

王俊的照片参见: http://blog.donews.com/xinhaiguang/archive/2005/07/18/471058.aspx

7月20日，募捐款达到10万（不含亲友借款）

王俊托我们向大家说：感谢所有的哥们

原以为大胃这样的高手是不用金山词霸的呢。
TT跟金山词霸也有冲突。他们两家人是不是闹什么矛盾啊？彼此都是最流行的国产软件，居然没有彼此做过兼容性测试？
断线跟电信网络这段时间不稳定有关吧。
我有个朋友现在都改用手机上QQ了，7*24在线，因为现在动感地带的一个套餐是gprs10元包月不限时不限流量。

改起来总没有写起来麻烦。可以在word里面编辑好了粘贴到blog里面。要突出的评论也不一定要通过颜色。

铁手的批注很好看，可惜粉红色很难看，斜体也很难看。

---

出于开发成本考虑，老板总是希望工程师无所不会，这样才能减少成本嘛？！才会出现很多招聘广告上这样写道“精通A,B,C,D,E。。。。，工作经验2年”薪水却只开到2K。这样的事天天发生。是觉得可笑吗？还是觉得悲哀。是觉得人事部门的问题，还是该公司的技术管理着根本就不懂。或者就是老板的问题。不，这是市场的问题。同一个软件，规模和功能几乎一样，在国内买个10万，很高了，在英国卖到60万英镑。呵呵，这就是市场。市场就绝对正确吗？可是房价天天涨，现在毕业的程序员，看着房价怎的不愁？NND.

---

愁啊，虽然毕业多年了，一样愁。市场变成现在的样子，不是没有原因的。

快两个月过去了，对iBatis SqlMap 的研究有否进展？

>>我们比较两个String的值，最好用equals()方法，而最好不要使用==

结论是对的，但是跟string pool没什么关系。

>>另外，声明String的时候，最好用=，这样就可以体现String pool的作用了。

结论也是对的，但是这样做不是为了体现String pool的作用而是避免重复创建对象。

不需要取模吧。直接random.nextInt(100)就可以了嘛：

...
* @param n the bound on the random number to be returned. Must be
* positive.
* @return a pseudorandom, uniformly distributed <tt>int</tt>
* value between 0 (inclusive) and n (exclusive).
* @exception IllegalArgumentException n is not positive.
* @since 1.2
*/

public int nextInt(int n) {
...

作者： 冰云(BJUG)
2005-07-11
目前帐户中总额达到了14万左右，其中8万左右为各位朋友的募捐，6万左右是王俊亲友的借款。另有一些朋友直接将钱交到了王俊家人手中，再加上他自己原本借到的一些，已经基本凑足了20万手术费。

具体帐户数目请参见：http://befresh.bjug.org/content/view/20/3/

王俊已经向医生预约了手术，11日就将进入医院做全面的术前身体检查，并将一直住院直到康复。具体手术时间需要视王俊体检情况和医院的安排来定，目前暂无法得知。手术押金将在手术时间确定后缴纳。

手术后将是最危险的一段时间，由于白细胞皆被化疗杀死，病人将非常脆弱，免疫力极其低下，必须住在无菌病房中。再加上术后的排异药物，术后保健等，仍需要一些资金支持。(以上医学知识本人只是了解大概，可能不太准确)

因此我们的目标为30万。在这里再次呼吁我们其它同样有爱心的兄弟姐妹们，我们已经筹集了到了20万（包括亲属筹集），但是还有10万的缺口需要补齐，希望能得到您的帮助。我们也在用其他的方式进行筹集，相信不久，我们就能够凑够所有的治疗费用。

让我们一起为王俊祈祷，祝他早日康复吧。

同时，感谢所有献出爱心的朋友，祝福你们：
http://befresh.bjug.org/content/view/12/12/

嘿嘿，emu（鸸鹋）跟鸵鸟倒恰好是一家。

可是你说的是泛形带来的其他问题，而这个问题其实不是泛形带来的。

daniel 只是和 emu 观点不同而已，并不是糨糊脑袋，我猜想他是看到了发愣分子或者其他一些方舟的对头编造的谣言。不过具体是什么样的谣言我也很好奇。

这是jdk1.5一个已经报告的bug：
http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5103041


问题在于在jdk1.5中Timestamp多定义了一个比较方法：

public int compareTo(java.util.Date o) {
return compareTo((Timestamp)o);
}

这样如楼主所说，在1.4中Timestamp.compareTo(Date)的时候会调用继承来的Date.compareTo(Date)方法来完成比较，而Date.compareTo(Date)在比较前会把参数造型成Date对象，因此可以完成比较；而在1.5中Timestamp则直接使用自己的Timestamp.compareTo(Date)方法来比较，并试图在其中把参数造型成Timestamp，因此抛出造型异常。

但是这并不像楼主想像的，“Generics也会带来一些其他的问题”，而是sun有意为之。看上面这个compareTo方法的相关说明：

// This forwarding method ensures that the compareTo(Date) method defined
// in java.util.Date is not invoked on a Timestamp

显然sun认为1.4中的做法是不对的，下定决心在以放弃兼容性为代价在1.5中更正这个错误，而不是一个bug(真的要修复这个bug的话只要把上面这个方法删掉就行了)。sun坚持的正好就是楼主说的原则问题：只比较具有相同类型的两个对象

放弃兼容性的代价就是有一些在1.4下面正常的代码在1.5下面不能允许了，包括大名鼎鼎的JIRA。对此JIRA的反应是：

JDK 1.5 has a bug that prevents JIRA from processing mail correctly. Until the issue is resolved, JIRA does not support JDK 1.5. We recommend you use JDK 1.4.x but it is possible to continue with JDK 1.5 by restarting the server with option \'-Dallow.jdk.1.5=true\'. You can find the JDK bug at http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5103041


可是JIRA想要等“issue is resolved”那一天恐怕等不着了，这是个原则问题嘛 :)