区块链习题练习---考证习题

Posted 2023-04-06 爱睡觉的小馨

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了区块链习题练习---考证习题相关的知识，希望对你有一定的参考价值。

题目描述：CA是联盟链上证书认证机构，请完成下方的题目：
1、CA叫认证机构，是fabric的证书颁发机构，由______和_______组成的。
A、服务器、数据库
B、数据库、客户端
C、底座、数据集
D、服务器、客户端

正确答案：D
答案解析：（Ca（Certificate Authority）叫认证机构，是Fabric的证书颁发机构，由服务器（server）和客户端（client）组成）

题目描述：Fabric CA是联盟链上发放证书的服务机构，其本身也是联盟链上的一个节点。那么，请完成Fabric上CA节点的相关问题？
1、Fabric CA Root Server的秘钥文件：
A、keystore
B、ca-cert.pem
C、chainfile

正确答案：A
答案解析：（Fabric CA Root Server的秘钥文件）

2、Fabric CA Root Server的证书文件：
A、keystore
B、ca-cert.pem
C、chainfile
<>br
正确答案：B
答案解析：（Fabric CA Root Server的证书文件）

3、Fabric CA Root Server的证书链文件：
A、keystore
B、ca-cert.pem
C、chainfile

正确答案：C

题目描述：本题目主要考察CA证书机构的主要功能，属于概念认知型题目，请完成下方的题目
1、CA认证中心的主要功能是：证书的颁发、证书的更新、_________、证书的作废、证书的归档。
A、证书的撤销
B、证书的允许
C、证书的查询
D、证书的使用

正确答案：C
答案解析：（证书的颁发：中心接收、验证用户 ( 包括下级认证中心和最终用户 ) 的数字证书的申请，将申请的内容进行备案，并根据申请的内容确定是否受理该数字证书申请。证书的更新：认证中心可以定期更新所有用户的证书，或者根据用户的请求来更新用户的证书。证书的查询：证书的查询可以分为两类，其一是证书申请的查询；其二是用户证书的查询证书的作废：当用户的私钥由于泄密等原因造成用户证书需要申请作废时，用户需要向认证中心提出证书作废的请求，认证中心根据用户的请求确定是否将该证书作废。证书的归档：证书具有一定的有效期，证书过了有效期之后就将作废，但是我们不能将作废的证书简单地丢弃，因为有时我们可能需要验证）

题目描述：构建Fabric排序与共识服务：本试题考察的是整个排序服务中kafka共识组件的相关问题
1、kafka是一个分布式消息队列。具有_________、持久化、多副本备份、_________。
A、高性能、横向扩展能力
B、延展性、不可重复性
C、不可重复性、高性能
D、横向扩展能力、延展性

正确答案：A
答案解析：（kafka是一个分布式消息队列。具有高性能、持久化、多副本备份、横向扩展能力。）

题目描述：peer节点是整个联盟链上的核心成员，承接了链上的业务功能，是连接业务的关键入口，请完成下方的题目：
1、关于peer节点下列说法正确的是？
A、peer节点负责排序和打包
B、peer维护通道账本数据
C、所有的peer节点都是记账节点，记录的是节点已加入通道的账本数据。
D、peer负责通道创建、通道配置更新等操作

正确答案：B

题目描述：Fabric联盟链中的通道分为系统通道和应用通道，系统通道主要负责系统配置数据的存储，应用通道主要负责用户交易数据的存储。请根据通道的搭建过程和配置项，完成下方关于通道的相关问题。
1、联盟链的通道是实现链上数据隔离和隐私保护的关键服务，通道的搭建必然和其他的服务组件有多重链接，那么请选择出下面那些组件与通道产生直接关联。
A、Broadcast
B、Dliver
C、orderer节点
D、kafka共识组件
E、锚节点
F、区块链账本
G、世界状态
H、组织
I、系统链码

正确答案：CEFGI
答案解析：（联盟链的通道是实现链上数据隔离和隐私保护的关键服务，通道的搭建必然和其他的服务组件有多重链接，那么请选择出下面那些组件与通道产生直接关联。）

题目描述：完成下方题目。题目描述：完成下方题目。
1、Gossip的性能有哪些？
A、低延迟
B、非常可靠
C、轻量级
D、高负载

正确答案：ABC

2、Fabric的层级有哪些？
A、数据层
B、合约层
C、应用层
D、共识层

正确答案：ABCD

答案解析：（Hyperledger Fabric 可以分为7层，分别是存储层、数据层、通道层、网络层、共识层、合约层、应用层。）

题目描述：完成下方题目。
1、系统链码有哪些？
A、LSCC
B、CSCC
C、ESCC
D、VSCC

