精华内容
下载资源
问答
  • 现有一近似模型h(x), 以下说法正确的是: 贪心算法往往是这种自顶向下的设计,先做出一个选择,然后再求解下一个问题,而不是自底向上解出许多子问题,然后再做出选择 以下数据结构体在64位机器上占用的内存(sizeof...
    凸函数、凸集
    集合范围内 任意两点的连线 不会超出集合范围
    
    以下哪个集合不是凸(convex)的?
    选C 
    
    { (x, y) | (x -2)^2 + (y-2)^2 <= 2}
    空集合
    {x | ||x|| >= 1}, ||x||表示x的绝对值
    {(x, y) | x + y = 2}
    
    假设每天投稿池中,每1000个视频中会有1个营销号视频,为了净化社区环境,
    b站同事训练了一个检测营销号视频的模型。模型评估结果如下:
    如果某视频是营销号视频,就一定会被模型检测出来,
    但是如果某视频是正常视频,也会有1%的概率被误判成营销号视频。
    提问:现在有一个新投稿的视频,被模型判定成了营销号视频,
    那么它原本真正是营销号视频的概率是多少()
    
    X:是否为营销号
    Y:预测为营销号 
    P(x=1) = 0.001
    P(x=0) = 0.999
    P(Y=1 | X=1 ) = 1
    P(Y=1 | X=0 ) = 0.01
    P(X=1 | Y=1) = P(Y=1|X=1)*P(x=1) / p(y=1)
    			 = 0.001/0.109
    			 = 0.09099
    P(Y=1) = P(Y=1 | X=1 )*P(x=1)  +  P(Y=1 | X=0 ) *P(x=0) 
    	   =	0.001 + 0.01*0.999
    	   = 0.001 + 0.0999
    	   = 0.109
    	  
    神经网络中的dropout的效果跟以下哪种机器学习方法的效果类似:
    	Boostraping
    	Bootstrap Method:在统计学中,Bootstrap从原始数据中抽取子集,
    		然后分别求取各个子集的统计特征,最终将统计特征合并。
    		例如求取某国人民的平均身高,不可能测量每一个人的身高,
    		但却可以在10个省市,分别招募1000个志愿者来测量并求均值,最终再求取各省市的平均值
    

    在这里插入图片描述

    	Bagging
    		Bagging(Bootstrap Aggregating):应用了 Bootstrap的思想,
    		从Training Set抽取k次subset,分别用来训练k个单独的模型,
    		然后用这k个模型来做预测。最终,如果是Regression问题,
    		则Average k个模型的输出;如果是Classification问题,则进行Majority Vote。
    		经过 bagging 得到的结果方差(variance)更小。
    	Boosting
    

    在这里插入图片描述

    具体过程:
    
    通过加法模型将基础模型进行线性的组合。
    每一轮训练都提升那些错误率小的基础模型权重,
    同时减小错误率高的模型权重。
    在每一轮改变训练数据的权值或概率分布,
    通过提高那些在前一轮被弱分类器分错样例的权值,
    减小前一轮分对样例的权值,来使得分类器对误分的数据有较好的效果。
    
    样本选择上:
    
    Bagging:训练集是在原始集中有放回选取的,从原始集中选出的各轮训练集之间是独立的。
    Boosting:每一轮的训练集不变,只是训练集中每个样例在分类器中的权重发生变化。而权值是根据上一轮的分类结果进行调整。
    样例权重:
    Bagging:使用均匀取样,每个样例的权重相等
    Boosting:根据错误率不断调整样例的权值,错误率越大则权重越大。
    预测函数:
    Bagging:所有预测函数的权重相等。
    Boosting:每个弱分类器都有相应的权重,对于分类误差小的分类器会有更大的权重。
    并行计算:
    Bagging:各个预测函数可以并行生成
    Boosting:各个预测函数只能顺序生成,因为后一个模型参数需要前一轮模型的结果。
    
    Stacking
    一般来说,就是训练一个多层(一般是两层,本文中默认两层)的学习器结构,
    第一层(也叫学习层)用n个不同的分类器
    (或者参数不同的模型)将得到预测结果合并为新的特征集,
    并作为下一层分类器的输入
    

    在这里插入图片描述

    	向量 A=[1, 3, 6, 4, -9, 0]的L1范数为
    	L1范数(L1 norm)是指向量中各个元素绝对值之和
    	1+3+6+4+9 = 23
    	
    	正则化是为了防止过拟合, 进而增强泛化能力
    	
    	L0范数是指向量中非0的元素的个数
    	L1范数是指向量中各个元素绝对值之和 遵从拉普拉斯分布
    	L2范数是指向量各元素的平方和然后求平方根	遵从高斯分布
    	
    	不属于判别模型的算法是:
    	
    	生成方法由数据学习联合概率分布P(X,Y),然后求出条件概率分布P(Y|X)
    	作为预测的模型。即生成模型
    	之所以称为生成方法,是因为模型表示了给定输入X产生输出Y的生成关系
    	
    判别方法由数据直接学习决策函数f(X)
    或者条件概率分布P(Y|X)
    作为预测的模型,即判别模型。 
    典型的判别模型包括:KNN、感知机、决策树、线性回归、
    逻辑斯蒂回归模型、支持	向量机、神经网络、boosting提升方法。
    
    	现有6个相同的抽屉,一个小球等可能得存在于其中任何一个抽屉,
    	也可能隐藏于抽屉之外(其概率为1/8)。
    	一个人检查完前5个抽屉,都没有发现该小球,
    	那么此时小球在第6个抽屉的概率是多少?
    	
    	假设A=小球在第6个抽屉的概率,B=小球不在前5个抽屉的概率。
    	P(A)=P(AB)=(1-1/8)/6=7/48, P(B)=(1-1/8)/6+1/8=13/48, 
    	所以P(A|B)=P(AB)/P(B)=7/13。
    	有一观测数据集X:{x1, x2, ..., xn}, 假设其真实分布为N(μ,σ^2) 简记其为f(x); 现有一近似模型h(x), 以下说法正确的是:
    

    在这里插入图片描述

    贪心算法往往是这种自顶向下的设计,先做出一个选择,然后再求解下一个问题,而不是自底向上解出许多子问题,然后再做出选择
    

    在这里插入图片描述
    以下数据结构体在64位机器上占用的内存(sizeof(data))是多少:

    typedef struct _data
    {
          int id;
          char name[6];
          long long time;
          char add[4];
    }data
    
    64位机器会按8字节对齐 
    按8个字节为单位分配存储空间,如果不足,会自动补充,
    本次分配不足以存放下面的变量时,会重新分配空间
    int id 4字节
    char name[6] 6字节
    long long time  8字节
     char add[4]  4字节 
     4+6+6+8+4+4 = 32
    
    激活函数是为了引入非线性,故不可以是线性函数
    
    四种主要的遍历思想为:
    
    前序遍历:根结点 ---> 左子树 ---> 右子树
    中序遍历:左子树---> 根结点 ---> 右子树
    后序遍历:左子树 ---> 右子树 ---> 根结点
    层次遍历:只需按层次遍历即可
    
    已知一个二叉树树的前序遍历结果(ABCDEFGH)
    和中序遍历结果(CDBAGFEH),那么其后序遍历结果为
    
    第1个假设, 离群点要着重考虑, 第一点是对的
    第2个假设, 正态分布不是必须的. 当然, 如果是正态分布, 训练效果会更好
    第3个假设, 有少量的多重线性相关性也是可以的, 但是我们要尽量避免
    

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 一、笔试题 笔试题1:自定义函数实现strcpy()函数的功能; char *strcpy(char *strDestination, const char *strSource) { assert(strDestination != NULL && strSource != NULL);...char *str = ...

    一、笔试题
    笔试题1:自定义函数实现strcpy()函数的功能;

      char * strcpy(char * strDest, const char * strSrc) 
      {
      	if ((strDest==NULL)||(strSrc==NULL))                   
    	return NULL;   
    	
    	char * strDestCopy=strDest; 
    	while ((*strDest++ = *strSrc++) != '\0');    
    
        return strDestCopy;
      }
    
    

    笔试题2:原地翻转带头结点的单链表;

    struct Node {
        int data;
        Node *next;
    };
    
    void reverse(Node* head)
    {
    
        if (head == NULL||head->next == NULL) return;
    
        Node* pre = NULL;
        Node* cur = head->next;
        Node* next;
    
        while (cur) 
        {
            next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
    
        head->next = pre;
    }
    

    二、问答题:
    谈一谈C++的多态是如何实现的?
    1、C++的多态性用一句话概括就是:在基类的函数前加上virtual关键字,在派生类中重写该函数,运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类,就调用派生类的函数;如果对象类型是基类,就调用基类的函数;
    2、虚函数,子类函数为什么能覆盖父类函数?
    答:存在虚函数的类都有一个一维的虚函数表叫做虚表,类的对象有一个指向虚表开始的虚指针。虚表是和类对应的,虚表指针是和对象对应的。

    展开全文
  • 题号 题目 知识点 难度 通过率 BL1 扭蛋机 递归 中等 32.67% BL2 小A最多会新认识的多少人 图 中等 15.20% BL3 简单表达式计算 字符串模拟栈 中等 29.30% BL4 山寨金闪闪 数组 中等 17.53% ...
    题号 	题目	知识点	难度	通过率 
     BL1	扭蛋机	递归	中等	32.67%
     BL2	小A最多会新认识的多少人	图	中等	15.20%
     BL3	简单表达式计算	字符串模拟栈	中等	29.30%
     BL4	山寨金闪闪	数组	中等	17.53%
     BL5	顺时针打印数字矩阵	递归数组模拟	中等	16.87%
     BL6	精灵鼠从入口到出口的最少减少速度	动态规划字符串	中等	35.73%
     BL7	比较两个版本字符串version1和version2	字符串	中等	21.86%
     BL8	写一段程序判断IP字符串是否属于内网IP	字符串模拟	中等	39.96%
     BL9	给定一个整数数组,判断其中是否有3个数和为N	排序数组哈希	中等	22.39%
     BL10	脸滚键盘	字符串模拟	中等	15.64%
     BL11	实现一个HTML语法检查器	字符串模拟栈	中等	10.45%
     BL12	翻转链表	模拟链表	中等	21.86%
     BL13	孙悟空的徒弟	数组穷举	中等	7.67%
     BL14	ん...红茶?	排序数组穷举	中等	14.96%
    

    BL1 扭蛋机

    题目描述

    22娘和33娘接到了小电视君的扭蛋任务:
    一共有两台扭蛋机,编号分别为扭蛋机2号和扭蛋机3号,22娘使用扭蛋机2号,33娘使用扭蛋机3号。
    扭蛋机都不需要投币,但有一项特殊能力:
    扭蛋机2号:如果塞x(x范围为>=0正整数)个扭蛋进去,然后就可以扭到2x+1个
    扭蛋机3号:如果塞x(x范围为>=0正整数)个扭蛋进去,然后就可以扭到2x+2个
    22娘和33娘手中没有扭蛋,需要你帮她们设计一个方案,两人“轮流扭”(谁先开始不限,扭到的蛋可以交给对方使用),用“最少”的次数,使她们能够最后恰好扭到N个交给小电视君。
    

    输入描述:

    输入一个正整数,表示小电视君需要的N个扭蛋。
    

    输出描述:

    输出一个字符串,每个字符表示扭蛋机,字符只能包含"2"和"3"。
    

    示例1

    输入

    10
    

    输出

    233
    备注:
    1<=N<=1e9
    
    import java.util.*;
    import java.io.*;
    //逆向思考,奇偶敏感
    public class Main {
        public static void main(String[] args) throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int n = Integer.parseInt(br.readLine());
            StringBuffer sb = new StringBuffer();
            play(n, sb);
            sb.reverse();
            System.out.println(sb);
        }
        public static void play(int N, StringBuffer sb) {
            if (N <= 0) return;
            if (N % 2 == 0) {
                sb.append(3);
                play((N - 2) / 2, sb);
            } else {
                sb.append(2);
                play((N - 1) / 2, sb);
            }
        }
    }
    

    BL2 小A最多会新认识的多少人

    题目描述

    小A参加了一个n人的活动,每个人都有一个唯一编号i(i>=0 & i<n),其中m对相互认识,在活动中两个人可以通过互相都认识的一个人介绍认识。现在问活动结束后,小A最多会认识多少人?
    

    输入描述:

    第一行聚会的人数:n(n>=3 & n<10000);
    第二行小A的编号: ai(ai >= 0 & ai < n);
    第三互相认识的数目: m(m>=1 & m
    < n(n-1)/2);
    第4到m+3行为互相认识的对,以','分割的编号。
    

    输出描述:

    输出小A最多会新认识的多少人?
    

    示例1

    输入

    7
    5
    6
    1,0
    3,1
    4,1
    5,3
    6,1
    6,5
    

    输出

    3
    
    import java.util.Scanner;
    import java.io.*;
    public class Main {
        public static void main(String[] args) throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int N = Integer.parseInt(br.readLine());
            int num = Integer.parseInt(br.readLine());
            int m = Integer.parseInt(br.readLine());
            int[] a = new int[N];
            for (int i = 0; i < N; i++) {
                a[i] = i;
            }
            int oldFriends = 1;
            for (int i = 0; i < m; i++) {
                String[] string = br.readLine().split(",");
                int first = Integer.parseInt(string[0]);
                int second = Integer.parseInt(string[1]);
                if (findRoot(a, first) != findRoot(a, second)) a[findRoot(a, second)] = findRoot(a, first);
                if (first == num || second == num) oldFriends++;
            }
            int friends = 0;
            int tag = findRoot(a, num);
            for (int i = 0; i < N; i++) {
                if (findRoot(a, a[i]) == tag) friends++;
            }
            System.out.println(friends - oldFriends);
        }
        static int findRoot(int[] a, int ele) {
            if (a[ele] != ele) return a[ele] = findRoot(a, a[ele]);
            else return a[ele];
        }
    }
    

    BL3 简单表达式计算

    题目描述

    给定一个合法的表达式字符串,其中只包含非负整数、加法、减法以及乘法符号(不会有括号),例如7+3*4*5+2+4-3-1,请写程序计算该表达式的结果并输出;
    

    输入描述:

    输入有多行,每行是一个表达式,输入以END作为结束
    

    输出描述:

    每行表达式的计算结果
    

    示例1

    输入

    7+3*4*5+2+4-3-1
    2-3*1
    END
    

    输出

    69
    -1
    备注:
    每个表达式的长度不超过10000,保证所有中间结果和最后结果在[-2e9,2e9]范围内
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    public class Main {
        public static char[] arr;
        public static int index = 0;
        public static int length;
        public static void main(String[] args) throws IOException {
            BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
            String str = bf.readLine();
            while (!str.equals("END")) {
                arr = str.toCharArray();
                length = str.length();
                index = 0;
                int res = getNum();
                while (index < arr.length) {
                    if (arr[index] == '-') {
                        index++;
                        res -= getNum();
                    } else {
                        index++;
                        res += getNum();
                    }
                }
                System.out.println(res);
                str = bf.readLine();
            }
        }
        public static int getNum() {
            int num = arr[index] - '0';
            int res = num;
            index++;
            while (index < length) {
                num = arr[index] - '0';
                if (0 <= num && num <= 9) {
                    res = res * 10 + num;
                    index++;
                } else if (arr[index] == '*') {
                    index++;
                    return res * getNum();
                } else {
                    break;
                }
            }
            return res;
        }
    }
    

    BL4 山寨金闪闪

    题目描述

    金闪闪死后,红A拿到了王之财宝,里面有n个武器,长度各不相同。红A发现,拿其中三件武器首尾相接,组成一个三角形,进行召唤仪式,就可以召唤出一个山寨金闪闪。(例如,三件武器长度为10、15、20,可以召唤成功。若长度为10、11、30,首尾相接无法组成三角形,召唤失败。)红A于是开了一个金闪闪专卖店。他把王之财宝排成一排,每个客人会随机抽取到一个区间[l,r],客人可以选取区间里的三件武器进行召唤(客人都很聪慧,如果能找出来合适的武器,一定不会放过)。召唤结束后,客人要把武器原样放回去。m个客人光顾以后,红A害怕过多的金闪闪愉悦太多男人,于是找到了你,希望你帮他统计出有多少山寨金闪闪被召唤出来。
    

    输入描述:

    第一行武器数量:n <= 1*10^7
    第二行空格分隔的n个int,表示每件武器的长度。
    第三行顾客数量:m <= 1*10^6
    后面m行,每行两个int l,r,表示每个客人被分配到的区间。(l<r)
    

    输出描述:

    山寨金闪闪数量。
    

    示例1

    输入

    5
    1 10 100 95 101
    4
    1 3
    2 4
    2 5
    3 5
    

    输出

    3
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.Arrays;
    public class Main {
        //1.把读取的武器长度存入到一个长度为武器数量的数组中去
        //2.判断客人分配的区间是否可以组成一个三角形:把这个区间里的武器长度排序,每三个逐个往后移动,如果能组成则这个区间内一定能组成三角形
        public static int[] arr;
        public static void main(String[] args) throws IOException {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            int n = Integer.parseInt(reader.readLine()); //把读取到的字符串的n转换为int类型的
            //把读取的武器长度存入到一个长度为武器数量的数组中去
            String[] str = reader.readLine().split(" ");
            arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = Integer.parseInt(str[i]);
            }
            //判断每个区间内的武器长度能否组成三角形,并计算数量
            int count = 0;
            int m = Integer.parseInt(reader.readLine());
            for (int i = 0; i < m; i++) {
                String[] str1 = reader.readLine().split(" ");
                int l = Integer.parseInt(str1[0]);
                int r = Integer.parseInt(str1[1]);
                //当区间长度大于一定值的时候一定会有三角形
                if (r - l + 1 > 46) count++;
                else if (isTriango(l, r)) count++;
            }
            System.out.println(count); //输出能组成三角形的数量
        }
        //把这个区间里的武器长度排序,每三个逐个往后移动,如果能组成则这个区间内一定能组成三角形
        private static boolean isTriango(int l, int r) {
            int[] newArr = Arrays.copyOfRange(arr, l - 1, r);
            //排序
            Arrays.sort(newArr);
            //每三个遍历一下
            for (int i = 0; i < newArr.length - 2; i++) {
                if (newArr[i] + newArr[i + 1] > newArr[i + 2]) return true;
            }
            return false;
        }
    }
    

    BL5 顺时针打印数字矩阵

    题目描述

    给定一个数字矩阵,请设计一个算法从左上角开始顺时针打印矩阵元素
    

    输入描述:

    输入第一行是两个数字,分别代表行数M和列数N;接下来是M行,每行N个数字,表示这个矩阵的所有元素;当读到M=-1,N=-1时,输入终止。
    

    输出描述:

    请按逗号分割顺时针打印矩阵元素(注意最后一个元素末尾不要有逗号!例如输出“1,2,3”,而不是“1,2,
    3,”),每个矩阵输出完成后记得换行
    

    示例1

    输入

    3 3
    1 2 3
    4 5 6
    7 8 9
    -1 -1
    

    输出

    1,2,3,6,9,8,7,4,5
    备注:
    M,N为正整数且 M*N<=300000
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.io.IOException;
    public class Main {
        public static void main(String[] args) throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            while (br.ready()) {
                String[] s = br.readLine().split(" ");
                int m = Integer.parseInt(s[0]);
                int n = Integer.parseInt(s[1]);
                if (m == -1 && n == -1) break;
                int[][] matrix = new int[m][n];
                for (int i = 0; i < m; i++) {
                    String[] temp = br.readLine().split(" ");
                    for (int j = 0; j < n; j++) matrix[i][j] = Integer.parseInt(temp[j]);
                }
                printMatrix(matrix, m, n);
            }
        }
        public static void printMatrix(int[][] matrix, int row, int col) {
            //创建StringBuffer存储,因为有,号
            StringBuilder sb = new StringBuilder();
            if (matrix == null || row == 0 || col == 0) return;
            //记录圈数
            int start;
            //其他人的方法
            start = (Math.min(col, row) - 1) / 2 + 1;//确定需要的层数
            for (int i = 0; i < start; i++) {
                //从左到右打印
                for (int k = i; k < col - i; k++) sb.append(matrix[i][k]).append(",");
                //从右上到右下
                for (int j = i + 1; j < row - i; j++) sb.append(matrix[j][col - i - 1]).append(",");
                //从右到左
                for (int k = col - i - 2; (k >= i) && (row - i - 1 != i); k--)
                    sb.append(matrix[row - i - 1][k]).append(",");
                //从左下到左上
                for (int j = row - i - 2; (j > i) && (col - i - 1 != i); j--) sb.append(matrix[j][i]).append(",");
            }
            //输出,记得去掉最后一个“,”
            System.out.println(sb.substring(0, sb.length() - 1));
        }
    }
    

    BL6 精灵鼠从入口到出口的最少减少速度

    题目描述

    猛兽侠中精灵鼠在利剑飞船的追逐下逃到一个n*n的建筑群中,精灵鼠从(0,0)的位置进入建筑群,建筑群的出口位置为(n-1,n-1),建筑群的每个位置都有阻碍,每个位置上都会相当于给了精灵鼠一个固定值减速,因为精灵鼠正在逃命所以不能回头只能向前或者向下逃跑,现在问精灵鼠最少在减速多少的情况下逃出迷宫?
    

    输入描述:

    第一行迷宫的大小: n >=2 & n <= 10000;
    第2到n+1行,每行输入为以','分割的该位置的减速,减速f >=1 & f < 10。
    

    输出描述:

    精灵鼠从入口到出口的最少减少速度?
    

    示例1

    输入

    3
    5,5,7
    6,7,8
    2,2,4
    

    输出

    19
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.util.*;
    public class Main {
        public static void main(String[] args) throws Exception {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int n = Integer.parseInt(br.readLine());
            int[][] w = new int[n][n];
            int[] dp = new int[n + 1];
            dp[0] = 0;
            for (int i = 1; i <= n; i++) dp[i] = 100000;
            for (int i = 1; i <= n; i++) {
                String s = br.readLine();
                for (int j = 0; j < s.length(); j += 2) {
                    int x = j / 2 + 1;
                    dp[x] = Math.min(dp[x - 1], dp[x]) + (s.charAt(j) - '0');
                }
                dp[0] = 100000;
            }
            System.out.println(dp[n]);
        }
    }
    

    BL7 比较两个版本字符串version1和version2

    题目描述

    如果version1 > version2 返回1,如果 version1 < version2 返回-1,不然返回0.
    输入的version字符串非空,只包含数字和字符.。.字符不代表通常意义上的小数点,只是用来区分数字序列。例如字符串2.5并不代表二点五,只是代表版本是第一级版本号是2,第二级版本号是5.
    

    输入描述:

    两个字符串,用空格分割。
    每个字符串为一个version字符串,非空,只包含数字和字符.
    

    输出描述:

    只能输出1, -1,或0
    

    示例1

    输入

    0.1 1.1
    

    输出

    -1
    备注:
    version1和version2的长度不超过1000,由小数点'.'分隔的每个数字不超过256。
    
    import java.io.*;
    public class Main {
        public static void main(String[] args) throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String[] inarr = br.readLine().split(" ");
            String[] str1 = inarr[0].split("\\.");
            String[] str2 = inarr[1].split("\\.");
            //先直接进行比较,看看谁的版本高
            for (int i = 0; i < str1.length && i < str2.length; i++) {
                if (Integer.parseInt(str1[i]) < Integer.parseInt(str2[i])) {
                    System.out.println("-1");
                    return;
                } else if (Integer.parseInt(str1[i]) > Integer.parseInt(str2[i])) {
                    System.out.println("1");
                    return;
                }
            }
            //当前面的比较没有成功,有如下情况
            //长度相同时版本一致,
            //一长一短,并且短的部分与长的前面相同
            if (str1.length == str2.length) System.out.println("0");
            else if (str1.length < str2.length) System.out.println("-1");
            else System.out.println("1");
        }
    }
    

    BL8 写一段程序判断IP字符串是否属于内网IP

    题目描述

    从业 666 年的 BILIBILI 网络安全工程师 KindMo 最近很困惑,公司有一个业务总是受到 SSRF 攻击。请帮他写一个程序,判断输入的字符串是否属于内网IP,用于防御该漏洞。
    我们知道常见的内网IP有,127.0.0.1,192.168.0.1 等。
    

    输入描述:

    每次输入仅包含一个IP字符串,即一个测试样例
    

    输出描述:

    对于每个测试实例输出整数1或0,1代表True,即输入属于内网IP,0代表False,即输入不属于内网IP或不是IP字符串。
    

    示例1

    输入

    42.96.146.169
    

    输出

    0
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    public class Main {
        public static void main(String[] args) throws IOException {
             /*
            思路:ip转换为整数,判断数字是否属于内网地址对应的数字:
            10.0.0.0 - 10.255.255.255:  需要判断:10
            127.0.0.0 - 127.255.255.255 需要判断: 127
            172.16.0.0 - 172.31.255.255 需要判断: 127 16 和 127 31
            192.168.0.0 - 192.168.255.255 需要判断: 192 168
            */
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String line = br.readLine();
            String[] ips = line.split("\\.");
            int v1 = Integer.parseInt(ips[0]);
            int v2 = Integer.parseInt(ips[1]);
            if (v1 == 10 || (v1 == 172 && (v2 >= 16 && v2 <= 31)) || (v1 == 192 && v2 == 168)) System.out.println(1);
            else System.out.println(0);
        }
    }
    

    BL9 给定一个整数数组,判断其中是否有3个数和为N

    题目描述

    给定一个整数数组,判断其中是否有3个数和为N
    

    输入描述:

    输入为一行
    逗号前为一个整数数组,每个元素间用空格隔开;逗号后为N
    

    输出描述:

    输出bool值
    True表示存在3个和为N的数
    False表示不存在3个和为N的数
    

    示例1

    输入

    1 2 3 4 5,10
    

    输出

    True
    备注:
    数组长度不超过2000,所以数均为int范围的正整数
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args) throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String[] s = br.readLine().split(",");
            String[] arr = s[0].split(" ");
            int[] a = new int[arr.length];
            int n = Integer.parseInt(s[1]);
            for (int i = 0; i < arr.length; i++) {
                a[i] = Integer.parseInt(arr[i]);
            }
            Arrays.sort(a);
            for (int i = 0; i < a.length - 2; i++) {
                int k = a.length - 1;
                for (int j = i + 1; j < k; ) {
                    if (a[i] == n - a[j] - a[k]) {
                        System.out.println("True");
                        return;
                    } else if (a[i] < n - a[j] - a[k]) j++;
                    else k--;
                }
            }
            System.out.println("False");
        }
    }
    

    BL10 脸滚键盘

    题目描述

    av394281 中,充满威严的蕾米莉亚大小姐因为触犯某条禁忌,被隙间妖怪八云紫(紫m……èi)按住头在键盘上滚动。
    同样在弹幕里乱刷梗被紫姐姐做成罪袋的你被指派找到大小姐脸滚键盘打出的一行字中的第 `k` 个仅出现一次的字。
    (为简化问题,大小姐没有滚出 ascii 字符集以外的字)
    

    输入描述:

    每个输入都有若干行,每行的第一个数字为`k`,表示求第`k`个仅出现一次的字。然后间隔一个半角空格,之后直到行尾的所有字符表示大小姐滚出的字符串`S`。
    

    输出描述:

    输出的每一行对应输入的每一行的答案,如果无解,输出字符串`Myon~`
    (请不要输出多余的空行)
    为了方便评测,如果答案存在且为c,请输出[c]
    

    示例1

    输入

    2 misakamikotodaisuki
    3 !bakabaka~ bakabaka~ 1~2~9!
    3 3.1415926535897932384626433832795028841971693993751o582097494459211451488946419191919l91919hmmhmmahhhhhhhhhh
    7 www.bilibili.com/av170001
    1 111
    

    输出

    [d]
    [9]
    [l]
    [7]
    Myon~
    备注:
    字符串S仅包含可见ascii码,长度不超过100000
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    public class Main {
        public static void main(String[] args) throws IOException {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            while (reader.ready()) {
                String line = reader.readLine();
                int index = 0;
                while (line.charAt(index) != ' ') ++index;
                int k = Integer.parseInt(line.substring(0, index));
                System.out.println(appearFirst(k, line.substring(index + 1)));
            }
            reader.close();
        }
        private static String appearFirst(int k, String s) {
            char[] ar = s.toCharArray();
            int[] hash = new int[128];
            for (char c : ar) hash[c]++;
            for (char c : ar) {
                if (hash[c] == 1 && k == 1) return "[" + c + "]";
                else if (hash[c] == 1) --k;
            }
            return "Myon~";
        }
    }
    

    BL11 实现一个HTML语法检查器

    题目描述

    实现一个HTML语法检查器。HTML语法规则简化如下:标签必须闭合,可以由开始和结束两个标签闭合,如<div></div>,也可以自闭合,
    如<div />
    标签可以嵌套如<div><a></a></div>或者 <div><a/></div>,但是标签不能交叉:<div><a></div></a>是不允许的标签里可以有属性
    如<div id="a<1"></div>
    属性的规则是name="任意非引号字符",多属性声明之间必须有空格,属性声明不符合规则时,整段HTML都算语法错误
    输入文本只会出现字母a-z和<>"=
    请用任意语言实现一个HTML语法检查器函数,有语法错误返回1,没有语法错误返回0
    

    输入描述:

    一行,一个HTML字符串
    

    输出描述:

    有语法错误返回1,没有语法错误返回0
    

    示例1

    输入

    <div><a></a></div>
    

    输出

    0
    示例2
    输入
    <div><a></div></a>
    

    输出

    1
    备注:
    字符串长度不超过100
    
    import java.util.*;
    import java.util.Stack;
    public class Main {
        public static void main(String[] args) {
            Scanner input = new Scanner(System.in);
            String str = input.nextLine();
            int result = 1;
            if (solve(str)) result = 0;
            System.out.println(result);
        }
        public static boolean solve(String str) {
            str = str.trim(); //消除前后的空格
            Stack<String> stack = new Stack<>(); //记录标签的入栈顺序
            int i = 0;
            while (i < str.length()) {
                if (i == 0 && str.charAt(i) != '<') return false; //第一个字符不是<,则表明不是以标签开始
                if (i == str.length() - 1 && str.charAt(i) != '>') return false; //最后的字符不是>,则表明不是以标签结束
                if (str.charAt(i) == '<') {
                    int j = i + 1;
                    //'<'之后如果是标签,紧跟在'<'之后的字符必定是a-z或者'/'
                    if (j < str.length() && (str.charAt(j) >= 'a' && str.charAt(j) <= 'z' || str.charAt(j) == '/')) {
                        //获取标签字符串<xx xx="">
                        boolean inStr = false; //是否处于字符串"里面
                        while (j < str.length()) {
                            //标签结束
                            if (!inStr && str.charAt(j) == '>') {
                                //传入的标签已经去除'<'和'>'字符
                                if (!checkAtt(str.substring(i + 1, j), stack)) return false; //属性有语法错误
                                i = j;
                                break;
                            } else if (str.charAt(j) == '"') inStr = !inStr;
                            j++;
                        }
                    }
                }
                i++;
            }
            return stack.isEmpty();
        }
        public static boolean checkAtt(String str, Stack<String> stack) {  //处理标签里面的属性
            if (str == null && str.length() == 0) {
                return true;
            }
            int type = 0; //记录标签的类型,0为开始标签<x>,1为结束标签</x>,2为自闭合标签<x/>
            if (str.charAt(0) == '/') {  //判断是否是结束标签
                if (!(str.length() >= 2 && str.charAt(1) >= 'a' && str.charAt(1) <= 'z')) {
                    return false; //结束标签的'/'之后必须紧跟字母
                }
                type = 1; //为结束标签
                str = str.substring(1);
            }
            str = str.trim(); //去除字符串后面的空格
            if (str.charAt(str.length() - 1) == '/') { //判断是否是自闭合标签
                if (type == 1) return false; //不能同时为结束标签,又是自闭合标签
                type = 2;
                str = str.substring(0, str.length() - 1);// 去除最后的'/'
            }
            int i = 0;
            //获取标签的名字,并判断是否符合闭合规则
            while (i < str.length() && str.charAt(i) != ' ') i++;
            String name = str.substring(0, i);
            if (type == 0) stack.push(name);
            else if (type == 1) {
                if (!stack.isEmpty() && stack.peek().equals(name)) stack.pop();
                else return false;
            }
            //判断其属性是否有语法错误
            boolean hasAtt = false; //判断该标签是否有属性,针对结束标签不能有属性
            boolean hasBlank = false; //判断属性name之前是否有空格
            while (i < str.length()) {
                while (i < str.length() && str.charAt(i) == ' ') {
                    hasBlank = true;
                    i++;
                }
                while (i < str.length() && str.charAt(i) != '=' && str.charAt(i) != ' ') i++; //获取属性名字
                if (i < str.length() && str.charAt(i) == '=') { //如果没有'='说明不是属性,不进行处理
                    i++;
                    if (i >= str.length() || str.charAt(i) != '"') return false; //'='之后必须是双引号
                    i++;
                    while (i < str.length() && str.charAt(i) != '"') i++; //寻找下一个双引号
                    if (i >= str.length()) return false;
                    if (!hasBlank) return false; //属性之前没有空格,语法错误
                }
                hasBlank = false;
                hasAtt = true;
                i++;
            }
            return type != 1 || !hasAtt; //结束标签不能有属性
        }
    }
    

    BL12 翻转链表

    题目描述

    对于一个链表 L: L0→L1→…→Ln-1→Ln,
    将其翻转成 L0→Ln→L1→Ln-1→L2→Ln-2→…
    输入是一串数字,请将其转换成单链表格式之后,再进行操作
    

    输入描述:

    一串数字,用逗号分隔
    

    输出描述:

    一串数字,用逗号分隔
    

    示例1

    输入

    1,2,3,4,5
    

    输出

    1,5,2,4,3
    备注:
    数组长度不超过100000
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    public class Main {
        public static void main(String[] args) throws IOException {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String[] strings = reader.readLine().split(",");
            StringBuilder buffer = new StringBuilder();
            int i = 0;
            int left = 0;
            int right = strings.length - 1;
            while (left < right) {
                if (i % 2 == 0) buffer.append(strings[left++]);
                else buffer.append(strings[right--]);
                buffer.append(",");
                i++;
            }
            buffer.append(strings[left]);
            System.out.println(buffer);
        }
    }
    

    BL13 孙悟空的徒弟

    题目描述

    打败魔人布欧以后,孙悟空收了n个徒弟,每个徒弟战斗力各不相同。他教导所有的徒弟和体术,合体后战斗力为原战斗力相乘。任何两个徒弟都可以合体,所以一共有n*(n-1)/2种合体徒弟。有一天,他想考验一下孙悟天战斗力如何,希望在所有n*(n-1)/2种合体徒弟中选择战斗力第k高的,与孙悟天对战。可是孙悟空徒弟太多了,他已然懵逼,于是找到了你,请你帮他找到对的人。
    

    输入描述:

    第一行两个int。徒弟数量:n <= 1*10^6;战斗力排名:k <= n*(n-1)/2
    第二行空格分隔n个int,表示每个徒弟的战斗力。
    

    输出描述:

    战斗力排名k的合体徒弟战斗力。
    

    示例1

    输入

    5 2
    1 3 4 5 9
    

    输出

    36
    
    import java.io.*;
    import java.util.*;
    public class Main {
        public static void main(String[] args) throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String[] s = br.readLine().split(" ");
            int n = Integer.parseInt(s[0]);
            long k = Long.parseLong(s[1]);
            long[] num = new long[n];
            String[] s1 = br.readLine().split(" ");
            for (int i = 0; i < n; i++) {
                num[i] = Long.parseLong(s1[i]);
            }
            Arrays.sort(num);
            long min = 0, max = num[n - 1] * num[n - 2];
            while (min < max) {
                long mid = (min + max + 1) / 2;
                long cur = 0;
                int left = 0, right = n - 1;
                while (left < right && cur < k) {
                    while (left < right && num[left] * num[right] < mid) left++;
                    cur += Math.max(right - left, 0);
                    int i = right--;
                }
                if (cur >= k) min = mid;
                else max = mid - 1;
            }
            System.out.println(min);
        }
    }
    

    BL14 ん…红茶?

    题目描述

    高贵的蕾米莉亚大小姐每天需要饮用定量 B 型血的红茶以保持威严,并且要分两杯在不同时段饮用。
    女仆长十六夜咲夜每天可以制作很多杯不同剂量 B 型血的红茶供蕾米莉亚大小姐饮用。
    某日,你和天才妖精琪露诺偷偷潜入红魔馆被咲夜抓住,要求在今日份的红茶中挑出所有满足大小姐要求的茶杯,否则……
    

    输入描述:

    每个样例有三行输入,第一行输入表示茶杯个数,第二行输入表示每份茶杯里的 B 型血剂量,第三行表示大小姐今天的定量
    

    输出描述:

    对每一个样例,输出所有可能的搭配方案,如果有多种方案,请按每个方案的第一杯 B 型血剂量的大小升序排列。
    如果无法找到任何一种满足大小姐的方案,输出"NO"(不包括引号)并换行。
    

    示例1

    输入

    7
    2 4 6 1 3 5 7
    7
    

    输出

    1 6
    2 5
    3 4
    备注:
    茶杯个数不超过100000,保证茶杯里的B型血剂量两两不同。
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.Arrays;
    import java.util.Scanner;
    public class Main {
        public static void main(String[] args) throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int n = Integer.parseInt(br.readLine());
            String[] s = br.readLine().split(" ");
            int[] nums = new int[s.length];
            for (int i = 0; i < s.length; i++) {
                nums[i] = Integer.parseInt(s[i]);
            }
            int r = Integer.parseInt(br.readLine());
            Arrays.sort(nums);
            int left = 0;
            int right = nums.length - 1;
            boolean flag = false;
            while (left < right) {
                if (nums[left] + nums[right] > r) right--;
                else if (nums[left] + nums[right] < r) left++;
                else {
                    flag = true;
                    System.out.println(nums[left] + " " + nums[right]);
                    left++;
                }
            }
            if (!flag) System.out.println("NO");
        }
    }
    
    展开全文
  • 单选23道,46分;编程3道,60分;总分106。 单选记不得了,趁着代码思路还在,记录编程题如下(题目名字我乱起的): 一、字典序拼接 给一个数组,元素值非负。将数组中元素拼接起来,要求拼接后的数值最大。...

    单选23道,46分;编程3道,60分;总分106。

    单选记不得了,趁着代码思路还在,记录编程题如下(题目名字我乱起的):

    一、字典序拼接

    给一个数组,元素值非负。将数组中元素拼接起来,要求拼接后的数值最大。为了避免溢出,以字符串的形式输出拼接结果。

    示例1:

    输入:30,1

    输出:301

    个人测试用例:

    输入:15,30,7,3,8

    输出:8733015

    题解:

    先按字典序将数组从大到小排序,然后再拼接起来输出即可。

    (1)为满足字典序排序,先遍历一遍数组,记录每个元素的长度,并找出最长的长度,即为max_length;

    (2)对每个元素,使用ASCII码表中取值最大的字符,进行填充,使得每个元素的长度都等于max_length;

    (3)使用python自带的排序函数list.sort(reverse=True),对数组元素进行排序(默认会按照字典序进行排列);

    (4)将排序后的数组元素进行拼接,并剔除额外填充的ASCII字符,输出即可。

    对于步骤(2)中选择ASCII码表中的值最大的字符进行填充,这里简单解释一下:

    因为字典序的排序是从大到小,选择最大ASCII码值的字符进行填充,不会影响字典序的排列,例如B和BA,按字典序排列,应该是BBA,假设填充的字符为Z,那么BZ还是大于BA,排序之后是BZBA,剔除掉额外填充的字符Z之后,依然还是BBA。

    代码实现如下(没有来得及提交,不知道AC情况):

    def calc(arys):
        imax = 0
        nums = 0
        tns = []
        for item in arys:     # 找出数组中长度最长的元素,并记录其长度
            nums += 1
            tn = len(item)
            tns.append(tn)
            if tn > imax:
                imax = tn
    
        # 按照ASCII码表,使用最大的字符填充数组中元素,使得每个元素的长度都等于最长元素的长度
        for i in range(nums):
            arys[i] = arys[i] + '~'*(imax-tns[i])
    
        # 使用自带排序算法库函数,按字典排序
        arys.sort(reverse=True)
        print(''.join(arys).replace('~', ''))
        pass
    
    
    if __name__ == '__main__':
        # line = input().split(',')
        line = ['15', '30', '7', '3', '8']
        calc(line)
        pass
    

    二、视频点击

    大概意思跟广告推荐有点像,就是给你一个视频(记为avid_from),你看了这个视频之后可能还会去点击其他相关的视频(记为avid_to),这样就形成了一条点击记录。现在请计算,哪个avid_from关联的视频数量最多,输出这个视频的ID,即avid_from。如果两个视频的关联数量相等,则输出ID较大的那一个。

    示例:(示例很珍贵,比较幸运的是,直接一次100%AC,所以没有再考虑其他示例)

    输入:

    5(表示总共有几组数据)

    33956 27538

    79731 91415

    25288 33956

    33956 84925

    79731 24288

    输出:

    79731

    题解:

    (1)使用字典结构,以avid_from作为key,对应的value为list,存储与其对应的所有avid_to;

    (2)针对字典的每一个key,进行深度优先搜索遍历,并统计遍历到的元素数量,取元素数量最多的输出即可;

    (3)另外,对于特殊情况,按照key的大小进行判别输出即可;

    代码实现如下(AC 100%):

    if __name__ == '__main__':
        num = int(input())
        ans = []
        dct = {}
        for i in range(num):
            line = input().split(' ')
            avid_f, avid_t = line[0], line[1]
            if avid_f not in dct.keys():
                dct[avid_f] = [avid_t]
            else:
                dct[avid_f].append(avid_t)
    
        imax = 0
        kys = list(dct.keys())
        rst = kys[0]
    
        for ky in kys:
            avid = dct[ky]
            count = len(avid)
            queue = []
            for item in avid:
                if item not in kys:
                    continue
    
                queue = queue + dct[item]
                while queue:
                    kyt = queue.pop()
                    count += 1
                    if kyt not in kys:
                        continue
                    queue = queue + dct[kyt]
    
            if count > imax:
                rst = ky
                imax = count
            if count == imax:
                if int(ky) > int(rst):
                    rst = ky
    
        print(rst)
        pass
    

    三、逛展台

    感觉上好像跟硬币组合差不多,我理个整体意思,大家仔细分辨。

    给定一个数组,数组元素表示每个展台商品的价格(每个展台只有一个商品),然后给出总价值S,问最少需要几个展台的商品,才能使它们的价值大于等于S。

    示例:

    5 7

    1 2 3 4 5

    输出:

    2

    5表示有5个展台,下一行的[1,2,3,4,5]即是每个展台的商品价格。7是给定的总价值S。

    题解:(有好思路的还请不吝赐教,谢谢!)

    (1)采用的暴力方式,两个循环,第一个循环锚定起始元素,然后依次向右遍历,直到相加和大于等于S;

    (2)特殊情况:数组和小于S时,输出-1;

    代码实现如下(AC 60%):

    def calc(ans, value):
        length = len(ans)
        imin = length
        for i in range(length-1):
            start = ans[i]
            if start >= value:
                imin = 1
                break
    
            count = 1
            temp = start
            for j in range(i+1, length):
                temp += ans[j]
                count += 1
                if temp >= value:
                    break
            if imin > count:
                imin = count
    
        return imin
        pass
    
    
    if __name__ == '__main__':
        line = input().split(' ')
        num, value = int(line[0]), int(line[1])
        ans = input().split(' ')
        ans = list(map(int, ans))
        if sum(ans) < value:
            print(-1)
        else:
            rst = calc(ans, value)
            print(rst)
        pass
    

    以上即是个人的编程体验,还是太菜了?,大佬们如果有什么好的思路或见解,还请不吝赐教,谢谢~

     

     

     

     

     

     

    展开全文
  • 编程题 题目一 求最长回文字串 题目二 数组的最大连续和 题目三 大鱼吃小鱼: 一次操作中,体积大的鱼会吃掉后面第一个比它小的鱼, 如[6,5,4]一次操作后只剩6,6吃5,5吃4 问几次操作后,鱼的数量才不变?...
  • 算卷积的过程 import sys h, w = list(map(int, input().split())) imageIn = [] for i in range(h): imageIn.append(list(map(int, input().split()))) m = int(input()) kernel = [] for i in range(m): ...
  • 哔哩哔哩稿件号转换

    千次阅读 2020-03-25 13:49:03
    关于哔哩哔哩稿件号转换。 我提供的是C++代码来转换av号与BV号。 算法来自知乎大佬,代码中并没有关于算法的注释,但我想看完算法之后应该在理解代码上不会有太大问题。
  • python模拟哔哩哔哩滑块登入验证 准备工具 pip3 install PIL pip3 install cv2 pip3 install numpy 谷歌驱动 谷歌驱动 谷歌驱动下载链接 :http://npm.taobao.org/mirrors/chromedriver/ 前言 本篇文章采用的是cv2的...
  • 学编程又一火爆网站:哔哩哔哩

    万次阅读 2020-10-01 21:42:41
    最近哔哩哔哩学编程,里面有很多编程的视频,质量比较好。 有个算法视频:力扣&拉勾网算法 讲的不错 身边的同事都在使用
  • 语言(c/c++/java),算法,数据结构DS,系统调用和计算机网络(Linux+网络基础+网络编程) ⑥面试题+笔试题+面试技巧 第二课作业 ①vscode搞定一定可以编代码 新建项目,必须是一个工程文件应该分类 ②想看到结果:...
  • 4 cache置换算法 5 数组和链表的快慢,寻址,涉及比较深 6项目问题 7 前K大数的算法复杂度,及其推导过程(手写) 二面: 1 mysql数据库,引擎,各种解释对比 2 数据库连接池 3 tomcat的配置,常
  • 2021-06-07

    2021-06-07 10:57:29
    ##递归算法 图来源(哔哩哔哩算法设计与分析) 归纳法证明
  • 从JAVA移植的(从python移植的B站AV号BV号互转算法源码)//套娃 引用@ty1937 https://blog.csdn.net/ty1937/article/details/105080093?ops_request_misc=%257B%2522request%255Fid%2522%253A%252...
  • 10.16 哔哩哔哩商业技术部前端一面,没有参加笔试,直接打电话问参不参加面试。 面试:50min 自我介绍 说一下学习前端的过程,是受否参与过实习或者有写一些项目 项目相关,遇到了哪些困难,怎么解决的 对闭包的...
  • 哔哩哔哩21届秋招算法岗笔试 题目描述: 假设货币系统包含面值1元、4元、16元、64元共计4种硬币,以及面值1024元的纸币。现在小明使用1024元的纸币购买了一件价值为N(0<N<=1024)的商品,请问最少他会收到...
  • 教程合集

    2018-04-04 19:07:02
    教程合集 哔哩哔哩算法讲堂 渗透测试 多语言教程合集 教程论坛 Google资源搜索教程
  • 准备工具 pip3 install PIL pip3 install opencv-python pip3 install numpy 谷歌驱动 建议指定清华源下载速度会更快点 ...谷歌驱动 ...前言 本篇文章采用的是cv2的Canny边缘检测算法进行...Canny边缘检测算法参考链接
  • 从python移植的B站AV号BV号互转算法源码 private static String table = fZodR9XQDSUm21yCkr6zBqiveYah8bt4xsWpHnJE7jL5VG3guMTKNPAwcF; private static HashMap mp = new HashMap(); private static HashMap ...
  • 小A参加了一个n人的活动,每个人都有一个唯一编号i(i>=0 & i<n),其中m对相互认识,在活动...算法:并查集 #include<iostream> #include<algorithm> #include<vector> using nam...
  • B站 (哔哩哔哩) 泄露源码中的有趣片段(彩蛋)

    千次阅读 多人点赞 2020-02-17 18:19:32
    这两天闲来无事,回顾了一下年前B站沸沸扬扬的代码泄露事件,大致翻阅了一些泄露的代码发现了一些有意思的事情,其中就包括B站视频推荐算法的相关代码。 不过后期 B站官方辟谣说是老版本代码,并且已经进行相应的...
  • 给定一个数字矩阵,请设计一个算法从左上角开始顺时针打印矩阵元素 输入描述 输入第一行是两个数字,分别代表行数M和列数N;接下来是M行,每行N个数字,表示这个矩阵的所有元素;当读到M=-1,N=-1时,输入终止。 ...
  • 本人为初一中学生,正好遇见了B站将av号改为bv号的历史时刻,然后又看见许多的大佬公布了算法,于是我借助大佬们公布的算法用C++代码实现bv号转换为av号,(算法来源:https://www.bilibili.com/video/BV1R7411y7kw...
  • 1、一定要把基本的数据结构,经典的算法,Unix编程,程序编译链接及计算机原理等基础知识扎牢,这些会长远影响你的职业发展。 2、 推荐从C语言入门,不单是因为很多操作系统、网络协议栈开源代码由C/C++实现,更多是...
  • 给定一个数字矩阵,请设计一个算法从左上角开始顺时针打印矩阵元素 输入描述 输入第一行是两个数字,分别代表行数M和列数N;接下来是M行,每行N个数字,表示这个矩阵的所有元素;当读到M=-1,N=-1时,输入终止。 ...
  • SVM空降指挥部性能压力山大,思考之后还是用以图搜图的算法来做比较平衡 目录结构 util:工具 可复用的函数 codec:媒体文件(flv/ass/mkv)生成 service:与B站页面交互 从B站抓数据 在页面上模拟用户操作 监控页面...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 151
精华内容 60
关键字:

哔哩哔哩算法