【Java】 牛客网华为机试108题汇总

2023-05-16


文章目录

目录

目录

1、求字符串最后一个单词长度

2、计算字符串个数

3、明明的随机数

4、字符串分割

5、进制转换

6、质数因子

7、HJ19 简单错误记录

8、HJ25 数据分类处理

9 HJ30 字符串合并处理



1、求字符串最后一个单词长度


计算字符串最后一个单词的长度,单词以空格隔开。

import java.util.Scanner;

/**
 * @Author: Stephen
 * @Date: 2020/3/21 13:24
 * @Content: 计算字符串最后一个单词的长度,单词以空格隔开。
 */
public class StrLength01 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while (input.hasNext()){
            String[] str = input.nextLine().split(" ",-1);
            System.out.println(str[str.length-1].length());
        }
    }
}


2、计算字符串个数


写出一个程序,接受一个由字母和数字组成的字符串,和一个字符,
然后输出输入字符串中含有该字符的个数。不区分大小写。

import java.util.Scanner;

/**
 * @Author: Stephen
 * @Date: 2020/3/21 14:17
 * @Content: 写出一个程序,接受一个由字母和数字组成的字符串,和一个字符,
 * 然后输出输入字符串中含有该字符的个数。不区分大小写。
 */
public class WordCount {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        String cha = input.nextLine();
        int count = 0;
        if (str != null && str.length()>0){
            for (int i=0;i<str.length();i++){
                if (cha.toLowerCase().charAt(0)==str.toLowerCase().charAt(i)){
                    count++;
                }
            }
        }
        System.out.println(count);
    }
}



3、明明的随机数


明明想在学校中请一些同学一起做一项问卷调查,为了实验的客观性,他先用计算机生成了N个1到1000之间的随机整数(N≤1000),
对于其中重复的数字,只保留一个,把其余相同的数去掉,不同的数对应着不同的学生的学号。
然后再把这些数从小到大排序,按照排好的顺序去找同学做调查。
请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据,希望大家能正确处理)。

方法一:arrayList+Collections

import java.util.*;

/**
 * @Author: Stephen
 * @Date: 2020/3/21 14:45
 * @Content:
 * 明明想在学校中请一些同学一起做一项问卷调查,为了实验的客观性,他先用计算机生成了N个1到1000之间的随机整数(N≤1000),
 * 对于其中重复的数字,只保留一个,把其余相同的数去掉,不同的数对应着不同的学生的学号。
 * 然后再把这些数从小到大排序,按照排好的顺序去找同学做调查。
 * 请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据,希望大家能正确处理)。
 */
public class RandomTest {
    public static void main(String[] args) {
         Scanner num = new Scanner(System.in);
        while (num.hasNext()){
            int number = num.nextInt();
            Set<Integer> numbers = new HashSet<Integer>();
            List<Integer> list = new ArrayList<Integer>();
            for (int i =0;i<number;i++){
                // 曲解了题意误以为随机输入是用随机数输入
//            Random rand = new Random();
//            int a=rand.nextInt(1001);
                numbers.add(num.nextInt());
            }
            for (int a:numbers){
                list.add(a);
            }
            Collections.sort(list);
            for (int a:list){
                Systems.out,println(a);
            }
        }
    }
}


方法二:treeset 去重
写的时候是用hashset去重再转arrayList排序,经阅读代码补充使用treeset直接去重排序treeset详解

import java.util.*;
public class RandomTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){

            int num = sc.nextInt();
            TreeSet<Integer> set = new TreeSet<Integer>();
            for(int i = 0 ; i < num ;i++){
                int curr = sc.nextInt();
                set.add(curr);
            }
            for(Integer i : set){
                System.out.println(i);
            }
        }
    }
}

方法三:Arrays+TreeSet

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

/**
 * Created by Administrator on 2022/11/29.
 */
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        while (sc.hasNext()) {
            int num = sc.nextInt();
            int[] arr = new int[num];
            //存数组
            for (int i = 0; i < num; i++) {
                arr[i] = sc.nextInt();
            }
            //升序
            Arrays.sort(arr);
            //set自带去重
            Set<Integer> set = new TreeSet<>();
            for (int i = 0; i < num; i++) {
                set.add(arr[i]);
            }
            //遍历输出
            for (Integer integer : set) {
                System.out.println(integer);
            }

        }
    }
}

方法四:有序TreeSet 

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

