HJ5 进制转换 、NC61 两数之和、HJ3 明明的随机数

HJ5 进制转换

题目描述
写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。

输入描述：
输入一个十六进制的数值字符串。
输出描述：
输出该数值的十进制字符串。不同组的测试用例用\n隔开。

示例1
输入：
0xAA
输出：
170

好久没做编程题了，感觉回到了刚学变成的时候，Java API 太强大了，包罗万象；

通过答案一：使用JavaAPI Integer.valueOf(xx, 进制);

    public static void main(String[] args) {

        while(in.hasNextLine()) {
            String input = in.nextLine();
            String target = input.substring(2);
            Integer valueOf = Integer.valueOf(target, 16);
            System.out.println(valueOf);
        }
    }

通过答案二：

1. 去除0x两个字符， 获得剩余字符串target；
2. 从后往前遍历， 最末尾的位置为 target.length() - 1, 对应的指数pow为 0；
3. 若该位置的值 为 ‘0’ - ‘9’, 则减去‘0’，得到该位置的真正值；
4. 若该位置的值为‘A’ -‘F’, 则减去‘A’ 再加10， 得到该位置的真正值；
6. 遍历倒数第二个位置为target.length() - 2， 对应进制指数为1；重复3,4步骤；
7. 最终得到结果；

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

        while(in.hasNextLine()) {
            String input = in.nextLine();
            String target = input.substring(2);
            double finalVal = 0;
            int pow = 0;
            for(int index = target.length() - 1; index >= 0; index --) {
                char indexVal = target.charAt(index);
                int temp = 0;
                if(indexVal >= '0' && indexVal <= '9') {
                    temp = indexVal - '0';
                }else if(indexVal >= 'A' && indexVal <= 'Z') {
                    temp = indexVal - 'A' + 10;
               }
                finalVal = finalVal + temp * Math.pow(16, pow);
                pow = pow + 1;
            }
            System.out.println(finalVal);
        }
    }

NC61 两数之和

描述
给出一个整型数组 numbers 和一个目标值 target，请在数组中找出两个加起来等于目标值的数的下标，返回的下标按升序排列。
（注：返回的数组下标从1开始算起，保证target一定可以由数组里面2个数字相加得到）

输入：
[3,2,4],6
返回值：
[2,3]
说明：
因为 2+4=6 ，而 2的下标为2 ， 4的下标为3 ，又因为 下标2 < 下标3 ，所以返回[2,3]

方法一：暴力破解
两层for循环，相加为目标值，就把两个索引返回；

import java.util.*;
public class Solution {
    /**
     * 
     * @param numbers int整型一维数组 
     * @param target int整型 
     * @return int整型一维数组
     */
    public int[] twoSum (int[] numbers, int target) {
        // write code here
        int n = numbers.length;
        int[] res = {-1, -1};
        //遍历数组
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                //判断相加值是否为target
                if (numbers[i] + numbers[j] == target) {
                    res[0] = i+1;
                    res[1] = j+1;
                    //返回值
                    return res;
                }
            }
        }
        return res;
    }
}

该方法时间复杂度为n^2, 若是时间复杂度有要求，则会出现超时；

方法2：利用哈希结构
变量 beforeIndex : 表示第一个坐标；
变量 afterIndex : 表示第二个锁表；
存在关系： num[beforeIndex] + num[afterIndex] = target;
即：target - num[afterIndex] = num[beforeIndex];
将num[beforeIndex] 放入Map, key为num[beforeIndex]， val为索引坐标；

流程：

1. 判断 Map中是否存在target - num[afterIndex]索引；
2. 若不存在，则以 target - num[afterIndex] 为key， val为索引坐标afterIndex放入map中；
3. 若存在， 则target - num[afterIndex]为key, 拿到beforeIndex返回；
   代码：

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param numbers int整型一维数组 
     * @param target int整型 
     * @return int整型一维数组
     */
    public int[] twoSum (int[] numbers, int target) {
        // write code here
        int left  = 0;
        int right = 0;
        int[] result = {-1, -1};
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int index = 0; index < numbers.length; index ++) {
            Integer val = target - numbers[index];
            boolean flag = map.containsKey(val);
            if (flag) {
               Integer beforeIndex =  map.get(val);
               result[0] = beforeIndex + 1;
               result[1] = index + 1;
               return result;
            }else {
                map.put(numbers[index], index);
            }

        }
        
        return result;
    }
}

HJ3 明明的随机数

描述
明明生成了N个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。
数据范围： 1≤n≤1000 ，输入的数字大小满足 1≤val≤500
输入描述：
第一行先输入随机整数的个数 N 。 接下来的 N 行每行输入一个整数，代表明明生成的随机数。 具体格式可以参考下面的"示例"。

输出描述：
输出多行，表示输入数据处理后的结果

输入：
3
2
2
1
输出：
1
2
说明：
输入解释：
第一个数字是3，也即这个小样例的N=3，说明用计算机生成了3个1到500之间的随机整数，接下来每行一个随机数字，共3行，也即这3个随机数字为：
2
2
1
所以样例的输出为：
1
2

方案一：利用TreeSet， 有序无重复特点，即可解决该问题；

import java.util.*;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //获取个数
        int num = sc.nextInt();
        //创建TreeSet进行去重排序
        TreeSet set = new TreeSet();
        //输入
        for(int i =0 ; i < num ;i++){
            set.add(sc.nextInt());
        }

        //输出
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

方式2：利用HashMap去重，流Stream排序；
工作中没怎么使用TreeSet, 大部分都是使用Stream来排序，若是以前工作，我会这么做；限制在了java8

        Scanner sc = new Scanner(System.in);
        //获取个数
        int num = sc.nextInt();
        //创建TreeSet进行去重排序
        HashMap<Integer, Integer> map = new HashMap<>();
        //输入
        for(int i =0 ; i < num ;i++){
            map.put(sc.nextInt(), 1);
        }

        map.keySet().stream().sorted().collect(Collectors.toList()).forEach(val -> System.out.println(val));

方式3：利用数据大小<500, 数量小于1000， 因此可以参加一个长度大于1000得数组， 每输入一个数，就将对应坐标的值置为1；
输入结束后，遍历数组，判断数组元素值是否为1， 若为1，则打印下表，否则跳过；
代码：

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    public static void main(String[] args) {
        Scanner scaner = new Scanner(System.in);
        int count =  scaner.nextInt();
        int[] data = new int[1001];
        for(int index = 1; index <= count; index ++) {
            int val = scaner.nextInt();
            data[val] = 1;
        }

        for(int index = 0; index < data.length; index++) {
            if(data[index] == 1) {
                System.out.println(index);
            }
        }

        scaner.close();
    }
}

个人感觉

Java API强大包罗万象，像后者的写法，更像是大二大三学编程时的做法， 考研程序设计能力；