这几天再给学校里做一个考试系统，有选择题、判断题和多选题，前两个题型判断比较容易，但是在多选题上就卡壳了。要求是正确答案在三个及以上，考生输入的两个及以上正确答案挣1分。全对挣1.5分。

由于是web端的考试系统所以获取到的考生答案和正确答案均为字符串数组

代码如下：



package demo;

import java.util.Arrays;

public class MultSelectTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int count_all = 0;
        int count_part = 0;
        String[] sure_answer = { "1", "2", "3", "4" };
        String[] user_answer = { "1", "2", "3", "4" };
        if (user_answer.length <= sure_answer.length) {
        //jdk自带方法：判断两个数组是否完成相等（一一对应）
            if (Arrays.equals(sure_answer, user_answer)) {
                count_all++;
            } else if (MultSelectTest.containArray(sure_answer, user_answer)) {
                count_part++;
            }
        }
        System.out.println("多选题全对的有：" + count_all + ",多选题部分对的有：" + count_part);
    }

    // 判断sure_answer数组是否全部包含user_answer数组并且相同的元素不少于两个
    public static boolean containArray(String[] sure_answer,
            String[] user_answer) {
        //true表示多选题部分对，false表示不对
        boolean bool = true;
        // 用户输入的每一个答案都遍历正确答案数组，如果count等于正确答案数组的个数，则这个答案是错的。
        int count = 0;
        // 对题的个数：防止出现考生输入一个答案的情况
        int ques_count = 0;

        for (int i = 0; i < user_answer.length; i++) {
            for (int j = 0; j < sure_answer.length; j++) {
                if (!user_answer[i].equals(sure_answer[j])) {
                    count++;
                }
            }
            //看count声明时的注释
            if (count == sure_answer.length) {
                bool = false;
                break;
            } else {
                //表示这个打算对了
                ques_count++;
            }
            // 出现一个错误选项直接返回false
            if (!bool) {
                return bool;
            }

        }
        //相对元素的个数在两个以上才算对
        if (ques_count <= 1) {
            bool = false;
        }
        return bool;
    }
}


在注释里已经写的非常清楚了…..如果有问题的话，欢迎私信或评论….

刚开始写的那个逻辑有点混乱，只通过了三个测试点，所以今天索性又重新写了一个，这次更加的注重逻辑的实现，主要的就是使用了两个字典，一个是dir_count_wrong，用来保存每个题错误选项的次数，还有一个就是dir_list_wrong，是用来保存每个题的错误选项。
（1）首先是对正确选项以及同学的答案进行处理，放到字典中；
（2）对每一个同学的选择题进行分析，分为三种情况，全对，部分对以及答案错误，并且算出该同学的得分；
（3）在将同学的答题情况分为三种后，就可以分别进行统计， 全对时不用考虑，然后就是考虑部分对以及答案错误的情况；
（4）对每个同学的每个选项进行分析，若是错误的（这个错误包括漏选以及多选），则将该题的选项保存到该题的dir_list_wrong字典中，这个字典中的值就是错误选项的list，主要的作用就是判断该题的该选项是否是第一次出错；然后再根据是否是第一次出错，对保存选项次数的dir_count_wrong进行操作；
（5）之后就是统计出错的最多的选项，然后输出相应的格式。
def get_input(M, dir_right_answers, list_grades):
	#得到所有标准答案并存放在字典中, 并返回分数list	
	for i in range(M):
		string_right = input()
		dir_right_answers[i] = string_right
		list_grades.append(int(string_right[0]))
		
def deal_my_answer(string_my_answer):
	#对学生的答案进行处理，得到标准的list
	string_my_answer = string_my_answer[1:-1]
	string_my_answer = string_my_answer.split(') (')
	return string_my_answer
	
def judge_wrong_or_partRight(my_answer, right_answer):
	#一个同学的某个答案在没有全对的情况下判断是属于全错还是部分对的情况
	wrong_flag = False
	for num in my_answer:
		if num not in right_answer:
			wrong_flag = True
	return wrong_flag

def get_part_right_per_count(right_answer, my_answer, list_wrong, count_per):
	#得到部分正确选项的遗漏选项次数
	for num in right_answer:
		if num not in my_answer:
			if num not in list_wrong:
				list_wrong.append(num) #从来没有的加入到错误选项list
				count_per[num] = 1
			else:
				count_per[num] += 1
				
