CCCJava真题练习

已于 2022-11-05 13:03:20 修改
阅读量542 收藏 1
点赞数
文章标签： java 算法 开发语言
于 2022-11-03 17:52:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44101221/article/details/127675218
版权

目录

1.日志排序

3.太阳能板最大面积

4.分糖果

7.连续数组和

8.射击比赛游戏

11.停车场统计

12.数组去重排序

33.字符串比较

2.出错的或电路

5.计算面积

1.日志排序

package huawei;

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;

/**
 * @Description 日志排序
 * @Author caocc
 * @Date 2022/11/2 22:47
 */
public class FirstCode01 {
    static class Info {
        String a;
        String b;
        String c;
        String d;

        public Info(String a, String b, String c, String d) {
            this.a = a;
            this.b = b;
            this.c = c;
            this.d = d;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = Integer.valueOf(sc.nextLine());

        PriorityQueue<Info> queue = new PriorityQueue<>((Comparator<Info>) (o1, o2) -> {
            if (Integer.parseInt(o1.a) - Integer.parseInt(o2.a) != 0){
                return  Integer.parseInt(o1.a) - Integer.parseInt(o2.a);
            }
            if (Integer.parseInt(o1.b) - Integer.parseInt(o2.b) != 0){
                return  Integer.parseInt(o1.b) - Integer.parseInt(o2.b);
            }

            if (Integer.parseInt(o1.c) - Integer.parseInt(o2.c) != 0){
                return  Integer.parseInt(o1.c) - Integer.parseInt(o2.c);
            }

            if (Integer.parseInt(o1.d) - Integer.parseInt(o2.d) != 0){
                return  Integer.parseInt(o1.d) - Integer.parseInt(o2.d);
            }

            return 0;
        });

        for (int i = 0; i < n; i++) {
            String[] strings = sc.nextLine().replace(".", ":").split(":");
            Info info = new Info(strings[0], strings[1], strings[2], strings[3]);
            queue.add(info);
        }

        while (!queue.isEmpty()){
            Info info = queue.poll();
            System.out.println(info.a + ":" + info.b + ":" + info.c + "." + info.d);
        }

    }
}

3.太阳能板最大面积

package huawei;

import java.util.Scanner;

/**
 * @Description 太阳能板最大面积
 * @Author caocc
 * @Date 2022/11/3 15:17
 */
public class FirstCode03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String[] strings = sc.nextLine().split(",");
        int[] num = new int[strings.length];

        for (int i = 0; i < strings.length; i++) {
            num[i] = Integer.parseInt(strings[i]);
        }

        int L = 0;
        int R = num.length - 1;

        int max = 0;

        while (L < R) {
            max = Math.max(max, Math.min(num[L], num[R]) * (R - L));
            if (num[L] < num[R]) {
                L++;
            } else {
                R--;
            }
        }
        System.out.println(max);
    }
}

4.分糖果

package huawei;

import java.util.HashMap;
import java.util.Scanner;

/**
 * @Description 分糖果
 * @Author caocc
 * @Date 2022/11/3 15:23
 */
public class FirstCode04 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        HashMap<Integer, Integer> map = new HashMap<>();
        int num = sc.nextInt();
        System.out.println(process(num, map));

    }

    public static int process(int nums, HashMap<Integer, Integer> map) {
        if (map.containsKey(nums)){
            return map.get(nums);
        }
        if (nums == 1) {
            return 0;
        }
        int times = 0;
        if ((nums & 1) == 0) {
            times =  process(nums / 2, map) + 1;
        } else {
            int p1 = process((nums - 1) / 2, map) + 2;
            int p2 = process((nums + 1) / 2, map) + 2;
            times = Math.min(p1, p2);
        }

        map.put(nums, times);
        return times;
    }
}

7.连续数组和

package huawei;

import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

/**
 * @Description 连续数组和
 * @Author caocc
 * @Date 2022/11/3 16:27
 */
public class FirstCode07 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int target = sc.nextInt();
        TreeMap<Integer, Integer> treeMap = new TreeMap<>();
        treeMap.put(0, 1);

        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = sc.nextInt();
        }
        int sum = 0;
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            int preSum = sum - target;
            for (Map.Entry<Integer, Integer> entry : treeMap.entrySet()) {
                if (entry.getKey() <= preSum) {
                    count += entry.getValue();
                }else {
                    break;
                }
            }

            if (treeMap.containsKey(sum)) {
                treeMap.put(sum, treeMap.get(sum) + 1);
            } else {
                treeMap.put(sum, 1);
            }
        }
        System.out.println(count);
    }
}

8.射击比赛游戏

package huawei;

import java.util.*;

