兴业数金笔试

4.16日参加兴业数金的笔试40道单选题，10道多选，2个问答题，1个编程题.

整体还不错，编程题只A了57%？

晚上复盘一下

 

问答题

1、多线程同步和互斥有几种实现方法，都是什么？

       线程同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另外一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。

       线程互斥是指对于共享的进程系统资源，每个线程访问时的排他性。当有若干个线程都要使用某一个共享资源时，任何时刻最多只允许一个线程去使用，其他线程必须等待，直到占用资源者释放该资源。线程互斥可以看成是一种特殊的线程同步。

线程间的同步方法大体可以分为两类：用户模式和内核模式

　　　　1、用户模式：原子操作（例如一个单一的全局变量），临界区

　　　　2、内核模式：事件、信号量、互斥量

　　内核模式就是利用系统内核对象的单一性来进行同步，使用时需要切换内核态与用户态，而用户模式就是不需要切换内核态，只在用户态完成操作

1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。 
2、互斥量:为协调共同对一个共享资源的单独访问而设计的。 
3、信号量:为控制一个具有有限数量用户资源而设计。 
4、事件:用来通知线程有一些事件已发生，从而启动后继任务的开始。

 

2、当前计算机系统一般会采用层次结构存储数据，请介绍下典型计算机存储系统一般分为哪几个层次，为什么采用分层存储数据能有效提高程序的执行效率？

答：所谓存储系统的层次结构，就是把各种不同存储容量，存取速度和价格的存储器按照层次结构组成多层存储器，并通过管理软件和辅助硬件有机的组合成为一个整体，使所存放的程序和数据按照层次分布在各种存储器中。目前，在计算机系统中通常采用三级层次结构来构成存储系统，主要是由高速缓冲存储器cache，主存储器，和辅助存储器组成。

存储系统多级层次结构中，由上向下分为三级，其容量逐渐增大，速度逐渐降低，成本则逐次减少。整个结构又可以看成两个层次：他们分别是主存---辅存层次和Cache---主存层次。这个层次系统中的每一种存储器都不再是孤立的存储器，而是一个有机的整体。他们在辅助硬件和计算机操作系统的管理下，可以把主存--辅存层次作为一个存储整体，形成的可寻存储空间比主存储器空间大得多。由于辅存的容量大，价格低，是的存储系统的整体平均价格低。由于Cache的存取速度可以和cpu的工作速度相媲美，所以cache--主存层次可以缩小主存和cpu之间的速度差距，从整体上提高存储器系统的存取速度。尽管cache成本高，但是由于容量小，故不会使存储系统的整体价格增加。

综上所述，一个较大的存储系统是由各种不同类型的存储设备构成的，是一个具有多级层次结构的存储系统。该系统既有与cpu相近的速度，又有极大的容量，而且成本较低。其中高速缓存解决了存储系统的速度问题，辅助存储器则解决了系统的容量问题。采用多级层次结构的存储器可以有效的解决存储器的速度，容量，价格之间的矛盾。

 

编程题

找出最接近的对称数字

考试时写的代码：

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 = br.readLine();

        StringBuffer sb1 = new StringBuffer();
        StringBuffer sb2 = new StringBuffer();


        int halfLength = s.length()/2;
        //找出前半段放进sb2中
        for (int i = 0; i < halfLength; i++) {
            sb1.append(s.charAt(i));
        }
        sb2.append(sb1);

        //如果是奇数个数，则把中间的数字加入sb2
        if (s.length() % 2 == 1){
            sb2.append(s.charAt(halfLength));
        }
        //前半段直接逆序输出到后半段
        sb2.append(sb1.reverse());
        System.out.println(sb2.toString());
    }
}

编译通过57%，后来想了下这个方法不严谨

//例：9， 答案为8（没有单个数的测试用例）
//例：1291，答案为1331，而非1221
//例：1800，答案为1771，而非1881

链接：https://www.nowcoder.com/questionTerminal/e605ba77112b425889bee3f40481fe93?f=discussion
来源：牛客网

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
 
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String s = bufferedReader.readLine();
        String leftStr = s.substring(0, (s.length() + 1) / 2);
        long left = Long.parseLong(leftStr);
        long smaller = getLeftSmallerSymmetry(s.length(), left, leftStr.length());
        long bigger = getLeftBiggerSymmetry(s.length(), left, leftStr.length());
        long sValue = Long.parseLong(s);
        long sToSmaller=sValue - smaller;
        long sToBigger=bigger - sValue;
        long closestValue;
        long minDistance;
        if (sToSmaller <= sToBigger) {
            closestValue = smaller;
            minDistance=sToSmaller;
        } else {
            closestValue = bigger;
            minDistance=sToBigger;
        }
        if (!isSymmetry(s)) {
            long equal = getLeftEqualSymmetry(s.length(), left, leftStr.length());
            long sToEqual = Math.abs(equal - sValue);
            if (sToEqual < minDistance) {
                closestValue = equal;
            } else if (sToEqual == minDistance) {
                if (equal < sValue) {
                    closestValue = equal;
                }
            }
        }
        System.out.println(closestValue);
    }
 
    //判断s是否对称
    static boolean isSymmetry(String s) {
        int mid = s.length() / 2;
        for (int i = 0, j = s.length() - 1; i < mid; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
        }
        return true;
    }
 
    //将左半部分反转到右半部分
    static void reverseLeftToRight(char[] cs) {
        int mid = cs.length / 2;
        for (int i = 0, j = cs.length - 1; i < mid; i++, j--) {
            cs[j] = cs[i];
        }
    }
 
    //获取左半部分减去1的对称值
    static long getLeftSmallerSymmetry(int originLen, long leftValue, int leftLen) {
        long leftSmaller = leftValue - 1;
        String leftSmallerStr = String.format("%0" + leftLen + "d", leftSmaller);
        char[] temp;
        temp = Arrays.copyOf(leftSmallerStr.toCharArray(), originLen);
        reverseLeftToRight(temp);
        if (temp[0] == '0' && temp.length > 1) {
            temp = String.valueOf(temp, 1, temp.length - 1).toCharArray();
            temp[temp.length - 1] = '9';
        }
        return Long.parseLong(String.valueOf(temp));
    }
 
    //获取左半部分相等的对称值
    static long getLeftEqualSymmetry(int originLen, long leftValue, int leftLen) {
        String leftEqualStr = String.valueOf(leftValue);
        char[] temp = Arrays.copyOf(leftEqualStr.toCharArray(), originLen);
        reverseLeftToRight(temp);
        return Long.parseLong(String.valueOf(temp));
    }
 
    //获取左半部分加上1的对称值
    static long getLeftBiggerSymmetry(int originLen, long leftValue, int leftLen) {
        long leftBigger = leftValue + 1;
        String leftBiggerStr = String.valueOf(leftBigger);
        char[] temp;
        if (leftBiggerStr.length() > leftLen) {
            temp = Arrays.copyOf(leftBiggerStr.toCharArray(), originLen + 1);
        } else {
            temp = Arrays.copyOf(leftBiggerStr.toCharArray(), originLen);
        }
        reverseLeftToRight(temp);
        return Long.parseLong(String.valueOf(temp));
    }
}