pdd笔试题

于 2021-08-08 21:43:17 发布
阅读量361 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuyan_jia/article/details/119521401
版权

 一、圆和坐标轴交点个数

输入 

第一行 圆的数量

其余 x y r

输入 

3

1 1 1

1 1 2

3 4 5

输出 交点个数

2

4

3

package sort;
import java.util.*;

public class AxisCircle {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int circleNum = scanner.nextInt();
        int[] xAbs = new int[circleNum];
        int[] yAbs = new int[circleNum];
        int[] r = new int[circleNum];
        for(int i = 0; i < circleNum; i++) {
            xAbs[i] = Math.abs(scanner.nextInt());
            yAbs[i] = Math.abs(scanner.nextInt());
            r[i] = scanner.nextInt();
        }
        for(int i = 0; i < circleNum; i++) {
            if(r[i] < xAbs[i] && r[i] < yAbs[i]){
                System.out.println(0);
                continue;
            }
            if((r[i] == xAbs[i] && r[i] < yAbs[i]) || (r[i] < xAbs[i] && r[i] == yAbs[i])){
                System.out.println(1);
                continue;
            }
            if((r[i] == xAbs[i] && r[i] == yAbs[i]) || (r[i] < xAbs[i] && r[i] > yAbs[i]) || (r[i] > xAbs[i] && r[i] < yAbs[i])){
                System.out.println(2);
                continue;
            }
            if((r[i] == xAbs[i] && r[i] == yAbs[i]) || (r[i] < xAbs[i] && r[i] > yAbs[i]) || (r[i] > xAbs[i] && r[i] < yAbs[i])){
                System.out.println(2);
                continue;
            }
            if((r[i] == xAbs[i] && r[i] > yAbs[i]) || (r[i] > xAbs[i] && r[i] == yAbs[i]) || (r[i]*r[i] == xAbs[i]*xAbs[i] + yAbs[i]*yAbs[i])){
                System.out.println(3);
                continue;
            }
            if( (r[i]*r[i]) > (xAbs[i]*xAbs[i] + yAbs[i]*yAbs[i])){
                System.out.println(4);
                continue;
            }

        }
    }
}

上面最后一个条件判断错误，只通过百分之四的案例，最后条件应为(r>x && r>y && r^2 != x^2 + y^2), 并且2的情况写了两次,下面为根据别人通过代码测试随机案例，鉴定出以上错误

package zsh;
import java.util.*;

public class AxisCircle {

    public static int[] circle1(int[] xAbs, int[] yAbs, int[] r){
        int[] res = new int[r.length];
        for(int i = 0; i < r.length; i++) {
            if(r[i] < xAbs[i] && r[i] < yAbs[i]){
                res[i] = 0;
                continue;
            }
            if((r[i] == xAbs[i] && r[i] < yAbs[i]) || (r[i] < xAbs[i] && r[i] == yAbs[i])){
                res[i] = 1;
                continue;
            }
            if((r[i] == xAbs[i] && r[i] == yAbs[i]) || (r[i] < xAbs[i] && r[i] > yAbs[i]) || (r[i] > xAbs[i] && r[i] < yAbs[i])){
                res[i] = 2;
                continue;
            }
//            if((r[i] == xAbs[i] && r[i] == yAbs[i]) || (r[i] < xAbs[i] && r[i] > yAbs[i]) || (r[i] > xAbs[i] && r[i] < yAbs[i])){
//                res[i] = 2;
//                continue;
//            }
            if((r[i] == xAbs[i] && r[i] > yAbs[i]) || (r[i] > xAbs[i] && r[i] == yAbs[i]) || (r[i]*r[i] == xAbs[i]*xAbs[i] + yAbs[i]*yAbs[i])){
                res[i] = 3;
                continue;
            }
            if( (r[i] > xAbs[i] && r[i] > yAbs[i] && r[i]*r[i] != xAbs[i]*xAbs[i] + yAbs[i]*yAbs[i])){
                res[i] = 4;
                continue;
            }
        }
        return res;
    }