/**
 * @Description 统计射击比赛成绩
 * @Author caocc
 * @Date 2022/11/3 17:03
 */
public class FirstCode08 {

    static class Info {
        int id;
        int sum;

        public Info(int id, int sum) {
            this.id = id;
            this.sum = sum;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = Integer.parseInt(sc.nextLine());
        String[] ids = sc.nextLine().split(",");
        String[] scores = sc.nextLine().split(",");


        HashMap<Integer, PriorityQueue<Integer>> map = new HashMap<>();


        for (int i = 0; i < ids.length; i++) {
            if (map.containsKey(Integer.parseInt(ids[i]))) {
                PriorityQueue<Integer> minStack = map.get(Integer.parseInt(ids[i]));
                if (minStack.size() == 3 && minStack.peek() < Integer.parseInt(scores[i])) {
                    minStack.poll();
                }
                minStack.add(Integer.parseInt(scores[i]));
            } else {
                PriorityQueue<Integer> minStack = new PriorityQueue<Integer>();
                minStack.add(Integer.parseInt(scores[i]));
                map.put(Integer.parseInt(ids[i]), minStack);
            }
        }

        PriorityQueue<Info> maxStack = new PriorityQueue<>(new Comparator<Info>() {
            @Override
            public int compare(Info o1, Info o2) {
                return o1.sum == o2.sum ? -(o1.id - o2.id) : -(o1.sum - o2.sum);
            }
        });

        for (Map.Entry<Integer, PriorityQueue<Integer>> entry : map.entrySet()) {
            Integer id = entry.getKey();
            PriorityQueue<Integer> items = entry.getValue();
            int sum = 0;
            for (Integer item : items) {
                sum += item;
            }
            maxStack.add(new Info(id, sum));
        }
        StringBuilder sb = new StringBuilder();
        while (!maxStack.isEmpty()) {
            Info info = maxStack.poll();
            sb.append(info.id).append(",");
        }

        sb.delete(sb.length() - 1, sb.length());

        System.out.println(sb.toString());
    }
}

11.停车场统计

package huawei;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @Description TODO
 * @Author caocc
 * @Date 2022/11/3 18:03
 */
public class FirstCode11 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] split = sc.nextLine().split(",");
        int[] nums = new int[split.length];

        for (int i = 0; i < split.length; i++) {
            nums[i] = Integer.parseInt(split[i]);
        }

        List<Integer> list = new ArrayList<>();
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == 1) {
                count++;
            } else {
                if (count != 0) {
                    list.add(count);
                    count = 0;
                }
            }
        }
        if (count != 0) {
            list.add(count);
        }
        int cars = 0;

        for (Integer num : list) {
            if (num % 3 == 0) {
                cars += num / 3;
                continue;
            } else if (num % 2 == 0) {
                cars += num / 2;
                continue;
            }else if (num == 1){
                cars += 1;
                continue;
            }


            cars += num / 3;
            num = num % 3;
            cars += num / 2;
            num = num % 2;
            cars += num / 1;

        }
        System.out.println(cars);
    }
}

12.数组去重排序

package huawei;

import java.util.Comparator;
import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.Scanner;

/**
 * @Description TODO
 * @Author caocc
 * @Date 2022/11/3 18:38
 */
public class FirstCode12 {
    static class Info {
        int index;
        int times;
        int val;

        public Info(int index, int times, int val) {
            this.index = index;
            this.times = times;
            this.val = val;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String[] str = sc.nextLine().split(",");
        int[] nums = new int[str.length];

        for (int i = 0; i < str.length; i++) {
            nums[i] = Integer.parseInt(str[i]);
        }

        HashMap<Integer, Info> map = new HashMap<>();

        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                Info info = map.get(nums[i]);
                info.times++;
            } else {
                Info info = new Info(i, 1, nums[i]);
                map.put(nums[i], info);
            }
        }

        PriorityQueue<Info> stack = new PriorityQueue<>(new Comparator<Info>() {
            @Override
            public int compare(Info o1, Info o2) {
                return o1.times == o2.times ? o1.index - o2.index : -(o1.times - o2.times);
            }
        });
        for (Info value : map.values()) {
            stack.add(value);
        }

        StringBuilder sb = new StringBuilder();

        while (!stack.isEmpty()){
            Info info = stack.poll();
            sb.append(info.val).append(",");
        }

        sb.delete(sb.length()-1,sb.length());
        System.out.println(sb);
    }
}

33.字符串比较

package huawei;

import java.util.Scanner;

/**
 * @Description TODO
 * @Author caocc
 * @Date 2022/11/4 14:33
 */
