算法练习一

一、查找重复代码

题目描述

解题思路：

找到两行输入中较短的哪一行，然后用双重for循环遍历从最小的子字符串判断，存入结果后，继续如果有更长的子字符串，替换，循环结束玩输入。

代码：

	Scanner sc = new Scanner(System.in);
        String str1 = sc.nextLine();
        String str2 = sc.nextLine();
        if (str1.length() > str2.length()) {
            String temp = str1;
            str1 = str2;
            str2 = temp;
        }
        // str2的长度一定大于str1
        String res = "";
        for (int i = 0; i < str1.length(); i++) {
            for (int j = i+1; j < str1.length(); j++) {
                String substring = str1.substring(i, j);
                if (str2.contains(substring) && res.length()<substring.length()) {
                    res = substring;
                }
            }
        }
        System.out.println(res);

二、猜字谜

解题思路：

遍历谜面，针对每个谜面遍历所有谜底 ，针对单个某个谜面和谜底 分别加入HashSet里，刚好满足去重和特定排序。

代码：

// 2 猜字谜 
	public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        List<String> diResult = new ArrayList<>();
        String mian = sc.nextLine();
        String di = sc.nextLine();
        String[] mianArr = mian.split(",");
        String[] diArr = di.split(",");
        for (String mStr : mianArr) {
            boolean isExist = false;
            for (String diStr: diArr) {
                if (isSame(mStr, diStr)) {
                    diResult.add(diStr);
                    isExist =true;
                    break;
                }
            }
            if(!isExist) {
                diResult.add("not found");
            }
        }
        System.out.println(String.join(",", diResult));
    }

    private static boolean isSame(String mStr, String diStr) {
        Set<Character>  mSet = new HashSet<>();
        Set<Character>  dSet = new HashSet<>();
        char[] mCharArray = mStr.toCharArray();
        char[] diCharArray = diStr.toCharArray();
        for (char m : mCharArray) {
            mSet.add(m);
        }
        for (char d : diCharArray) {
            dSet.add(d);
        }
        return mSet.equals(dSet);
    }

三、寻找关键钥匙

题目描述：

解题思路

将 key的每个字节放入一个set;
遍历box里的每个box 字符串 将字符串的每个字节判断是否是字符Character.isLetter(），并且转为为小写 加入到另一个set；
判断两个set是否相等，如果相等就返回该box的坐标+1（题目中问的是第几个）。

代码块：

    	// 寻找关键钥匙
        //abc   s,sdf134 A2c4b
        String keyStr = sc.nextLine();
        String boxStr = sc.nextLine();
        Set<String> kSet = new HashSet<>();
        for (char k : keyStr.toCharArray()) {
            kSet.add(String.valueOf(k));
        }
        boolean isFound = false;
        String[] boxs = boxStr.split(" ");
        for (int i = 0; i < boxs.length; i++) {
            Set<String> bSet = new HashSet<>();
            for (char b : boxs[i].toCharArray()) {
                if (Character.isLetter(b)) {
                    bSet.add(String.valueOf(b).toLowerCase());
                }
            }
            // 只有 小写字母的set
            if (kSet.equals(bSet)) {
                isFound = true;
                System.out.println(i+1);
                break;
            }
        }
        if (!isFound) {
            System.out.println(-1);
        }

四、对称美学

题目描述：

解题思路：

递归调用 直到n=1,最终要的逻辑就是 当前 需要输出的k 如果大于等于当前字符串长度一半（2的（n-1）次方）直接递归前一次，如果小于的话，需要取反 即 如果是‘R’取‘B’，最后记住用long性接收，int会超。

代码：

Scanner sc4 = new Scanner(System.in);
        int t = sc4.nextInt();
        long[][] longArr = new long[t][2];
        for (int i = 0; i < t; i++) {
            longArr[i][0] = sc4.nextLong();
            longArr[i][1] = sc4.nextLong();
        }
        deal(t, longArr);

    }

    private static void deal(int t, long[][] longArr) {
        for (int i = 0; i < t; i++) {
            long n = longArr[i][0];
            long k = longArr[i][1];
            char aChar = findChar(n, k);
            System.out.println(aChar == 'R'? "red" :"blue");
        }
    }
    private static char findChar(long n, long k) {
        if (n == 1) {
            return 'R';
        }
        long length = BigInteger.valueOf(2).pow((int) (n-1)).longValue();
        if (k>= length/2) {
            return  findChar(n-1, k-length/2);
        }
        else {
            return  findChar(n-1, k) == 'R'?'B':'R';
        }
    }