/**
 * Created by Administrator on 2022/11/29.
 */
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        while (sc.hasNext()) {
            int num = sc.nextInt();
            //set自带去重
            Set<Integer> set = new TreeSet<>();
            //存数组
            for (int i = 0; i < num; i++) {
                set.add(sc.nextInt());
            }
            //遍历输出
            Iterator iterator = set.iterator();
            while (iterator.hasNext()) {
                Integer element = (Integer) iterator.next();
                System.out.println(element);
            }
        }
    }
}


4、字符串分割


连续输入字符串,请按长度为8拆分每个字符串后输出到新的字符串数组;
长度不是8整数倍的字符串请在后面补数字0,空字符串不处理。

import java.util.Scanner;

/**
 * @Author: Stephen
 * @Date: 2020/3/21 15:38
 * @Content:
 * •连续输入字符串,请按长度为8拆分每个字符串后输出到新的字符串数组;
 * •长度不是8整数倍的字符串请在后面补数字0,空字符串不处理。
 */
public class StrSplit {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while (input.hasNext()){
            String str = input.nextLine();
            while (str.length()>=8){
                System.out.println(str.substring(0,8));
                str=str.substring(8);
            }
            if (str.length()<8 && str.length()>0){
                str = str+"0000000";
                System.out.println(str.substring(0,8));
            }
        }
    }
}


5、进制转换


写出一个程序,接受一个十六进制的数,输出该数值的十进制表示。(多组同时输入 )

import java.util.Scanner;

/**
 * @Author: Stephen
 * @Date: 2020/3/21 15:57
 * @Content:
 * 写出一个程序,接受一个十六进制的数,输出该数值的十进制表示。(多组同时输入 )
 */
public class SystemTransform {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        while(sc.hasNext()){
            String str = sc.nextLine();
            System.out.println(fun(str.substring(2)));
        }
    }

    public static int fun(String s){
        int n=0;
        int count= 0;
        int temp = 0;
        char ch;

        while(count<s.length())
        {
            ch = s.charAt(s.length()-count-1);
            if(ch>='0'&&ch<='9'){
                temp = ch-'0';
            }else if(ch>='A'&&ch<='Z'){
                temp = ch-'A'+10;
            }else if(ch>='a'&&ch<='z'){
                temp = ch-'a'+10;
            }else{
                break;
            }
            n += temp*Math.pow(16,count);
            count++;
        }

        return n;
    }
}


6、质数因子


输入一个正整数,按照从小到大的顺序输出它的所有质因子(如180的质因子为2 2 3 3 5 )
最后一个数后面也要有空格

package com.njbdqn.services;

import java.util.Scanner;

/**
 * @Author: Stephen
 * @Date: 2020/3/23 21:46
 * @Content:
 * 输入一个正整数,按照从小到大的顺序输出它的所有质因子(如180的质因子为2 2 3 3 5 )
 * 最后一个数后面也要有空格
 */
public class Primefactors {
    public static void main(String[] args) {
        public static void main(String [] args)
        {
            Scanner sc=new Scanner(System.in);
            long params=sc.nextLong();
            if(params<2)
            {
                sc.close();
                return ;
            }
            String result =getResult(params);
            System.out.println(result);
            sc.close();

        }
    }
    public static String getResult(long ulDataInput){
        StringBuilder str=new StringBuilder();
        int index=2;
        while(index<=ulDataInput)
        {
            if(ulDataInput%index==0){
                if(index==ulDataInput){
                    str.append(index).append(" ");
                    break;
                }else{
                    str.append(index).append(" ");
                    ulDataInput=ulDataInput/index;
                }
            }else
            {
                index++;
            }
        }
        return str.toString();
}

7、HJ19 简单错误记录

方法一:HashMap 方式 ,这个位置发生变化,需要借助数组方式保存进入顺序

import java.util.Scanner;
import java.lang.String;
import java.util.HashMap;
import java.util.Arrays;
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        // while (in.hasNextInt()) { // 注意 while 处理多个 case
        //     int a = in.nextInt();
        //     int b = in.nextInt();
        //     System.out.println(a + b);
        // }
        int start=0;
        HashMap<String,Integer> hm=new HashMap<String,Integer> ();
        ArrayList<String> errKeyList = new ArrayList<String>();
        ArrayList<Integer> errValueList = new ArrayList<Integer>();

