【leetcode】Elegant Code

1.第168后面评论区里面的答案

这道题类似于十进制转换成26进制。有个大神使用了一行的递归代码convertToTitle：

class Solution {
    public String convertToTitle(int n) {
        return n == 0 ? "" : convertToTitle(--n / 26) + (char)('A' + (n % 26));
    }
}

相当优秀

2.179 （Meduim）Largest Number

https://blog.youkuaiyun.com/AXIMI/article/details/89106492
这道题的意思是，给定一个数组例如[12,345,9,912]，要求输出这些数字能组合出来的最大数字（用字符串表示）。
主要方法是将int型的数组转为String（方便数字的拼接和比较），然后重载Collections.sort()中的compare方法来对数组进行排序
最后使用StringBuilder串起数组中的数字，然后在剃掉字符串前面的0.
我的写法是：

class Solution{
	public String largestNumber(int[] nums) {
		// 将int数组改为String数组，方便后面进行比较
		List<String> list=new ArrayList<String>();
		for(int num : nums)
			list.add(String.valueOf(num));
		
		// 使用Collections.sort()对数组进行排序，排序规则为两个字符串相加后的
		// 结果比较。这里是逆序排序
		Collections.sort(list,new Comparator<String>() {
			@Override
			public int compare(String s1,String s2) {
				return Long.parseLong(s1+s2)>Long.parseLong(s2+s1)?-1:1;
			}
		});
		
		// 将排序后的结果串起来
		StringBuilder sbuilder=new StringBuilder();
		for(String s :list)
			sbuilder.append(s);
		
		// 剃掉前面的0
		while(sbuilder.charAt(0)=='0'&&sbuilder.length()>1)
			sbuilder.delete(0,1);
		
		return sbuilder.toString();
	}
}

可以看到重载compare方法的时候使用的是传统的@Override的方式，
同时在剔除字符串前面的0的时候，使用了while循环和StringBuilder的delete方法

评论区大神的代码为：

class Solution {
    public String largestNumber(int[] nums) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < nums.length; i++)
            list.add(Integer.toString(nums[i]));
        Collections.sort(list,(a,b) -> (int)(Long.parseLong(b+a) - Long.parseLong(a+b)) );
        StringBuilder sb = new StringBuilder();
        for(String x:list) {
            sb.append(x);
        }
        //remove leading 0
        return sb.toString().replaceFirst("^0+(?!$)", "");
    }
}

重载compare方法和剔除字符串前面的0都只用了一行代码。。
这里重载compare方法应该是使用了es6的语法。

3.剔除排序好的数组中的重复数字

例如数组：2 2 2 3 5 5 5 6 6 7 8 11 中有一些重复的数字，下面的代码可以简洁地剔除其中重复的数字。

int len=0,i=0;
while(i<nums.length) {
     while(i<nums.length&&nums[i]==nums[len])
          i++;
     if(i<nums.length)
          nums[++len]=nums[i];
}

上面这个代码直接在原数组中进行修改，剔除了重复数字的数组的数字个数为len

4.227题评论区的答案

我的解法是：

class Solution {
    public int calculate(String s) {
    	int res=0,p=0,num=0,tmp=0,flag=1;
    	Stack<Integer> stack=new Stack<Integer>();
    	
    	while(p<s.length()) {
    		if(s.charAt(p)>='0'&&s.charAt(p)<='9') {
    			num=s.charAt(p)-'0';
    			while(p+1<s.length()&&s.charAt(p+1)>='0'&&s.charAt(p)<='9') {
    				num*=10;
    				num+=s.charAt(p+1)-'0';
    				p++;
    			}
    			stack.push(flag*num);
    			flag=1;
    		}else if(s.charAt(p)=='-') {
    			flag=-1;
    		}else if(s.charAt(p)=='*') {
    			while(s.charAt(p+1)==' ') p++;
    			tmp=s.charAt(++p)-'0';
    			while(p+1<s.length()&&s.charAt(p+1)>='0'&&s.charAt(p+1)<='9') {
    				tmp*=10;
    				tmp+=s.charAt(++p)-'0';
    			}
    			res=stack.pop()*tmp;
    			stack.push(res);
    		}else if(s.charAt(p)=='/') {
    			while(s.charAt(p+1)==' ') p++;
    			tmp=s.charAt(++p)-'0';
    			while(p+1<s.length()&&s.charAt(p+1)>='0'&&s.charAt(p+1)<='9') {
    				tmp*=10;
    				tmp+=s.charAt(++p)-'0';
    			}
    			res=stack.pop()/tmp;
    			stack.push(res);
    		}
    		p++;
    	}
    	
    	res=0;
    	while(!stack.isEmpty())
    		res+=stack.pop();
    	return res;
    }
}

