Day57

819、最常见的单词

给定一个段落 (paragraph) 和一个禁用单词列表 (banned)。返回出现次数最多，同时不在禁用列表中的单词。题目保证至少有一个词不在禁用列表中，而且答案唯一。禁用列表中的单词用小写字母表示，不含标点符号。段落中的单词不区分大小写。答案都是小写字母。

 使用正则表达式来把除小写字母的字符替换掉

class Solution {
    public String mostCommonWord(String paragraph, String[] banned) {
        paragraph = paragraph.toLowerCase();//段落中的单词不区分大小写。答案都是小写字母。
        
        //只有replaceAll才能用正则表达式
        paragraph = paragraph.replaceAll("[^a-z]", " ");//将除了小字字母的字符全部替换成空格
        
        //因为考虑到禁用单词不是答案，所以也替换成空格
        for (String temp : banned) {
            paragraph = paragraph.replaceAll(temp, " ");
        }

        int times = -1;//判断每一个单词出现的次数
        String[] s = paragraph.split(" ");
        Map<String, Integer> map = new HashMap<>();
        for (String ans : s) {
            if (ans.length() > 0) {//防止split里有空字符串传入数组里
                if (map.containsKey(ans)) {
                    map.put(ans, map.get(ans) + 1);
                } else {
                    map.put(ans, 1);
                }

            } else {
                continue;
            }
        }

        /*这些注释里的两个循环的功能等同于下面的一个循环的功能
        for(Map.Entry<String,Integer>entry:map.entrySet()){
            times=Math.max(times,entry.getValue());//记录单词出现次数最多的
        }

        for(Map.Entry<String,Integer>entry:map.entrySet()){
            if(times== entry.getValue()){
                return entry.getKey();
            }
        }
        */

        String ans="";
        for(Map.Entry<String, Integer> entry : map.entrySet()) {
            if(entry.getValue() > times) {
                times = entry.getValue();
                ans = entry.getKey();
            }
        }
        
        return ans;
    }
}

859、亲密字符串

给你两个字符串 s 和 goal ，只要我们可以通过交换 s 中的两个字母得到与 goal 相等的结果，就返回 true ；否则返回 false 。

暴力解法（s的字符进行两两交换）——超时 

注意一个知识点：

char[]c=s.toCharArray();

new String(c) 可以让c变成s字符串

c.toString() 把c变成s字符串的地址

所以应该用new String(c).equals(goal)来判断 数组转成字符串与goal 判断字符串是否相同

class Solution {
    public boolean buddyStrings(String s, String goal) {
        for(int i=0;i<s.length();i++){
            for(int j=i+1;j<s.length();j++){
               if(swap(s,i,j,goal)){
                   return true;
               }else{
                   continue;
               }
            }
        }
        return false;


    }
    public boolean swap(String s,int start,int end, String goal){
        String ans=s;
//        System.out.println(ans);
        char[]c=ans.toCharArray();
        char temp=c[start];
        c[start]=c[end];
        c[end]=temp;
//        System.out.println(new String(c));
        if(new String(c).equals(goal)){
            return true;
        }else{
            return false;
        }
    }
}

亲密字符（2,3的判断是亲密字符）
1.当s 与goal长度或词频数不同，必然不为亲密字符;
2.当「s 与goal位置不同的字母个数为2」——eg："abab"  "abba"   ab和ba的相对位置是不同的，这样的字母有2个。
3.当「s 与goal 位置不同的字符数量为0，但同时s中有出现至少一次单个字符数量≥2的字符」——eg："ab" "ab"这样子不是亲密字符   "abc"  "abc"这样是亲密字符  "aa" "aa" 这样是亲密字符

针对但同时s中有出现至少一次单个字符数量≥2的字符解释举例说明："abcd" "abcd"显然不是亲密字符     "abca" "abca" 是亲密字符

class Solution {
    public boolean buddyStrings(String s, String goal) {
        //亲密字符说明(1):若s和goal的长度不相等直接返回false
        if (s.length() != goal.length()) return false;

        //初始化两个数组 用来存放s 和 goal的字母
        int a[] = new int[26], b[] = new int[26];
        int x, y, sum = 0;
        for (int i = 0; i < s.length(); i++) {
            x = s.charAt(i) - 'a';
            y = goal.charAt(i) - 'a';
            a[x]++;//对每一个字母计数
            b[y]++;
            if (x != y) sum++;//亲密字符说明(2):记录位置不同的字母个数
        }
        boolean flag = false;
        for (int i = 0; i < 26; i++) {
            if (a[i] != b[i]) return false;//亲密字符说明(1):判断s和goal的其中每个字母的数量是否一样 若不一样直接返回false
            if (a[i] > 1) flag = true;//亲密字符说明(3)若有字母数量超过1则把flag置为true
        }
        //能走到这一步说明s和goal的长度相同，字母相同
        //只有两种能返回true：
        // 第一种：s和goal有两个位置不同的
        // 第二种：没有位置不同的但是需要有字母的数量大于1 例如："ab" "ab" return false  "abb" "abb" returen true
        return sum == 2 || (sum == 0 && flag == true);
    }
}

2043、简易银行系统

注意题目的红色和蓝色标注

因为账户有1~n个，所以1≤account≤balance.length。因为是使用数组，所以accoun=1存放在balance[0]去 ，account=balance.length存放在balance[balance.length-1]里

class Bank {
    long[]balance;
    //账户有1~n个，因为是使用数组，所以accoun=1存放在balance[0]去 
    boolean check(int account) { //检查账户是否在1~n之间
        return account>=1&&account<=balance.length;
    }

    public Bank(long[] balance) {//构造器
        this.balance=balance;
    }
    
    public boolean transfer(int account1, int account2, long money) {
        if(check(account1)&&check(account2)){
            if(balance[account1-1]>=money){
                balance[account1-1]-=money;
                balance[account2-1]+=money;
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }
    
    public boolean deposit(int account, long money) {
        if(check(account)){
            balance[account-1]+=money;
            return true;
        }else{
            return false;
        }
        

    }
    
    public boolean withdraw(int account, long money) {
        if(check(account)&&balance[account-1]>=money){
            balance[account-1]-=money;
            return true;
        }else{
            return false;
        }
    }
}

/**
 * Your Bank object will be instantiated and called as such:
 * Bank obj = new Bank(balance);
 * boolean param_1 = obj.transfer(account1,account2,money);
 * boolean param_2 = obj.deposit(account,money);
 * boolean param_3 = obj.withdraw(account,money);
 */