一些Java代码(0201)

sunnxin

已于 2024-02-02 13:55:27 修改

阅读量1.4k

点赞数 31

文章标签： java

于 2024-02-01 16:52:16 首次发布

本文链接：https://blog.csdn.net/weixin_43867181/article/details/135969838

版权

文章涉及四个编程问题：寻找非负整数序列中缺失的数，设计扭蛋机策略获取特定数量的扭蛋，计算Git分支分割点，以及求解连续子数组的最大和。

摘要由CSDN通过智能技术生成

序列找数

描述

从非负整数序列 0, 1, 2, ..., n中给出包含其中n个数的子序列，请找出未出现在该子序列中的那个数。

输入描述：

输入为n+1个非负整数，用空格分开。
其中：首个数字为非负整数序列的最大值n，后面n个数字为子序列中包含的数字。

输出描述：

输出为1个数字，即未出现在子序列中的那个数。

示例1

输入：

3 3 0 1

复制输出：

import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;
 
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        //获取用户输入的字符串
        String str = in.nextLine();
        List<Integer> list =Arrays.asList(str.split(" ")).stream().map(Integer::valueOf).collect(Collectors.toList());
        int count = list.get(0);
        list.remove(0);
        list = list.stream().sorted().collect(Collectors.toList());
        for(int i=0;i<=count;i++) {
            if(count == i) {
                System.out.println(i);
                break;
            }
            if(list.get(i)-i==1){
                System.out.println(i);
                break;
            }
        }
        in.close();
         
    }
}

扭蛋机

描述

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.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        //获取小电视君需要扭蛋数量
        int eggCount = in.nextInt();
        StringBuffer buffer = new StringBuffer();
        while (eggCount != 0) {
            if (eggCount % 2 == 1) {
                buffer.append("2");
                eggCount = (eggCount-1) / 2;
            } else {
                buffer.append("3");
                eggCount = (eggCount-2) / 2;
            }
        }
        System.out.println(buffer.reverse().toString());
        in.close();
    }
}

小米Git

Git 是一个常用的分布式代码管理工具，Git 通过树的形式记录文件的更改历史（例如示例图），树上的每个节点表示一个版本分支，工程师经常需要找到两个分支的最近的分割点。

例如示例图中 3,4 版本的分割点是 1。3,5 版本的分割点是 0。

给定一个用邻接矩阵 matrix 表示的树，请你找到版本 versionA 和 versionB 最近的分割点并返回编号。

注意：

1.矩阵中从第一行（视为节点 0 ）开始，表示与其他每个点的连接情况，例如 [01011,10100,01000,10000,10000] 表示节点 0 与节点 1 ， 3 ， 4相连，节点 1 与节点 0 ， 2相连，其他点的以此类推。

2.并不保证是一棵二叉树，即一个节点有可能有多个后继节点，我们把节点 0 视为树的根节点。

数据范围：树上节点数量满n≤100

示例图

示例1

输入：["01011","10100","01000","10000","10000"],1,2

返回值：1

示例2

输入：["0"],0,0

返回值：0

import java.util.*;
import java.util.stream.Collectors;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param matrix string字符串一维数组
     * @param versionA int整型
     * @param versionB int整型
     * @return int整型
     */
    public int Git (String[] matrix, int versionA, int versionB) {
        int node = 0;
        // 一维数组不为空
        if (Objects.nonNull(matrix)) {
            Map<Integer, List<Integer>> map = new HashMap<>();
            for (int i = 0; i < matrix.length; i++) {
                map.put(i, getBlood(matrix[i]));
            }
            List<Integer> listA =  map.get(versionA);
            List<Integer> listB =  map.get(versionB);
            if (listB.contains(versionA)) {
                map.remove(versionA);
                map.remove(versionB);
                for (Integer i : map.keySet()) {
                    if (map.get(i).contains(versionA)) {
                        node = versionA;
                    } else if (map.get(i).contains(versionB)) {
                        node = versionB;
                    }
                }
            } else {
                map.remove(versionA);
                map.remove(versionB);
                for (Integer i : map.keySet()) {
                    if (map.get(i).contains(versionA)
                            && map.get(i).contains(versionB)) {
                        node = i;
                    }
                }
            }
        }
        System.out.println(node);
        return node;
    }

    //将string转换成List<Integer>
    public List<Integer>  getBlood(String str) {
        List<Integer> list =  new ArrayList<>();
        for (int i = 0; i < str.length(); i++) {
            if (str.substring(i, i + 1).equals("1")) {
                list.add(i);
            }
        }
        return list;
    }
}

