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, 得到该位置的真正值;
  5. 遍历倒数第二个位置为target.length() - 2, 对应进制指数为1;重复3,4步骤;
  6. 最终得到结果;
    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强大包罗万象,像后者的写法,更像是大二大三学编程时的做法, 考研程序设计能力;

你可能感兴趣的:(面试笔试,java)