【牛客】【刷题节】美团2024届秋招笔试第二场编程真题

已于 2024-04-27 17:17:15 修改
阅读量1.7k 收藏 35
点赞数 34
分类专栏： 刷题训练营 文章标签： 算法 数据结构 java
于 2024-02-25 16:40:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lt_BeiMo/article/details/136260118
版权

1.小美的加法【简单题】

题意理解：

        给定一个数组做连加操作，其中只能将一个加号变成乘号

        将哪个加号变成乘号，使式子最后的结果最大

解题思路：

        只有将两个相邻且乘机最大的数之间变成乘号后，才能保证整个式子结果最大

        所以第一步找到这两个数的位置

        在所有元素和中减去这两个元素，加上这两个元素的乘积即可。

        这里采用滑动窗口来找相邻乘积最大的两个元素，其中滑动窗口大小为2.

注意：数组的元素顺序不能变，所以不能排序

1.滑动窗口解题

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int len=in.nextInt();
        long[] nums=new long[len];
        for(int i=0;i<len;i++) nums[i]=in.nextLong();
        Main main=new Main();
        System.out.println(main.compuate(nums));
    }

    public Long compuate(long[] nums){
        long result=0;
        int maxNeighbor=0;
        for(int i=0;i<nums.length-1;i++){
            result+=nums[i];
            if(nums[i]*nums[i+1]>nums[maxNeighbor]*nums[maxNeighbor+1]){
                maxNeighbor=i;
            }
        }
        result+=nums[nums.length-1];
        result=result-nums[maxNeighbor]-nums[maxNeighbor+1]+nums[maxNeighbor]*nums[maxNeighbor+1];
        return result;
    }
}

2.复杂度分析

时间复杂度：O(n) 遍历数组的时间耗费

空间复杂度：O(n) 数组存储的空间耗费

2.小美的数组操作【技巧】

题意理解：

        给定一个数组，每次选中两个数，一个元素+1，一个元素-1

        最终使数组中的众数出现的次数最多。

解题思路：

        我的思路：求平均数，然后将数组排序，让所有的数都向平均数靠近。

        对于平均数为整数的来说，可以实现。但对于平均数不为整数的发生错误。

        借鉴大佬的思路：

        

个人理解：

        对于平均数为整数的，所有数向平均数靠近。

        对于平均数部位整数的，去掉一个元素，保证其他元素的平均数是整数，此时重复上述操作。 关键：如何挑选去除的那个元素呢，即如何选取垃圾数。 

        贪心思路：选取最大值或最小值为垃圾数，将多余的位数分给垃圾数——将avg+1和avg-1分别作为众数来计算，进行比较。

注意：+1和-1操作是对称的，有k个+1则有k个-1操作

        对于[2,2,4,4]来说，不操作，2/4都是众数，都有两个。但是不满组足众数最多。

        操作后：[3,3,3,3]，众数是3有4个

1.贪心解题

import java.util.Scanner;
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int len = in.nextInt();
        long[] nums = new long[len];
        for (int i = 0; i < len; i++) {
            nums[i] = in.nextLong();
        }
        Main main = new Main();
        System.out.println(main.compute(nums));
    }
    public long compute(long[] nums){
        long count=0;
        int len=nums.length;
        Arrays.sort(nums);
        long sum=0;
        for(int i=0;i<len;i++){
            sum+=nums[i];
        }
        if(sum%len==0){
            //没有垃圾数
            count=countK(nums,sum/len,0,len-1)/2;
        }else{
            //选最大的数为垃圾数
            long avg=(sum-nums[len-1])/(len-1);
            //丢垃圾
            long countMA1=countK(nums,avg,1,len-2)+Math.abs(avg-nums[0])+Math.abs((sum-nums[len-1]-avg*(len-1)));//中间得操作+第一个数取+垃圾桶丢
            long countMA2=countK(nums,avg+1,1,len-2)+Math.abs(avg+1-nums[0])+Math.abs((sum-nums[len-1]-(avg+1)*(len-1)));//中间操作+第一个数取+垃圾桶拿

            //选最小的数为垃圾数
            avg=(sum-nums[0])/(len-1);
            long countMI1=countK(nums,avg,1,len-2)+Math.abs(avg-nums[len-1])+Math.abs((sum-nums[0]-avg*(len-1)));//中间操作数+最后一个数丢+垃圾桶丢
            long countMI2=countK(nums,avg+1,1,len-2)+Math.abs(avg+1-nums[len-1])+Math.abs((sum-nums[0]-(avg+1)*(len-1)));//中间操作数+最后一个数丢+垃圾桶拿
            count=Math.min(Math.min(countMI1,countMI2),Math.min(countMA1,countMA2))/2;
        }
        return count;
    }

    public long countK(long[] nums,long avg,int left,int right){
        long count=0;
        for(int i=left;i<=right;i++){
            if(nums[i]<avg){
                count+=avg-nums[i];
            }
            if(nums[i]>avg){
                count+=nums[i]-avg;
            }
        }
        return count;
    }
}

