华为Oj题（01-10）

题目1：

import java.util.Scanner;

/**
 * Created by huststl on 2018/3/11 22:16
 * 计算字符串最后一个单词的长度，单词以空格隔开。
 */
public class demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //是否还有其他行，一次可以测试多行
        while(scanner.hasNext()){
            String input = scanner.nextLine();
            System.out.println(findLastLength(input));
        }
        scanner.close();
    }

    public static int findLastLength(String input) {
        //最后一个字母的位置
        int last = input.length()-1;
        //找最后一个字母出现的位置
        while (last>=0 && input.charAt(last)==' '){
            last--;
        }
        //找到最后一个字母之前的第一个空白字符
        int pos = last-1;
        while (pos>=0&&input.charAt(pos)!=' '){
            pos--;
        }

        return last-pos;
    }
}

题2

import java.util.Scanner;

/**
 * Created by huststl on 2018/3/11 22:38
 * 写出一个程序，接受一个有字母和数字以及空格组成的字符串，和一个字符，
 * 然后输出输入字符串中含有该字符的个数。不区分大小写。
 */
public class demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while(scanner.hasNext()){
            String str = scanner.next();
            String ch = scanner.next();
            System.out.println(countCharNumber(str,ch));

        }
    }

    private static int  countCharNumber(String str, String chStr) {
        char ch = 0;
        for(int i=0;i<chStr.length();i++){
            if(chStr.charAt(i)!=' '){
                ch = chStr.charAt(i);
                break;
            }
        }

        ch = toUppercase(ch);
        int count = 0;
        for(int i=0;i<str.length();i++){
            if(toUppercase(str.charAt(i))==ch){
                count++;
            }
        }
        return count;

    }

    private static char toUppercase(char ch) {
        if(ch>='a'&& ch<='z'){
            return (char)('A'+(ch-'a'));
        }
        return ch;
    }

}

题3

import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

/**
 * Created by huststl on 2018/3/12 8:35
 * 输入多行数字，进行去重和排序
 */
public class demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()){
            //读取输入的数字数
            int num = scanner.nextInt();
            //存放输入的数字
            Set<Integer> set = new TreeSet<>();
            while ((--num)>=0){
                set.add(scanner.nextInt());
            }
            System.out.println(setToString(set));
        }

    }

    private static String setToString(Set<Integer> set)
    {
        StringBuilder builder = new StringBuilder(128);
        for(Integer i:set){
            builder.append(i).append("\n");
        }
        return builder.toString();
    }
}

题4：

import java.util.Scanner;

/**
 * Created by huststl on 2018/3/12 8:45
 * 连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；
 •长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
 */
public class demo04 {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        /*StringBuilder builder = new StringBuilder(256);
        while (scanner.hasNext()){
            builder.setLength(0);
            String input = scanner.nextLine();
            stringSplit(builder,input);
            input = scanner.nextLine();
            stringSplit(builder,input);
            System.out.println(builder);
        }*/
        while (sc.hasNext()){
            String str = new String(sc.nextLine());
            if(str.length()%8!=0){
                str = str +"00000000";

            }
            while (str.length()>8){
                System.out.println(str.substring(0,8));
                str = str.substring(8);

            }
        }

    }

    /*private static void stringSplit(StringBuilder builder, String str) {
        if(str == null || str.length()<1){
            return;
        }
        int pos = 0;
        while((pos+8)<str.length()){
            builder.append(str.substring(pos-8,pos)).append("\n");
        }

        //如果str.length()<pos 说明最后字符不足8个或刚好8个
        if(str.length()<=pos){
            builder.append(str.substring(pos-8,str.length()));
            for(int i=str.length();i<pos;i++){
                builder.append(0);
            }
            builder.append("\n");
        }
    }*/
}

题5：

import java.util.Scanner;

/**
 * Created by huststl on 2018/3/12 9:21
 * 进制转换（输入16进制输出10进制）
 */
public class demo05 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()){//多个测试用例用while(sc.hasNext()){}
            String str = sc.next().substring(2);
            System.out.println(Integer.parseInt(str,16));
            /*System.out.println(hexToDec(str));*/
        }
    }

   /* private static int hexToDec(String str) {
        final int BASE = 16;
        int result = 0;

        for(int i=2;i<str.length();i++){
            result = result * BASE + hexToNum(str.charAt(i));
        }
        return result;
    }*/

    /*private static int hexToNum(char c) {

        if(c >='0' && c<='9'){
            return c-'0';
        }else if(c>='a'&& c<='z'){
            return c -'a'+10;
        }else {
            return c-'A'+10;
        }
    }*/
}

