【华为OD机试真题 JAVA】最远足迹【2022 Q4 | 100分】

■ 题目描述

【最远足迹】

某探险队负责对地下洞穴进行探险。探险队成员在进行探险任务时，随身携带的记录器会不定期地记录自身的坐标，但在记录的间隙中也会记录其他数据。探索工作结束后，探险队需要获取到某成员在探险过程中相对于探险队总部的最远的足迹位置。

1. 仪器记录坐标时，坐标的数据格式为(x,y)，如(1,2)、(100,200)，其中0<x<1000，0<y<1000。同时存在非法坐标，如(01,1)、(1,01)，(0,100)属于非法坐标。
2. 设定探险队总部的坐标为(0,0)，某位置相对总部的距离为：x*x+y*y。
3. 若两个座标的相对总部的距离相同，则第一次到达的坐标为最远的足迹。
4. 若记录仪中的坐标都不合法，输出总部坐标（0,0）。

备注：

不需要考虑双层括号嵌套的情况，比如sfsdfsd((1,2))。

输入描述

字符串，表示记录仪中的数据。

如：ferga13fdsf3(100,200)f2r3rfasf(300,400)

输出描述

字符串，表示最远足迹到达的坐标。

如： (300,400)

示例1 输入输出示例仅供调试，后台判题数据一般不包含示例

输入

ferg(3,10)a13fdsf3(3,4)f2r3rfasf(5,10)

输出

(5,10)

说明

记录仪中的合法坐标有3个： (3,10)， (3,4)， (5,10)，其中(5,10)是相距总部最远的坐标， 输出(5,10)。

示例2 输入输出示例仅供调试，后台判题数据一般不包含示例

输入

asfefaweawfaw(0,1)fe

输出

(0,0)

说明

记录仪中的坐标都不合法，输出总部坐标（0,0）。

---

Java代码实现一：

import java.util.ArrayList;

public class Expedition {
    public static String solution(String s) {
        s = s.replaceAll("[a-z]", "");
        char[] scArr = s.toCharArray();

        ArrayList<Integer> leftBracketIndexes = new ArrayList<>();
        ArrayList<Integer> rightBracketIndexes = new ArrayList<>();
        ArrayList<Integer> commaIndexes = new ArrayList<>();

        ArrayList<Integer> xs = new ArrayList<>();
        ArrayList<Integer> ys = new ArrayList<>();

        for (int i = 0; i < scArr.length; i++) {
            if (Character.toString(scArr[i]).equals("(")) {
                leftBracketIndexes.add(i);
            }
            if (Character.toString(scArr[i]).equals(")")) {
                rightBracketIndexes.add(i);
            }
            if (Character.toString(scArr[i]).equals(",")) {
                commaIndexes.add(i);
            }
        }

        for (int i = 0; i < leftBracketIndexes.size(); i++) {
            StringBuilder str1 = new StringBuilder();
            StringBuilder str2 = new StringBuilder();
            for (int a = leftBracketIndexes.get(i) + 1; a < commaIndexes.get(i); a++) {
                str1.append(scArr[a]);
            }
            xs.add(Integer.valueOf(String.valueOf(str1)));

            for (int b = commaIndexes.get(i) + 1; b < rightBracketIndexes.get(i); b++) {
                str2.append(scArr[b]);
            }
            ys.add(Integer.valueOf(String.valueOf(str2)));
        }

        int resIndex = 0;
        int distance = 0;

        for (int i = 0; i < xs.size(); i++) {

            if (xs.get(i) <= 0 || xs.get(i) >= 1000 || ys.get(i) <= 0 || ys.get(i) >= 1000) {
                return "(0,0)";
            }

            if (xs.get(i) + ys.get(i) > distance) {
                distance = xs.get(i) + ys.get(i);
                resIndex = i;
            }
        }
        return "(" + xs.get(resIndex) + "," + ys.get(resIndex) + ")";
    }

    public static void main(String[] args) {
        System.out.println(solution("ferga13fdsf3(100,200)f2r3rfasf(300,400)"));
        System.out.println(solution("ferg(3,10)a13fdsf3(3,4)f2r3rfasf(5,10)"));
        System.out.println(solution("asfefaweawfaw(0,1)fe"));
    }
}

Java代码实现二：

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        String s = sc.nextLine();
        int r = 0;
        int l = 0;

        List<Integer> list = new ArrayList<>();
        List<List<Integer>> lists = new ArrayList<>();

        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                l = i + 1;
            } else if (s.charAt(i) == ')') {
                r = i;
            }
            if (r != 0) {
                String[] ss = s.substring(l, r).split(",");  
                int j = Integer.parseInt(ss[0]);
                int w = Integer.parseInt(ss[1]);
                if (j > 0 && j < 1000 && w > 0 && w < 1000 && ss[0].charAt(0) != '0' && ss[1].charAt(0) != '0') {
                    list.add(j);
                    list.add(w);
                    lists.add(list);
                    list = new ArrayList<>();
                }
                l = r = 0;
            }
        }

        if (lists.size() == 0) {
            System.out.println("(0,0)");
        } else {
            lists.sort((a, b) -> { 
                int ax = a.get(0) * a.get(0) + a.get(1) * a.get(1);
                int bx = b.get(0) * b.get(0) + b.get(1) * b.get(1);
                if (bx >= ax) {
                    return 1;
                }
                return -1;
            });

            System.out.println("(" + lists.get(0).get(0) + "," + lists.get(0).get(1) + ")");
        }
    }
}