代码里有一个技巧：

2.复杂度分析

时间复杂度：O(n*log(n)) 排序的时间复杂度

空间复杂度：O(n) 排序所需的额外空间

主要是Arrays.sort的损耗

3.小美的01串翻转【技巧】-动态规划

题意理解：

        这道题理解起来有点绕：首先明确：  一个01串的权重：使得相邻位不同的最小操作数

        其次：统计所有子串（包含其本身、长度>=2的）权重的和。即为所求的值。

解题思路：

不成熟且错误的思路，故借鉴大佬思路：

        

个人理解：       

        操作字符串的目的：为了使字符串相邻字符不相同

        那么：长度为s.len 的满足条件的子串有两种，要么以1开头，要么以0开头

        即：s=10001   那么满足条件的修改为： 10101  或01010

        将其子串与这两个目标串进行比较,同一位置值不同则说明需要修改，统计不同的字符，即为修改次数。

        两个修改次数取最小值，即为所求。

        上表中的每个位置[i,j]表示从i到位置j的子串的权值是多少

重新发现思路：

        这道题目可以用动态规划来解决。其中如何和动态规划结合起来呢。

        首先是子串，子串有一个开始位置和起始位置，其中每个位置有两种可能0或1

        （1）定义三维dp数组

        dp[i][j][0]表示从i开始到j位置的子串，若以0结尾的权值

        dp[i][j][1]表示从i开始到j位置的子串，若以1结尾的权值

        （2）递推公式

        dp[i][j][x] 表示从i到j位置得子串，以x结尾的权值
        //子串当前以0结尾
        dp[i][j][0]=dp[i][j-1][1];
        dp[i][j][1]=dp[i][j-1][0]+1;
        //当前以1结尾
        dp[i][j][0]=dp[i][j-1][1]+1;
        dp[i][j][1]=dp[i][j-1][0];

        （3）初始化：

        则i,j的权值=min(dp[i][j][0],dp[i][j][1])
        初始化： 对于dp[i][j]的值总是和dp[i][j-1]有关，所以从左到右填数
        dp[i][i]=0

1.解题

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String num = in.nextLine();
        Main main = new Main();
        System.out.println(main.compute(num));
    }
    public int compute(String num){
        /**
         * dp[i][j][x] 表示从i到j位置得子串，以x结尾的权值
         * //当前以0结尾
         * dp[i][j][0]=dp[i][j-1][1];
         * dp[i][j][1]=dp[i][j-1][0]+1;
         * //当前以1结尾
         * dp[i][j][0]=dp[i][j-1][1]+1;
         * dp[i][j][1]=dp[i][j-1][0];
         *                 }
         * 则i,j的权值=min(dp[i][j][0],dp[i][j][1])
         * 初始化： 对于dp[i][j]的值总是和dp[i][j-1]有关，所以从左到右填数
         * dp[i][i]=0
         */
        int sum=0;
        int len=num.length();
        int[][][] dp=new int[len][len][2];
        for(int i=0;i<len;i++){
            if(num.charAt(i)=='0'){
                dp[i][i][0]=0;
                dp[i][i][1]=1;
            }else{
                dp[i][i][0]=1;
                dp[i][i][1]=0;
            }
        }
        //遍历所有的子串
        for(int i=0;i<len-1;i++){
            for(int j=i+1;j<len;j++){
                if(num.charAt(j)=='0'){//当前以0结尾
                    dp[i][j][0]=dp[i][j-1][1];
                    dp[i][j][1]=dp[i][j-1][0]+1;
                }else{//当前以1结尾
                    dp[i][j][0]=dp[i][j-1][1]+1;
                    dp[i][j][1]=dp[i][j-1][0];
                }
                sum+=Math.min(dp[i][j][0],dp[i][j][1]);
            }
        }

        return sum;
    }
}

