华为机试小练习

最新推荐文章于 2024-06-28 11:55:06 发布

duoduo18up

最新推荐文章于 2024-06-28 11:55:06 发布

阅读量763

点赞数 1

分类专栏： -----算法文章标签：华为机试

本文链接：https://blog.csdn.net/duoduo18up/article/details/82154774

版权

-----算法专栏收录该内容

44 篇文章 1 订阅

订阅专栏

1. 去重+排序问题

链接：https://www.nowcoder.com/questionTerminal/3245215fffb84b7b81285493eae92ff0
来源：牛客网

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

Input Param

n 输入随机数的个数

inputArray n个随机整数组成的数组

Return Value

OutputArray 输出处理后的随机整数
注：测试用例保证输入参数的正确性，答题者无需验证。测试用例不止一组。

输入描述

输入多行，先输入随机整数的个数，再输入相应个数的整数

输出描述:

返回多行，处理后的结果

示例1

输入

输出

同时实现去重和排序功能（位图法）：

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

public class Main{
    public static void main(String [] args){
        Scanner sc=new Scanner(System.in);
        //先处理输入多组数据
        //用空间换时间采用计数排序位图法排序
        while(sc.hasNext()){
            int N=sc.nextInt();
            int a[ ]=new int [1001];
            while(N>0){
                int n=sc.nextInt();
                a[n]=1;
                N--;
            }
            for(int  i=0;i<1001; i++){
                if(a[i]!=0)
                    System.out.println(i);
            }
        }
    }
}

原始TreeSet去重：

while(sc.hasNext()){
            int n=sc.nextInt();
            TreeSet<Integer> ts=new TreeSet<>();
            while(n>0){
                ts.add(sc.nextInt());
                n--;
            }
            for(int i: ts){
                System.out.println(i);
            }
        }

2 切割字符串补0

链接：https://www.nowcoder.com/questionTerminal/d9162298cb5a437aad722fccccaae8a7
来源：牛客网

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

输入描述:

连续输入字符串(输入2次,每个字符串长度小于100)

输出描述:

输出到长度为8的新字符串数组

示例1

输入

abc
123456789

输出

abc00000
12345678
90000000

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){        
            String s = new String(sc.nextLine());
            if(s.length()%8 !=0 )
                s = s + "00000000";
             
            while(s.length()>=8){
                System.out.println(s.substring(0, 8));  //切割字串 包括前面--不包括后面
                s = s.substring(8);  //开始下标----结束位置
            }
        }
    }
}

缺点：字符串不断进行这样的计算，其实效率比较低，最好建议直接使用StringBuffer这样可变数组进行操作。

import java.util.*;

public class Main{
    public static void main(String [] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String s=sc.nextLine();
            StringBuffer sb=new StringBuffer(s);
            if( s.length() %8!=0){
                for(int i=0; i< 8- s.length()%8 ;i++)
                    sb.append('0');
            }
            while(sb.length() >=8){
                System.out.println(sb.substring(0,8));
                sb.delete(0,8);
            }
        }
    }
}

3 字符串反转

- trim()
  返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。

将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            String str = in.nextLine();
            String[] s = str.split(" ");
            StringBuffer sb = new StringBuffer();
            for(int i = s.length-1; i >= 0; i--){
                sb.append(s[i] + " ");
            }
            System.out.println(sb.toString().trim());
        }
    }
}

单独把最后一个列出来打印：

import java.util.*;
public class Main{
    public static void main(String [] args){
        Scanner sc=new Scanner(System.in);
        String oriStr=sc.nextLine();
        String [] arr=oriStr.split(" ");
        for(int i=arr.length-1; i>0;i--){
            System.out.print(arr[i]+" "); //除了最后一个单词没有打印
        }
        System.out.print(arr[0]);
    }
}

4 字符串排序

需要注意的一些点：

1 Character.isLetter(char c) ：判断是否是字母

2 Collections.sort(Collection , new Comparater<>(){

public int compare(......)

return ......

});

编写一个程序，将输入字符串中的字符按如下规则排序。

规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。

如，输入： Type 输出： epTy

规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。

如，输入： BabA 输出： aABb

规则 3 ：非英文字母的其它字符保持原来的位置。

如，输入： By?e 输出： Be?y

样例：

输入：

A Famous Saying: Much Ado About Nothing(2012/8).

输出：

A aaAAbc dFgghh : iimM nNn oooos Sttuuuy (2012/8).

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {
            String str = in.nextLine();
            List<Character> list = new LinkedList<Character> ();
            char[] ss = str.toCharArray();
            for(char c: ss) {
                if(Character.isLetter(c))
                    list.add(c);  
             }  
              
             Collections.sort(list, new Comparator<Character> () {
                @Override
                public int compare(Character o1, Character o2) {
                    return Character.toLowerCase(o1)-Character.toLowerCase(o2);
                }
                 
             });
              
             StringBuilder sb = new StringBuilder();
             int totalLen = 0;
             for(char temp: ss) {
                if(Character.isLetter(temp) && totalLen<list.size()) {
                    sb.append(list.get(totalLen));
                    totalLen += 1;
                }else {
                    sb.append(temp);
                }
                 
             }
             System.out.println(sb.toString());
        }
         
    }
}