正确答案：ABCD
答案解析：（系统链码包括：LSCC：生命周期系统链码；QSCC：配置系统链码；CSCC：查询系统链码；ESCC：背书系统链码；VSCC：验证系统链码；）

题目描述：本试题主要侧重在节点在组织内部的角色重要性和不通过分工，是考察考生对节点的掌握。
1、普通节点有哪些？
A、锚节点
B、主节点
C、记账节点
D、背书节点

正确答案：ABCD
答案解析：（节点一般包括：主节点：主节点是组织的与排序服务通信的代表，一般由选举产生，一个组织只有一个。锚节点：锚节点就类似与灯塔，本节点主要用于让联盟链通道中的其他节点发现自己组织中的节点，每个组织在一个通道内有且只能由一个锚节点。记账节点：普通节点，用于验证与存储链上数据。背书节点：用于给上链的数据提供背书签名。" ）

《Java练习题》进阶练习题

编程合集： https://www.cnblogs.com/jssj/p/12002760.html

前言：不仅仅要实现，更要提升性能，精益求精，用尽量少的时间复杂度和空间复杂度解决问题。

【程序68】
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

public class ListNode {
    int val;
    ListNode next;
    ListNode(){

    }
    ListNode(int x) { val = x; }
}

/**
 * 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
 */
public class Subject68 {
    public static void main(String[] args) {
        ListNode listNode0 = new ListNode(1);
        ListNode listNode1 = new ListNode(2);
        ListNode listNode2 = new ListNode(3);
        ListNode listNode3 = new ListNode(-9);
        ListNode listNode4 = new ListNode(3);
        listNode0.next = listNode1;
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;

        ListNode listNode01 = new ListNode(5);
        ListNode listNode11 = new ListNode(7);
        listNode01.next = listNode11;

        ListNode tmp = mergeTwoLists(listNode3,listNode01);
        StringBuilder stringBuilder = null;
        while(tmp !=null){  //指向位置是否为空
            if(stringBuilder == null){
                stringBuilder = new StringBuilder();
                stringBuilder.append(tmp.val);
            }else{
                stringBuilder.append(" -> "+ tmp.val);
            }
            tmp = tmp.next;    // 指向下一个节点
        }
        System.out.println(stringBuilder.toString());
    }

    /**
     * 递归实现链表插入
     * @param l1
     * @param l2
     * @return
     */
    public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        }
        else if (l2 == null) {
            return l1;
        }
        else if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        }
        else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