2.复杂度分析

时间复杂度：O(n^2)  遍历所有子串（开始和截止位置）

空间复杂度：O(n^3) 记录结果值得损耗 

4.小美的外卖订单编号【简单题】

题意理解：

        订单号：[1,m],超过m时，重新从1开始计数

        题目的问题是：第q个订单的订单编号x是多少?

解题思路：

        编号1到m，很容易想到取余的操作。

        一个数对m取余获得[0,m-1]的区域

        第1单： 1%m==1

        第2单： 2%m==2

              ……

        第m单：m%m==0，此时单号应该是m，而不是0

        除第m单特殊之外，其余单没有什么不同。         

1.解题

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
     public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int len=in.nextInt();
        int[][] nums=new int[len][2];
        for(int i=0;i<len;i++){
            nums[i][0]=in.nextInt();
            nums[i][1]=in.nextInt();
        }
        Main main=new Main();
        int[] result= main.compute(nums);
        for(int i=0;i<len;i++){
            System.out.println(result[i]);
        }
    }
    public int[] compute(int[][] nums){
        int[] result=new int[nums.length];
        for(int i=0;i<nums.length;i++){
            if(nums[i][1]%nums[i][0]==0){
                result[i]=nums[i][0];
            }else{
                result[i]=nums[i][1]%nums[i][0];
            }
        }
        return result;
    }
}

2.复杂度分析

时间复杂度：O(n) 遍历的时间损耗

空间复杂度：O(n) 保存结果的时间损耗 

5.小美的数组操作2【简单题】

题意理解：

        根据选择的数，做出对应操作，最后判断数组是否是递增序列。

        是输出Yes,否则输出No

解题思路：

        根据输入，做指定操作，

        遍历检查数组是否是递增的

1.解题

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t=in.nextInt();
        Main main=new Main();
        String[] result=new String[t];
        for(int i=0;i<t;i++){//t次询问
            int n=in.nextInt();//数组长度
            int k=in.nextInt();//k次操作
            int[] nums=new int[n];
            int[][] kOpt=new int[k][2];
            for(int j=0;j<n;j++) nums[j]=in.nextInt();
            for(int j=0;j<k;j++){
                kOpt[j][0]=in.nextInt();
                kOpt[j][1]=in.nextInt();
            }
            result[i]=main.compute(nums,k,kOpt);
        }
        for(int i=0;i<t;i++){
            System.out.println(result[i]);
        }
    }

    public String compute(int[] nums,int k,int[][] kOpt){
        for(int i=0;i<k;i++){
            int u=kOpt[i][0]-1;
            int v=kOpt[i][1]-1;
            nums[u]++;
            nums[v]--;

        }
        for(int i=1;i<nums.length;i++){
            if(nums[i]<nums[i-1]) return "No";
        }
        return "Yes";
    }
}

2.复杂度分析

时间复杂度：O(n) 遍历数组进行检查的时间损耗

空间复杂度：O(n) 保存结果的空间损耗 

6.小美的数组构造【较难】-动态规划

题意理解：

        数组a和数组b对应位置数不同，但a和b元素和相等。

        构造符合条件的正整数b有多少种方式。

解题思路：

        没思路，这道题。

        结果这道题是一个动态规划类的题目。

        我去看了下别人的思路，然后猛的一看，不懂。纯看代码分析思路太难受了。啊啊啊啊