    public static int[] circle2(int[] xAbs, int[] yAbs, int[] r){
        int[] res = new int[r.length];
        for(int i = 0; i < r.length; i++) {
            if (xAbs[i] < r[i]){
                res[i] += 2;
            }
            else if(xAbs[i] == r[i]){
                res[i]++;
            }
            if (yAbs[i] < r[i]){
                res[i] += 2;
            }
            else if(yAbs[i] == r[i]){
                res[i]++;
            }
            if(xAbs[i]*xAbs[i] + yAbs[i]*yAbs[i] == r[i]*r[i]){
                res[i]--;
            }
        }
        return res;
    }
    public static int index = -1;  //错误索引
    // 对比两个数组（用于测试）
    public static boolean isEqual(int[] arr1, int[] arr2) {
        if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
            return false;
        }
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1.length != arr2.length) {
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                System.out.println(arr1[i]);
                System.out.println(arr2[i]);
                index = i;
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);
//        int circleNum = scanner.nextInt();
        int num = 10000;
        int[] x = new int[num];
        //生成随机数组
        for (int i = 0; i < x.length; i++) {
            x[i] = (int) ((10000 + 1) * Math.random()) - (int) (10000 * Math.random());
        }
        int[] y = new int[num];
        for (int i = 0; i < x.length; i++) {
            y[i] = (int) ((10000 + 1) * Math.random()) - (int) (10000 * Math.random());
        }
        int[] r = new int[num];
        for (int i = 0; i < x.length; i++) {
            r[i] = (int) ((10000 + 1) * Math.random()) - (int) (10000 * Math.random());
        }
//
//
//        int num = 1;
//        int[] x = {-3574};
//        int[] y = {-2864};
//        int[] r = {3780};
//        int a = r[0]*r[0];
//        long b = r[0]*r[0];
        int[] xAbs = new int[num];
        int[] yAbs = new int[num];
        for(int i = 0; i < num; i++) {
            xAbs[i] = Math.abs(x[i]);
            yAbs[i] = Math.abs(y[i]);
        }
//        int c = xAbs[0]*xAbs[0] + yAbs[0]*yAbs[0];
        int[] res1 = circle1(xAbs, yAbs, r);
        int[] res2 = circle2(xAbs, yAbs, r);


        boolean succeed = true;
        if (!isEqual(res1, res2)) {
            succeed = false;
        }
        if(index >= 0){
            System.out.println("x "+x[index]);
            System.out.println("y "+y[index]);
            System.out.println("r "+r[index]);
        }
        System.out.println(succeed);
    }
}

三、键入括号序列，文本框初始为空白，随即进行N次操作：

1. L:光标向前移动一个字符，（光标前没有字符则保持不动）（左移）

2. R:光标向后移动一个字符，（光标后没有字符则保持不动）（右移）

3. D:删除光标前的字符（光标前没有字符则保持不动）

4. ‘（’ 或 ‘）’：键入括号

评分标准：

1. 如果括号序列合法，得分为括号最大嵌套深度。

2. 如果括号序列不合法，得分为-x，x为使得该序列合法需要插入的最少括号字符个数。

输入 

第一行 操作数 整数 N

第二行 长度为N字符串，每个字符代表一次操作，字符均合法；

输出：一行，空格隔开N个整数，第i个整数，代表第i次操作后的实时分数。

输入

4

（）DD

输出

-1 1 -1 0

分析：leecode921,20,1111融合一起 括号的有效性判断+括号的最大深度+有效的最小添加

不能一轮完成，因为涉及回退等，每回操作完的序列，经上述三步操作完成。

第一个为参考答案，第二个自己微改的

package zsh;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Brackets2 {
    public static void main(String[] args) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); //和scanner区别
        int num = 1;
        char[] inputs2 = new char[num];
        try {
            num = Integer.valueOf(br.readLine());
            System.out.println(num);
            inputs2 = new char[num];
            for (int i = 0; i < num; i++){
                inputs2[i] = (char)br.read();
            }
        }
        catch (IOException e) {  //学习
            e.printStackTrace();
        }
        List<Character> list = new ArrayList<>();
        int cur = 0;
        List<Integer> ans = new ArrayList<>();
        for (char c : inputs2){
            if (c == '('){
                list.add(cur, '(');
                cur++;
            }
            else if (c == ')')
            {
                list.add(cur,')');
                cur++;
            }
            else if (c == 'L'){
                if (cur > 0){
                    cur--;
                }
            }
            else if (c == 'R'){
                if (cur < list.size()){
                    cur++;
                }
            }
            else {
                if (cur >0){
                    list.remove(cur -1);
                    cur -- ;
                }
            }
            if (isValid(list)){
                ans.add(maxDepth(list));
            }
            else {
                ans.add(minAddToMakeValid(list));
            }
        }
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < ans.size(); i++){
            stringBuffer.append(String.valueOf(ans.get(i)));
            if (i != ans.size()-1){
                stringBuffer.append(' ');
            }
        }
        System.out.println(stringBuffer.toString());
    }
    static boolean isValid(List<Character> s){
        Deque<Character> stack = new LinkedList<>();
        for (int i = 0; i < s.size(); i++){
            if (s.get(i) == '('){
                stack.push(s.get(i));
            }else {
                if (stack.isEmpty()){
                    return false;
                }
                else if (stack.peek() == '('){
                    stack.pop();
                }
                else {
                    return false;
                }
            }
        }
        if (stack.isEmpty()){
            return true;
        }
        return false;
    }
    static int maxDepth(List<Character> s){
        int depth = 0;
        int max = 0;
        for (Character c: s){
            if (c == '('){
                depth++;
                max = Math.max(depth, max);
            }
            else {
                depth--;
            }
        }
        return max;
    }
    static int minAddToMakeValid(List<Character> s){
        int ans = 0;  // 匹配 ））（，记录）数量
        int bal = 0;  // 正向匹配，如（（（）
        for (int i = 0; i < s.size(); i++){
            bal += s.get(i) == '('?1:-1;
            if (bal == -1){
                ans++;
                bal++;
            }
        }
        return -(ans + bal);
    }
}