时间复杂度： $O (n$

运行结果：

【程序69】
给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。

import java.util.ArrayList;
import java.util.List;

/**
 * 给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。
 */
public class Subject69 {
    public static void main(String[] args) {
        System.out.println(generateParenthesis(4));
    }

    /**
     * 递归解题
     * @param n
     * @return
     */
    public static List<String> generateParenthesis(int n) {
        if(n == 1){
            List<String> list = new ArrayList<>();
            list.add("()");
            return list;
        }else{
            List<String> list = generateParenthesis(n-1);
            int sizes = list.size();
            List<String> newList = new ArrayList<>();
            for (int i = 0; i < sizes; i++) {
                String tmp = list.get(i);
                char[] arr = tmp.toCharArray();
                for (int j = 0; j < arr.length; j++) {
                    String tmp0 = tmp.substring(0,j);
                    String tmp1 = tmp.substring(j,tmp.length());
                    String tmp2 = tmp0 + "()" +tmp1;
                    if(!newList.contains(tmp2)){
                        newList.add(tmp2);
                    }
                }
            }
            return newList;
        }
    }
}

运行结果：

【程序70】
合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

public class ListNode {
    int val;
    ListNode next;
    ListNode(){

    }
    ListNode(int x) { val = x; }
}

/**
 * 合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
 */
public class Subject70 {
    public static void main(String[] args) {

        ListNode listNode0 = new ListNode(-10);
        ListNode listNode1 = new ListNode(-9);
        ListNode listNode2 = new ListNode(-9);
        ListNode listNode3 = new ListNode(-3);
        ListNode listNode4 = new ListNode(-1);
        ListNode listNode5 = new ListNode(-1);
        ListNode listNode6 = new ListNode(0);

        listNode1.next = listNode0;
        listNode2.next = listNode1;
        listNode3.next = listNode2;
        listNode4.next = listNode3;
        listNode5.next = listNode4;
        listNode6.next = listNode5;

        ListNode listNode01 = new ListNode(-5);
        ListNode listNode02 = new ListNode(4);
        ListNode listNode03 = new ListNode(-8);


        ListNode listNode11 = null;

        ListNode listNode20 = new ListNode(-9);
        ListNode listNode21 = new ListNode(-6);
        ListNode listNode22 = new ListNode(-5);
        ListNode listNode23 = new ListNode(-4);
        ListNode listNode24 = new ListNode(-2);
        ListNode listNode25 = new ListNode(2);
        ListNode listNode26 = new ListNode(3);

        listNode21.next = listNode20;
        listNode22.next = listNode21;
        listNode23.next = listNode22;
        listNode24.next = listNode23;
        listNode25.next = listNode24;
        listNode26.next = listNode25;

        ListNode listNode30 = new ListNode(-3);
        ListNode listNode31 = new ListNode(-3);
        ListNode listNode32 = new ListNode(-2);
        ListNode listNode33 = new ListNode(-1);
        ListNode listNode34 = new ListNode(0);

        listNode31.next = listNode30;
        listNode32.next = listNode31;
        listNode33.next = listNode32;
        listNode34.next = listNode33;

        ListNode[] arr = new ListNode[]{listNode6,listNode01,listNode02,listNode03,listNode11,listNode26,listNode34};
        ListNode tmp= mergeKLists(arr);
        StringBuilder stringBuilder = null;
        while(tmp !=null){  //指向位置是否为空
            if(stringBuilder == null){
                stringBuilder = new StringBuilder();
                stringBuilder.append(tmp.val);
            }else{
                stringBuilder.append(" -> "+ tmp.val);
            }
            tmp = tmp.next;    // 指向下一个节点
        }
        System.out.println(stringBuilder.toString());
    }

    /**
     *  合并链表
     * @param lists
     * @return
     */
    public static ListNode mergeKLists(ListNode[] lists) {
        if(lists.length == 0){
            return null;
        }
        ListNode[] arr = mergeKLists0(lists);
        return arr[0];
    }

    /**
     * 使用合并算法，组合链表
     * @param lists
     * @return
     */
    public static ListNode[] mergeKLists0(ListNode[] lists) {
        int length = lists.length;
        if(length == 1){
            return lists;
        }
        ListNode[] listTmp = new ListNode[(int)Math.ceil(length/2.0)];
        ListNode[] listTmp0 =  null;
        for (int i = 0 ,j = 0; i < length; i = i+2 , j++) {
            ListNode tmp0 = null;
            if(i+1 <= length-1){
                tmp0 = mergeTwoLists(lists[i],lists[i+1]);
            }else{
                tmp0 = mergeTwoLists(lists[i],null);
            }
            listTmp[j] = tmp0;
        }
        listTmp0 = mergeKLists0(listTmp);
        return listTmp0;
    }

    /**
     * 递归实现链表插入
     * @param l1
     * @param l2
     * @return
     */
    public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        }
        else if (l2 == null) {
            return l1;
        }
        else if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        }
        else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

