牛客在线编程-华为机试-简单

最新推荐文章于 2022-04-04 00:34:41 发布
最新推荐文章于 2022-04-04 00:34:41 发布
阅读量380 收藏 4
点赞数
分类专栏： 数据结构与算法 Java 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feiyanaffection/article/details/123886605
版权
题号题目知识点难度通过率
HJ1字符串最后一个单词的长度字符串简单32.49%
HJ2计算某字符出现次数字符串 哈希简单30.43%
HJ4字符串分隔字符串简单28.60%
HJ5进制转换字符串简单33.28%
HJ6质数因子排序简单27.01%
HJ8合并表记录简单35.02%
HJ10字符个数统计字符串 哈希简单47.31%
HJ11数字颠倒字符串简单58.51%
HJ12字符串反转字符串简单59.14%
HJ13句子逆序数组简单40.02%
HJ14字符串排序字符串 排序简单41.54%
HJ15求int型正整数在内存中存储时1的个数位运算简单57.06%
HJ21简单密码字符串 模拟简单41.47%
HJ22汽水瓶模拟简单28.19%
HJ23删除字符串中出现次数最少的字符字符串 哈希简单33.23%
HJ31单词倒排字符串 排序简单24.03%
HJ34图片整理字符串 排序简单46.95%
HJ35蛇形矩阵数组简单43.86%
HJ37统计每个月兔子的总数排序简单43.87%
HJ40统计字符字符串 哈希简单44.43%
HJ51输出单向链表中倒数第k个结点链表 双指针简单26.49%
HJ53杨辉三角的变形基础数学简单48.85%
HJ54表达式求值字符串 栈 基础数学简单56.06%
HJ56完全数计算基础数学简单50.33%
HJ60查找组成一个偶数最接近的两个素数穷举 基础数学简单44.77%
HJ61放苹果递归 动态规划简单47.80%
HJ62查找输入整数二进制中1的个数位运算简单50.24%
HJ72百钱买百鸡问题简单50.25%
HJ73计算日期到天数转换字符串简单42.46%
HJ76尼科彻斯定理基础数学简单46.29%
HJ80整型数组合并数组 哈希 排序简单34.02%
HJ81字符串字符匹配字符串 哈希简单31.83%
HJ83二维数组操作数组简单30.56%
HJ84统计大写字母个数字符串简单43.80%
HJ85最长回文子串字符串 穷举简单40.91%
HJ86求最大连续bit数位运算简单45.56%
HJ87密码强度等级字符串 模拟简单32.74%
HJ91走方格的方案数动态规划 基础数学简单47.52%
HJ94记票统计哈希简单29.77%
HJ96表示数字字符串 模拟简单33.74%
HJ97记负均正数组简单22.04%
HJ99自守数简单39.10%
HJ100等差数列基础数学简单40.99%
HJ102字符统计字符串 哈希 排序简单31.74%
HJ106字符逆序字符串简单45.10%
HJ108求最小公倍数递归 基础数学简单37.30%
1.字符串最后一个单词的长度 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String[] s = str.split(" ");
        int length = s[s.length - 1].length();
        System.out.println(length);
    }
}
2.计算某字符出现次数 
public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String input1= s.nextLine();
        String input2 = s.nextLine();
        String res = input1.toLowerCase().replaceAll(input2.toLowerCase(), "");
        System.out.println(input1.length() - res.length());
    }
}
3.字符串分隔 
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();
            StringBuilder sb = new StringBuilder();//牢记字符串缓冲区的建立语法
            sb.append(str);//字符串缓冲区的加入
            int addZero = 8 - str.length() % 8;//addzero的可能值包括8
            while((addZero > 0)&&(addZero<8)){//注意边界调节，避免addzero=8
                sb.append("0");//使用‘’或“”都可
                addZero--;
            }
            String str1 = sb.toString();
            while(str1.length()>0){
                System.out.println(str1.substring(0,8));
                str1 = str1.substring(8);
            }
        }
    }
}
4.进制转换 
public class Main {
  private final static int BASE = 16;
  private static Map<Character, Integer> map = new HashMap<Character, Integer>()
  {{
      put('0', 0);
      put('1', 1);
      put('2', 2);
      put('3', 3);
      put('4', 4);
      put('5', 5);
      put('6', 6);
      put('7', 7);
      put('8', 8);
      put('9', 9);
      put('A', 10);
      put('B', 11);
      put('C', 12);
      put('D', 13);
      put('E', 14);
      put('F', 15);
      put('a', 10);
      put('b', 11);
      put('c', 12);
      put('d', 13);
      put('e', 14);
      put('f', 15);
  }};

  public static int getDecimal(String number) {
      int res = 0;
      for (char ch : number.toCharArray()) {
          res = res * BASE + map.get(ch);
      }
      return res;
  }

