求教二个笔试题，请大家能给出合理的答案

Question

1、今天笔试一道题说一个字符串String A是由N个小写字母(a至z)构成，定义为byte A[N],用更少的空间表示这个字符串，并说出原理和节省空间的比率 
2、一个人花30买的货物,40卖出，50买进，60卖出，问写个程序分析下他的经济效益

Answer 1

1,提供你一种简单的无损压缩办法：
假设字符串为:aaaabcdeeefghiiii，那么可以压缩为：4a-3bcd3e-3fgh4i
解压时，被压缩的字符串一个为正整数N时，后面的一个字符将被展开N次，比如说4a，那么解开后是aaaa
如果，是负整数-N，那么说明后面跟的N个字符是没有被压缩的，比如说，-3bcd，那么还原后是bcd，
以此类推，可以还原出全部的。
压缩算法和解压算法都没有什么难度，就不多说了。
节省空间的比率要看重复数据的多少而定。连续的字符，比方说aaa，可以被压缩成3a，不连续的,比方说abc，变成了-3abc，长度会变长，考虑最坏情况，比方说aabcddefgghi....，变成2a-2bc2d-2ef2g-2hi，
每2个连续字符后紧跟2个不连续字符，那么空间可能是原来的2倍。但是，连续字符多的情况下，压缩率还是
非常可观的。

Answer 2

第一题两个N应该是一样的吧
byte[] b=a.getByte(); 就可以了

Answer 3

小写a-z int值 97-122 在Byte范围内
完全可以代替由char[]实现的string

Answer 4

byte A[N],用更少的空间表示这个字符串A

Answer 5

1.由于在java中char占16bit位，而byte占8bit位，
但是由于a-z的ascii码值在97-122之间，在byte能表示范围之间
所以用byte来存储能节省空间

Answer 6

我又想了下,比方说"aaaeeeg"可以压缩成"3a3e1g",也可以压缩成"3a3e-1g",有二义性,不过我采用的是第2种.没压缩的话都是用"-1"表示.对于重复的比较厉害的字符串这种方法还是很可取的.

Answer 7

第一个问题：
首先在32位的机器上，一个Object占用的内存是8byte.一个引用占4byte
在来考虑String占用的内存public class String 
{
    private final char value[];
    private final int offset;
    private final int count;
    private int hash; 
}所以，不考虑那个char[]的占用，一个String最少占用 [8+4+4+4+4]=24bytes加上引用，共28bytes
在加上char[]所占的内存就等于28+[8+4+2*value.length]
用字节数组表示所占用的内存
4+8+4+1*length
比例你可以算一算注意的是jvm对所有的Object有限制！这个限制就是不管什么Object占的空间，要是8的倍数

Answer 8

我又想了下,比方说"aaaeeeg"可以压缩成"3a3e1g",也可以压缩成"3a3e-1g",有二义性,不过我采用的是第2种.没压缩的话都是用"-1"表示.对于重复的比较厉害的字符串这种方法还是很可取的.

Answer 9

a-z,26个字母，用二进制5位。用一个long型的话就能保存12个字母。
long l[]=new long[N/12+1];
int index=0;
for(int i=0;i<l.length;i++)
{
    for(int j=0;j<12;j++)
    {
        l[i]+=byte[index++];
        if(j!=11)
        {
            l[i]<<5;
        }
    }
}
节省率：64/(12*8)=66.6%;

Answer 10

分析
30  ----买入
40  ----卖出  赚 10  ----  +10   
50  成本+10 即现在的成本是40
60  卖出 ------相对成本来说就+20
如此类推，即每一次买卖都会赚10public class WinMoney { public static void main(String[] args) {
System.out.println(getWinMoney(10,2));
}

/**
 * @param win:每次赚的钱/再次买入添加的成本
 * @param n:交易次数( 1 就表示1次买入和1次卖出)
 * return 返回最后的总钱数
 */
public static int getWinMoney(int win,int n){
int winMoney=0;

if(n==1){
winMoney=win;
return winMoney;
}else if(n>1){
for(;n>=1;n--){
if(n==1){
winMoney+=win;
}else{
winMoney=getMoney(winMoney,win);
}

}
}else{
return winMoney;
}
return winMoney;
} private static int getMoney(int winMoney, int win) {
winMoney+=win;
return winMoney;
}
}

Answer 11

写错了，getWinMoney(int win,int n)是返回最后的利润数。
不知道是否符合题目意思。

Answer 12

修正下
public class WinMoney {    public static void main(String[] args) {
        System.out.println(getWinMoney(10,2));
    }
    
    /**
     * @param win:每次赚的钱/再次买入添加的成本
     * @param n:交易次数( 1 就表示1次买入和1次卖出)
     * return 返回最后的利润数
     */
    public static int getWinMoney(int win,int n){
        int winMoney=0;
        
        if(n==1){
            winMoney=win;
            return winMoney;
        }else if(n>1){
            return winMoney*n;
        }else{
            return winMoney;
        }
        
    }    private static int getMoney(int winMoney, int win) {
        winMoney+=win;
        return winMoney;
    }
}

Answer 13

我觉得一楼的想法是不错的，但是从存储的角度来讲，26个小写字母，完全不需要一个byte的空间，
5Bit-8Bit足够了，如果还想再小，就需要Huffman树了。PS:坚决反对倒买倒卖。

Answer 14

第一个我用下面的这个表示字符串，大家看对不对
Byte A[]="abcd..z";
String A = new (A.getByte());

Answer 15

public class Penefit {
private double firstPrice, firstOut, secondPrice, secondOut;
public Penefit(double firstPrice, double firstOut, double secondPrice, double secondOut){
this.firstPrice = firstPrice;
this.firstOut = firstOut;
this.secondOut = secondOut;
this.secondPrice = secondPrice;
}
public double calcProfit(){
double upRate = (secondPrice - firstPrice)/firstPrice;//计算膨胀率
return ((firstOut-firstPrice)*(1+upRate) + (secondOut-secondPrice));
}
public static void main(String args[]){
Penefit p = new Penefit(30,40,50,60);
System.out.println(p.calcProfit());
}}