package zsh;
import java.util.*;

public class Brackets {
    //判断是否有效括号
    public static boolean isValid(List<Character> list){
        Deque<Character> stack = new LinkedList<Character>();
        for(char c : list){
            if(c == '('){
                stack.push(c);
            }
            else {
                if(stack.isEmpty()){
                    return false;
                }
                if(stack.peek() == '('){
                    stack.pop();
                }
                else{
                    return false;
                }
            }
        }
        if(stack.isEmpty()){
            return true;
        }
        return false;
    }
    //括号嵌套深度
    public static int maxDepth(List<Character> list){
        int depth = 0;
        int maxDepth = 0;
        for(char c : list){
            if(c == '('){
                depth++;
                maxDepth = Math.max(maxDepth, depth);
            }
            else {
                depth--;
            }
        }
        return maxDepth;
    }
    //差几个使之有效
    public static int makeValid(List<Character> list){  //平衡法
        int left = 0;   //正向匹配，如（（（）
        int right = 0;  // 匹配 ））（，记录）数量
        for(char c : list){
            if(c == '('){
                left++;
            }
            else{
                left--;
            }
            if(left < 0){
                left++;
                right++;
            }
        }
        return -(left+right);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int optionNum = Integer.valueOf(scanner.nextLine());
        String s = scanner.nextLine();
        int cur = 0;  //光标位置
//        int[] score = new int[Integer.valueOf(optionNum)];
        List<Integer> score = new ArrayList<Integer>();
        List<Character> list = new ArrayList<Character>();
        for(Character c : s.toCharArray()){
            switch(c){
                case 'L':  //后退
                    if(cur > 0){
                        cur--;
                    }
                    break;
                case 'R':  //前进
                    if(cur < list.size()){
                        cur++;
                    }
                    break;
                case 'D':
                    if(!list.isEmpty()){
                        list.remove(cur-1);
                        cur--;
                    }
                    break;
                case '(':
                    list.add(cur, c);
                    cur++;
                    break;
                case ')':
                    list.add(cur, c);
                    cur++;
                    break;
            }
            if(isValid(list)){
                score.add(maxDepth(list));
            }
            else{
                score.add(makeValid(list));
            }
        }
        for(int i = 0; i < optionNum; i++){
            System.out.print(score.get(i));
            if(i != optionNum-1){
                System.out.print(" ");
            }
        }
    }
}

