牛客网华为机试java版

最新推荐文章于 2024-06-18 08:30:00 发布
最新推荐文章于 2024-06-18 08:30:00 发布
阅读量785 收藏 15
点赞数 15
分类专栏： 计算机 文章标签： 华为 java 牛客网 机试 三道题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiangshangdemayi/article/details/139417993
版权

目录

HJ1 字符串最后一个单词的长度

在这里插入图片描述
方法1：用时20ms

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        if(s.length() > 5000)return;
        Integer index = s.lastIndexOf(" ");
        String word = s.substring(index+1);
        System.out.print(word.length());
    }
}

方法2：用时8ms

import java.util.Scanner;
import java.io.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException{
        InputStream inputStream = System.in ;
        int length=0;
        char c;
        while('\n' != (c=(char)inputStream.read())){
            length ++ ;
            if(c == ' '){
                length = 0;
            }
        }
        System.out.println(length);
    }
}

HJ2 计算某字符出现次数

在这里插入图片描述
方法1：用时30ms

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        // Scanner in = new Scanner(System.in);
        // String first = in.nextLine();
        // char second = in.next().charAt(0);
        // int times = 0;
        // for(int i=0;i<first.length();i++){
        //     char te = first.charAt(i);
        //     if(second == te || second == te - 32 || second == te+32){
        //         times++;
        //     }
        // }
        // System.out.print(times);

        Scanner in = new Scanner(System.in);
        String s = in.nextLine().toLowerCase();
        String b = in.nextLine().toLowerCase();
        System.out.println(s.length() - s.replaceAll(b, "").length());
    }
}

方法2：用时6ms

import java.io.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException {
        int count = 0;
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        char[] first = bufferedReader.readLine().toLowerCase().toCharArray();
        char[] second = bufferedReader.readLine().toLowerCase().toCharArray();
        char tar = second[0];
        for(char c : first){
            if(c == tar){
                count++;
            }
        }
        System.out.print(count);
    }
}

HJ3 明明的随机数

在这里插入图片描述

方法1：用时10ms

import java.io.*;
import java.util.Arrays;
import java.util.HashMap;
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(
                System.in));
        Integer n = Integer.parseInt(bufferReader.readLine());
        HashMap<String, String> hashMap = new HashMap<String, String>();

        for (int i = 0; i < n; i++) {
            String str = bufferReader.readLine();
            if (str != null) {
                if (!hashMap.containsKey(str)) {
                    hashMap.put(str, "");
                }
            }
        }
        Object[] keyArray = hashMap.keySet().toArray();
        Integer[] list = new Integer[keyArray.length];
        for (int i = 0; i < keyArray.length; i++) {
            list[i] = Integer.parseInt(keyArray[i].toString());
        }
        Arrays.sort(list);
        for (int i : list) {
            System.out.println(i);
        }
    }
}

方法2：用时8ms

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

	public static void main(String[] args) throws IOException {
		
		BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
		String str;
		while((str=bf.readLine())!=null)
		{
            
			boolean[] stu=new boolean[1001];
			StringBuilder sb=new StringBuilder();
			int n=Integer.parseInt(str);
			for(int i=0;i<n;i++)
				stu[Integer.parseInt(bf.readLine())]=true;
			for(int i=0;i<1001;i++)
				if(stu[i])
					sb.append(i).append("\n");
			sb.deleteCharAt(sb.length()-1);
			System.out.println(sb.toString());
		}
	}
}

HJ4 字符串分隔

在这里插入图片描述
方法1：用时9ms

import java.io.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(System.in));
        String str = bufferReader.readLine();
        int length = str.length();
        if((length % 8)<8 && (length % 8)!=0){
            int n = 8-(length % 8);
            for(int i=0;i<n;i++){
                str+="0";
            }
           
        }
        char[] arr = str.toCharArray();
        String temp = "";
        for(int i=0;i<arr.length;i++){
            temp+=arr[i];
            if((i+1)%8 == 0){
                System.out.println(temp);
                temp = "";
            }
        }
    }
}

方法2：用时6ms

import java.io.*;