  public static void main(String[] args) {
      Scanner in = new Scanner(System.in);
      while (in.hasNext()) {
          String number = in.next();
          int res = getDecimal(number.substring(2));
          System.out.println(res);
      }
  }
}
5.质数因子 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long num = scanner.nextLong();
        long k = (long) Math.sqrt(num);
        for (long i = 2; i <= k; ++i) {
            while (num % i == 0) {
                System.out.print(i + " ");
                num /= i;
            }
        }
        System.out.println(num == 1 ? "" : num + " ");
    }
}
6.合并表记录 
public class Main{
    public static void main(String[] args) throws Exception{
        Scanner sc = new Scanner(System.in);
        TreeMap<Integer, Integer> map = new TreeMap<>(); // 输出结果要求有序！
       while(sc.hasNextInt()){
            int n = sc.nextInt();
            for(int i = 0; i < n; ++i){
                int a = sc.nextInt();
                int b = sc.nextInt();
                map.put(a,map.getOrDefault(a,0) + b);
            }
       }
       for (Integer i : map.keySet()) {
           System.out.println(i + " " + map.get(i));
       }
    }
}
7.字符个数统计 
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String str=in.next();
        HashSet<Character> hs=new HashSet<>();
        for(int i=0;i<str.length();i++)
            hs.add(str.charAt(i));
        System.out.println(hs.size());
    }
}
8.数字颠倒 
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = String.valueOf(in.nextInt());
        StringBuffer strb = new StringBuffer(str);
        strb.reverse();
        System.out.println(strb.toString());
    }
}
9.字符串反转 
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        StringBuilder strb = new StringBuilder(str);
        strb.reverse();
        System.out.println(strb.toString());
    }
}
10.求int型正整数在内存中存储时1的个数 
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();    //读取数字
        int n = 0;    //计数变量
        for(int i=0; i<32; i++) {
            if ((num & 1) == 1) {
                n++;
            }
            num = num >>> 1;
        }
        System.out.println(n);
    }
}
11.简单密码 
public class Main {
    private static Map<String, String> map = new HashMap<String, String>() {
        {
            put("a", "2");
            put("b", "2");
            put("c", "2");
 
            put("d", "3");
            put("e", "3");
            put("f", "3");
 
            put("g", "4");
            put("h", "4");
            put("i", "4");
 
            put("j", "5");
            put("k", "5");
            put("l", "5");
 
            put("m", "6");
            put("n", "6");
            put("o", "6");
 
            put("p", "7");
            put("q", "7");
            put("r", "7");
            put("s", "7");
 
            put("t", "8");
            put("u", "8");
            put("v", "8");
 
            put("w", "9");
            put("x", "9");
            put("y", "9");
            put("z", "9");
        }
    };
 
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        char[] arr = str.toCharArray();
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] >= 'A' && arr[i] <= 'Z') {
                    if (arr[i] == 'Z') {
                        arr[i] = 'a';
                    } else {
                        int c = (int) String.valueOf(arr[i]).toLowerCase().charAt(0);
                        arr[i] = (char) ++c;
                    }
                } else if (arr[i] >= 'a' && arr[i] <= 'z') {
                    arr[i] = map.get(String.valueOf(arr[i])).charAt(0);
                }
        }
         
       System.out.println(String.valueOf(arr));
    }
}
12.汽水瓶 
public class Main {
  public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextInt()){
            int bottle = sc.nextInt();
            if(bottle==0){
                break;
            }
            System.out.println(bottle/2);
        }
    }
}
13.删除字符串中出现次数最少的字符 
public class Main {
    public String delete(String str) {
        // Map记录每个字母的次数
        Map<Character, Integer> map = new HashMap<>();
        for (char ch : str.toCharArray()) {
            map.put(ch, map.getOrDefault(ch, 0) + 1);
        }
        // 快速找出最少次数
        int min = Integer.MAX_VALUE;
        for (int times : map.values()) {
            min = Math.min(min, times);
        }
        StringBuilder res = new StringBuilder();
        for (char ch : str.toCharArray()) {
            if (map.get(ch) != min) {
                res.append(ch);
            }
        }
        return res.toString();
    }

    public static void main(String[] args) {
        Main solution = new Main();
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {
            String str = in.nextLine();
            String res = solution.delete(str);
            System.out.println(res);
        }
    } 
}
14.单词倒排 
public class Main {
   public static String reverse(String str) {
        // 匹配非字母的字符进行分割
        String[] words = str.split("[^A-Za-z]");
        StringBuilder result = new StringBuilder();
        // 逆序添加分割完的单词
        for (int i = words.length - 1; i >= 0; i--) {
            result.append(words[i]).append(" ");
        }
        return result.toString().trim();
    }

