Question

Given a string s and a character letter, return* the percentage of characters in s that equal letter rounded down to the nearest whole percent.*

Solution

一次遍历，计算字符出现的次数。
返回字符出现的次数除以字符长度乘以100。

Code

1
2
3
4
5
6
7
8
9
10
11

class Solution {
    public int percentageLetter(String s, char letter) {
        int count = 0;
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == letter){
                count++;
            }
        }
        return count * 100 / s.length();
    }
}

Problem

The bitwise AND of an array nums is the bitwise AND of all integers in nums.

• For example, for nums = [1, 5, 3], the bitwise AND is equal to 1 & 5 & 3 = 1.

• Also, for nums = [7], the bitwise AND is 7.

You are given an array of positive integers candidates. Evaluate the bitwise AND of every combination of numbers of candidates. Each number in candidates may only be used once in each combination.

Return *the size of the largest combination of candidates with a bitwise AND greater than *0.

Solution

相当于将各个数字进行掩码操作，计算各个数组的同一个位上1的数量即可。

bin[]数组记录各个数字的各个位上的1的数量。
如果当前数字与1进行掩码操作后等于1，则将该位数量加一。
然后将当前数字向右移动一位，直至将所有的位都统计完。

最后返回各个位上的最大值即可。

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Solution {
    public int largestCombination(int[] candidates) {
        int[] bin = new int[31];
        int res = 0;
        for(int candidate : candidates){
            int count = 0;
            while(count < 31){
                if((candidate & 1) == 1){
                    bin[count]++;
                }
                candidate = candidate >> 1; 
                count++;
            }
        }
        for(int time : bin){
            res = Math.max(res, time);
        }
        return res;
    }
}

Question

Alice manages a company and has rented some floors of a building as office space. Alice has decided some of these floors should be special floors, used for relaxation only.

You are given two integers bottom and top, which denote that Alice has rented all the floors from bottom to top (inclusive). You are also given the integer array special, where special[i] denotes a special floor that Alice has designated for relaxation.

Return the maximum number of consecutive floors without a special floor.

Solution

可以视为特殊的动态规划。

计算每个特殊房间与上一个特殊房间的层数。（可以将底层的上一个房间视为特殊房间，需要将第一个房间设置为bottom-1）。
当距离大于当前结果时则更新res。

最后需要计算最后一层到上一个特殊房间的距离。（可以将顶楼的上一层视为特殊房间，因此直接计算top - lastRoom的层数即可）

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Solution {
    public int maxConsecutive(int bottom, int top, int[] special) {
        int res = 0;
        int lastRoom = bottom-1;
        Arrays.sort(special);
        
        for(int room : special){
            int temp = room - lastRoom - 1;
            res = Math.max(res, temp);
            lastRoom = room;
            
        }
        int temp = top - lastRoom;
        res = Math.max(res, temp);
        
        return res;
    }
}

Problem

You are given a 0-indexed string array words, where words[i] consists of lowercase English letters.

In one operation, select any index i such that 0 < i < words.length and words[i - 1] and words[i] are anagrams, and delete words[i] from words. Keep performing this operation as long as you can select an index that satisfies the conditions.

Return words after performing all operations. It can be shown that selecting the indices for each operation in any arbitrary order will lead to the same result.

An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase using all the original letters exactly once. For example, "dacb" is an anagram of "abdc".

Solution

由于只用查看上一个元素。
记录一个prev[]数组记录上一个元素的字符情况。
遍历words，用数组bin[]统计每个字母出现的次数，同时减去prev数组的统计数字。
如果数组中的每个统计结果都为0，则是上一个字符串的Anagram。
否则是一个新的字符串，将其加入结果。
然后将上一个数组prev更新为当前的统计数组bin[]。

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class Solution {
    public List<String> removeAnagrams(String[] words) {
        int[] prev = new int[26];
        
        List<String> ans = new ArrayList<>();
        
        for(String word : words){
            int[] bin = new int[26];
            char[] chars = word.toCharArray();
            for(int i = 0; i < chars.length; i++){
                prev[chars[i]-'a']--;
                bin[chars[i]-'a']++;
            }
            if(!allZero(prev)){
                ans.add(word);
            }
            prev = bin;
        }
        return ans;
    }
    
    private boolean allZero(int[] bin){
        for(int num : bin){
            if(num != 0) return false;
        }
        return true;
    }
}