笔试题1

最近的笔试较多，把做过的笔试题做一个大致的总结（编程题）：

H3C笔试题：

question_1：1,2,3,4,四个数，通过组合成一个不重复的三位数，共有多少种组合方式，并将其输出。

public class H3C_question1{
    public static void main(String[] args){
        int i = 0;
        for(int numOne = 1; numOne <= 4; numOne++){
            for(int numTwo = 1; numTwo <= 4; numTwo++){
                for(int numThree = 1; numThree <= 4; numThree++){
                    if(numOne != numTwo && numTwo != numThree && numOne != numThree){
                        i++;
                        int num = numOne * 100 + numTwo * 10 + numThree;
                        System.out.println(num);
                   　}
                }
            }
        }
　　　　　System.out.println("共有" + i + "个不重复的组合。");
　　}
}

# -*- coding: utf-8 -*-

count = 0
for numOne in range(1, 5):
    for numTwo in range(1, 5):
        for numThree in range(1, 5):
            if numOne != numTwo and numTwo != numThree and numOne != numThree:
                count += 1
                num = numOne * 100 + numTwo * 10 + numThree
                print(numThree)

print('共有' + str(count) + '个不重复的组合。')

question_2：对于一个文本表达式如"((a+b) * (c + (d+e)))"，来看它的括号是否匹配，如果匹配则输出括号最大嵌套层数。 如")()()"或"(a+b))*(c+d)"这样的都是括号不匹配的。

public class H3C_question2{
    public static void main(String[] args){
        int leftCount = 0;
        int rightCount = 0;
        int max = 0;
        String txt = "((a + b) * (c + (d + e)))";
        for(int i = 0; i < txt.length(); i++){
            if(txt.charAt(i) == '('){
                leftCount++;
            }else if(txt.charAt(i) == ')'){
                rightCount++;
                if(leftCount == 0){
                    System.out.println("不匹配");
　　　　　　　　　　　　break;
                }else{
                    if(max < leftCount){
                        max = leftCount;
                    }
                    leftCount--;
                    rightCount--;
                }
            }else{
                continue;
            }
        }
        if(leftCount == 0 && rightCount == 0){
　　　　　　System.out.println("匹配，且最大嵌套层数为：" + max);
　　　　 }else{
　　　　　　System.out.println("不匹配");
　　　　 }

    }
}

# -*- coding: utf-8 -*-
def max_CengShu(s):
    leftCount = 0 
    rightCount = 0
    max = 0
    for i in range(len(s)):
        if s[i] == '(':
            leftCount += 1
        elif s[i] == ')':
            rightCount += 1
            if leftCount == 0:
                print('不匹配')
                break
            else:
                if max < leftCount:
                    max = leftCount
                leftCount -= 1
                rightCount -= 1
        else:
            continue
    if leftCount == 0 and rightCount == 0:
        print('匹配，且最大嵌套层数为：' + str(max))
    else:
        print('不匹配')

s = '((a+b) * (c + (d+e)))'
max_CengShu(s)

print('-------------------------------------------------')

s = '((a+b) * (c + (d+e))'
max_CengShu(s)

print('-------------------------------------------------')

s = '(a+b) * (c + (d+e)))'
max_CengShu(s)

print('-------------------------------------------------')

s = '(a+b) * (c + (d+e))'
max_CengShu(s)

print('-------------------------------------------------')

华为笔试题：

question_1：字符串压缩，对输入字符串进行压缩，输入"aaabcccdde"，输出"3ab3c2de"，即对连续出现的字符进行压缩。

　　   思路：使用索引i来遍历字符串，对每个当前索引i的字符进行计数（用count），遍历的过程中用一个while来判断索引i和i+1的两个字符是否相等，如果相等，则count+1且i+1，不相等，则跳出while，判断count的值。然后继续遍历字符串。

public class HuaWei_question1{
    public static String string_compress(String s){
        int length = s.length();
        int count = 0;
        int i;
        String retStr = "";
        if(length == 0){
            return "字符串为空";
        }
        
        for(i = 0; i < length; i++){
            count = 1;
            if(i == length - 1){  // 避免出现length-1和length进行比较（会超出字符串长度）
                retStr = retStr + s.charAt(i);
                break;
            }
            while(s.charAt(i) == s.charAt(i + 1)){
                count++;
                i++;
                if(i == length - 1){  // 避免出现length-1和length进行比较（会超出字符串长度）
                    break;
                }
            }
            if(count > 1){
                retStr = retStr + count + s.charAt(i);
            }else{
                reStr = retStr + s.charAt(i);
            }
        }
    }
    