5 字符串中最长回文串长度

思路：以一个字符往左右分别扩展考虑奇数和偶数两种情况

中心扩展就是把给定的字符串的每一个字母当做中心，向两边扩展，这样来找最长的子回文串。算法复杂度为O(N^2)。

但是要考虑两种情况：

1、像aba，这样长度为奇数。

2、想abba，这样长度为偶数。

//题意：输入一个字符串--->输出此字符串中最长的回文串
//思路：最直观的思路以一个字符为中心向两边进行扩展--->考虑奇数字符串和偶数字符串
import java.util.*;
public class Main{
    public static void main(String [] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String s=sc.nextLine();
            System.out.println(maxLength(s));
        }
    }
    //对输入的字符串进行奇数和偶数两种扩展
    private static int maxLength(String s){
        //考虑输入字符串的各种情况
        int len=s.length();
        if(len<1)
            return 0;
        int max=1;   //长度为1或者最小回文字符串长度为1
        //考虑奇数的情况 k i j   k-- j-- 存在不符合的就break
        for(int i=1; i<len;i++){
            int k=i-1;
            int j=i+1;
            int count=0;  //统计符合条件的对数
            while(k>=0 && j<= len-1){
                if(s.charAt(k--)==s.charAt(j++))
                    count++;
                else 
                    break;
            }
            //记录最大值 每一轮的所有可能的count都已经比较并记录
            max=( max >= 2*count+1) ? max: 2*count+1;
        }
        
        //考虑偶数的情况 其实就是 k i(j) k-- j++ 同步移动
        for(int i=1;i<len-1;i++){
            int k=i-1;
            int j=i;
            int count=0;
            while( k>=0 && j<= len-1){
                if(s.charAt(k--)== s.charAt(j++))
                    count++;
                else
                    break;
            }
            max=( max>= 2*count)? max: 2* count ;
        }
        //max是全局变量所以经历奇数偶数两种情况之后此时记录的一定是最长回文串的长度
        return max;
    }
}

6 整数中1 的个数（转为二进制后最多有几个1）

思路： 就是位运算的思路 n&1 ----n=n>>1 统计

另一种抵消1 n=n &(n-1) count++

另一种是利用java自带的转换函数 String Integer.toBinartString(int n) ---->去统计其中每一位上字符为'1'的个数即可

输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。

输入描述:

输入一个整数（int类型）

输出描述:

这个数转换成2进制后，输出1的个数

import java.util.*;
 
public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int count = 0;
        while(n>0){
            if((n&1)>0){  //注意（）这个细节 必须作为一个整体 否则会失败
                count++;
            }
            n=n>>1;
        }
        System.out.println(count);
    }
}

//另一种：抵消1  n&(n-1)
import java.util.*;
public class Main{
    public static void main(String [] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int count=0;
        while(n>0){
            n=n&(n-1);
            count++;
        }
        System.out.println(count);
    }
}

//利用java 自带一些函数进行二进制转换
import java.util.*;
public class Main{
    public static void main(String [] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int count=0;
        String s=Integer.toBinaryString(n);
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)=='1')
                count++;
        }
        System.out.println(count);
    }
}

7 删除字符串中出现次数最少的字符

解法：当字符只有字母时可以想到位图法

//思路1：用位图法去做都是小写字母最多有26个
//遍历一遍装桶再遍历一遍确定最小的再遍历一遍寻找最小的不是最小的则输出

//思路2：用map结构存放字符和对应出现次数---Collections现有函数取出最小值---StringBuffer去装载不是最小值的字符--输出即可

实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。

输入描述:

字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。

输出描述:

删除字符串中出现次数最少的字符后的字符串。

import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        while(cin.hasNext()) {
            int[] num = new int[26];
            String line = cin.nextLine();
            for(int i=0; i<line.length(); i++) {
                char c = line.charAt(i);
                int n = (int)(c - 'a');
                num[n] ++;
            }
            int min = Integer.MAX_VALUE;
            for(int i=0; i<26; i++) {
                if(num[i] != 0 && num[i] < min) {
                    min = num[i];
                }
            }
            for(int i=0; i<line.length(); i++) {
                char c = line.charAt(i);
                int n = (int)(c - 'a');
                if(num[n] != min) {
                    System.out.print(c);
                }
            }
            System.out.println();
        }
    }
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
             
        String string=sc.nextLine();
        char[] A=string.toCharArray();
        Map<Character,Integer> m=new LinkedHashMap<Character,Integer>();
       
         
        for(char c:A){
            if(!m.containsKey(c)){
                 m.put(c,1);
                 
            }else{
                m.put(c,m.get(c)+1);
                
            }     
        }
        Collection<Integer> al=m.values();
        int index=Collections.min(al);
      StringBuffer sb=new StringBuffer("");
        for(char c:A){
            if(m.get(c)!=index)
                sb.append(c);
        }
             
            System.out.print(sb.toString());
             
       }
        
    }
}

duoduo18up

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
华为机试小练习

1. 去重+排序问题链接：https://www.nowcoder.com/questionTerminal/3245215fffb84b7b81285493eae92ff0来源：牛客网明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的...
复制链接

扫一扫