    public static void main(String[] args) {
        Main solution = new Main();
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {
            String str = in.nextLine();
            String res = reverse(str);
            System.out.println(res);
        }
    } 
}
15.图片整理 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String str = sc.nextLine();
            char[] chars = str.toCharArray();
            Arrays.sort(chars);
            StringBuilder resultStr = new StringBuilder();
            for (char aChar : chars) {
                resultStr.append(aChar);
            }
            System.out.println(resultStr);
        }
    }
}
16.蛇形矩阵 
public class Main{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNextInt()){
            int n = in.nextInt();    //读入正整数n
            
            int y = 1;
            int yCnt = 1;
            for(int i=1; i<=n; i++) {
                int x = y;
                int xCnt = i + 1;
                for (int j = 1; j<=n-i+1; j++) {
                    System.out.print(x+" ");//循环输出x
                    x += xCnt++;    //等差数列每次+1
                }
                System.out.println("");//换行
                y+=yCnt; //等差数列每次加1
                yCnt++;
            }
            
        }
    }
}
17.统计每个月兔子的总数 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
          System.out.println(solution(scanner.nextInt()));
        }
    }

    private static int solution(int month) {
      // 第一个月初始化
      // 一月龄兔子总数
      int oneMonth = 1;
      // 二月龄兔子总数
      int twoMonth = 0;
      // 三月龄及以上兔子总数
      int threeMonth = 0;
      // 下个月将繁殖的兔子数量
      int addVal = 0;
      // 第二个月开始递推, i表示第i个月
      for(int i = 2; i <= month; i++) {
        // 三月龄及以上兔子总数 = 二月龄兔子总数 + 原本三月龄及以上兔子总数
        threeMonth += twoMonth;
        // 二月龄兔子总数 = 上个月的一月龄兔子总数
        twoMonth = oneMonth;
        // 一月龄（即这个月出生）兔子总数 = 上个月将繁殖的兔子数量
        oneMonth = addVal;
        // 下个月将出生的兔子 = 下个月成为三月龄及以上的兔子数量
        addVal = twoMonth + threeMonth;
      }
      return (oneMonth + twoMonth + threeMonth);
    }
}
18.统计字符 
public class Main{
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        while(in.hasNext()){
            String str=in.nextLine();
            String s1=str.replaceAll("[A-Z]+|[a-z]+", "");
            System.out.println(str.length()-s1.length());
            String s2=s1.replaceAll(" ", "");
            System.out.println(s1.length()-s2.length());
            String s3=s2.replaceAll("[0-9]+", "");
            System.out.println(s2.length()-s3.length());
            System.out.println(s3.length());
        }
    }
}
19.输出单向链表中倒数第k个结点 
public class Main {
    static class ListNode {
        int val;
        ListNode next;
  
        public ListNode(int n) {
            this.val = n;
            this.next = null;
        }
    }
  
    public static ListNode FindKthToTail(ListNode pListHead, int k) {
        if (pListHead == null || k <= 0)
            return null;
        ListNode target = pListHead;
        ListNode temp = pListHead;
        for (int i = 0; i < k; i++) {
            temp = temp.next;
        }
        while (temp != null) {
            target = target.next;
            temp = temp.next;
        }
        temp = null;
        target.next = null;
        return target;
    }
  
    public static void main(String[] args) {
        int n = 0;
        Scanner scan = new Scanner(System.in);
        // System.out.println("请输入节点个数： ");
        while (scan.hasNext()) {
            n = scan.nextInt();
            ListNode head = new ListNode(-1);
            ListNode temp = head;
            // System.out.println("请输入n个节点： ");
            for (int i = 0; i < n; i++) {
                temp.next = new ListNode(scan.nextInt());
                temp = temp.next;
            }
            // System.out.println("请输入要查找的倒数第k个节点： ");
            int k = scan.nextInt();
            ListNode target = FindKthToTail(head.next, k);
            if (target != null)
                System.out.println(target.val);
            else
                System.out.println(0);
        }
    }
}
20.杨辉三角的变形 
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int n = in.nextInt();
            if(n<=2)
                System.out.println(-1);
            else if(n%2==1){
                System.out.println(2);
            }else{
                if(n%4==0)
                    System.out.println(3);
                else
                    System.out.println(4);
            }
        }
        in.close();
    }
}
21.表达式求值 
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String s=sc.nextLine();
      //将其他括号，替换成小括号
        s=s.replace("{","(");
        s=s.replace("[","(");
        s=s.replace("}",")");
        s=s.replace("]",")");
        System.out.println(slove(s));
    }
    
    public static int slove(String s) {
        Stack<Integer> stack = new Stack<>();
        int n = s.length();
        char[] chs = s.toCharArray();
        int index = 0;
        char sign = '+';
        int number = 0;
        for(int i=0; i<n; i++) {
            char ch = chs[i];
            if (ch == ' ') continue;
            
            if (Character.isDigit(ch)) {
                number = number * 10 + ch - '0';
            }
            
            if (ch == '(') {
                int j = i + 1;
                // 统计括号的数量
                int cnt = 1;
                while(cnt > 0) {
                    if (chs[j] == ')') 
                        cnt--;
                    if (chs[j] == '(')
                        cnt++;
                    j++;
                }
                number = slove(s.substring(i+1, j-1));
                i = j-1;
            }
            
            // 遇到符号，将数字处理后放进栈中
            if (!Character.isDigit(ch) || i == n-1) {
                if (sign == '+') {
                    stack.push(number);
                } else if(sign == '-') {
                    stack.push(-1 * number);
                } else if(sign == '*') {
                    stack.push(stack.pop() * number);
                } else if(sign == '/') {
                    stack.push(stack.pop() / number);
                }
                sign = ch;
                number = 0;
            }
        }
        int ans = 0;
        while(!stack.isEmpty()) {
            ans += stack.pop();
        }
        return ans;
    }
}
22.完全数计算 
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int N = in.nextInt();
            int count = 0;
            for(int i=1;i<=N;i++){
                int sum=0;
                // 判断素数的方法
                for(int j=1;j<i/2+1;j++){
                    if(i%j==0){
                        sum+=j;
                    }
                }
                if(sum==i){
                    count++;
                }
            }
            System.out.println(count);
        }
    }
}
23.查找组成一个偶数最接近的两个素数 
public class Main {