题6：

import java.util.Scanner;

/**
 * Created by huststl on 2018/3/12 9:34
 * 质子因子
 * :输入一个正整数，按照从小到大的顺序输出它的所有质数的因子（如180的质数因子为2 2 3 3 5 ）
 */
public class demo06 {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        while (sc.hasNext()){
            long num = sc.nextLong();
            System.out.println(findPrime(num));
        }

    }

    private static String findPrime(long num) {

        StringBuilder builder = new StringBuilder(128);

        long i = 2;

        while (i<=num){
            //每次的i一定是质数才会满足
            while (num%i==0){
                builder.append(i).append(' ');
                num /=i;
            }
            i++;
        }
        return builder.toString();
    }
}

题7：

import java.util.Scanner;

/**
 * Created by huststl on 2018/3/12 9:46
 * 取近似值
 * 写出一个程序，接受一个浮点数值，输出该数值的近似整数值。
 * 如果小数点后数值大于等于5,向上取整；小于5，则向下取整。
 */
public class demo007 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        while (sc.hasNext()){
            float num = sc.nextFloat();
            System.out.println(floatToNearInt(num));
        }
    }

    private static int floatToNearInt(float num) {
        //取整的计算方式
        return (int) ((num*10+5)/10);
    }
}

题8：

import java.util.Scanner;
import java.util.SortedMap;
import java.util.TreeMap;

/**
 * Created by huststl on 2018/3/12 9:52
 * 数据表记录包含表索引和数值，请对表索引相同的记录进行合并，
 * 即将相同索引的数值进行求和运算，输出按照key值升序进行输出。
 */
public class demo008 {
    public static void main(String[] args) {
        Scanner scan =new Scanner(System.in);

        while (scan.hasNext()){
            int pares = Integer.parseInt(scan.nextLine());
            SortedMap<Integer,Integer> map = new TreeMap<>();
            for(int i=0;i<pares;i++){
                String[] nums = scan.nextLine().split("\\s+");
                addPare(map,nums);
            }
            System.out.println(mapToString(map));
        }
    }

    private static String mapToString(SortedMap<?, ?> map) {
        StringBuilder builder = new StringBuilder();

        for(SortedMap.Entry<?,?> e:map.entrySet()){
            builder.append(e.getKey()).append(" ").append(e.getValue()
            ).append("\n");
        }

        return builder.toString();
    }


    private static void addPare(SortedMap<Integer, Integer> map, String[] nums) {

        int key = Integer.parseInt(nums[0]);
        int val = Integer.parseInt(nums[1]);

        if(map.containsKey(key)){
            map.put(key,map.get(key)+val);
        }else {
            map.put(key,val);
        }
    }
}

题9：

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Scanner;

/**
 * Created by huststl on 2018/3/12 10:10
 * 提取不重复的整数
 * 输入一个int型整数，
 * 按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
 */
public class demo009 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()){
            /*int num = scanner.nextInt();
            System.out.println(extractNumber(num+""));*/
            String str = scanner.nextLine();

            int len = str.length();

            int[] arr1 = new int[10];

            for(int i=len-1;i>=0;i--){
                if(arr1[str.charAt(i)-48]==0){
                    System.out.println(str.charAt(i)-48);
                    //字符与整数之间差48
                    arr1[str.charAt(i)-48]++;
                }
            }

        }

    }

    /*private static String extractNumber(String s) {

        StringBuilder builder = new StringBuilder();

        HashSet<Character> set = new LinkedHashSet<>();
        for(int i=s.length()-1;i>=0;i++){
            set.add(s.charAt(i));
        }
        for(Character c:set){
            builder.append(c);
        }

        //如果第一个字符是0
        if(builder.charAt(0)=='0'){
            return builder.substring(1,builder.length());
        }

        return builder.toString();
    }*/
}

题10：

import java.util.Scanner;

/**
 * Created by huststl on 2018/3/12 10:30
 * 010--字符个数统计
 * 编写一个函数，计算字符串中含有的不同字符的个数。
 * 字符在ACSII码范围内(0~127)。不在范围内的不作统计。
 */
public class demo10 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            int[] arr = new int[128];
            String str = scanner.nextLine();
            countChar(arr,str);
            System.out.println(countCharNum(arr));
        }
    }

    private static int countCharNum(int[] arr) {
        int result = 0;
        for(int i:arr){
            if(i!=0){
                result++;
            }
        }
        return result;
    }

    private static void countChar(int[] arr, String str) {
        for(int i=0;i<str.length();i++){
            char c = str.charAt(i);
            if(c<=127){
                arr[c]++;
            }
        }
    }
}