理解了，分析一下：

        这道题目还是一个动态规划的题，里面涉及状态转移的思路。

        以1 1 1数序列来演示
        dp[i][j]:表示sum=i,长度为j的串的可能的构造次数。
        则有：dp.size=(sum+1,len+1)=(4,4)

        其中特别的要求：b的元素是正整数，所以b的元素>=1
        根据题意：dp[0][j] 和dp[i][0]是没有意义的，全部初始化为0

       dp[j][j]（j>=1）可以构造出全1的数列，若对应位置 a[j-1]不等于1，则该位置上可以取1，一种构造方式，否则为0.【题目要求对应位置元素不一致】

        当计算dp[3][3]时，我们可以将3分解为：（1，2）（2，1）两种方式

        当第3位取2时，前面的数有dp[1][2]种方式(nums[3-1]=1,此位置可以取2)

        当第2位取1时，前面的数有dp[2][2]种方式(nums[3-1]=1,此位置不可以取2)——不符合要求

        即dp[3][3]=dp[1][2]=0

        具体步骤来说：

        （1）首先定义二维dp数组，其中size 为[sum+1][len+1]

        dp[i][j]表示和为i，长度为j的，符合条件的构造方式有几种。

        （2）递推公式

       dp[i][j]首先判断，将sum=i分解为两部分，有多少种排列

        如：sum=3   则有（1，2）、（2，1）两种方式

        sum=i时，第j位的取值范围是[1,j-1]

        其中第j位的值==a[j-1]时，j值不能取，应为会和a的j-1位置重复，不符合要求

        当第j位取k值时，sum=i-k,长度=j-1有dp[i-k][j-1]种构造方法

        遍历k值，若第j位能取k，则dp[i][j]+=dpdp[i-k][j-1]

         (3) 初始化

       dp[0][j] 和dp[i][0]是没有意义的，全部初始化为0

       dp[j][j]（j>=1）可以构造出全1的数列，若对应位置 a[j-1]不等于1，则该位置上可以取1，一种构造方式，否则为0.【题目要求对应位置元素不一致】

特别的：

        这道题目计算的数值会很大，所以元素及需要求和的值定义为long

        同时某个元素也可能会很大，所以在做加时，及时对元素做取模操作(%(7+10^9))

这道题目对我来说算是这7个里面最难的了，理解题想了半天，然后看明白了，不知道咋动手，想到应该用动态规划做，有没有思路了。想到了dp[sum][len]，搞明白意义，理清楚之后，突然豁然开朗，也不是很难了，好像。但是搞明白还是花了很长时间。

1.解题

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int len = scanner.nextInt();
        long[] arrA = new long[len];
        for(int i=0;i<len;i++){
            arrA[i]=scanner.nextLong();
        }
        Main main=new Main();
        System.out.println(main.compute(arrA));

    }
public long compute(long[] nums ) {
        long sum = 0;
        int len = nums.length;
        for (int i = 0; i < nums.length; i++) sum += nums[i];
        long[][] dp = new long[(int) (sum + 1)][len + 1];//求dp[sum][0];
        for (int i = 1; i < sum + 1; i++) {
            Arrays.fill(dp[i], 0);
            if (nums[0] == i) {
                dp[i][1] = 0;
            } else {
                dp[i][1] = 1;
            }
        }
        for (long i = 2; i <= sum; i++) { //遍历和sum
            for (int j = 2; j <= len; j++) { //遍历长度len
                /**
                 * 计算dp[i][j]只需要固定第j个位置上的数字+dp[i-1][j-1]集合
                 * 其中位置j可以取的值：从1开始，到i-1,用k来遍历，为了不和原串a冲突
                 * 要判断j位置不可以取nums[j-1]的值
                 */
                long res=0;
                for (int k = 1; k <= i - 1; k++) {
                    if (nums[j - 1] == k) continue;
                    res= (long) ((res%(7+Math.pow(10,9)))+ (dp[(int)i - k][j - 1]%(7+Math.pow(10,9))));
                }
                dp[(int)i][j]=res;
            }

        }
        return dp[(int)sum][len];

    }
}

2.复杂度分析

时间复杂度：O(n^2) for循环时间损耗

空间复杂度：O(n^2) dp数组空间损耗

7.美团商家注册系统【简单题】

题意理解：

 这道题不难，考验数据的一个处理过程。

 其中我们需要统计的信息包含： 店铺名，主店地址，分店地址

 其中一些操作包含：

          只包含小写字母的店铺名；

          存在的店铺，比较地址是否和主店一致：

                和主店一致：注册失败

                和主店不一致：注册为分店

          注册为分店时：店铺名一致，地址一致，注册失败

          按店铺名升序输出

解题思路：

        使用两个map来对数据进行组织

        businessMap维护店铺名和主店地址

        businessInfoMap维护店铺名，分店地址Set

        Set将分店地址去重，即可获得分店数量。