public class Main{
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str;
        while((str = br.readLine())!=null){
            int len = str.length();
            int start = 0;
            while (len >= 8){
                System.out.println(str.substring(start, start + 8));
                start += 8;
                len -= 8;
            }
            if (len > 0) {
                char[] tmp = new char[8];
                for(int i = 0;i<8;i++){
                    tmp[i]='0';
                }
                for(int i = 0; start < str.length(); i++) {
                    tmp[i] = str.charAt(start++);
                }
                System.out.println(String.valueOf(tmp));
            }
        }
    }
}

HJ5 进制转换

方法1：用时9ms

import java.io.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(System.in));
        String str = bufferReader.readLine();
        if(str.startsWith("0x")){
            Long n = Long.parseLong(str.substring(2),16);
            System.out.println(n);
        }else{
            Long n = Long.parseLong(str,16);
            System.out.println(n);
        }
    }
}

方法2：用时5ms

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


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

        // 先读取控制台输入
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String str;

        char[] num_arr =new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

        while (null != (str = reader.readLine())) {
            // 取出 0x 后面的字符串
            String hexNum = str.substring(2);
            // 字符串长度，可以用来表示位数
            int digit = hexNum.length();
            // 存放十进制结果
            int result = 0;
            for (int i = 0; i < digit; i++) {
                char cur_char = hexNum.charAt(i);
                int cur_num = indexOf(num_arr, cur_char);
                result += cur_num * Math.pow(16, digit - i - 1);
            }
            System.out.println(result);
        }
    }

    public static int indexOf(char[] arr, char num) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                return i;
            }
        }
        return 0;
    }
    
}

HJ6 质数因子

在这里插入图片描述
方法1：用时10ms

import java.io.*;

import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(System.in));
        String str = bufferReader.readLine();
        Integer num = Integer.parseInt(str);
        printPrimeFactors(num);

    }
    public static void printPrimeFactors(int number) {
        while(number % 2 == 0){
            System.out.print(2+" ");
            number /= 2;
        }
        for(int i=3;i<=Math.sqrt(number);i+=2){
            while(number % i == 0){
                System.out.print(i+" ");
                number /= i;
            }
        }
        if(number>2){
            System.out.print(number);
        }

    }
}

方法2：用时6ms

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str;
        while ((str = br.readLine()) != null) {
            int num = Integer.parseInt(str);
            StringBuilder sb = new StringBuilder();
            for (int i = 2; i <= Math.sqrt(num); i++) {
                if (num % i == 0) {
                    sb.append(i).append(" ");
                    num = num / i;
                    i--;
                }
            }
            sb.append(num).append(" ");
            System.out.println(sb.toString());
        }
    }
}

HJ7 取近似值

在这里插入图片描述
方法1：用时8ms

import java.io.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(System.
        in));
        String str = bufferReader.readLine();        
        double num = Double.parseDouble(str);
        int res = (int)num;
        if(num-res >= 0.5){
            System.out.println(res+1);
        }else{
            System.out.println(res);
        }

    }
}

方法2：用时9ms

import java.util.*;
import java.io.*;
public class Main {
    public static void main(String args[])throws Exception{
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String str = bf.readLine();
        int index = str.indexOf(".");
        int a = Integer.parseInt(str.substring(0, index));
        int b = Integer.parseInt(str.substring(index + 1, index + 2));
        if(b >= 5){
            a++;
            System.out.println(a);
        }else{
            System.out.println(a);

        }
    }
}

HJ8 合并表记录

在这里插入图片描述
方法1：用时11ms

import java.io.*;
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(System.in));
        String str = bufferReader.readLine();
        int num = Integer.parseInt(str);
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        while((str = bufferReader.readLine())!= null){
            String[] arr = str.split(" ");
            Integer key = Integer.parseInt(arr[0]);
            Integer value = Integer.parseInt(arr[1]);
            if(!map.containsKey(key)){
                map.put(key,value);
            }else{
                map.put(key,map.get(key)+value);
            }
        }
        Integer[] keys = map.keySet().toArray(new Integer[0]);
        Arrays.sort(keys);
        for(Integer i : keys){
            System.out.println(i+" "+map.get(i));
        }
    }
}

方法2：用时8ms