yuyan_jia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PDD笔试题——数字组合、字符变换
weixin_45629738的博客
06-14 450
题目描述：
PDD正式批笔试
Mia_keep_going的博客
11-14 549
为了准备实习面试三天速成了SQL（正如我所说，我的动力来源之一是DDL）,正好收到了Pdd笔试，别人告诉我说一般是三道SQL一道ABtest一道业务题。我想着正好我速成了耶！结果，恩，原来我只是速成了基础。 这边整理一下题目重新做一遍。 ...
PDD寻梦计划笔试题
SE_Totoro的博客
09-05 287
第一题： if __name__ == '__main__': input_info = input().strip().split(';') N = int(input_info[1]) num_arr = list(map(int,input_info[0].split(','))) num_odd = [] num_even = [] for ...
pdd笔试题种树
weixin_40161962的博客
11-05 357
import java.util.Scanner; public class Main { private static boolean flag = false; public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nex...
JVM面试题 PDD 下载
07-02
【标题】"JVM面试题 PDD 下载"所涉及的知识点主要集中在Java虚拟机（JVM）上，这是Java编程中的核心部分，对于开发者尤其是面试者来说，深入理解JVM至关重要。PDD可能指的是“问题、解答、讨论”或者“拼多多”（PDD...
pdd:pdd golang sdk. （拼多多开放平台 golang SDK）
04-30
p := pdd.NewPdd(&pdd.Config{ ClientId: "your client id", ClientSecret: "your client secret", RetryTimes: 3, // 设置接口调用失败重试次数 }) // 初始化多多客相关 API 调用 d := p.GetDDK() // 或者 d := ...
pdd-anticontent.js
12-04
拼多多anticontent参数破解
pdd_2020
04-01
标题"PDD_2020"可能指的是拼多多在2020年的某个项目或活动，而"描述"中没有提供具体信息，我们只能基于提供的标签"Java"来推测这是一个与Java编程相关的项目。"pdd_2020-main"可能是该项目的主代码库或者主要模块。 ...
2018年拼多多内推笔试题-java开发-针对2019届
09-01
2018年拼多多内推笔试题-java开发-针对2019届，4道编程题
实习笔试题（1：pdd）
weixin_39804483的博客
03-11 417
// // main.cpp // pdd // // Created by 吴珝君 on 2019/3/11. // Copyright © 2019年 闲着也是贤者. All rights reserved. // #include &lt;iostream&gt; #include &lt;string&gt; #include &lt;vector&gt; //找最小序...
刷PDD笔试题--编程
Jiana_Feng的博客
04-27 491
序言 这几天开始刷PDD的一些算法题，有一起的找实习的小伙伴么哈哈哈 一起加油呀！！ 多多鸡有N个魔术盒子（编号1～N），其中编号为i的盒子里有i个球。 多多鸡让皮皮虾每次选择一个数字X（1 <= X <= N），多多鸡就会把球数量大于等于X个的盒子里的球减少X个。 通过观察，皮皮虾已经掌握了其中的奥秘，并且发现只要通过一定的操作顺序，可以用最少的次数将所有盒子里的球变没。 那么请问聪明的你，是否已经知道了应该如何操作呢？ 思路是 比如5的话，就是需要操作三次，减去3 减去 2 减去 1 那
PDD 7.28秋招笔试题
weixin_30418341的博客
07-31 138
四道编程题 1. Java1.8代码： import java.util.ArrayList;import java.util.Collections;import java.util.Scanner;public class A1 { public static void main(String[] args){ int i = 0; int j...
pdd笔试20190728
qq_37119939的博客
07-30 370
前言： 拼多多的笔试题对我来讲比较难，参考牛客大佬的题解，自己开始预习题目中涉及的知识点吧 作者：Sss201903111816437 链接：https://www.nowcoder.com/discuss/212692 来源：牛客网 One：几乎严格升序 2.回溯 Two：首尾相连的一组字符串(回溯) Three: 多任务的执行顺序（贪心+拓扑） 题目：现在一共有N个待执行的任务，每个...
2020年PDD数据分析笔试题 | 附解答
SeizeeveryDay的博客
04-09 3439
前言19届同学反馈,拼夕夕的数据分析SQL部分出的很好，20届感叹道，说的太对了。拼夕夕的笔试题一共五道，考试时只划分为一个部分，答题时间90分钟。第一部分：SQL查询题3道第一题...
PDD笔试-小熊吃糖
m0_37541228的博客
09-02 415
代码： import java.util.Arrays; import java.util.Comparator; import java.util.Scanner; public class Main2 { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n =
【leetcode】圆括号匹配问题（pdd笔试-4）
littlemichelle
03-13 238
圆括号 遇到了一个问题：python中数组与多维数组用法介绍 # 构建dp # 这样构建会浅拷贝，造成！ # row = [0]*(n+1) # dp = [row]*(m+1) # 从x中选0个，选1个，选2个，选3个。共有4种可能 # print(dp) # [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] dp[1][0]...
已知两圆圆心坐标及半径求两圆交点 (C语言|参数方程求解)
热门推荐
smilelance的移动开发专栏
09-30 1万+
已知两圆圆心坐标及半径求两圆交点 (C语言|参数方程求解)    在一个二维平面上给定两个圆的圆心横纵坐标、半径共6个参数, 求交点. 这个问题无非是解二元二次方程组.普通二元二次方程联立消元求解的困难在于, 中间过程里的系数会变得非常复杂, 从而导致容易出错---因为公式毕竟还是要人来推导,人的出错率比计算机要高得多得多---改用圆的参数方程求解, 可以在显著地减轻这个负担.     现
软件设计师历年真题pdd
最新发布
04-11
很抱歉，我无法提供历年真题pdd的具体内容，因为这涉及到版权问题。但是，我可以给你一些关于软件设计师考试的一般信息和备考建议。 软件设计师考试是中国计算机技术与软件专业技术资格（CITP）认证考试之一，由...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值