1.解题

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    Map<String,String> businessMap=new HashMap<>();
    Map<String, Set<String>> businessInfoMap=new HashMap<>();
    public static void main(String[] args) {
        Main main=new Main();
        Scanner in = new Scanner(System.in);
        int n=in.nextInt();
        in.nextLine();
        for(int i=0;i<n;i++){
            String business=in.nextLine();
            main.compute(business.split(" "));
        }
        String[] names=new String[main.businessMap.size()];
        int index=0;
        for(String name:main.businessMap.keySet()){
            names[index++]=name;
        }
        Arrays.sort(names);
        for(String name:names){
            System.out.println(name+" "+main.businessMap.get(name)+" "+main.businessInfoMap.get(name).size());
        }

    }
    public void compute(String[] businessInfo){
        //只能是小写字母
        char[] letter=businessInfo[0].toCharArray();
        for(int i=0;i<letter.length;i++){
            if(letter[i]>'z'||letter[i]<'a') return;
        }
        //注册
        if(!businessMap.containsKey(businessInfo[0])){//未注册过
            //注册
            businessMap.put(businessInfo[0],businessInfo[1]);
            businessInfoMap.put(businessInfo[0],new HashSet<>());
        }else{
            //已经注册过:是分店吗？
            if(!businessMap.get(businessInfo[0]).equals(businessInfo[1])){//是分店
                businessInfoMap.get(businessInfo[0]).add(businessInfo[1]);
            }
        }
    }
}

代码有个能改进的地方：关于按照餐厅名升序输出

List<String> keys=new ArrayList<>(businessMap.keySet())

Collections.sort(keys);

2.时间复杂度分析

时间复杂度：O(n*logn)主要耗费在店铺排序

空间复杂度：O(n)数据保存得空间耗费

 总结

题目见的得少，结果看到题目的时候，看了半天没理解题目的意思

对于int long的范围要有概念，否则会导致结果出错

看懂题目后，大部分其实是简单题，一些难一点的题目是动态规划问题。

关键点在于如何和动态规划思路联合起来，说起来还是题目做的少了。