import java.util.*;
import java.io.*;
public class Main {
    public static void main(String[] args) throws Exception{
         StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        st.nextToken();      // 分隔符
        int n = (int) st.nval;   // 强转
        int[] arr = new int[n];
 
        for (int i = 0; i < n; i++) {
            st.nextToken();
            int key = (int) st.nval;
            st.nextToken();
            int value = (int) st.nval;
            arr[key] = arr[key] + value;
        }
 
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length ; i++) {
            if(arr[i] != 0){
                sb.append(i).append(" ").append(arr[i]).append("\n");
            }
        }
        System.out.println(sb.toString());
    }
}

题目貌似没说key是连续的，可以使用TreeMap代替普通的数组实现，无非都想要自带的排序效果。

HJ9 提取不重复的整数

方法1：用时10ms

import java.io.*;

import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args)throws IOException {
        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(System.in));
        String str = bufferReader.readLine();
        HashMap<Integer,Boolean> map = new HashMap<Integer,Boolean>();
        char[] arr = str.toCharArray();
        for(int i = arr.length-1;i>=0;i--){
            Integer key = Integer.parseInt(arr[i]+"");
            if(!map.containsKey(key)){
                map.put(key,true);
                System.out.print(key);
            }
        }

    }
}

方法2：用时5ms

import java.io.InputStream;

public class Main {

    public static void main(String[] args) throws Exception {
        InputStream in = System.in;
        int available = in.available()-1;
        char[] chars = new char[available];
        while (available-- > 0) {
            chars[available] = (char) in.read();
        }
        StringBuilder resul = new StringBuilder();
        for (int i = 0; i < chars.length; i++) {
            if (resul.lastIndexOf(String.valueOf(chars[i])) != -1){
                continue;
            }
            resul.append(chars[i]);
        }
          System.out.println(resul.toString());
    }

}

HJ26 字符串排序

在这里插入图片描述
方法1：用时7ms

import java.util.*;

import java.io.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args)throws IOException {
        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(System.in));
        String str = bufferReader.readLine();
        StringBuilder sb = new StringBuilder();
        for (int j = 0; j < str.length(); j++) {
            char ch = str.charAt(j);
            if ((ch >= 65 && ch <=90) || (ch >= 97 && ch <= 122)) {
                sb.append('0');
            } else {
                sb.append(ch);
            }

        }
        for (int i = 65; i < 97; i++) {
            int m = 0;
            for (int j = 0; j < str.length(); j++) {
                char ch = str.charAt(j);
                char nch = sb.charAt(m);
                if (ch == i || ch == i + 32) {
                    if (nch == '0') {
                        sb.setCharAt(m, ch);
                        while(m<str.length()){
                            m++;
                            nch = sb.charAt(m);
                            if(nch == '0'){
                                break;
                            }
                        }
                    } else {
                        int n = m + 1;
                        while (n < str.length()) {
                            nch = sb.charAt(n);
                            if (nch == '0') {
                                sb.setCharAt(n, ch);
                                m++;
                                break;
                            }
                            n++;
                        }
                    }


                }
            }
        }
        System.out.print(sb.toString());

    }
}

方法2：用时6ms

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main{
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s;
        while((s = br.readLine()) != null){
            char[] ch = s.toCharArray();
            char[] chars = new char[ch.length];
            int flag = 65, j=0;
            while(flag<=90){
                for(int i=0; i<ch.length; i++){
                    if((ch[i]>=65&&ch[i]<=90) || (ch[i]>=97&&ch[i]<=122)){
                        if(ch[i]==flag || ch[i]== flag+32){
                            chars[j] = ch[i];
                            j++;
                        }
                    }
                }
                flag++;
            }
            
            j=0;
            for(int i=0; i<ch.length; i++){
                 if((ch[i]>=65&&ch[i]<=90) || (ch[i]>=97&&ch[i]<=122)){
                     ch[i] = chars[j];
                     j++;
                 }
            }
            System.out.println(String.valueOf(ch));
        }
    }
}

HJ80 整型数组合并

在这里插入图片描述
方法1：用时10ms

import java.util.*; 