def get_wrong_count(right_answer, my_answer, list_wrong, count_per):
	#得到错误答案选项中的次数
	right_answer_copy = right_answer
	#my_answer_copy = my_answer
	for num in my_answer:
		if num in right_answer:
			right_answer_copy.remove(num)
		elif num not in list_wrong:
			list_wrong.append(num)
			count_per[num] = 1
		else:
			count_per[num] += 1
	if right_answer_copy:
		for num in right_answer_copy:
			if num not in list_wrong:
				list_wrong.append(num) #从来没有的加入到错误选项list
				count_per[num] = 1
			else:
				count_per[num] += 1			
			
def judge_my_answer(M, string_my_answer, dir_right_answers, list_grades, dir_count_wrong, dir_list_wrong,
		flag_wrong):
	#判断一个同学的答案是否正确, 并且得到其本道题的分数
	my_grades = 0
	for i in range(M):
		wrong_flag = False
		right_answer = dir_right_answers[i].split()
		right_answer = right_answer[3:] #得到只含选项的正确答案
		my_answer = string_my_answer[i].split()
		my_answer = my_answer[1:] #得到只含选项的同学所做答案
		if my_answer == right_answer:
			my_grades += list_grades[i] #全对的情况
			#print("OK")
		else: #其他的情况
			flag_wrong = True
			wrong_flag = judge_wrong_or_partRight(my_answer, right_answer)
			if wrong_flag:
				#pass
				get_wrong_count(right_answer, my_answer, dir_list_wrong[i], dir_count_wrong[i])
				#print("NO")
			else:
				my_grades += list_grades[i] * 0.5				
				get_part_right_per_count(right_answer, my_answer, dir_list_wrong[i], dir_count_wrong[i])
	print("%.1f" % my_grades)
	return flag_wrong

def get_initilazition_list(M, dir_list_wrong, dir_count_wrong):
	#初始化存放错误选项的list以及存放错误次数的字典
	for i in range(M):
		dir_list_wrong[i] = []
		dir_count_wrong[i] = {}

def get_max_count(M, dir_count_wrong, dir_list_wrong):
	#寻找错误次数最多的选项
	dir_max = {}
	max_all = 0
	list_count_all = []
	for i in range(M):
		list_count = []
		my_dir = dir_count_wrong[i]
		for num in dir_list_wrong[i]:
			list_count.append(my_dir[num])
		dir_max[i] = max(list_count)
		list_count_all.append(dir_max[i])
	max_all = max(list_count_all)
	
	#列出所有的错误次数最多的选项
	for i in range(M):
		if dir_max[i] == max_all:
			my_wrong_list = dir_list_wrong[i]
			my_wrong_list = sorted(my_wrong_list)
			for num in my_wrong_list:
				if dir_count_wrong[i][num] == max_all:
					print("%d %d-%s" % (max_all, i + 1, num))
		
if __name__ == '__main__':
	string_N_AND_M = input().split()
	N, M = int(string_N_AND_M[0]), int(string_N_AND_M[1])
	dir_right_answers = {} #存放正确答案的字典
	flag_wrong = False #标识是否有错误答案
	dir_count_wrong = {} #存放每个题所有错误答案次数的字典
	
	dir_list_wrong = {} #存放每一题错误选项list的字典
	get_initilazition_list(M, dir_list_wrong, dir_count_wrong)
	
	list_grades = [] #存放每个题分数的list
	get_input(M, dir_right_answers, list_grades)
	#print(list_grades)
	for i in range(N): #对每一个同学的情况进行分析
		string_my_answer = input()
		string_my_answer = deal_my_answer(string_my_answer)
		flag_wrong = judge_my_answer(M, string_my_answer, dir_right_answers, list_grades,
			dir_count_wrong, dir_list_wrong, flag_wrong)
	#print(dir_count_wrong)
	#print(dir_list_wrong)
	if flag_wrong:
		get_max_count(M, dir_count_wrong, dir_list_wrong)
	else:
		print("Too simple")
	

逻辑推理题是软件企业招聘的必考题型。旨在考查应聘者掌握和运用逻辑分析方法的能力。通过理解、分析、综合、判断、归纳等过程，引出概念、寻求规律，对事物间关系或事件的走向趋势做出合理判断与分析，确定解决问题的途径和方法。

1

一间囚房里关押着两个犯人。每天监狱都会为这间囚房提供一罐汤，让这两个犯人自己来分。起初，这两个人经常会发生争执，因为他们总是有人认为对方的汤比自己的多。后来他们找到了一个两全其美的办法：一个人分汤，让另一个人先选。于是争端就这么解决了。可是，现在这间囚房里又加进来一个新犯人，现在是三个人来分汤。必须寻找一个新的方法来维持他们之间的和平。该怎么办呢？按：心理问题，不是逻辑问题