        // String temp="esdd\\ed";
        // String[] temp2=temp.split("\\\\");
        // System.out.print(temp2.length);
        // System.out.print(temp2[0]);
        // System.out.print(temp2[1]);

        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String a = in.nextLine();
            String[] b =a.split(" ");
            String c2="";
            if (b[0].indexOf("\\")!=-1)     // 有\就截取,没有就原封不动
			    c2 = b[0].substring(b[0].lastIndexOf("\\")+1,b[0].length());
            else
                c2 = b[0];
            start=0;
            if(c2.length()>16){
                start=c2.length()-16;
                c2=c2.substring(start,c2.length());
            }
            String d=c2+" "+b[1];
            Integer pos=hm.get(d);
            if(pos==null){
                hm.put(d,errKeyList.size());
                errKeyList.add(d);
                errValueList.add(1);
            }else{
                errValueList.set(pos,errValueList.get(pos)+1);
            }
        }
        start=0;
        if(errKeyList.size()>8) start=errKeyList.size()-8;
        for(int i=start;i<errKeyList.size();i++){
            String keyString=errKeyList.get(i);
            String[] keyArray=keyString.split(" ");
            System.out.print(keyArray[0]);
            System.out.print(" ");
            System.out.print(keyArray[1]);
            System.out.print(" ");
            System.out.println(errValueList.get(i));
        }
    }
}

方法二:  LinkedHashMap 方式,map 位置不变

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

public class Main{
    public static void main(String[] args) throws IOException{
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        Map<String,Integer> map = new LinkedHashMap();
        String tstr = null;
        while((tstr = bf.readLine()) != null && !tstr.equals("")){
            String[] str = tstr.split("\\s+");//空格符隔开
            String fname=str[0].substring(str[0].lastIndexOf("\\") + 1);
            fname = fname.substring(Math.max(fname.length()-16 ,0))+" "+str[1];
            Integer tmp = map.get(fname);
            if(tmp == null)
                map.put(fname,1);
            else
                map.put(fname, tmp+1);
        }
        int count = 0;
        //遍历map,entrySet()返回了 HashMap 中所有映射项的一个 set 集合视图
        for(Map.Entry<String,Integer> it : map.entrySet()){
            if(map.size() - count <= 8)
                System.out.println(it.getKey()+" "+it.getValue());
            count++;
        }
    }
}

8、HJ25 数据分类处理

方法一:treeset(是小到大有序的)+indexof(或contains,包含字串)

import java.util.Scanner;
import java.lang.String;
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        // while (in.hasNextInt()) { // 注意 while 处理多个 case
        //     int a = in.nextInt();
        //     int b = in.nextInt();
        //     System.out.println(a + b);
        // }
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String I = in.nextLine();
            String[] I2=I.split(" ");
            int i=0;
            String R = in.nextLine();
            String[] R2=R.split(" ");
            TreeSet<Integer> ts=new TreeSet<Integer>();
            for(i=1;i<R2.length;i++){
                ts.add(Integer.parseInt(R2[i]));
            }
            Iterator iter=ts.iterator();
            int count2=0;
            ArrayList<Integer> rs=new ArrayList<Integer>();

            for(i=0;i<ts.size();i++){
                Integer strTempi1=(Integer)iter.next();
                String strTempi=Integer.toString(strTempi1);
                // System.out.println(strTempi);
                int equitcont=0;
                for(int j=1;j<I2.length;j++){
                    if(I2[j].contains(strTempi)){
                        equitcont++;
                        if(equitcont==1){
                            rs.add(Integer.parseInt(strTempi));
                            rs.add(equitcont);
                            count2=rs.size();
                        }
                        rs.set(count2-1,equitcont);
                        rs.add(j-1);
                        rs.add(Integer.parseInt(I2[j]));
                    }
                   
                }
            }

            if(rs.size()>0){
                System.out.print(rs.size());
                System.out.print(" ");
                for(i=0;i<rs.size();i++){
                    System.out.print(rs.get(i));
                    System.out.print(" ");
                }
            }
            

        }


    }
}

方法二:Arrays.sort函数 ++indexof(或contains,包含字串)

