笔试记录

4399笔试-8-28-Java开发

相近的：https://www.nowcoder.com/discuss/520990591115714560?sourceSSR=post

题型：10道选择题 3道简答题 3道编程题 2道主观题

选择题cpp python都有，垃圾

简答题：

设计一个商品分类表，要求一个商品至少能分3类，比如男装-上衣-衬衫，写出建表语句并说明为什么
事务的隔离类别；并发事务存在的问题
设计一个高并发、低时延的在线聊天系统，从架构设计、方案选型等，针对多用户在线、消息传递、数据存储等说明

编程题：

1、打家劫舍 *******************************************

2、雀魂启动 https://www.nowcoder.com/practice/448127caa21e462f9c9755589a8f2416?tpId=137&tqId=33897

import java.util.*;

public class Main {
    static boolean flag;

    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int[] nums = new int[10];
        for (int i = 0; i < 13; i++) {
            nums[cin.nextInt()]++;
        }

        for (int i = 1; i <= 9; i++) {
            if (nums[i] <= 3) {
                int[] card = Arrays.copyOf(nums, nums.length); // 深拷贝一份card
                card[i]++;
                if (isHu(card, 1, 0, 0)) {
                    flag = true;
                    System.out.print(i + " ");
                }
            }
        }
        if(flag == false) // 不能和牌
            System.out.print(0);
    }

    public static boolean isHu(int[] card, int start, int quetou, int lian){
        if(start>=10){
            // 胡牌条件：1个雀头，4个顺子或刻子（这里我一起称之为lian）
            if(quetou==1 && lian==4) return true;
            else  //全部搜索完都没和牌 
                return false;
        }
        // 从start开始,用作雀头
        if(card[start]>=2 && quetou==0){
            card[start] -=2;
            if(isHu(card, start, 1, lian)) return true;
            card[start] +=2;
        }
        // 从start开始，用作刻子
        if(card[start]>=3){
            card[start] -=3;
            if(isHu(card, start, quetou, lian+1)) return true; 
            card[start] +=3;
        }
        // 从start开始，用作顺子
        if (start + 2 <= 9 && card[start] > 0 && card[start + 1] > 0 && card[start + 2] > 0){
            card[start]--;
            card[start + 1]--;
            card[start + 2]--;
            if(isHu(card, start, quetou, lian+1)) return true;
            card[start]++;
            card[start + 1]++;
            card[start + 2]++;
        }
        // 当前牌无法组成雀头、顺子或刻子，直接跳到下一个数额的牌
        if(isHu(card, 1+start, quetou, lian)) return true;
        return false;
    }
}

3、基地打怪

import java.util.*;

public class Main{
    public static int[] arrive(int x, int[] num, int k){
        //持有初始能量x，到达k所需的最小初始能量
        int have = 0;
        while(true){
            have = x;
            for(int i=0; i<=k; ++i){
                have = 2*have-num[i];
            }
            if(have < 0) 
                x++;
            else 
                break;
        }
        return new int[]{x, have};
    }
    public static void main (String[] args) {
        Scanner cin = new Scanner(System.in);
        int N = cin.nextInt();
        int[] num = new int[N];
        for(int i=0; i<N; ++i){
            num[i] = cin.nextInt();
        }
        int[][] dp = new int[N][2];
        dp[0][0] = num[0]; //存最小初始能量
        dp[0][1] = num[0]; //到达终点时的能量
        for(int i=1; i<N; ++i){
            if(2*dp[i-1][1] >= num[i]){ //可以达到i
                dp[i][0] = dp[i-1][0];
                dp[i][1] = 2*dp[i-1][1]-num[i];
            }else{
                int[] ans = arrive(dp[i-1][0]+1, num, i);
                dp[i][0] = ans[0];
                dp[i][1] = ans[1];
            }
        }
        // System.out.println(Arrays.deepToString(dp));
        System.out.println(dp[N-1][0]);
    }
}

得物-0829-java笔试

UML类图

在面向对象的软件设计中，有几种常见的关系来描述类与类之间的关联。以下是对扩展、包含、继承、泛化和聚合关系的简要解释：

扩展（Extension）关系：表示一个类（子类）继承另一个类（父类）的属性和方法，并可以通过添加新的功能来扩展父类的行为。子类是对父类的一种特化。使用关键字 "extends" 表示扩展关系。
包含（Composition）关系：表示一个类（整体）包含另一个类（部分），整体对象负责创建和管理部分对象，并且部分对象的生命周期与整体对象相关联。当整体对象被销毁时，部分对象也会被销毁。使用关键字组合或者通过构造函数参数传递部分对象来表示包含关系。
继承（Inheritance）关系：表示一个类（子类）继承另一个类（父类）的属性和方法。子类可以重用父类的属性和方法，并可以添加新的属性和方法。使用关键字 "extends" 表示继承关系。
泛化（Generalization）关系：表示一个类（子类）是另一个类（父类）的概括或通用化。子类继承了父类的特性，并可能添加新的特性或修改父类的特性。泛化关系是一种更一般的继承关系，可用于建立类的层次结构。使用关键字 "extends" 表示泛化关系。
聚合（Aggregation）关系：表示一个类（整体）包含另一个类（部分），但部分对象可以独立存在，并且可以属于多个整体对象。整体对象在创建和管理部分对象方面具有更弱的控制权。使用关键字组合或者通过构造函数参数传递部分对象来表示聚合关系。

需要注意的是，这些关系是用于描述类之间的语义关系，而不是用于表达类之间的实现方式。在实际设计中，根据具体的需求和问题领域选择适当的关系来建模类之间的关联。

两道编程题：https://www.nowcoder.com/discuss/526021190201131008?sourceSSR=search

题解网址：https://mp.weixin.qq.com/s/zrBag2G8cRSi4xqqTbHtwA