public class FirstCode33 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char[] str1 = sc.nextLine().toCharArray();
        char[] str2 = sc.nextLine().toCharArray();
        int V = sc.nextInt();

        int L = 0;
        int R = 0;
        int sum = 0;
        int max = 0;
        while (R < str1.length){
            sum += Math.abs(str1[R] - str2[R]);

            if (sum <= V){
                max = Math.max(max, R - L + 1);
            }else {
                sum -= Math.abs(str1[L] - str2[L]);
                L++;
            }

            R++;
        }

        System.out.println(max);
    }
}

2.出错的或电路

package huawei;

import java.util.Scanner;

/**
 * @Description TODO
 * @Author caocc
 * @Date 2022/11/4 16:38
 */
public class SecondCode02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = Integer.parseInt(sc.nextLine());

        String str1 = sc.nextLine();
        String str2 = sc.nextLine();

        int oneCount = 0;
        int zeroCount = 0;

        for (int i = 0; i < n; i++) {
            if (str1.charAt(i) == '0') {
                zeroCount++;
            } else {
                oneCount++;
            }
        }

        int count = 0;

        for (int i = 0; i < n; i++) {
            if (str2.charAt(i) == '0') {
                if (str1.charAt(i) == '0') {
                    count += oneCount;
                } else {
                    count += zeroCount;
                }
            }
        }

        System.out.println(count);
    }
}

5.计算面积

package huawei;

import java.util.Scanner;

/**
 * @Description TODO
 * @Author caocc
 * @Date 2022/11/4 17:50
 */
public class SecondCode05 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] str = sc.nextLine().split(" ");
        int n = Integer.parseInt(str[0]);
        int end = Integer.parseInt(str[1]);

        str = sc.nextLine().split(" ");
        int x = Integer.parseInt(str[0]);
        int height = Integer.parseInt(str[1]);

        int sum = 0;

        for (int i = 1; i < n; i++){
            str = sc.nextLine().split(" ");
            int curX = Integer.parseInt(str[0]);
            int curHeight = Integer.parseInt(str[1]);
            sum += Math.abs((curX - x) * height);

            x = curX;
            height += curHeight;
        }

        sum += Math.abs((end - x) * height);


        System.out.println(sum);
    }
}