2

有两个父亲分别给他们的儿子一些钱。其中一个父亲给了儿子150元，另一个父亲给了儿子100元钱。但两个儿子却说他们一共只得了150元。那100元哪里去了呢？

3

某城市发生了一起汽车撞人逃跑事件，该城市只有两种颜色的车,蓝15%绿85%，事发时有一个人在现场看见了，他指证是蓝车，但是根据专家在现场分析,当时那种条件能看正确的可能性是80%那么,肇事的车是蓝车的概率到底是多少?

4

100个人回答五道试题，有81人答对第一题，91人答对第二题，85人答对第三题，79人答对第四题，74人答对第五题，答对三道题或三道题以上的人算及格， 那么，在这100人中，至少有（ ）人及格。

5

有A、B、C和D四个少女。她们正在接受训练以便成为预言家。实际上，后来她们之中只有一个人成了预言家，并在特尔斐城谋得一个职位。其余三个人，一个当了职业舞蹈家、一个当了宫廷女侍、第三个当了演奏家。

一天，她们四个人在练习讲预言。


	
A预言：“B无论如何也成不了职业舞蹈家”。
	
	

	
B预言：“C将成为特尔斐城的预言家”。
	
	

	
C预言：“D不会成为演奏家”。
	
	

	
D预言：“她自己将嫁给一个叫阿特的男人”。
	
可是，事实上她们四个人中，只有一个人的预言是正确的，而正是这个人当了特尔斐城的预言家。能分析出这四个人的职业吗？

答案


	
是让甲分汤，分好后由乙和丙按任意顺序给自己挑汤，剩余一碗留给甲。这样乙和丙两人的总和肯定是他们两人可拿到的最大。然后将他们两人的汤混合之后再按两人的方法再次分汤。
	
	

	
这三个人就是祖孙三代，爷爷给爸爸150元钱，爸爸给儿子100元钱。这样爸爸和儿子总共得到了150元钱，爸爸是爷爷的儿子，儿子是爸爸的儿子。这样就完全满足题意了。
	
	

	
15%*80%/(85％×20％＋15%*80%)
	
	

	
70
	
	

	
A是预言家、B是宫廷女侍、C是舞蹈家、D是演奏家，没有和阿特结婚。
	
最新原创推荐：

一文轻松理解内存对齐

一文轻松理解打印有效日志

一文读懂C语言与C++动态内存

面试中常见的C语言与C++区别的问题

数据结构之线性表

深拷贝与浅拷贝到底是什么

JSON封装数据和解析数据

C/C++字符串操作的全面总结

 

为什么要特别拿出来说这周呢？因为自己在做复选题时感觉只有一个答案正确，但他是多选题，所以试错了两次后，终于在第三次错了要等8小时的恐惧下使用了百度，然后发现是单选....

因为coursera经常会调整选项顺序和答案内容，比如这周第一题，所以建议各位不要抄答案，理解了再去做。

然后上结果，先证明自己是对的，这下你们就可以听我胡说了，23333.





第一题

第一个选项：加入一个新特征总可以使样本而非训练集表现更好或相同。但童鞋你要知道你是在拟合训练集啊，所以应该是训练集更好而非样本。

第二个选项：给模型引入正则化总会在样本而非训练集上表现更好或相同，但是你要知道太大就成直线了，那是欠拟合啊。

第三个选项：同上。

第四个选项：加入更多特征确实是会导致过拟合。

 



第二题，因为最后会引入正则化项，正则化参数越大，系数就会越小，所以从0到1，我们只要找最小的就可以了



第三题：

第一个选项：因为逻辑回归输出范围在[0,1]中，无论如何，正则化只能稍微收缩一下它的范围，所以正则化通常是没用的，抱歉，正则化解决的是过拟合问题，而且收缩的是也不是输出。

第二个选项：用一个大的会导致过拟合，可以通过减小来解决。抱歉，如果是欠拟合就对了。

第三个选项：考虑一个分类问题，正则化可能会使分类错误。对呀，如果太大不就分类错了。

第四个选项：使用一个非常大的会损害你的假设模型，我们不把它设的很多的唯一原因是避免数值问题。（可以理解为计算量大引发的计算复杂问题），同上，因为可能欠拟合。