大神的解法是：

if (s == null || s.length() == 0) return 0;
        Stack<Integer> stack = new Stack<>();
        s += '+';
        char op = '+';
        for (int i = 0, n = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (Character.isDigit(c)) { n = n * 10 + c - '0'; continue; }
            if (c == ' ') continue;
            if (op == '+') stack.push(n);
            else if (op == '-') stack.push(-n);
            else if (op == '*') stack.push(stack.pop()*n);
            else if (op == '/') stack.push(stack.pop()/n);
            op = c;
            n = 0;
        }

        int total = 0;
        while (!stack.isEmpty()) total += stack.pop();
        return total;

主要是以下的处理比较好：
1.判断字符是数字的时候我使用的是：

s.charAt(p)>='0'&&s.charAt(p)<='9';

更简洁地写法是：

Character.isDigit(c);

2.我的代码中频繁使用s.charAt(p)这个表达式，其实循环开始的时候直接使用一个变量代替会简洁很多

5.289 Game of Life

这道题的意思是，有一个二维数组，数组中的数字需要根据周围的8个数字来更新。
例如二维数组中[i][j]中的数字，需要获得它周围8个数字的数据。由于不是所有位置的数字都有8个相邻数，所以我在遍历数组的时候使用了8个三元表达式。。。很不简洁。
我的总代码如下：

class Solution {
    public void gameOfLife(int[][] board) {
    	if(board==null|| board.length==0||board[0].length==0)	return;
    	
    	int m = board.length;
    	int n = board[0].length;
    	int[][] neighbors = new int[m][n];
    	
    	for(int i=0;i<m;i++) {
    		for(int j=0;j<n;j++) {
    			neighbors[i][j]+=((i-1)>=0)&&((j-1)>=0)?board[i-1][j-1]:0;
    			neighbors[i][j]+=((i-1)>=0)?board[i-1][j]:0;
    			neighbors[i][j]+=((i-1)>=0)&&((j+1)<=n-1)?board[i-1][j+1]:0;
    			neighbors[i][j]+=(j-1)>=0?board[i][j-1]:0;
    			neighbors[i][j]+=(j+1)<=n-1?board[i][j+1]:0;
    			neighbors[i][j]+=((i+1)<=m-1)&&((j-1)>=0)?board[i+1][j-1]:0;
    			neighbors[i][j]+=((i+1)<=m-1)?board[i+1][j]:0;
    			neighbors[i][j]+=((i+1)<=m-1)&&(j+1)<=n-1?board[i+1][j+1]:0;
    		}
    	}
    	
    	for(int i=0;i<m;i++) {
    		for(int j =0;j<n;j++) {
    			if(neighbors[i][j]<2||neighbors[i][j]>3)
    				board[i][j]=0;
    			if(neighbors[i][j]==3)
    				board[i][j]=1;
    		}
    	}
    	
    }
}

其实第一个for循环可以使用更优雅的方式来表达：

for (int x = Math.max(i - 1, 0); x <= Math.min(i + 1, m - 1); x++) {
        for (int y = Math.max(j - 1, 0); y <= Math.min(j + 1, n - 1); y++) {
            ......
        }
    }

6.331

这道题是给一个字符串，判断该字符串是否是一棵树先序遍历的结果。
刚开始需要将该字符串调整为字符串数组，我还傻乎乎的写了函数完成这个过程：

public ArrayList<String> getNumbers(String s) {
    	ArrayList<String> res=new ArrayList<String>();
    	
    	int p1=0,p2=0,len=s.length();
    	while(p2<len) {
    		while(p2<s.length()&&s.charAt(p2)!=',')	p2++;
    		res.add(s.substring(p1,p2));
    		p1=p2+1;p2=p1;
    	}
    	
    	return res;
    }

其实直接使用split函数就可以了：

String[] numbers = preorder.split(",");

7

nums[0]=1;nums[1]=1;

可以写为：

nums[0]=nums[1]=1;

8

if(num<nums[i]){
	res1=0;
else{
	res1++;
	if(res1==threshold){
	res2++;
	res1=0;
}

if(num<nums[i])
	res1=0;
else if(++res1==threshold){
	res2++;
	res1=0;
}