import java.io.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(System.in));
        Integer first = Integer.parseInt(bufferReader.readLine());
        Integer[] firstArr = new Integer[first];
        String[] firstStrArr = bufferReader.readLine().split(" ");
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i=0;i<first;i++){
            firstArr[i] = Integer.parseInt(firstStrArr[i]);
            if(!map.containsKey(firstArr[i])){
                map.put(firstArr[i],0);
            }
            
        }
        Integer second = Integer.parseInt(bufferReader.readLine());
        Integer[] secondArr = new Integer[second];
        String[] secondStrArr = bufferReader.readLine().split(" ");
        for(int i=0;i<second;i++){
            secondArr[i] = Integer.parseInt(secondStrArr[i]);
           if(!map.containsKey(secondArr[i])){
                map.put(secondArr[i],0);
            }
        }
        Integer[] res = map.keySet().toArray(new Integer[0]);
        Arrays.sort(res);
        for(Integer i:res){
            System.out.print(i);
        }
       
    }
}

方法2：用时9ms

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
  
public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = br.readLine()) != null && line.length() > 0) {
            String[] strs = br.readLine().split(" ");
            int[] array1 = new int[strs.length];
            for (int i = 0; i < array1.length; ++i)
                array1[i] = Integer.parseInt(strs[i]);
  
            line = br.readLine();
            strs = br.readLine().split(" ");
            int[] array2 = new int[strs.length];
            for (int i = 0; i < array2.length; ++i)
                array2[i] = Integer.parseInt(strs[i]);
  
            System.out.println(combineBySort(array1, array2));
  
        }
    }
  
    static String combineBySort(int[] array1, int[] array2) {
        int[] outPut = new int[array1.length + array2.length];
        Arrays.sort(array1);
        Arrays.sort(array2);
  
        int M = array1.length, R = array2.length;
        int idx = 0, i = 0, j = 0;
        if (array1[i] > array2[j]) {
            outPut[idx++] = array2[j++];
        } else if (array1[i] < array2[j]) {
            outPut[idx++] = array1[i++];
        } else {
            outPut[idx++] = array1[i++];
            j++;
        }
        while (i < M && j < R) {
            if (array1[i] > array2[j]) {
                if (outPut[idx - 1] != array2[j])
                    outPut[idx++] = array2[j];
                ++j;
            } else if (array1[i] < array2[j]) {
                if (outPut[idx - 1] != array1[i])
                    outPut[idx++] = array1[i];
                ++i;
            } else {
                if (outPut[idx - 1] != array1[i])
                    outPut[idx++] = array1[i];
                ++i;
                ++j;
            }
        }
  
        if (i == M) {
            while( j < R){
                if (outPut[idx - 1] != array2[j])//去重
                    outPut[idx++] = array2[j];
                j++;
            }
                
        } else {
            for (; i < M; ++i)
                if (outPut[idx - 1] != array1[i])
                    outPut[idx++] = array1[i];
        }
  
        StringBuilder sb = new StringBuilder();
        for (i = 0; i < idx; ++i)
            sb.append(outPut[i]);
  
        return sb.toString();
    }
  
}

HJ101 输入整型数组和排序标识，对其元素按照升序或降序进行排序

在这里插入图片描述
方法1：用时11ms

import java.util.*;

import java.io.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args)throws IOException {
        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(System.in));
        Integer sum = Integer.parseInt(bufferReader.readLine());
        Integer[] arrInt = new Integer[sum];
        String[] arrStr = bufferReader.readLine().split(" ");
        for(int i=0;i<arrInt.length;i++){
            arrInt[i] = Integer.parseInt(arrStr[i]);
        }
        Integer sort = Integer.parseInt(bufferReader.readLine());
        Arrays.sort(arrInt);
        if(sort == 0){
            for(int i =0;i<arrInt.length;i++){
                System.out.print(arrInt[i]+" ");
            }
        }else{
            for(int i =arrInt.length-1;i>=0;i--){
                System.out.print(arrInt[i]+" ");
            }
        }
    }
}

方法2：用时13ms

/**
 * @FileName: Test
 * @Author: KipFcrs
 * @Date: 2020/8/3 16:27
 */

import java.util.*;
import java.io.*;

public class Main {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String inputCount;

