2020.9.25搜狗笔试

题目结构

三道编程题

1.判断对的题目的个数

数学推理题

import java.util.*;

class Interval {
  int start;
  int end;
}

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 返回Interval类，start代表汪仔最少做对了多少道题，end代表汪仔最多做对了多少道题。
     * @param n int整型 选择题总数
     * @param k int整型 朋友做对的题数
     * @param str1 string字符串 长度为n只包含ABCD的字符串，其中第i个代表汪仔第i题做出的选择
     * @param str2 string字符串 长度为n只包含ABCD的字符串，其中第i个代表朋友第i题做出的选择
     * @return Interval类
     */
    public Interval solve (int n, int k, String str1, String str2) {
        // write code here
        int  count = 0;
        for(int i = 0; i < n; i++){
            if(str1.charAt(i) == str2.charAt(i)){
                count++;
            }
        }

        int i = count;
        Interval val = new Interval();

        //最多
        if(i > k){
            val.end = k+(n-i);
        }else{
            val.end = i+(n-k);
        }

        //最少
        if(k < n-i){
            val.start = 0;
        }else{
            val.start = k-(n-i);
        }

        return val;

    }

}

2.旋转数组

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 返回一行字符串，表示原文。
     * @params1 string字符串一维数组 N*N的01矩阵，表示解密纸，0表示透明，1表示涂黑
     * @params2 string字符串一维数组 字符矩阵，表示密文
     * @return string字符串
     */

    public static void main(String[] args) {
        String[] s1 = {"1101","1010","1111","1110"};
        String[] s2 = {"ABCD","EFGH","IJKL","MNPQ"};
        System.out.println(new Solution().rotatePassword(s1, s2));
    }

    /*
    ["1101","1010","1111","1110"],["ABCD","EFGH","IJKL","MNPQ"]

    "CFHQGLMPAIKNBDEJ"

     */
    public String rotatePassword (String[] s1, String[] s2) {
        // write code here

        int n = s1.length;

        StringBuilder sb = new StringBuilder();

        int k = 4;
        int[][] num = change(s1);
        while((k--) > 0){
            for(int i = 0; i < n;i++){
                for(int j = 0; j < n; j++){
                    if(num[i][j] == 0){
                        sb.append(s2[i].charAt(j));
                    }
                }
            }
            rotate(num);
        }

        //System.out.println(sb);
        return sb.toString();

    }

    //把字符串数组改成int数组
    public static int[][] change(String[] s){
        int n = s.length;
        int[][] num = new int[n][n];

        for(int i = 0; i < n;i++){
            for(int j = 0; j < n; j++){
                num[i][j] = s[i].charAt(j) - '0';   //直接取出来是字符0
                //System.out.println(num[i][j]);
            }
        }
        return num;
    }



    public static void rotate(int[][] matrix){
        int n=  matrix.length;
        int[][] newMatrix = new int[n][n];

        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                newMatrix[j][n-i-1] = matrix[i][j];
            }
        }

        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                matrix[i][j] = newMatrix[i][j];
            }
        }
    }
}

3.图遍历

借楼，别人家的，参考一下，学习一下，记录在此
原链接

 public Interval trim(int n, int m, Interval[] conn) {
        // write code here
        Map<Integer, List<Integer>> opp = new HashMap<>();
        Map<Integer, List<Integer>> neg = new HashMap<>();

        int[] color = new int[n + 1];
        for (int i = 0; i < m; i++) {
            List<Integer> oppList = opp.computeIfAbsent(conn[i].start, k -> new ArrayList<>());
            List<Integer> negList = neg.computeIfAbsent(conn[i].end, k -> new ArrayList<>());
            oppList.add(conn[i].end);
            negList.add(conn[i].start);
        }
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(-1);
        while (!queue.isEmpty()) {
            int cur = queue.poll();
            List<Integer> negList = neg.get(cur);
            if (negList != null) {
                for (int next : negList) {
                    if (color[next] == 0) {
                        color[next] = 1;
                        queue.offer(next);
                    }
                }
            }
        }
        queue.offer(0);
        while (!queue.isEmpty()) {
            int cur = queue.poll();
            List<Integer> oppList = opp.get(cur);
            if (oppList != null) {
                for (int next : oppList) {
                    if (next != -1 && color[next] == 1) {
                        color[next] = 2;
                        queue.offer(next);
                    }
                }
            }
        }
        int cnt = 0, sum = 0;
        for (int i = 1; i <= n; i++) {
            if (color[i] == 2) {
                cnt++;
                sum += i;
                sum %= 100000007;
            }
        }
        return new Interval(cnt, sum);
    }