import java.util.Scanner;
import java.lang.String;
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        // while (in.hasNextInt()) { // 注意 while 处理多个 case
        //     int a = in.nextInt();
        //     int b = in.nextInt();
        //     System.out.println(a + b);
        // }
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String I = in.nextLine();
            String[] I2=I.split(" ");
            int i=0;
            String R = in.nextLine();
            String[] R2=R.split(" ");
            int[] R1=new int[R2.length-1];
            for(i=1;i<R2.length;i++){
                R1[i-1]=Integer.parseInt(R2[i]);
            }
            Arrays.sort(R1);
            int count2=0;
            ArrayList<Integer> rs=new ArrayList<Integer>();

            for(i=0;i<R1.length;i++){
                if(i>0 && R1[i-1]==R1[i]) continue;
                String strTempi=Integer.toString(R1[i]);
                int equitcont=0;
                for(int j=1;j<I2.length;j++){
                    if(I2[j].contains(strTempi)){
                        equitcont++;
                        if(equitcont==1){
                            rs.add(Integer.parseInt(strTempi));
                            rs.add(equitcont);
                            count2=rs.size();
                        }
                        rs.set(count2-1,equitcont);
                        rs.add(j-1);
                        rs.add(Integer.parseInt(I2[j]));
                    }
                   
                }
            }

            if(rs.size()>0){
                System.out.print(rs.size());
                System.out.print(" ");
                for(i=0;i<rs.size();i++){
                    System.out.print(rs.get(i));
                    System.out.print(" ");
                }
            }
            

        }


    }
}

9 HJ30 字符串合并处理

方法一:自己编写

import java.util.Scanner;
import java.lang.String;
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        // while (in.hasNextInt()) { // 注意 while 处理多个 case
        //     int a = in.nextInt();
        //     int b = in.nextInt();
        //     System.out.println(a + b);
        // }
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String a = in.nextLine();
            String c = a.replace(" ", "");
            char[] d = new char[c.length() / 2];
            if (c.length() % 2 == 1) d = new char[(c.length() + 1) / 2];
            char[] e = new char[c.length() / 2];
            char[] f = c.toCharArray();
            int i = 0;
            for (i = 0; i < f.length; i++) {
                if (i % 2 == 0)
                    d[i / 2] = f[i];
                else {
                    e[i / 2] = f[i];
                    // System.out.println(i/2);
                }

            }
            Arrays.sort(d);
            Arrays.sort(e);
            HashMap<Character, Character> map = new HashMap<Character, Character>();
            map.put('0', '0');
            map.put('1', '8');
            map.put('2', '4');
            map.put('3', 'C');
            map.put('4', '2');
            map.put('5', 'A');
            map.put('6', '6');
            map.put('7', 'E');
            map.put('8', '1');
            map.put('9', '9');
            map.put('a', '5');
            map.put('b', 'D');
            map.put('c', '3');
            map.put('d', 'B');
            map.put('e', '7');
            map.put('f', 'F');
            map.put('A', '5');
            map.put('B', 'D');
            map.put('C', '3');
            map.put('D', 'B');
            map.put('E', '7');
            map.put('F', 'F');
            for (i = 0; i < d.length; i++) {
                if(map.get(d[i])!=null){
                    d[i] = map.get(d[i]);
                } 
            }
            
            for (i = 0; i < e.length; i++) {
                if(map.get(e[i])!=null)
                    e[i] = map.get(e[i]);
            }
            for (i = 0; i < d.length; i++) {
                System.out.print(d[i]);
                if (i < e.length) System.out.print(e[i]);
            }
            ;
        }
    }
}

方法二:网上收集,采用 StringBuilder.reverse() 方法

package nowcoder.x3x;

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

public class HJ030 {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = br.readLine();
        // 合并第一步
        String m = line.replace(" ", "");

        char[] chars = m.toCharArray();
        // 第二步 偶数位
        for (int i = 0; i < chars.length; i = i + 2) {
            for (int j = 0; j < chars.length - 2; j = j + 2) {
                if (chars[j] > chars[j + 2]) {
                    char temp = chars[j];
                    chars[j] = chars[j + 2];
                    chars[j + 2] = temp;
                }
            }
        }

        // 第二步 奇数位
        for (int i = 1; i < chars.length; i = i + 2) {
            for (int j = 1; j < chars.length - 2; j = j + 2) {
                if (chars[j] > chars[j + 2]) {
                    char temp = chars[j];
                    chars[j] = chars[j + 2];
                    chars[j + 2] = temp;
                }
            }
        }

        // 第三步 转换
        StringBuilder stringBuilder = new StringBuilder();
        for (char c : chars) {
            if ((c >= '0' && c <= '9')
                    || (c >= 'A' && c <= 'F')
                    || (c >= 'a' && c <= 'f')
            ) {
                StringBuilder binaryString = new StringBuilder(Integer.toBinaryString(Integer.parseInt(String.valueOf(c), 16)));
                int len = binaryString.length();
                if (len < 4) {
                    for (int i = 0; i < 4 - len; i++) {
                        binaryString.insert(0, "0");
                    }
                }
                binaryString.reverse();
                int y = Integer.parseInt(binaryString.toString(), 2);
                stringBuilder.append(Integer.toHexString(y).toUpperCase());
            } else {
                stringBuilder.append(c);
            }
        }
        System.out.println(stringBuilder);
    }
}