        while ((inputCount = br.readLine()) != null) {
            int count = Integer.parseInt(inputCount);
            String[] input = br.readLine().split(" ");
            int flag = Integer.parseInt(br.readLine());
            int[] num = new int[input.length];
            for (int i = 0; i < input.length; i++) {
                num[i] = Integer.parseInt(input[i]);
            }
            quickSort(num,0,num.length - 1);
            StringBuilder sb = new StringBuilder();
            if(flag == 0){
                for (int j = 0; j < num.length; j++) {
                    sb.append(num[j]).append(" ");
                }
            }else{
                for (int k = num.length - 1; k >= 0; k--) {
                    sb.append(num[k]).append(" ");
                }
            }
            System.out.println(sb.substring(0,sb.length()-1));
        }

    }

    public static void quickSort(int[] num, int L, int R) {
        if (L >= R) {
            return;
        }
        int p = partition(num, L, R);
        quickSort(num, L, p - 1);
        quickSort(num, p+1, R);
    }

    public static int partition(int[] num, int L, int R) {
        int key = num[L];
        int pivot = L;

        for (int i = L + 1; i <= R; i++) {
            if (num[i] < key) {
                int temp = num[++pivot];
                num[pivot] = num[i];
                num[i] = temp;
            }
        }
        int tt = num[pivot];
        num[pivot] = num [L];
        num[L] = tt;
        return pivot;
    }

}
AIGIS.
关注
  • 15
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
牛客网华为机试考试java_牛客网华为机试题（JavaScript）
weixin_34803977的博客
02-24 1343
华为机试题牛客网在javascript V8引擎下处理输入输出如下： 利用了readline()接收输入的每一行，多行处理可以用多个readline() 输出函数用print()和console.log()都可以，多个输出会根据print个数在拆解，或者使用 print(results+’\n’); 拆行文章目录华为机试题1. 字符串最后一个单词的长度2. 计算字符个数3. 明明的随机数4. 字符...
【华为机试】牛客网华为机试刷题总结C++/Java
sssssqwq的博客
05-23 353
利用STL库中的set的特性完成题目，即set中的key值是有序的且不允许重复。进制转换，从低位到高位计算。
牛客网华为机试题---HJ1
m0_52096807的博客
04-10 123
计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）输入：hello nowcoder，输出：8，说明：最后一个单词为nowcoder，长度为8。输入一行，代表要计算的字符串，非空，长度小于5000。输出一个整数，表示输入字符串最后一个单词的长度。
【Java】 牛客网华为机试108题汇总
张伟的专栏
11-30 2325
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），* 对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。* 写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
牛客网：华为机试刷题记录
qq_46119575的博客
07-19 883
本文主要是想记录一下华为机试刷题过程中的总结
牛客网华为机试考试java_牛客网——华为机试（题17：坐标移动）（Java）
weixin_34186408的博客
02-24 329
题目描述：开发一个坐标计算工具，A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从(0,0)点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。输入：合法坐标为A(或者D或者W或者S)+数字(两位以内)坐标之间以;分隔。非法坐标点需要进行丢弃。如AA10;A1A;$%$;YAD;等。下面是一个简单的例子如：A10;S20;W10;D3...
牛客网华为机试（python）
qq_43504837的博客
06-09 3392
牛客网华为机试（https://www.nowcoder.com/exam/oj/ta?tpId=37） 按难度分为入门，简单，中等，困难，较难五个等级HJ7 取近似值 HJ9 提取不重复的整数 提取到输入字符串后就对其进行倒置，排序时直接按ls1的顺序进行排列 HJ46 截取字符串 字符串切片 HJ58 输入n个整数，输出其中最小的k个 map()函数是为了初始化n,k以及列表中的str类型为int类型 最后输出的*nums[:k]是对num[:k]的解包。 HJ101 输入整型数组和排序标识，对其元素按
牛客网华为机试（持续更新ing）
HVACoder
04-11 4159
坐标移动 string str; string sub=str.substr(0,n);//取得str的子串，从0坐标开始总计n个字符 sub=str.substr(index);//取得子串，从index下标开始的后半部分子串 stoi(string);// string向int 的转换 str.find("xxx")!=string::npos; //找到了目标子串 //pair的初始化 vec.push_back({data1,data2}); vec.push_back(make_pair.
牛客网华为机试考试java_牛客网华为机试训练第3题 明明的随机数
weixin_29189381的博客
02-24 270
今天花了一下午才把明明的随机数这个搞明白,期间和牛客网的编译器殊死搏斗.一直发现在本地编译器运行成功,但是在牛客上的老师不能通过.整的十分的恼火和焦躁.后来看到了相同的问题,才发现解决之道.时间限制：1秒空间限制：32768K热度指数：222608本题知识点：数组题目描述明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数(N≤100...
华为机试108题源码（题目&&解答）
06-08
华为机试 ├─001 字符串最后一个单词长度 │ └─Source ├─002 计算字符个数 │ └─Source ├─003 明明的随机数 │ └─Source ├─004 字符串分隔 │ └─Source ├─005 进制转换 │ └─Source ├─006 质数...
牛客网-华为机试练习题1
08-04
前言在找工作笔试刷题的过程中，对于动态规划问题不熟悉，找了很多资料，最终发现知乎上的一个回答不错，这里对其进行简单总结。原回答链接如下：https://www.
华为OD机考100题，真题
06-05
华为OD机考100题
华为机试过的java题目
11-21
这里面包含了java的大部分的机试题，适合刚找工作的学习
华为OD机试矩阵扩散问题，
04-25
存在一个m*n的二维数组，其成员取值范围为0或1。其中值为1的成员具备扩散性，每经过1S，将上下左右值为0的成员同化为1。二维数组的成员初始值都为0， 将第[i,j]和[k,l]两个个位置上元素修改成1后，求矩阵的所有元素...
华为手环9省电设置
bineans的博客
06-17 694
如果您可以接受触摸屏幕或者按键亮屏，可通过手机“运动健康APP->设备->HUAWEI Band 9->设备设置->抬腕亮屏”路径关闭抬腕亮屏。（4）脉搏波心率失常分析：开启后佩戴手环期间会连续检测，可通过手机“运动健康APP->设备-> HUAWEI Band 9->脉搏波心律失常分析->点击右上角四个点->自动检测->心律失常自动检测”路径关闭。（2） 血氧自动检测：开启后佩戴手环期间会连续检测，可通过手机“运动健康APP->设备-> HUAWEI Band 9->健康监测->血氧自动检测”路径关闭；
RIP路由附加度量值（华为）
h11016616的博客
06-16 932
RIP（Routing Information Protocol）路由协议中的附加度量值是指在RIP路由原来度量值的基础上所增加的额外度量值，通常以跳数来表示。这个附加度量值可以是正值，也可以是负值，用于影响路由选择的过程。在某些场景下，网络管理员可能希望通过手动增加或减少特定路由的度量值来控制或优化路由路径。
openEuler 24.03 LTS - 华为欧拉开源版（华为 RHEL 兼容发行版）
最新发布
sysin | SYStem INside
06-18 878
openEuler 24.03 LTS - 华为欧拉开源版（华为 RHEL 兼容发行版）
牛客网华为机试js输入输出
08-24
根据引用，牛客网华为机试题解的JavaScript版本提供了第11到20题的解答。其中包括了数字颠倒、字符串反转、句子逆序、字符串排序、求int型数据在内存中存储时1的个数、购物单、坐标移动、识别有效的IP地址和掩码并进行分类统计、简单错误记录和密码验证合格程序。 根据引用，题目描述了如何将输入的整数以字符串的形式逆序输出。程序不考虑负数的情况，如果数字中包含0，逆序形式也会包含0。 根据引用，题目描述了如何计算输入的正整数在内存中存储时1的个数。题目要求输入一个整数（int类型），并将该数转换成二进制形式后输出其中1的个数。 需要注意的是，输入和输出的具体实现可能因题目而异，以上引用提供了一些示例代码，但并不代表所有题目的通用解法。正确的输入输出取决于具体题目的要求和所给代码的实现方式。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [JavsScript牛客网华为机试(11-20)题解](https://blog.csdn.net/weixin_43465339/article/details/110709521)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

AIGIS.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值