连续最大和

描述

一个数组有 N 个元素，求连续子数组的最大和。例如：[-1,2,1]，和最大的连续子数组为[2,1]，其和为 3

输入描述：

输入为两行。第一行一个整数n(1 <= n <= 100000)，表示一共有n个元素第二行为n个数，即每个元素,每个整数都在32位int范围内。以空格分隔。

输出描述：

所有连续子数组中和最大的值。

示例1

输入：3

-1 2 1

输出：3

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int count = in.nextInt();
        int maxSum = 0;
        //注意！！！光标换到下一行
        in.nextLine();
        String s = in.nextLine();
        List<Integer> list = Arrays.asList(s.split(" "))
                             .stream().map(Integer::valueOf).collect(Collectors.toList());
        Integer[] integers = new ArrayList<Integer>(list).toArray(new Integer[0]);
        for (int i = 0; i < integers.length; i++) {
            if (i > 0) {
                maxSum = maxSum + integers[i];
                if (Math.abs(integers[i] - integers[i - 1]) != 1) {
                    maxSum = integers[i];
                }
            } else {
                maxSum = integers[i];
            }
        }
        in.close();
        System.out.println(maxSum);
    }
}

搬圆桌

描述

现在有一张半径为r的圆桌，其中心位于(x,y)，现在他想把圆桌的中心移到(x1,y1)。每次移动一步，都必须在圆桌边缘固定一个点然后将圆桌绕这个点旋转。问最少需要移动几步。

输入描述：

一行五个整数r,x,y,x1,y1(1≤r≤100000,-100000≤x,y,x1,y1≤100000)

输出描述：

输出一个整数，表示答案

示例1

输入：2 0 0 0 4

输出：1

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        String str = in.nextLine();
        String[] strArr = str.split(" ");
        int r = Integer.valueOf(strArr[0]);
        int x = Integer.valueOf(strArr[1]);
        int y = Integer.valueOf(strArr[2]);
        int x1 = Integer.valueOf(strArr[3]);
        int y1 = Integer.valueOf(strArr[4]);

        double dx = Math.abs(x1 - x) % (2 * r);
        double dy = Math.abs(y1 - y) % (2 * r);
        double s = Math.sqrt(dx * dx + dy * dy);
        int step = (int)(s / (2 * r)) +
                   Integer.valueOf(Math.abs(x1 - x) / (2 * r)) +
                   Integer.valueOf(Math.abs(y1 - y) / (2 * r));
        //当最后移动的距离不能被直径整除时，我们还要额外再移动一次
        if (s % (2 * r) != 0) {
            step++;
        }
        System.out.println(step);
        in.close();
    }
}

sunnxin

关注

31
点赞
踩
26

收藏

觉得还不错? 一键收藏
打赏
1
评论
一些Java代码(0201)

1.矩阵中从第一行（视为节点 0 ）开始，表示与其他每个点的连接情况，例如 [01011,10100,01000,10000,10000] 表示节点 0 与节点 1 ， 3 ， 4相连，节点 1 与节点 0 ， 2相连，其他点的以此类推。Git 是一个常用的分布式代码管理工具，Git 通过树的形式记录文件的更改历史（例如示例图），树上的每个节点表示一个版本分支，工程师经常需要找到两个分支的最近的分割点。输入：["01011","10100","01000","10000","10000"],1,2。
复制链接

扫一扫