21年10月第二周 力扣每日一题记录

本周每日一题 题目

  • lc482. 密钥格式化
  • lc284. 窥探迭代器
  • lc414. 第三大的数
  • lc434. 字符串中的单词数
  • lc187. 重复的DNA序列
  • lc352. 将数据流变为多个不相交区间
  • lc441. 排列硬币

10-04 lc482. 密钥格式化

  • 今天是个简单题,也是非常简单的一道题
  • 给一个字符串,经过处理
  • 然后给k值,将字符串分成多个k字符的分组,第一个小于等于k,那么很简单,第一个直接是n%k就可以了,后面的全部是k,当然,如果结果是0,那么每个都是k,第一个就置为k
  • 简单题,直接看代码,不多bb
class Solution {
    //按照-来分割字符串,然后第一个分组小于等于k,至少有一个,后面的要刚好包含k个字符
    //然后因为只有字母,所以要转成大写,这个有api
    //也就是第一个至少有1,但是有多少是按照后面的整除的情况来的
    public String licenseKeyFormatting(String s, int k) {
        char[] ss = String.join("",s.split("-")).toUpperCase().toCharArray(); //去掉破折号,并转大写,转成char数组
        int n = ss.length;
        //每一个的数量
        int each = n%k==0?k:n%k; //初始为第一个的数量,后面置为k
        //重组
        StringBuilder sb = new StringBuilder();
        for(int i=0; i<n; i++){
             if(each==0){
                 sb.append('-');
                 each = k;
             }
             sb.append(ss[i]);
             each--;
        }
        return sb.toString();
    }
}

10-05 lc284. 窥探迭代器

  • 这题一上来有点懵,搞不懂为什么
  • 看了java iterator的api,大概知道了,原始的api提供给我们hasNext()方法和next()方法,而我们自己要去实现peek()方法,该方法是返回下一个元素,而指针并不移动
  • 这里有个细节在于,我的peek其实只管用一次,就是在我用peek之后,我会返回下一个元素,而指针不动,那我再peek一次,还是之前的那个元素,因为指针并不移动
  • 所以这里的思路就是,使用一个int变量peekElement作为peek值的缓存
  • 如果使用了peek,那么我就调用原始api的next方法,将返回的值保存到peekElement中去,如果之后再peek,我都返回这个值,而如果之后调用了next方法,那么我就将peekElement返回,然后保证它只使用一次
  • 也就是说,我调用peek的时候,其实已经调用了next,只是通过缓存的方式,欺骗用户,让用户以为我的指针没动
  • 然后对应的,hasNext,next方法等,逻辑都要对peekElement先进行判断,这里我还加上了判空的逻辑,虽然题目没有要求
class PeekingIterator implements Iterator<Integer> {
    //通过原生的api明显是不能完成peek这个操作的,所以要自己用单独的方式实现
    //其次就是我不next的情况下,最多只能peek一次,也就是我只要存储一个数据就可以了,这个数据是前一个的
    //只要它不为0,那么就返回它,但只能使用一次
    private Iterator<Integer> iterator;
    private int peekElement = 0;// 0 代表无数据

	public PeekingIterator(Iterator<Integer> iterator) {
	    // initialize any member here.
        this.iterator = iterator;
	}
	
    // Returns the next element in the iteration without advancing the iterator.
	public Integer peek() {
        if(peekElement!=0) return peekElement;//peek可以无限用
        if(iterator.hasNext()) peekElement = iterator.next();
        return peekElement;
	}
	
	// hasNext() and next() should behave the same as in the Iterator interface.
	// Override them if needed.
	@Override
	public Integer next() {
        int res = 0;
        if(peekElement!=0||!iterator.hasNext()){
            res = peekElement;
            peekElement = 0;//只能使用一次
        }
        else res = iterator.next();
	    return res;
	}
	
	@Override
	public boolean hasNext() {
	    return iterator.hasNext()||peekElement!=0; //当peekElement不为0时,说明
	}
}

10-06 lc414. 第三大的数

  • 写的有点懵。。一直在想怎么写的更优雅,结果一直都不优雅
  • 两种解法,都差不多
class Solution {
    //需要是第三大的不同的数字,如果相同,则认为是一个
    //用三个变量来记录
    public int thirdMax(int[] nums) {
        long first = Long.MIN_VALUE;
        long second = Long.MIN_VALUE;
        long third = Long.MIN_VALUE;
        //先从小数来更新,就会出错,所以从大数来看
        for(int num: nums){
            long cur = num;
            if(cur>first){//swap
                long t = cur;
                cur = first;
                first = t;
            }
            else if(cur==first) continue;
            if(cur>second){//swap
                long t = cur;
                cur = second;
                second = t;
            }
            else if(cur==second) continue;
            if(cur>third){//swap
                long t = cur;
                cur = third;
                third = t;
            }
        }
        if(third!=Long.MIN_VALUE) return (int)third;
        return (int)first;
    }
}
  • 因为不能像go语言那样快速交换,所以这里写起来很丑,不然就三个swap,就很舒服了
  • 还有一种下面的写法,稍微短一些,看起来也还好
