携程笔试记录

1题 交通拥塞路段。浮点数比较大小可能出现问题,最好转换成整数比较
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; ++i) {
            arr[i] = sc.nextInt();
        }
        // 窗口范围[k,n], 平均值最大,次之窗口最宽
        int[] preSum = new int[n + 1];
        for (int i = 1; i<= n; ++i) {
            preSum[i] = preSum[i-1] +  arr[i-1]; // preSum[i] = sum(arr[1..i))
        }
        long sum = 0;
        int st = 0, ed = 0; // avg = sum / (ed - st)
        for (int i = 0; i <= n - k; ++i) {
            for (int j = i + k; j <= n; ++j) {
                long tmpSum = preSum[j] - preSum[i];
                if (sum * (j - i) < tmpSum * (ed - st)  // sum/(ed-st) < tmpSum/(j-i)
                    || sum * (j - i) == tmpSum * (ed - st) && (j - i) > (ed - st)) {
                    sum = tmpSum;
                    ed = j;
                    st = i;
                }
            }
        }
        System.out.println(st + " " + (ed - 1));
    }
}

2题 灯管的变化数。只能通过45%,哪里错了没有查出来。。快查自闭了。应该是超时了,时间复杂度写成了O(n^3),其实可以优化成O(n^2)。我想着n比较小,最大100,三次方也就百万级别,1s内可以运行出来。携程使坏,卡了时间。下面分别是没优化和优化的代码
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int[][] changeCount = {
                {0, 4, 3, 3, 4, 3, 2, 3, 1, 2},
                {4, 0, 5, 3, 2, 5, 6, 1, 5, 4},
                {3, 5, 0, 2, 5, 4, 3, 4, 2, 3},
                {3, 3, 2, 0, 3, 2, 3, 2, 2, 1},
                {4, 2, 5, 3, 0, 3, 4, 3, 3, 2},
                {3, 5, 4, 2, 3, 0, 1, 4, 2, 1},
                {2, 6, 3, 3, 4, 1, 0, 5, 1, 2},
                {3, 1, 4, 2, 3, 4, 5, 0, 4, 3},
                {1, 5, 2, 2, 3, 2, 1, 4, 0, 1},
                {2, 4, 3, 1, 2, 1, 2, 3, 1, 0},
                {6, 2, 5, 5, 4, 5, 6, 3, 7, 6},
        };
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        StringBuilder cache = new StringBuilder();
        for (int d = 1; d <= s.length(); ++d) { // 宽度
            cache.append(work(s, d, changeCount)).append(" ");
        }
        if (cache.length() > 0) {
            cache.deleteCharAt(cache.length() - 1);
        }
        System.out.println(cache);
    }


    private static int work(String s, int d, int[][] changeCount) {
        int count = 0;
        for (int i = 0; i < d; ++i) {
            count += changeCount[10][s.charAt(i) - '0'];
        }
        for (int i = 0; i < s.length() - d; ++i) {  // 第i天 变化数
            for (int j = i + 1; j <= i + d; ++j) {
                count += changeCount[s.charAt(j-1) - '0'][s.charAt(j) - '0'];
            }
        }
        return count;
    }
}
/*
说明:
所有测试数据正确率为 45%!
可以尝试再次完善代码,并调试,争取全部AC通过

温馨提示:有时候,申请大的全局数组会导致超时,如果有此类情况,请检查您的全局数组是否超过题目要求的内存大小。
排除这个错误后,再检查别的情况引起的超时错误:例如死循环、循环结束条件错误等,或者需要更好的算法!
 */
打表代码
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        init();
        for (int i = 0; i < changeCount.length; ++i) {
            System.out.println(Arrays.toString(changeCount[i]));
        }
    }

    static int[][] ligths = new int[][]{
            // 0  1  2  3  4  5  6
            {1, 1, 1, 1, 1, 1, 0},  // 0
            {0, 0, 0, 0, 1, 1, 0},  // 1
            {1, 0, 1, 1, 0, 1, 1},  // 2
            {1, 0, 0, 1, 1, 1, 1},  // 3
            {0, 1, 0, 0, 1, 1, 1},  // 4
            {1, 1, 0, 1, 1, 0, 1},  // 5
            {1, 1, 1, 1, 1, 0, 1},  // 6
            {1, 0, 0, 0, 1, 1, 0},  // 7
            {1, 1, 1, 1, 1, 1, 1},  // 8
            {1, 1, 0, 1, 1, 1, 1},  // 9
    };

    static final int[][] changeCount = new int[11][10];;
    static void init() {
        for (int i = 0; i <= 9; ++i) {
            for (int j = i + 1; j <= 9; ++j) {
                changeCount[i][j] = changeCount[j][i] = calc(i, j);
            }
        }
        changeCount[10] = new int[]{6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
    }
    private static int calc(int num1, int num2) {
        int count = 0;
        for (int i = 0; i < 7; ++i) {
            count += ligths[num1][i] ^ ligths[num2][i];
        }
        return count;
    }

}