9、HJ39 判断两个IP是否属于同一子网

方法一:作者编写

import java.util.Scanner;
import java.util.*;
import java.lang.*;


// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    // public static String fill(String a){
    //     String b="";
    //     for (int i=0;i<8-a.length();i++){
    //             b="0"+b;
    //     }
    //     return b;
    // }
    public static boolean isMaskError (String[] ip){
        String[] b={"","","",""};
        boolean result=false;
        for (int i=0;i<4;i++){
            b[i]=Integer.toBinaryString(Integer.valueOf(ip[i]));
            // fill
            if(b[i].length()<8){
                for(int j=0;j<8-b[i].length();j++){
                    b[i]="0"+b[i];
                }
            }
           
        }
        String link=b[0]+b[1]+b[2]+b[3];
        if(b[0].charAt(0)=='0') return true;
        if(link.contains("01")) result=true;
        return result;
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        // while (in.hasNextInt()) { // 注意 while 处理多个 case
        //     int a = in.nextInt();
        //     int b = in.nextInt();
        //     System.out.println(a + b);
        // }
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String[] a1=in.nextLine().split("\\.");
            String[] a2= in.nextLine().split("\\.");
            String[] a3 = in.nextLine().split("\\.");
            if(isMaskError(a1)) {
                System.out.println(1);
                continue;
            }
            int[] b1=new int[4];
            int[] b2=new int[4]; 
            int[] b3=new int[4];   
            int[] c1=new int[4];
            int[] c2=new int[4]; 
            int[] d1=new int[4];
            // String[] d2=new String[4];  
            int i=0;
            boolean isequit=true;
            boolean errorip=false;
            for(i=0;i<4;i++){
                b1[i]=Integer.parseInt(a1[i]);
                b2[i]=Integer.parseInt(a2[i]);
                b3[i]=Integer.parseInt(a3[i]);
                // ip or mask error 
                if(!(b1[i]>=0 && b1[i]<256 && b2[i]>=0 && b2[i]<256 && b3[i]>=0 && b3[i]<256)){
                    errorip=true;
                    break;
                }
                c1[i]=b1[i]&b2[i];
                c2[i]=b1[i]&b3[i];
                if(c1[i]!=c2[i]) isequit=false;
            }
            // is 0 not 2 error 1
            if(errorip) {
                System.out.println(1);
                continue;
            }
            // is 0 not 2 error 1
            if(isequit) System.out.println(0); else System.out.println(2);
          
        }
    }
}

本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)