弟中弟中弟
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
华为机试真题 Java 实现【出错的或电路】
MISAYAONE的博客
11-29 898
某生产门电路的厂商发现某一批次的或门电路不稳定，具体现象为计算两个二进制数的或操作时，第一个二进制数中某两个比特位会出现交换，交换的比特位置是随机的，但只交换这两个位，其他位不变。很明显，这个交换可能会影响最终的或结果，也可能不会有影响。为了评估影响和定位出错的根因，工程师需要研究在各种交换的可能下，最终的或结果发生改变的情况有多少种。
太阳能板最大面积
weixin_44219664的博客
03-28 2861
注意！答案仅作为参考（实际考试中下列代码通过用例100%，但不代表最优解） 给航天器一侧加装长方形和正方形的太阳能板(图中的斜线区域) 需要先安装两个支柱(图中的黑色竖条) 再在支柱的中间部分固定太阳能板 但航天器不同位置的支柱长度不同 太阳能板的安装面积受限于最短一侧的那支支柱的长度 现提供一组整型数组的支柱高度数据 假设每个支柱间的距离相等为一个单位长度 计算如何选择两根支柱可以使太阳能板的面积最大 输入描述 10,9,8,7,6,5,4,3,2,1 注释，支柱至少有两根，最多1
PAT 1082 射击比赛（20）（代码+思路）
ItaLink
07-24 396
1082 射击比赛（20 分） 本题目给出的射击比赛的规则非常简单，谁打的弹洞距离靶心最近，谁就是冠军；谁差得最远，谁就是菜鸟。本题给出一系列弹洞的平面坐标(x,y)，请你编写程序找出冠军和菜鸟。我们假设靶心在原点(0,0)。 输入格式： 输入在第一行中给出一个正整数 N（≤ 10 000）。随后 N 行，每行按下列格式给出： ID x y 其中 ID 是运动员的编号（由 4 位数字...
PAT乙级 1076 Wifi密码 (15 分) Java 实现
A1sakaTaiga的博客
12-27 264
PAT乙级 1076 Wifi密码 (15 分) Java 实现
历年真题+练习.rar
11-28
《信息系统项目管理师历年真题与练习解析》 在信息技术领域，软考信息系统项目管理师认证是一项备受关注的专业资格考试，旨在考核考生在项目管理、信息系统设计与实施、业务流程改进等方面的能力。为了帮助备考者...
CCF练习题及真题.pdf
11-18
"CCF练习题及真题.pdf" 本文档汇总了多个 CCF 练习题及真题的知识点，涵盖了算法、数据结构、图像处理、游戏开发等多个领域。 题目1 相邻数对 知识点： * 排序算法 * 双指针技术 * 数组操作 描述：给定 n 个...
大唐杯真题练习.zip
最新发布
04-20
大唐杯真题 大唐杯真题涉及通信领域的多个方面，包括但不限于5G技术、物联网、车联网等。以下是一些可能出现在大唐杯真题中的题目类型和内容： 基础知识题：考察学生对通信基本原理、数字信号处理、计算机网络等...
蓝桥杯真题汇总-备考练习专用.rar
12-21
"蓝桥杯真题汇总-备考练习专用.rar"是一个压缩包文件，其中包含了自第五届至十一届蓝桥杯国赛的历年真题及部分参考答案，是参赛者准备比赛的重要参考资料。 这个资源包的亮点在于它提供了丰富的历年真题，这些题目...
C语言二级真题练习
05-05
"C语言二级真题练习"提供了一种高效的学习方法，让你能够针对实际考试中的问题进行有针对性的训练。C语言作为一门基础且广泛应用的编程语言，其二级考试通常会涵盖语法、数据类型、运算符、控制结构、函数、数组、...
【华为OD机试真题 JAVA】出错的或电路
qq_34465338的博客
06-12 2249
某生产门电路的厂商发现某一批次的或门电路不稳定，具体现象为计算两个二进制数的或操作时，第一个二进制数中某两个比特位会出现交换，交换的比特位置是随机的，但只交换这两个位，其他位不变。很明显，这个交换可能会影响最终的或结果，也可能不会有影响。为了评估影响和定位出错的根因，工程师需要研究在各种交换的可能下，最终的或结果发生改变的情况有多少种。...............
统计射击比赛成绩
科小勒的博客
10-22 578
统计设计比赛成绩 给定一个射击比赛成绩单，包含多个选手若干次射击的成绩分数，请对每个选手按其最高3个分数之和进行降序排名，输出降序排名后的选手ID序列。
PAT乙级真题 1082 射击比赛 C++实现
zhang35的博客
01-14 291
题目 本题目给出的射击比赛的规则非常简单，谁打的弹洞距离靶心最近，谁就是冠军；谁差得最远，谁就是菜鸟。本题给出一系列弹洞的平面坐标(x,y)，请你编写程序找出冠军和菜鸟。我们假设靶心在原点(0,0)。 输入格式： 输入在第一行中给出一个正整数 N（≤ 10 000）。随后 N 行，每行按下列格式给出： ID x y 其中 ID 是运动员的编号（由 4 位数字组成）；x 和 y 是其打出的弹洞的平...
机考[51 - 60]
csfun1的博客
05-03 4572
机考【51-60】
【华为OD机试真题 Java】太阳能板最大面积
qq_40642440的博客
11-25 281
给航天器一侧加装长方形或正方形的太阳能板（图中的红色斜线区域），需要先安装两个支柱（图中的黑色竖条），再在支柱的中间部分固定太阳能板。但航天器不同位置的支柱长度不同，太阳能板的安装面积受限于最短一侧的那根支柱长度。如图：现提供一组整形数组的支柱高度数据，假设每根支柱间距离相等为1个单位长度，计算如何选择两根支柱可以使太阳能板的面积最大。
【华为OD机试真题2023B卷 JAVA&JS】统计射击比赛成绩
qq_34465338的博客
05-29 3198
统计射击比赛成绩 给定一个射击比赛成绩单，包含多个选手若干次射击的成绩分数，请对每个选手按其最高3个分数之和进行降序排名，输出降序排名后的选手ID序列。
华为OD机试（JAVA）真题II
热门推荐
qq_34465338的博客
06-14 2万+
本栏有50+道题（夯更新中），保证都是牛客上的HW机试真题，大概率会考到原题。大家有什么不懂的都可以留言。
java和电路_关于Java的10个谎言
weixin_42530458的博客
02-24 78
下面的这些都算是比较高级的问题了，面试中一般也很少问到，因为它们可能会把面试者拒之门外。不过你可以自己找个时间来实践一下。System.exit(0)会跳过finally块的执行System.setSecurityManager( newSecurityManager() { @OverridepublicvoidcheckExit(intstatus){ thrownewThreadDeath(...
Python编程：真题练习与解析
"python 真题练习 教育/考试 cs" 这些题目涵盖了Python编程的基础知识，包括： 1. `print`命令：选项C正确，`print`在Python中用于在屏幕上输出文本或数字等内容。选项A错误，因为它通常不涉及物理打印机；选项B...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值