    public Main() {
    }

    // 判断是否是素数
    private boolean isPrime(int num) {
        for (int i = 2; i <= num/i; i++) {
            if (num % i == 0) return false;
        }
        return true;
    }

    public int count(int n) {
        int i = n/2, j = n - i;
        while (!isPrime(i) || !isPrime(j)) {
            i++;
            j--;
        }
        return j;
    }

    public static void main(String[] args) {
        Main solution = new Main();
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = Integer.parseInt(in.next());
            int res = solution.count(n);
            System.out.println(res);
            System.out.println(n - res);
        }
    } 
}
24.放苹果 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextInt()) {
            System.out.println(count(sc.nextInt(), sc.nextInt()));
        }
        sc.close();
    }
    public static int count(int m, int n) {
        if (m < 0 || n <= 0)
            return 0;
        //细分到苹果数为一或盘子数为一的情况返回一
        if (m == 1 || n == 1 || m == 0)
            return 1;
        //将此事件无线细分
        // 一是留一个空盘
        // 二是全满盘，每个盘先放一个苹果
        return count(m, n - 1) + count(m - n, n);
    }
}
25.查找输入整数二进制中1的个数 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int cnt = 0;
            while (n > 0) {
                if ( (n & 1) == 1) {
                    cnt++;
                }
                n = n >>> 1;
            }
            System.out.println(cnt);
        }
    }
}
26.百钱买百鸡问题 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        while (sc.hasNextInt()) {
            int num = sc.nextInt();
            //        5x+3y+z/3=100;
            //        x+y+z=100;
            //        简化得 7x+4y=100;
            int x, y, z, middle;
            for (x = 0; x <= 14; x++) {
                if ((100 - 7 * x) % 4 == 0) {
                    y = (100 - 7 * x) / 4;
                    z = 100 - x - y;
                    System.out.print(x + " ");
                    System.out.print(y + " ");
                    System.out.print(z + " ");
                    System.out.println();
                }
            }
        }
    }
}
27.计算日期到天数转换 
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int year = sc.nextInt();
            int month = sc.nextInt();
            int day = sc.nextInt();
            int[] month_day = {31,28,31,30,31,30,31,31,30,31,30,31};
            int sum = 0;
            for(int i = 0; i < month - 1; i++){
                sum += month_day[i];
            }
            sum += day;
            if(month > 2 && isLeap(year)){
                sum += 1;
            }
            System.out.println(sum);
        }
    }

    // 判断是都闰年
    public static boolean isLeap(int n){
        if(n % 4 == 0 && n % 100 != 0 || n % 400 == 0){
            return true;
        }else{
            return false;
        }
    }
}
28.尼科彻斯定理 
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            int n = in.nextInt();
            long sum = (long)Math.pow(n,3);
            int a1 = (int)sum/n - (n - 1);
            StringBuilder sb = new StringBuilder(Integer.toString(a1));
            for(int i = 1; i < n; i++){
                a1 = a1 + 2;
                sb.append("+");
                sb.append(a1);
            }
            System.out.println(sb);
        }
    }
}
29.整型数组合并 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int num1 = sc.nextInt();
            TreeSet<Integer> set = new TreeSet<>();
            for(int i=0;i<num1;i++){
                set.add(sc.nextInt());
            }
            int num2 = sc.nextInt();
            for(int i=0;i<num2;i++){
                set.add(sc.nextInt());
            }
            for(int temp:set){
                System.out.print(temp);
            }
            System.out.println();
        }
        sc.close();
    }
}
30.字符串字符匹配 
public class Main {