【Java】 牛客网华为机试108题汇总 的相关文章

  • python中大数据文件读取

    python中大数据文件读取 python中经常会遇到读取大文件的场景 文件较小时 xff0c 我通常采用下面方法 xff0c readlines xff08 xff09 xff0c 该方法会一次性读取文件的所有行 xff0c 并将其放入l
  • Linux|奇怪的知识|locate命令---文件管理小工具

    前言 Linux的命令是非常多的 xff0c 有一些冷门的命令 xff0c 虽然很少用 xff0c 但可能会有意想不到的功能 xff0c 例如 xff0c 本文将要介绍的locate命令 xff08 平常很少会想到使用此命令 xff0c f
  • python之装饰器

    引言 软件开发中 xff0c 当需要创建高度重复的代码时 xff0c 需要寻求一种优雅的解决方案 python中的元编程即解决这类问题 xff0c 通过创建函数和类来修改 生成或包装已有的代码 装饰器就是python中用来包装函数的一种机制
  • docker容器中程序退出异常,GPU未释放

    1 问题描述 近期在docker容器中对一批数据通过算法进行清洗时 xff0c 当数据处理完成后发现进程未正常退出 xff0c GPU内存未正常释放 span class token punctuation span root 64 ai6
  • 初识Redis

    什么是Redis Remote Dictionary Server xff0c 即远程字典服务 xff0c 是一款开源的 基于内存也支持持久化的key value数据库 xff0c 提供多种语言API 通常应用于需要处理大规模数据读写的场景
  • python之闭包

    前言 闭包作为python高级特性中的一个 xff0c 初学总觉其披着一层神秘的面纱 xff0c 这里我们来一起揭开这层面纱吧 那什么是闭包呢 xff1f 闭包 xff0c 又称闭包函数 xff0c 和普通的嵌套函数类似 xff0c 闭包中
  • 三个基础排序算法

    排序在计算机算法中非常常见也非常基础 xff0c 不管是准备面试还是纯属兴趣 xff0c 掌握它都很有必要 选择排序 基本思想 xff1a 预置list i 为最小 xff0c 逐个比较range i len list 里的元素 xff0c
  • 数据结构之链表

    和顺序表相对应 xff0c 有个链式存储的数据结构 xff0c 命名曰链表 单链表 节点中只存储后项节点指针的链表 xff0c 称为单链表 定义节点 class LinkNode object def init self data 61 N
  • 数据结构之哈希表

    概念 哈希表是一种数据结构 xff0c 通过哈希函数来组织数据 xff0c 以支持快速插入和搜索 哈希表的关键思想是使用哈希函数将键映射到存储桶 更确切地说 xff0c 当我们插入一个新的键时 xff0c 哈希函数将决定该键应该分配到哪个桶
  • 图片数据清洗

    前言 数据对于深度学习算法模型的效果至关重要 通常 xff0c 在对采集到的大量数据进行标注前需要做一些数据清洗工作 对于大量的数据 xff0c 人工进行直接清洗速度会很慢 xff0c 因此开发一些自动化清洗工具对批量数据首先进行自动清洗
  • PyQt5 多线程实例

    前言 PyQt的所有窗口都在UI主线程中 xff0c 也就是main函数中执行了QApplication exec 的线程中 xff0c 在该线程中执行耗时较长的操作时 xff0c 会导致当前窗口停止响应 为了避免上述情况发生 xff0c
  • 模型评价标准

    机器学习 机器学习是通过一些让计算机可以自动学习的算法 xff0c 从数据中分析获得规律 xff0c 然后利用规律对新样本进行预测 评价标准 为了了解模型的泛化能力 xff0c 即判断模型的好坏 xff0c 我们需要用某个指标来衡量 xff
  • postgresql|数据库|【postgresql-12的基于pg_basebackup的主从复制部署】

    前言 xff1a postgresql数据库说实话是真心好用 xff0c 但 xff0c 想用好是比较困难的 那么 xff0c 造成该数据库使用困难的是它的内置工具非常的多 xff0c 并且整体优化是比较难的 比如 xff0c 自带的备份工
  • windows上的中文文件名上传到linux上乱码问题解决

    问题描述 有很多多层文件夹存放的数据保存在windows上 xff0c 文件夹和文件名均含有中文 xff0c 将这些文件目录传到linux上 xff0c 中文名显示乱码 问题分析 windows上中文默认编码格式是gbk xff0c 而li
  • JAVA 面试题经典(附答案)

    JAVA JAVA8大基本数据类型 J AVA8大基本数据类型 HashMap和Hashtable的比较 Hashtable xff1a 1 Hashtable不允许key或者value为null xff0c 线程安全 xff0c 实现线程
  • u盘写入映像时提示:主引导记录(mbr)写入失败!!

    在使用软件写入U盘镜像时 xff0c 出现下面的提示 xff1a 解决方法是使用DiskGenius重新建立MBR
  • debian SID安装笔记

    1 声卡设置问题 添加了声卡驱动 xff0c 但是进入桌面没有声音 xff1f 一般是没有给用户使用设备的权限 解决方法 xff1a adduser audio eg adduser jerry audio xff08 解决 xff09 你
  • ubuntu下vncserver配置

    Ubuntu下设置VNCServer Virtual Network Computing VNC 是进行远程桌面控制的一个软件 客户端的键盘输入和鼠标操作通过网络传输到远程服务器 xff0c 控制服务器的操作 服务器的图形界面通过网络传输会
  • vsftp配置实例-虚拟用户锁定目录

    一 实验步骤 1 创建用户 创建ftpuser1登录用户 useradd g ftp d share soft s sbin nologin ftpuser1 为ftpuser1设置登录密码 passwd ftpuser1 2 编辑配置文件
  • 基于51的光立方制作

    单片机入门者必然会从点亮一盏LED灯开始 xff0c 如果LED数量比较多 xff0c 就不能使用单个引脚去控制 xff0c 例如光立方 xff0c 利用锁存器和人体的视觉暂留效果就可以占用少量引脚实现光立方 所需材料 xff1a STC8

随机推荐