庄园特聘拆椅狂魔
关注
  • 34
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
offer_牛客_剑指offer_剑指Offer算法题编程代码解析汇总_
10-02
实现了牛客凭条上的所有剑指offer的算法题，并且在每个算法中进行了详尽的解释和说明。
美团2024届秋招笔试第二场编程真题-小美的数组构造
sigd的博客
11-12 575
哪么按DP思路，先构造一个n-1的数组，总和是m-b[n]。=a[n]的方案数都是可行的。分析：暴力角度看，因为数组a和b总和一样，所以实际上是将总和m划分为n个数字，且每个数字都和a数组不一样的方案数。dp[i-1][[j-1]表示我们第i个元素选了1，所以还有j-1的总和给前i-1个元素。当然和a[i]相同的那个排除掉即可。哪么dp[i][j]=dp[i-1][[j-1]+dp[i1][j-2]+..........因此DP方程很容易得到，dp[i][j]表示构造一个i个数据元素，总和是j的数组。
【牛客】美团2024届秋招笔试第一场编程真题 - 5. 小美的排列构造【未完全解出】
u011644443的博客
11-29 1540
小美定义一个数组a的权值计算如下：首先将a的每一对相邻两项求和，得到一个b数组。那么b数组的最大值减最小值即为a数组的权值。例如，若a*=[2,1,3]，那么b=[3,4]，b数组的极差是1。因此a*数组的权值为1。现在小美希望你能构造一个长度为n的排列，满足权值尽可能小。你能帮帮她吗？排列是指一个长度为n的数组，其中 1 到n每个元素恰好出现一次。
牛客笔试｜美团2024春招第一场【测试方向】
最新发布
EANFSKK的博客
03-22 2477
小美拿到了一个由正整数组成的数组，但其中有一些元素是未知的（用 0 来表示）。现在小美想知道，如果那些未知的元素在区间 [l, r] 范围内随机取值的话，数组所有元素之和的最小值和最大值分别是多少？共有 q次 询输入描述：第一行输入两个正整数 n, q ，代表数组大小和询问次数。第二行输入 n 个整数。接下来的 q 行，每行输入两个正整数 l, r，代表一次询问。输出描述：输出 q 行，每行输出两个正整数，代表所有元素之和的最小值和最大值。示例：输入例子：3 21 0 3。
笔试题合集
qq_38069283的博客
09-13 36
先记录相邻两个数的成绩的最大值和对应的下标，然后通过前缀和数组快速求某个范围内的和。
202届秋招Java架构面试总结。包含：算法刷题、Java基础，集合、JVM
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多线程并发、netty、MySQL、MongoDB、Elasticsearch、Redis、HBASE
牛客网——美团2024届秋招笔试第三场编程真题
这里有一只小马吖
03-08 1194
1. 平均数为k的最长连续子数组 2. 小球投盒 3. 小红结账 4. 小美的游戏 5. 小美种果树 6. 小美的数组重排 7. 判断ip地址是否合法
【牛客】美团2024届秋招笔试第一场编程真题 - 4. 小美的排列询问
u011644443的博客
11-29 504
小美拿到了一个排列。她想知道在这个排列中，x和y是否是相邻的。你能帮帮她吗？排列是指一个长度为n的数组，其中 1 到n每个元素恰好出现一次。时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 256M，其他语言512M。
美团2024届秋招笔试第一场编程[汇总](上课口胡一下)
m0_64263546的博客
09-22 549
因为每次操作，对某个数加一，对另外一个数减一，这样相对于总数组的和还是不变的。所以从数组总和开始考虑：对数组中的所有数求和，然后除以数组的元素个数。因为预处理二维前缀和复杂度是O(n*n)，枚举横刀是O(n)，竖着也是O(n)，所以总时间复杂度是(n*n)O)，晚上自习去验证，如有一些错误，下期会纠正这期的解法。操作后的元素是 (n-1)个x 和 一个特殊的数(拿总和减去(n-1)*x)因为只能切一刀，总共的可能性就是(n+m-2)刀。求出操作完之后应该变成的值，也就是sum/n。时间复杂度：O(n*n)
小美的加法
陈进士学习的博客
09-04 476
【代码】小美的加法。
牛客刷题总结.docx
01-28
牛客刷题总结.docx
2018牛客暑期多校第二场题解
09-28
2018牛客暑期多校第二场题解
[中科大讯飞Interphonic.5.0语音合成系统].小美(女声粤语)
05-01
[中科大讯飞Interphonic.5.0语音合成系统].小美(女声粤语)
2018名企校招笔试真题精选技术篇
09-22
该文档包含了2018年各大知名互联网、软件公司校招的笔试面试真题。
牛客网_名企校招笔试真题精选技术篇
05-18
牛客网_2018名企校招笔试真题精选技术篇，有价值的资料
关于牛客刷题总结全部汇总
02-21
关于牛客刷题总结全部汇总
牛客SQL刷题 Day-07
12-14
2、将employees表的所有员工的last_name和first_name拼接起来作为Name，中间以一个空格区分 3、创建一个actor表，包含如下列信息 4、对于表actor批量插入如下数据 5、对于表actor批量插入如下数据,如果数据已经存在...
leetcode卡-Java-Algorithm:大学期间学习到的数据结构算法，LeetCode和牛客刷题代码。保存下来，方便以后查看
07-06
大学期间学习到的数据结构算法，LeetCode和牛客刷题代码。保存下来，方便以后查看。 时间：2020/04/27 电脑：宏碁E5-572-58HZ CPU：i5-4210M 显卡：英伟达独立显卡940M，2G显存 内存：8G 1600MHzDDR3 硬盘：256G...
牛客刷题 jsnode 输入输出
08-25
在牛客网上刷题，使用 JavaScript 和 Node.js 进行输入输出操作是非常常见的。下面是一个简单的示例，演示如何使用 Node.js 读取标准输入并输出结果： ```javascript // 导入内置的 `readline` 模块 const readline = require('readline'); // 创建 `readline` 接口 const rl = readline.createInterface({ input: process.stdin, // 设置输入流为标准输入 output: process.stdout // 设置输出流为标准输出 }); // 提示用户输入 rl.question('请输入一个数字：', (input) => { // 处理用户输入 const number = parseInt(input); // 输出结果 console.log(`输入的数字是：${number}`); // 关闭读取器 rl.close(); }); ``` 使用以上代码，你可以在命令行中输入一个数字，然后将其输出。 请注意，以上示例仅展示了如何进行简单的输入输出操作。在实际的题目中，你可能需要根据具体的需求进行更复杂的输入输出处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值