时间复杂度： $O (N$

运行结果：

【程序71】
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

public class ListNode {
    int val;
    ListNode next;
    ListNode(){

    }
    ListNode(int x) { val = x; }
}

/**
 * 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
 */
public class Subject71 {

    public static void main(String[] args) {
        ListNode listNode0 = new ListNode(1);
        ListNode listNode1 = new ListNode(2);
        ListNode listNode2 = new ListNode(3);
        ListNode listNode3 = new ListNode(-9);
        ListNode listNode4 = new ListNode(3);
        listNode0.next = listNode1;
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        ListNode tmp = swapPairs(listNode0);

        StringBuilder stringBuilder = null;
        while(tmp !=null){  //指向位置是否为空
            if(stringBuilder == null){
                stringBuilder = new StringBuilder();
                stringBuilder.append(tmp.val);
            }else{
                stringBuilder.append(" -> "+ tmp.val);
            }
            tmp = tmp.next;    // 指向下一个节点
        }
        System.out.println(stringBuilder.toString());
    }

    /**
     * 交换链表数据位置
     * @param head
     * @return
     */
    public static ListNode swapPairs(ListNode head) {
        ListNode newHead = new ListNode(0);
        ListNode resultHead = newHead;
        while(head != null){
            ListNode tmp0 = new ListNode(head.val);
            ListNode tmp1 = null;
            if(head.next != null){
                tmp1 = new ListNode(head.next.val);
                newHead.next = tmp1;
                tmp1.next = tmp0;
                head = head.next.next;
            }else{
                newHead.next = tmp0;
                head = null;
            }
            newHead = tmp0;

        }
        return resultHead.next;
    }
}

时间复杂度： $O(n)$

运行结果：

【程序72】
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
给你一个链表，每k个节点一组进行翻转，请你返回翻转后的链表。
k是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是k的整数倍，那么请将最后剩余的节点保持原有顺序。

示例 :
给定这个链表：1->2->3->4->5
当k= 2 时，应当返回: 2->1->4->3->5
当k= 3 时，应当返回: 3->2->1->4->5

说明 :
你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

public class ListNode {
    int val;
    ListNode next;
    ListNode(){

    }
    ListNode(int x) { val = x; }
}

/**
 * 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
 * 给你一个链表，每k个节点一组进行翻转，请你返回翻转后的链表。
 * k是一个正整数，它的值小于或等于链表的长度。
 * 如果节点总数不是k的整数倍，那么请将最后剩余的节点保持原有顺序。
 */
public class Subject72 {

    public ListNode head5 = new ListNode(0);
    public ListNode head4 = head5;

    public static void main(String[] args) {
        ListNode listNode0 = new ListNode(1);
        ListNode listNode1 = new ListNode(2);
        ListNode listNode2 = new ListNode(3);
        ListNode listNode3 = new ListNode(-9);
        ListNode listNode4 = new ListNode(3);
        listNode0.next = listNode1;
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        ListNode listNode5 = new Subject72().reverseKGroup(listNode0,2);
        StringBuilder stringBuilder = null;
        while(listNode5 !=null){  //指向位置是否为空
            if(stringBuilder == null){
                stringBuilder = new StringBuilder();
                stringBuilder.append(listNode5.val);
            }else{
                stringBuilder.append(" -> "+ listNode5.val);
            }
            listNode5 = listNode5.next;    // 指向下一个节点
        }
        System.out.println(stringBuilder.toString());
    }

    /**
     * 逆序K链表
     * @param head
     * @param k
     * @return
     */
    public ListNode reverseKGroup(ListNode head, int k){
        ListNode head0 = head;
        ListNode head1 = head;
        ListNode head2 = null;
        for (int i = 0; i < k-1; i++) {
            if(head0 != null){
                head0 = head0.next;
            }else{
                break;
            }
        }
        if(head0 != null){
            head2 = head0.next;
            head0.next = null;
        }else{
            head5.next = head;
            return head4.next;
        }
        ListNode head3 = reverseGroup(head);
        head5.next = head3;
        head5 = head3;
        while(head5.next != null){
            head5 = head5.next;
        }
        reverseKGroup(head2,k);
        return head4.next;
    }

    /**
     * 链表反转
     * @param head0
     * @return
     */
    public static ListNode reverseGroup(ListNode head0) {
        if(head0==null||head0.next==null){
            return head0;
        }
        ListNode nowHead = reverseGroup(head0.next);
        head0.next.next=head0;
        head0.next=null;
        return nowHead;
    }
}

时间复杂度： $O(n)$

运行结果：

【程序73】
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

/**
 * 给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
 * 不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
 */
public class Subject73 {
    public static void main(String[] args) {
        int[] nums = new int[]{1,2,3,4,5,5,6,6,7};
        System.out.println(new Subject73().removeDuplicates(nums));
    }

    /**
     * 删除重复元素
     * @param nums
     * @return
     */
    public int removeDuplicates(int[] nums) {
        int lengths = nums.length;
        if(lengths <=0 ){
            return 0;
        }
        int side = 0; //空位置
        int tmp = nums[0];
        boolean flag = true;
        for (int i = 1; i < lengths; i++) {
            if(tmp == nums[i]){
                if(flag){
                    side = i;
                    flag = false;
                }
            }else{
                tmp = nums[i];
                if(side > 0){
                    nums[side] = nums[i];
                    side++;
                }
            }
        }
        if(side == 0){
            return lengths;
        }
        return side;
    }
}

时间复杂度： $O(n)$

运行结果：

【程序74】
给定一个数组 nums和一个值 val，你需要原地移除所有数值等于val的元素，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

/**
 * 给定一个数组 nums和一个值 val，你需要原地移除所有数值等于val的元素，返回移除后数组的新长度。
 * 不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
 * 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
 */
public class Subject74 {
    public static void main(String[] args) {
        int[] nums = new int[]{3,2,2,3};
        System.out.println(new Subject74().removeElement(nums,3));
    }

    /**
     * 删除元素
     * @param nums
     * @param val
     * @return
     */
    public static int removeElement(int[] nums, int val) {
        int lengths = nums.length;
        if(lengths <=0 ){
            return 0;
        }
        int side = 0;
        for (int i = 0; i < lengths; i++) {
            if(val != nums[i]){
                nums[side] = nums[i];
                side++;
            }
        }
        return side;
    }
}

时间复杂度： $O(n)$

运行结果：

【程序75】
实现strStr()函数。
给定一个haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

/**
 * 实现strStr()函数。
 * 给定一个haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
 */
public class Subject75 {
    public static void main(String[] args) {
        String haystack = "ssss";
        String needle = "a";
        System.out.println(new Subject75().strStr(haystack,needle));
    }

    /**
     * 实现strStr()函数
     */
    public int strStr(String haystack, String needle) {
        if("".equals(needle) || needle == null){
            return 0;
        }else{
            if("".equals(haystack) || haystack == null ){
                return -1;
            }
        }
        char[] arr0= haystack.toCharArray();
        char[] arr1= needle.toCharArray();
        return strStr0(arr0,arr1,0,arr0.length,-1);
    }

    /**
     * 递归处理
     * @param arr0
     * @param arr1
     * @param side
     * @param lengths0
     * @param result
     * @return
     */
    public int strStr0(char[] arr0, char[] arr1,int side,int lengths0,int result) {
        if(result == 0){
            return side-1;
        }
        boolean flag = false;
        for (int i = side; i < lengths0; i++) {
            if(arr0[i] == arr1[0]){
                side = i;
                flag = true;
                break;
            }
        }
        int tmp = lengths0 - side;
        int lengths1 = arr1.length;
        if(tmp < lengths1 || !flag){
            return -1;
        }else{
            int identification = 0;
            for (int i = 1, j = side+1; i < lengths1; i++,j++) {
                if(arr0[j] != arr1[i]){
                    identification = -1;
                    break;
                }
            }
            side = side+1;
            return strStr0(arr0,arr1,side, lengths0,identification);
        }
    }
}

时间复杂度： $O(n)$

运行结果：

【程序76】
给定两个整数，被除数dividend和除数divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。
返回被除数dividend除以除数divisor得到的商。

/**
 * 给定两个整数，被除数dividend和除数divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。
 * 返回被除数dividend除以除数divisor得到的商。
 */
public class Subject76 {
    public static void main(String[] args) {
        int dividend = -2147483648;
        int divisor =  -1;
        System.out.println(-2147483648/2);
        System.out.println(new Subject76().divide(dividend,divisor));
    }

    /**
     * 实现除法，通过竖式的方式
     * @param dividend
     * @param divisor
     * @return
     */
    public int divide(int dividend, int divisor) {
        //排除一些特殊结果
        if(dividend == 0){
            return 0;
        }
        if(divisor == Integer.MIN_VALUE){
            if(dividend > Integer.MIN_VALUE){
                return 0;
            }else{
                return 1;
            }
        }

        if(divisor == 1){
            return dividend;
        }
        if(divisor == -1){
            if(dividend == Integer.MIN_VALUE) {
                return Integer.MAX_VALUE;
            }else{
                return -dividend;
            }
        }
        int result = 0;
        String s0 = String.valueOf(dividend);
        String s1 = String.valueOf(divisor);
        boolean flag = false;
        if(s0.charAt(0) == \'-\'){
            flag = true;
        }else{
            s0 = "-"+s0;
        }

        if(s1.charAt(0) == \'-\'){
            if(flag){
                flag = false;
            }else{
                flag = true;
            }
        }else{
            s1 = "-"+s1;
            divisor = -divisor;
        }
        int side = s1.length()-1;
        if(side > s0.length()-1){
            return 0;
        }
        int dividend0 = Integer.parseInt(s0.substring(0,side+1)); //临时除数
        while(true){
            side++;
            int num = dividend0 - divisor;
            int i = 0;
            while(num <= 0){
                i++;
                num = num - divisor;
            }
            result = Integer.parseInt(result+"0") + i;
            if(side >= s0.length()){
                break;
            }else{
                dividend0 = Integer.parseInt((num+divisor)+ "" +s0.charAt(side));
                if(dividend0 > 0){
                    dividend0 = -dividend0;
                }
            }
        }

        if(flag){
            return -result;
        }else{
            return result;
        }
    }
}

时间复杂度： $O(1)$

运行结果：

【程序77】
给定一个字符串s和一些长度相同的单词words。找出 s 中恰好可以由words 中所有单词串联形成的子串的起始位置。
注意子串要与words 中的单词完全匹配，中间不能有其他字符，但不需要考虑words中单词串联的顺序。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**区块链猎头分析区块链与密码货币如何相辅相成？
 区块链0216早报｜李礼辉央行数字货币将改变全球货币体系格局
 区块链数字货币真的来临了？
 区块链数字货币价值形成机制
 交易所系统开发数字货币区块链的未来
 第6讲 | 理解区块链之前，先上手体验一把数字货币