class Solution {
    public int thirdMax(int[] nums) {
        long first = Long.MIN_VALUE;
        long second = Long.MIN_VALUE;
        long third = Long.MIN_VALUE;
        for(int num: nums){
            if(num>first){
                third = second;
                second = first;
                first = num;
            } 
            else if(num>second&&num<first){
                third = second;
                second = num;
            }
            else if(num>third&&num<second) third = num;
        }
        return (int)(third ==Long.MIN_VALUE? first:third);
    }
}
  • 这里都通过long来解决边界,边界值太恶心了,要附加很多逻辑,不如用long

10-07 lc434. 字符串中的单词数

  • 简单题,就是需要自己去实现split,来解决空格问题
class Solution {
    //连续的不是空格的字符
    //测试用例太少了,只能试试了
    //"",",,,,     a, eaefa"
    public int countSegments(String s) {
        s += " ";
        char[] ss = s.toCharArray();
        int cnt = 0;
        for(int i=0; i<ss.length; i++){
            if(ss[i]==' '&&i>0&&ss[i-1]!=' ')
                cnt++;
        }
        return cnt;
    }

}

10-08 lc187. 重复的DNA序列

  • 题目没读清楚,就赶着做,有点蠢了,没看到目标子串的长度为10,所以就写了个O(n2)的,太蠢了
  • 因为限制了长度为10,所以实际上也就只有n-9个子串,那么把所有的子串放到set中去,如果重复,就加入结果集,如此便可以实现题目要求
  • 这里记录一个api,String s = new String(char[] chs, int offeset, int count), 这是从char数组中生成String的方法,很好用
  • 其实这里的问题在于,生成了过多的String,对gc其实蛮有压力的
class Solution {
    public List<String> findRepeatedDnaSequences(String s) {
        Set<String> set = new HashSet<>(); //存储出现元素
        Set<String> res = new HashSet<>(); //存储结果元素
        char[] ss = s.toCharArray();
        for(int i=0; i<ss.length-9; i++){
            String cur = new String(ss,i,10);
            if(set.contains(cur)) res.add(cur);
            set.add(cur);
        }
        //set转list
        return new ArrayList<String>(res);
    }
}

10-09 lc352. 将数据流变为多个不相交区间

  • 这题很好,但是写题目的人很辣鸡,题意没写清楚,我真是服了
  • 意思是,将连续的数字给写成一个区间
  • 难点在于,需要不断的插入新的数,导致情况变化,所以每次进行统计
  • 我这里是O(n2)方解法的,每次都是暴力解
class SummaryRanges {
    //这题出的很垃圾,题目意思没有讲清楚,导致看了示例之后更懵了,搞不清楚是为啥
    //终于明白了,这题的意思是连续的进行合并成一个区间,不连续的单独作为一个区间
    //O(n2)暴力解,用什么数据结构来存储呢,能够o1的存,然后O(n)的取
    //直接用数组存储就好了,因为范围有限
    private int[] vals;
    public SummaryRanges() {
        vals = new int[10001];
    }

    public void addNum(int val) {
        vals[val] = 1;
    }
    
    public int[][] getIntervals() {
        List<int[]> list = new ArrayList<>();
        int i = 0;
        while(i<=10000){
            while(i<=10000&&vals[i]==0) i++;
            if(i>10000) break;
            int[] cur = new int[2];
            cur[0] = i;
            cur[1] = i;
            while(i<=10000&&vals[i]!=0) i++;
            cur[1] = i-1;
            list.add(cur);
        }
        int[][] res = new int[list.size()][2];
        for(i=0; i<res.length; i++){
            int[] cur = list.get(i);
            res[i][0] = cur[0];
            res[i][1] = cur[1];
        }
        return res;
    }
}

10-10 lc441. 排列硬币

  • 是一个简单题,反正就很简单
  • 用求和公式来,首先找到平方数,向上取整,让后往下找,知道求和公式结果小于等于当前的n
  • 因为这里数会越界,所以全程用long来进行处理,就能解决
  • 同时,平方数离答案的距离已经很近了,这里就不用再用Ologn了,直接On往下遍历就行了
class Solution {
    //最后一行可以不完整,而前面必须完整i行必须有i个
    //最简单的思路,这是一个累加和,直接从1一直加到大于这个数,然后返回前一个就可以,这样会超时
    //用求和公式来,(1+k)*k/2 = (k+k2)/2--> 2n的平方根,然后分别往下去找
    public int arrangeCoins(int n) {
        long t = 2*(long)n;
        long i = (long)Math.sqrt(t)+1;//向上取整,此时累加是大于2n的
        while(sum(i)>t) i--;
        return (int)i;
    }

    private long sum(long sqrt){
        return (1+sqrt)*sqrt;
    }
}

你可能感兴趣的:(LeetCode,java,力扣,leetcode)