    public Main() {
    }

    public boolean isAllCharExist(String s1, String s2) {
        Set<Character> set = new HashSet<>();
        for (char ch : s2.toCharArray()) {
            set.add(ch);
        }
        for (char ch : s1.toCharArray()) {
            if (!set.contains(ch)) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Main solution = new Main();
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {
            String s1 = in.nextLine();
            String s2 = in.nextLine();
            boolean res = solution.isAllCharExist(s1, s2);
            System.out.println(res);
        }
    } 
}
31.二维数组操作 
public class Main {

    public static void main(String[] args) throws IOException {
        fx();
    }

    //region	83	二维数组操作
    private static void fx() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = null;
        while((str = br.readLine()) != null) {
            String[] strs = str.split(" ");
            //1. 行和列
            int row = Integer.parseInt(strs[0]);
            int column = Integer.parseInt(strs[1]);
            if(row >= 0 && row <= 9 && column >= 0 && column <= 9) {
                System.out.println("0");
            } else {
                System.out.println(-1);
            }

            //2.单元格的 行 列值
            String[] values = br.readLine().split(" ");
            int rowValue1 = Integer.parseInt(values[0]);
            int columnValue1 = Integer.parseInt(values[1]);
            // values = br.readLine().split(" ");
            int rowValue2 = Integer.parseInt(values[2]);
            int columnValue2 = Integer.parseInt(values[3]);
            if(rowValue1 >= 0 && rowValue1 < row && rowValue2 >= 0 && rowValue2 < row
                    && columnValue1 >= 0 && columnValue1 < column && columnValue2 >= 0 && columnValue2 < column) {
                System.out.println(0);
            } else {
                System.out.println(-1);
            }
            //3. 插入的行 的值  
            int insertRowValue = Integer.parseInt(br.readLine());
            if(insertRowValue >= 0 && insertRowValue < row && (row + 1) <= 9) {
                System.out.println(0);
            } else {
                System.out.println(-1);
            }
            //4. 插入的列 值
            int insertColumnValue = Integer.parseInt(br.readLine());
            if(insertColumnValue >= 0 && insertColumnValue < column && (column + 1) <= 9) {
                System.out.println(0);
            } else {
                System.out.println(-1);
            }
            //5. 运动轨迹的单元格
            strs = br.readLine().split(" ");
            int x = Integer.parseInt(strs[0]);
            int y = Integer.parseInt(strs[1]);
            if(x >= 0 && x < row && y >= 0 && y < column) {
                System.out.println(0);
            } else {
                System.out.println(-1);
            }
        }
        br.close();
    }
}
32.统计大写字母个数 
public class Main {
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        while(input.hasNext()){
            String s = input.nextLine();
            System.out.println(count(s));
        }
    }
    public static int count(String s){
        int count=0;
        char[] cs=s.toCharArray();
        for(char c:cs){
            if(c>='A' && c<='Z'){
                count++;
            }
        }
        return count;
    }
}
33.最长回文子串 
public class Main {
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        String s = input.nextLine();
        int max = 0;
        /**
        *双指针遍历找到最长子串
        */
        for (int i = 0; i < s.length(); i++) {
            for (int j = s.length(); j > i; j--) {
                String cur= s.substring(i, j);
                if (isPalindromeString(cur)) {
                    max = Math.max(max, j - i);
                }
            }
        }
        System.out.print(max);
    }
    
    /**
    *判断一个字符串是否是回文字符串的方法
    */
    static boolean isPalindromeString(String s) {
        return s.equals(new StringBuilder(s).reverse().toString());
    }
}
34.求最大连续bit数 
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNextInt()){
            int num = in.nextInt();
            int max = 0;
            int count = 0;
            while(num != 0){
                if((num&1) == 1){
                    count++;
                    max = Math.max(max,count);
                }
                else{
                    count = 0;
                }
                num >>>= 1;
            }
            System.out.println(max);
        }
    }
}
35.密码强度等级 
public class Main {
    /**
     *
     *  score 分数
     *  upCount 大写字母数目
     *  lowCount 小写字母数目
     *  numCount 数字数目
     *  sigCount 符号数目
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNextLine()){
            char[] ch = in.nextLine().toCharArray();
            int score = 0;

            //统计长度
            int len = ch.length;
            if(len <= 4) score += 5;
            else if(len >4 && len < 8) score += 10;
            else score += 25;

            //遍历获取大小写字母、数字、符号数目
            int upCount = 0;
            int lowCount = 0;
            int numCount = 0;
            int sigCount = 0;

            for (int i = 0; i < len; i++) {
                if(Character.isUpperCase(ch[i])) ++upCount;
                else if(Character.isLowerCase(ch[i])) ++lowCount;
                else if(Character.isDigit(ch[i])) ++numCount;
                else ++sigCount;
            }

            //字母分数
            if((upCount > 0 && lowCount == 0) || (upCount == 0 && lowCount > 0)) score += 10;
            else if(upCount > 0 && lowCount > 0) score += 20;
            else score += 0;

            //数字分数
            if(numCount == 1) score += 10;
            else if(numCount > 1) score += 20;
            else score += 0;

            //符号分数
            if(sigCount == 1) score += 10;
            else if(sigCount > 1) score += 25;
            else score += 0;

            //奖励分数
            if (numCount > 0 && upCount > 0 && lowCount > 0 && sigCount > 0) score += 5;
            else if(numCount > 0 && sigCount > 0 &&(upCount >0 || lowCount >0)) score += 3;
            else if(numCount > 0 &&(upCount >0 || lowCount >0)) score += 2;

            //评分
            if(score >= 90) System.out.println("VERY_SECURE");
            else if(score >= 80) System.out.println("SECURE");
            else if(score >= 70) System.out.println("VERY_STRONG");
            else if(score >= 60) System.out.println("STRONG");
            else if(score >= 50) System.out.println("AVERAGE");
            else if(score >= 25) System.out.println("WEAK");
            else System.out.println("VERY_WEAK");
        }
    }
}
36.走方格的方案数 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextInt()) {
            int m = sc.nextInt();
            int n = sc.nextInt();
            System.out.println(cal(m,n));
        }
        
    }
     private static int cal(int m,int n){
        if(m==1 || n== 1){
            return m+n;
        }
        return cal(m-1,n)+cal(m,n-1);
    }
}
37.记票统计 
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            //初始化
            int numOfCandidates = in.nextInt();
            in.nextLine();//指针移到下一行开头
            String[] nameOfCandidates = in.nextLine().split(" ");
            int numOfVotes = in.nextInt();
            in.nextLine();//指针移到下一行开头
            String[] voteFor = in.nextLine().split(" ");
            Map<String,Integer> dict = new HashMap<>();
            int invalid = 0;
            for(int i = 0; i < numOfCandidates; i++){
                dict.put(nameOfCandidates[i],0);
            }
            //计数
            for(int j = 0; j < numOfVotes; j++){
                if(!dict.containsKey(voteFor[j])){
                    invalid++;
                }
                else{
                    Integer pre = dict.get(voteFor[j]);
                    dict.put(voteFor[j],pre + 1);
                }
            }
            //输出结果
            StringBuilder res = new StringBuilder();
            for(String s : nameOfCandidates){
                res.append(s);
                res.append(" : ");
                res.append(dict.get(s));
                res.append("\n");
            }
            res.append("Invalid : ");
            res.append(invalid);
            System.out.println(res);
        }
    }
}
38.表示数字 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String input = scanner.next();
            //把所有的数字段提取出来，前后加上星号再放回去
            System.out.println(input.replaceAll("([0-9]+)", "*$1*")); 
        }
    }
}
39.记负均正 
public class Main {
 public static void main(String[] args){
     Scanner sc=new Scanner(System.in);
     while(sc.hasNext()){
         int sum=Integer.parseInt(sc.nextLine());
         String[] strs=sc.nextLine().trim().split(" ");
         List<Integer> list=new ArrayList<Integer>();
         for(String i:strs){
             list.add(Integer.parseInt(i));
         }
         int count=0;
         int total=0;
         int n=0;
         for(int j=0;j<list.size();j++){
             if(list.get(j)>0){
                 count=count+list.get(j);
                 n++;
             }else if(list.get(j)<0){
                 total++;
             }
         }
         System.out.print(total+" "+Math.round(count*10.0/n)/10.0);
         System.out.println();
     }
 }       
}
40.自守数 
public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            int count = 0;
            for(int i=0;i<=n;i++){
                int sum =i*i;
                String s1 = String.valueOf(i);
                String s2 = String.valueOf(sum);
                //从平方的尾部往前截取到与当前数长度相同的子串
                if(s2.substring(s2.length()-s1.length()).equals(s1)){
                    count++;
                }
            }
            System.out.println(count);
        }
    }
}
41.等差数列

通项公式：

an=a1+(n−1)d

前n项和：

Sn=n(a1+an)/2

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int length = sc.nextInt(); // n
            int first = 2, last = 3 * length - 1; // a1, an
            System.out.println((first + last) * length / 2);
        }
        sc.close();
    }
}
42.字符统计 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            System.out.println(count(sc.nextLine()).toString());
        }
    }
    public static StringBuilder count(String str) {
        char[] strArray = str.toCharArray();
        int[] chArray = new int[129];
        //字符对应ascll码值下标元素自增来统计数量
        for (char i : strArray)
            chArray[(int)i]++;
        int max = 0;
        //找出字符数量最多的ascll码值
        for (int i = 0; i < chArray.length; i++)
            if (max < chArray[i])
                max = chArray[i];
        StringBuilder sb = new StringBuilder();
        //按数量从大到小添加到可变字符序列sb
        while (max != 0) {
            for (int i = 0; i < chArray.length; i++)
                if (chArray[i] == max)
                    sb.append((char)i);
            max--;
        }
        return sb;
    }
}
43.字符逆序 
public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        String input = scan.nextLine();
        StringBuilder res = new StringBuilder(input);
        System.out.println(res.reverse());
    }
}
44.求最小公倍数

欧几里得求最大公约数gcd(a,b)，根据公式:最小公倍数lcm=a*b / gcd(a,b)
在这里插入图片描述

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int a=in.nextInt();
        int b=in.nextInt();
        System.out.println(a*b/gcd(a,b));
    }

    private static int gcd(int a, int b) {
        return b==0?a:gcd(b,a%b);
    }
}
45.句子逆序 
public static void main(String[] args) {
   Scanner in=new Scanner(System.in);
   String str=in.nextLine();
   String s[]=str.split(" ");
   for(int i=s.length-1;i>=0;i--)
       if(i!=0)
           System.out.print(s[i]+" ");
       else
           System.out.print(s[i]);
}
46.字符串排序 
import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        withPriorityQueue();
    }

    // 方法一: 调用API Arrays.sort
    public static void withArraysAPI() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        String[] ss = new String[n];
        for (int i = 0; i < n; i++) {
            ss[i] = br.readLine();
        }
        br.close();

        Arrays.sort(ss);

        for(int i = 0; i < n; i++) {
            System.out.println(ss[i]);
        }
    }

    // 方法二: 使用PriorityQueue
    public static void withPriorityQueue() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        PriorityQueue<String> pq = new PriorityQueue<>();
        String s = "";
        while ((s = br.readLine()) != null) {
            pq.offer(s);
        }
        br.close();

        while (!pq.isEmpty()) {
            System.out.println(pq.poll());
        }        
    }

    // 方法三: 使用list并自己实现Comparator, 比较能体现算法的思路
    public static void withComparator() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        List<String> list = new ArrayList<>();
        String s = "";
        while ((s = br.readLine()) != null) {
            list.add(s);
        }
        br.close();

        list.sort(new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                int i = 0;
                while (i < s1.length() && i < s2.length()) {
                    if (s1.charAt(i) != s2.charAt(i)) {
                        return (s1.charAt(i) > s2.charAt(i))? 1: -1;
                    }
                    i++;
                }
                if (s1.length() == s2.length()) {
                    return 0;
                } else {
                    return (s1.length() > s2.length())? 1: -1;
                }
            }
        });

        for(int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }  
}
phial03
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【牛客网-在线编程-Python入门篇】——开篇介绍
学Python的小白！
08-09 1万+
牛客网，是一个集笔面试系统、题库、课程教育、社群交流、招聘内推于一体的招聘类网站。
牛客网在线编程系统（OJ在线编程常见输入输出）javascript语言输入输出相关
leilei7407的博客
04-19 3745
在牛客网刷各大厂校招真题的时候，最头疼的就是输入数据的读取和结果的输出。牛客网在线判题使用帮助链接 在牛客网刷编程题的时候，编译器提供的是Javascript(v8 6.0.0)，在线编程部分前端编程还好，只用在题目给出的函数中补充就行。但我们不知道如何像C/C++这样实现输入，类似于C的scanf 和 C++的cin函数。因为平时JavaScript基本都是函数式编程，就是将程序全都封装在函数里面，然后再调用函数，通过console控制台或者node控制台查看结果。前提是，输入已经指定了。于是乎，牛客网.
牛客在线编程-华为机试-中等
feiyan的博客
04-04 1291
题号 题目 知识点 难度 通过率 HJ16 购物单 动态规划 中等 21.21% HJ17 坐标移动 字符串 中等 24.79% HJ20 密码验证合格程序 数组 字符串 模拟 中等 28.91% HJ24 合唱队 队列 动态规划 中等 26.04% HJ26 字符串排序 字符串 排序 中等 36.80% HJ27 查找兄弟单词 中等 21.10% HJ29 字符串加解密 字符串 模拟 中等 27.18% HJ32...
华为机试在线编程（二）
Bidding
07-19 1073
1、题目描述 开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。 处理： 1、 记录最多8条错误记录，循环记录，对相同的错误记录（净文件名称和行号完全匹配）只记录一条，错误计数增加； 2、 超过16个字符的文件名称，只记录文件的最后有效16个字符； 3、 输入的文件可能带路径，记录文件名称不能带路径。 输入描述: 一行或多行字符串。每行包括带路径文件名称，行号
两道华为在线编程题
奋斗豆角的博客
07-06 1670
华为在线编程题 1、输出100至1000以内的水仙花数 2、假设电报中用（.）表示1，用中划线（-）表示0，点与中划线的序列，能够编译成一个二进制数
凉小秋的牛客日记-华为机试
05-18
凉小秋的牛客日记-华为机试
牛客华为机试10道题答案c++.zip
01-05
牛客华为机试10道题答案c++.zip，适合华为机试的朋友，题目在注释部分，C++语言编写的，部分题有写了多种解法 1、快递运输 2、TLV解码 3、考勤信息 4、字符串分割 5、组成最大数 6、高矮个子排队 7、猴子爬山 8、...
牛客华为1机试10道题答案C++.zip
01-05
牛客华为1机试10道题，使用C++语言，适合准备华为机试的朋友。均在本地IDE运行通过。 1、求解连续数列 2、查找众数及中位数 3、寻找相同子串 4、字符串统计 5、磁盘容量排序 6、太阳能板最大面积 7、靠谱的车 8、...
华为 OD 机试真题部分题解+全部题解见《华为机试真题》专栏
04-10
机试题专栏 题目来自牛客平台机考同学的机试分享，题目描述信息可能记录不完整，题解无法保证通过率，只提供结题思路，注意！注意！！不要直接使用博主代码进行机考！ 欢迎加微信: Ayemmar 本文解法非最优解
牛客的代码leetcode代码区别-niuke:牛客
06-30
牛客的代码leetcode代码区别 niuke
华为实习编程测试题解（2018-03-21）
carson0408的博客
03-21 3421
        做了华为的三道编程题，以下是题解：1.在字符串中找出连续最长的数字串题目大意：输入一个字符串，输出最长的连续数字字符串，并输出其长度，中间用逗号隔开。比如输入123abc，输出123,3另外，要求数字串中每个数字不要求按顺序，比如123ab2357中最长数字串应该是2357；而且，如果有多个最长串，则输出最后一个，比如123ab234，则答案输出是234,3。解题思路：首先用一个数...
2017年华为实习编程题
u013760355的博客
03-17 6485
2017年华为实习在线笔试编程题
华为OJ（购物单）
yiqiwangxi的专栏
08-18 3697
述 王强今天很开心，公司发给N元的年终奖。王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：主件附件电脑打印机，扫描仪书柜图书书桌台灯，文具工作椅无如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。王强想买的东西很多，为了不超出预算，他把每件物品规定
HUAWEI在线编程题库180题
Test Oracle
07-20 2565
华为在线编程题库180题 写这个单纯就是一个记笔记的作用，还有就是可以总结一些新奇的思路。 题库链接华为机试 在线训练
《华为机试在线训练》之数字颠倒
阿黄啦啦
03-10 884
一，题目要求：     1，题目描述：输入一个整数，将这个整数以字符串的形式逆序输出，程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001     2，输入描述：输入一个int整数     3，将这个整数以字符串的形式逆序输出     4，输入例子：1516000     5，输出例子：0006151 二，题目分析：       1，第一种情况  
牛客网最全在线笔试、编程攻略(建议收藏)
热门推荐
a934079371的博客
09-12 2万+
来源：牛客网整理：大数据肌肉猿一、常见问题设备问题问: 浏览器使用问题？答：浏览器推荐使用最新版本的Chrome或者火狐浏览器，如果某一浏览器出现问题可以换个浏览器重新打开页面。问: 摄...
牛客网在线编程----算法入门篇
大白的博客
03-27 1919
标题本篇博文主要是记录下自己的在线编程情况，大家有需要可以去牛客网上面多练练！有需戳–>牛客网在线编程 NC103、题目描述 写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000） 示例1： 输入"abcd" 返回值"dcba" 解题分析：我主要是通过对str倒序循环，把要倒序的字符串倒着赋值给另一个 字符串result，最后返回result。 //个人代码 class Solution { public: string solve(string str
牛客网华为机试题库系列----python3
gh0stf1re的博客
02-26 1711
HJ108 求最小公倍数 有两个数a、b，我的想法是先求最大公约数，然后用他们的积除以最大公约数，就可以得到最小公倍数 使用欧几里得算法（又叫辗转相除法） 算法的介绍以及推导见OI-WIKI-最大公约数 def gcd(a, b): # 欧几里得算法求最大公约数 if a < b: a, b = b, a if a % b == 0: return b if b == 0: return a return gcd(b, a
牛客网在线编程输入多行
maoyeqiu的专栏
08-02 9576
import java.util.HashMap; import java.util.Map; import java.util.Random; import java.util.Scanner; public class HelloWorld{ public static void main(String[] args){ Scanner in = new Sc
牛客华为机试题库 c++
最新发布
07-29
牛客网是一个面向程序员的在线...总之，牛客华为机试题库C是一个有益于C语言学习和华为面试备考的资源，通过做题和参考题解，可以提高候选人的编程能力和竞争力，也可以帮助企业和招聘人员更好地进行招聘和选拔工作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

phial03

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值