    public static void main(String[] args){
        String s = "aaabbbbc";
    　　String s2 = "aaabcccdde";
        String retS = string_compress(s);
        System.out.pirntln(retS);
        Stirng retS2 = string_compress(s);
        System.out.println(retS2);
    }
}

# -*- coding: utf-8 -*-

def string_compress(s):
    length = len(s)
    retStr = ''
    if length == 0:
        return '字符串为空'
    for i in range(length):
        count = 1
        if i == length - 1:
            retStr = retStr + s[i]
            break;
        while s[i] == s[i + 1]:
            count += 1
            i += 1
            if i == length - 1:
                break;
        if count > 1:
            retStr = retStr + str(count) + s[i]
        else:
            retStr = retStr + s[i]
        # print(retStr)

    return retStr

s = "aaabbbbc"
retS = string_compress(s)
print(retS)

这个题的python版本是错误的，这是因为python和java在for循环性质上的错误：

　　　对于java的for循环，第一次i = 0，经过一次循环后，在循环体中i被改变了，因此在下一次循环的时候，i会在这个改变的基础上再加1。

　　　而对于python的for循环，第一次i = 0，经过一次循环后，在循环体中i被改变了，但是在下一次循环的时候，i是在i=0的基础上加1，即i为1。

　　    即在python的for循环中i不会因为循环体中语句对它的改变而改变。

question_3：在一个无序的数字列表中，找到它最大长度的子序列（子序列是从小到大排序的）。

　　   思路：找出该数字列表中所有我从小打到排列的子序列，然后找到最长的那一个即可。

在java中要用到集合类ArrayList

package test;import java.util.Arrays;
import java.util.ArrayList;

public class Huawei_question3 {
/*
 * 题目：在一个无序的数字列表中，找到它最大长度的子序列（子序列是从小到大排序的）。
 * 思路：找出该数字列表中所有我从小打到排列的子序列，然后找到最长的那一个即可。
 */
    public static int maxSubList(ArrayList<Integer> list){
        ArrayList<ArrayList<Integer>> arrayLists = new ArrayList<ArrayList<Integer>>();
        int length = list.size();
        for(int i = 0; i < length - 1; i++){
            ArrayList<Integer> arrayList = new ArrayList<Integer>();
            for(int j = i; j < length; j++){
                if(arrayList.isEmpty()){
                    arrayList.add(list.get(j));
                }else{
                    if(list.get(j) > arrayList.get(arrayList.size() - 1)){
                        arrayList.add(list.get(j));
                    }
                }
            }
            arrayLists.add(arrayList);
        }
        int maxlength = arrayLists.get(0).size();
        for(int i = 0; i < arrayLists.size(); i++){
            if(arrayLists.get(i).size() > maxlength){
                maxlength = arrayLists.get(i).size();
            }
        }
        for(int i = 0; i < arrayLists.size(); i++){
            System.out.println(arrayLists.get(i));
        }
        return maxlength;
    }
    
    public static void main(String[] args){
        int [] array = {3, 2, 5, 6, 8, 7, 9, 4, 1};
        int [] array2 = {7, 2, 3, 1, 5, 8, 9, 6};
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        for(int i = 0; i < array.length; i++){
            arrayList.add(array[i]);        
        }
        int maxlength = maxSubList(arrayList);
        System.out.println(maxlength);
                int maxlength2 = maxSubList(arrayList2);        
        System.out.println(maxlength2);
    }

}
    

# -*- coding: utf-8 -*-

def max_SubList(list_num):
    length = len(list_num)
    lists = []
    for i in range(length-1):
        li = []
        for j in range(i, length):
            if li == []:
                li.append(list_num[j])
            else:
                if list_num[j] > li[len(li) - 1]:
                    li.append(list_num[j])
        lists.append(li)
    for i in range(len(lists)):
        print(lists[i])
    maxlength = len(lists[0])
    for i in range(len(lists)):
        if len(lists[i]) > maxlength:
            maxlength = len(lists[i])
    return maxlength

l = [3, 2, 5, 6, 8, 7, 9, 4, 1]
maxlength = max_SubList(l)
print('最长的从小到大的子序列长度为：' + str(maxlength))

// 避免出现length-1和length进行比较（会超出字符串长度）