计算糖果、n个数里出现次数大于等于n/2的数

1.下列关于java并发的说法中正确的是：B
A.copyonwritearraylist适用于写多读少的并发场景
B.readwritelock适用于读多写少的并发场景
C.concurrenthashmap的写操作不需要加锁，读操作需要加锁
D.只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了
解析：
A：CopyOnWrite并发容器用于读多写少的并发场景，Copy-On-Write简称COW，是一种用于程序设计中的优化策略。其基本思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把内容Copy出去形成一个新的内容然后再改，这是一种延时懒惰策略。从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet。
C：在JDK1.7之前，ConcurrentHashMap是通过分段锁机制来实现的，所以其最大并发度受Segment的个数限制。因此，在JDK1.8中，ConcurrentHashMap的实现原理摒弃了这种设计，而是选择了与HashMap类似的数组+链表+红黑树的方式实现，而加锁则采用CAS和synchronized实现。读写都加锁
D：volatile保证内存可见性和有序性（内存屏障实现），不能保证原子性。
2.在Java中，HashMap中是用哪些方法来解决哈希冲突的？C
A.开放地址法
B.二次哈希法
C.链地址法
D.建立一个公共溢出区
解析：
解决哈希冲突常用的两种方法是：开放定址法和链地址法
开放定址法：当冲突发生时，使用某种探查(亦称探测)技术在散列表中形成一个探查(测)序列。沿此序列逐个单元地查找，直到找到给定的关键字，或者碰到一个开放的地址(即该地址单元为空)为止（若要插入，在探查到开放的地址，则可将待插入的新结点存人该地址单元）。查找时探查到开放的地址则表明表中无待查的关键字，即查找失败。
链地址法：将所有关键字为同义词的结点链接在同一个单链表中。
3.下列代码的输出结果是(B)

booleanb=true?false:true==true?false:true;
System.out.println(b);

A.true
B.false
C.null
D.空字符串
解析：
== 优先级高于三目运算符
第一步：((true==true)?false:true)结果为false;
第二步：true?false:false结果为false；第三步：b=false;
4.标题：计算糖果
A,B,C三个人是好朋友,每个人手里都有一些糖果,我们不知道他们每个人手上具体有多少个糖果,但是我们知道以下的信息：
A-B,B-C,A+B,B+C.这四个数值.每个字母代表每个人所拥有的糖果数. 现在需要通过这四个数值计算出每个人手里有多少个糖果,即A,B,C。这里保证最多只有一组整数A,B,C满足所有题设条件。
输入描述： 输入为一行，一共4个整数，分别为A-B，B-C，A+B，B+C，用空格隔开。范围均在-30到30之间(闭区间)。
输出描述： 输出为一行，如果存在满足的整数A，B，C则按顺序输出A，B，C，用空格隔开，行末无空格。如果不存在这样的整数A，B，C，则输出No
示例1: 输入 1-2 3 4 输出 2 1 3

public class Test1 {
    public static List<Integer> Solution(int[] num){
        List<Integer> list = new ArrayList<>(3);
        int a =  num[0]+num[2];
        int A = a/2;
        int b = num[1]+num[3];
        int B = b/2;
        int aac = num[0]+num[3];
        int C1 = aac-A;
        int dac = num[0]+num[1];
        int C2 = A-dac;
        if(C1!=C2){
            return null;
        }
        list.add(A);
        list.add(B);
        list.add(C1);
        return list;
    }
    public static void main(String[] args) {
        int[] num = new int[4];
        Scanner sc = new Scanner(System.in);
        for(int i = 0;i<num.length;i++){
            num[i] = sc.nextInt();
        }
        List<Integer> list = Solution(num);
        if(list==null){
            System.out.println("No");
        }else{
            System.out.println(list.get(0)+" "+list.get(1)+" "+list.get(2));
        }
    }
}
//方法二：
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int y1, y2, y3, y4;
        float a, b, c;
        while (in.hasNextInt()) {
            y1 = in.nextInt();
            y2 = in.nextInt();
            y3 = in.nextInt();
            y4 = in.nextInt();
            a = (y1 + y3) / 2f; b = (y3 - y1) / 2f; c = (y4 - y2) / 2f;
            if ((a - ((y1 + y3) / 2)) != 0) {
                System.out.print("No");
                return;
            }
            if ((b - ((y3 - y1) / 2) != 0) || (b != ((y2 + y4) / 2))) {
                System.out.print("No");
                return;
            }
            if ((c - ((y4 - y2) / 2)) != 0) {
                System.out.print("No");
                return;
            }
            //满足所有的约束条件，输出解。
            System.out.print((int) a + " " + (int) b + " " + (int) c);
        }
    }
}

5.标题：n个数里出现次数大于等于n/2的数
输入n个整数，输出出现次数大于等于数组长度一半的数。
输入描述：
每个测试输入包含n个空格分割的n个整数，n不超过100，其中有一个整数出现次数大于等于n/2。
输出描述：
输出出现次数大于等于n/2的数。 示例1: 输入 393256732333 输出 3

public class Test2 {
    public static List<Integer> Solution(List<Integer> list){
        List<Integer> result = new ArrayList<>();
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i = 0;i<list.size();i++){
            int num = list.get(i);
            int count = map.getOrDefault(num,0);
            map.put(num,count+1);
        }
        int len = list.size()/2;
        Set<Integer> set = map.keySet();
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()){
            int key = it.next();
            int value = map.get(key);
            if(value>=len){
                result.add(key);
            }
        }
//        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
//            int key = entry.getKey();
//            int value = entry.getValue();
//            if(value>=len){
//                result.add(key);
//            }
//        }
        return result;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        List<Integer> list = new ArrayList<>();
        String num = sc.nextLine();
        String[] number = num.split(" ");
        for(int i = 0;i<number.length;i++){
            String a = number[i];
            int b = Integer.parseInt(a);
            list.add(b);
        }
        List<Integer> result = Solution(list);
        System.out.println(result);
    }
}
//方法二
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[] strs = str.split(" ");
            int[] arr = new int[strs.length];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = Integer.valueOf(strs[i]);
            }
            int num = arr[0];
            int count = 0;
            for (int j = 1; j < arr.length; j++) {
                if (arr[j] == num) {
                    count++;
                } else if (count > 0) {
                    count--;
                } else {
                    num = arr[j];
                }
            }
            System.out.println(num);
        }
    }
}