优化后,时间复杂度O(n^2)。主要修改了代码中的work方法,将计算每次LED灯管变化数从O(n),降到了平均O(1)。
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int[][] changeCount = {
                {0, 4, 3, 3, 4, 3, 2, 3, 1, 2},
                {4, 0, 5, 3, 2, 5, 6, 1, 5, 4},
                {3, 5, 0, 2, 5, 4, 3, 4, 2, 3},
                {3, 3, 2, 0, 3, 2, 3, 2, 2, 1},
                {4, 2, 5, 3, 0, 3, 4, 3, 3, 2},
                {3, 5, 4, 2, 3, 0, 1, 4, 2, 1},
                {2, 6, 3, 3, 4, 1, 0, 5, 1, 2},
                {3, 1, 4, 2, 3, 4, 5, 0, 4, 3},
                {1, 5, 2, 2, 3, 2, 1, 4, 0, 1},
                {2, 4, 3, 1, 2, 1, 2, 3, 1, 0},
                {6, 2, 5, 5, 4, 5, 6, 3, 7, 6},
        };
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        StringBuilder cache = new StringBuilder();
        for (int d = 1; d <= s.length(); ++d) { // 宽度
            cache.append(work(s, d, changeCount)).append(" ");
        }
        if (cache.length() > 0) {
            cache.deleteCharAt(cache.length() - 1);
        }
        System.out.println(cache);
    }


    private static int work(String s, int d, int[][] changeCount) {
        int totalCount = 0;
        for (int i = 0; i < d; ++i) {
            totalCount += changeCount[10][s.charAt(i) - '0'];
        }
        if (d == s.length()) {
            return totalCount;
        }
        int count = 0;
        for (int j = 1; j <= d; ++j) {
            count += changeCount[s.charAt(j - 1) - '0'][s.charAt(j) - '0'];
        }
        totalCount += count;
        for (int j = 2; j < s.length() - d; ++j) {
            count += - changeCount[s.charAt(j-1) - '0'][s.charAt(j) - '0'] + changeCount[s.charAt(j+d-1) - '0'][s.charAt(j+d) - '0'];
            totalCount += count;
        }
        return totalCount;
    }
}


3 题 时间复杂度得O(nlogn),哎


#携程笔试##笔试题目##携程#
全部评论

相关推荐

刚刷到字节跳动官方发的消息,确实被这波阵仗吓了一跳。在大家还在纠结今年行情是不是又“寒冬”的时候,字节直接甩出了史上规模最大的转正实习计划——ByteIntern。咱们直接看几个最硬的数,别被花里胡哨的宣传词绕晕了。首先是“量大”。全球招7000多人是什么概念?这几乎是把很多中型互联网公司的总人数都给招进来了。最关键的是,这次的资源分配非常精准:研发岗给了4800多个Offer,占比直接超过六成。说白了,字节今年还是要死磕技术,尤其是产品和AI领域,这对于咱们写代码的同学来说,绝对是今年最厚的一块肥肉。其次是大家最关心的“转正率”。官方直接白纸黑字写了:整体转正率超过50%。这意味着只要你进去了,不划水、正常干,每两个人里就有一个能直接拿校招Offer。对于2027届(2026年9月到2027年8月毕业)的同学来说,这不仅是实习,这简直就是通往大厂的快捷通道。不过,我也得泼盆冷水。坑位多,不代表门槛低。字节的实习面试出了名的爱考算法和工程实操,尤其是今年重点倾斜AI方向,如果你简历里有和AI相关的项目,优势还是有的。而且,转正率50%也意味着剩下那50%的人是陪跑的,进去之后的考核压力肯定不小。一句话总结:&nbsp;27届的兄弟们,别犹豫了。今年字节这是铁了心要抢提前批的人才,现在投递就是占坑。与其等到明年秋招去千军万马挤独木桥,不如现在进去先占个工位,把转正名额攥在手里。
喵_coding:别逗了 50%转正率 仔细想想 就是转正与不转正
字节7000实习来了,你...
点赞 评论 收藏
分享
评论
3
15
分享

创作者周榜

更多
牛客网
牛客网在线编程
牛客网题解
牛客企业服务