算法和数据结构面试题(15)-8张扑克的游戏

最新推荐文章于 2021-05-22 10:54:53 发布
最新推荐文章于 2021-05-22 10:54:53 发布
阅读量2.2k 收藏 1
点赞数
分类专栏： 基础知识学习 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itfootball/article/details/42174117
版权

题目


有4 张红色的牌和4 张蓝色的牌，主持人先拿任意两张，
再分别在A、B、C 三人额头上贴任意两张牌，
A、B、C 三人都可以看见其余两人额头上的牌，
看完后让他们猜自己额头上是什么颜色的牌，
A 说不知道，B 说不知道，C 说不知道，然后A 说知道了。
请教如何推理，A 是怎么知道的。
如果用程序，又怎么实现呢？

解题思路


首先组合的情形是3×3×3 = 27


public void group() {
        String[] arg = { "蓝-蓝", "红-红", "红-蓝" };
        int size = arg.length;
        int index = 0;
        for (int i = 0; i < size; i++) {
            String A = arg[i];
            for (int j = 0; j < size; j++) {
                String B = arg[j];
                for (int k = 0; k < size; k++) {
                    String C = arg[k];
                    index++;
                    String group = String.format("%s-%s-%s", A, B, C);
                    String groupStr = String.format("%s %s %s", A, B, C);
                    System.out.print(index + ": ");
                    System.out.println(groupStr);
                }
            }
        }
    }


1: 蓝-蓝 蓝-蓝 蓝-蓝
2: 蓝-蓝 蓝-蓝 红-红
3: 蓝-蓝 蓝-蓝 红-蓝
4: 蓝-蓝 红-红 蓝-蓝
5: 蓝-蓝 红-红 红-红
6: 蓝-蓝 红-红 红-蓝
7: 蓝-蓝 红-蓝 蓝-蓝
8: 蓝-蓝 红-蓝 红-红
9: 蓝-蓝 红-蓝 红-蓝
10: 红-红 蓝-蓝 蓝-蓝
11: 红-红 蓝-蓝 红-红
12: 红-红 蓝-蓝 红-蓝
13: 红-红 红-红 蓝-蓝
14: 红-红 红-红 红-红
15: 红-红 红-红 红-蓝
16: 红-红 红-蓝 蓝-蓝
17: 红-红 红-蓝 红-红
18: 红-红 红-蓝 红-蓝
19: 红-蓝 蓝-蓝 蓝-蓝
20: 红-蓝 蓝-蓝 红-红
21: 红-蓝 蓝-蓝 红-蓝
22: 红-蓝 红-红 蓝-蓝
23: 红-蓝 红-红 红-红
24: 红-蓝 红-红 红-蓝
25: 红-蓝 红-蓝 蓝-蓝
26: 红-蓝 红-蓝 红-红
27: 红-蓝 红-蓝 红-蓝

然后再通过一些条件过滤掉上面组合中一些选项


条件1.组合中的红的数量或者蓝的数量不能超过4


public void group() {
		String[] arg = { "蓝-蓝", "红-红", "红-蓝" };
		int size = arg.length;
		int index = 0;
		for (int i = 0; i < size; i++) {
			String A = arg[i];
			for (int j = 0; j < size; j++) {
				String B = arg[j];
				for (int k = 0; k < size; k++) {
					String C = arg[k];
					index++;
					String group = String.format("%s-%s-%s", A, B, C);
					String groupStr = String.format("%s %s %s", A, B, C);
					if (getStrCount(group)) {
						System.out.print(index + ": ");
						System.out.println(groupStr);
					}
				}
			}
		}
	}

	public boolean getStrCount(String str) {
		String[] args = str.split("-");
		int blueCount = 0;
		int redCount = 0;
		for (int i = 0; i < args.length; i++) {
			if (args[i].equals("蓝")) {
				blueCount++;
			} else if (args[i].equals("红")) {
				redCount++;
			}
		}
		if (blueCount > 4 || redCount > 4) {
			return false;
		}
		return true;
	}


过滤掉上面编号为1，3，7，14，15，17，19，23八种情况。还剩19种。


2: 蓝-蓝 蓝-蓝 红-红
4: 蓝-蓝 红-红 蓝-蓝
5: 蓝-蓝 红-红 红-红
6: 蓝-蓝 红-红 红-蓝
8: 蓝-蓝 红-蓝 红-红
9: 蓝-蓝 红-蓝 红-蓝
10: 红-红 蓝-蓝 蓝-蓝
11: 红-红 蓝-蓝 红-红
12: 红-红 蓝-蓝 红-蓝
13: 红-红 红-红 蓝-蓝
16: 红-红 红-蓝 蓝-蓝
18: 红-红 红-蓝 红-蓝
20: 红-蓝 蓝-蓝 红-红
21: 红-蓝 蓝-蓝 红-蓝
22: 红-蓝 红-红 蓝-蓝
24: 红-蓝 红-红 红-蓝
25: 红-蓝 红-蓝 蓝-蓝
26: 红-蓝 红-蓝 红-红
27: 红-蓝 红-蓝 红-蓝

条件2.A不知道，B不知道，C不知道。说明三个人当中不能每个人手里的两张牌都是一样的颜色。


反证法：如果出现三个人当中每个人手里的牌都是颜色一样的。那么第一次的时候，3个人当中一眼就直接能猜出来了。


public void group() {
		String[] arg = { "蓝-蓝", "红-红", "红-蓝" };
		int size = arg.length;
		int index = 0;
		for (int i = 0; i < size; i++) {
			String A = arg[i];
			for (int j = 0; j < size; j++) {
				String B = arg[j];
				for (int k = 0; k < size; k++) {
					String C = arg[k];
					index++;
					String groupStr = String.format("%s %s %s", A, B, C);

					// 条件1
					String group = String.format("%s-%s-%s", A, B, C);
					if (!getStrCount(group))
						continue;
					// 条件2
					if (!isEveryOneSame(A) && !isEveryOneSame(B)
							&& !isEveryOneSame(C))
						continue;
					System.out.print(index + ": ");
					System.out.println(groupStr);
				}
			}
		}
	}

	// 条件2
    private boolean isEveryOneSame(String one) {
        String[] args = one.split("-");
        if (args[0].equals(args[1])) {
            return true;
        }
        return false;
    }

	// 条件1
	private boolean getStrCount(String str) {
		String[] args = str.split("-");
		int blueCount = 0;
		int redCount = 0;
		for (int i = 0; i < args.length; i++) {
			if (args[i].equals("蓝")) {
				blueCount++;
			} else if (args[i].equals("红")) {
				redCount++;
			}
		}
		if (blueCount > 4 || redCount > 4) {
			return false;
		}
		return true;
	}


可能的组合就剩下了下面几种了。


6: 蓝-蓝 红-红 红-蓝
8: 蓝-蓝 红-蓝 红-红
9: 蓝-蓝 红-蓝 红-蓝
12: 红-红 蓝-蓝 红-蓝
16: 红-红 红-蓝 蓝-蓝
18: 红-红 红-蓝 红-蓝
20: 红-蓝 蓝-蓝 红-红
21: 红-蓝 蓝-蓝 红-蓝
22: 红-蓝 红-红 蓝-蓝
24: 红-蓝 红-红 红-蓝
25: 红-蓝 红-蓝 蓝-蓝
26: 红-蓝 红-蓝 红-红
27: 红-蓝 红-蓝 红-蓝


可以排除编号2，4，5，10，11，13六种情况。还剩13种。


条件3.上面的情况中，要排除C可以根据A,B的不知道，然后可以一眼就能看出自己是什么牌组合。


这种情况就是A手中的牌颜色是一样的，B手中的牌颜色也是一样的。例如6和12


public void group() {
		String[] arg = { "蓝-蓝", "红-红", "红-蓝" };
		int size = arg.length;
		int index = 0;
		for (int i = 0; i < size; i++) {
			String A = arg[i];
			for (int j = 0; j < size; j++) {
				String B = arg[j];
				for (int k = 0; k < size; k++) {
					String C = arg[k];
					index++;
					String groupStr = String.format("%s %s %s", A, B, C);

					// 条件1
					String group = String.format("%s-%s-%s", A, B, C);
					if (!getStrCount(group))
						continue;
					// 条件2
					if (isEveryOneSame(A) && isEveryOneSame(B)
							&& isEveryOneSame(C))
						continue;
					// 条件3
					if (isEveryOneSame(A) && isEveryOneSame(B))
						continue;
					System.out.print(index + ": ");
					System.out.println(groupStr);
				}
			}
		}
	}

	// 条件2
	private boolean isEveryOneSame(String one) {
		String[] args = one.split("-");
		if (args[0].equals(args[1])) {
			return true;
		}
		return false;
	}

	// 条件1
	private boolean getStrCount(String str) {
		String[] args = str.split("-");
		int blueCount = 0;
		int redCount = 0;
		for (int i = 0; i < args.length; i++) {
			if (args[i].equals("蓝")) {
				blueCount++;
			} else if (args[i].equals("红")) {
				redCount++;
			}
		}
		if (blueCount > 4 || redCount > 4) {
			return false;
		}
		return true;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Problem22 problem = new Problem22();
		problem.group();
	}

}


还剩下11种情况。


8: 蓝-蓝 红-蓝 红-红
9: 蓝-蓝 红-蓝 红-蓝
16: 红-红 红-蓝 蓝-蓝
18: 红-红 红-蓝 红-蓝
20: 红-蓝 蓝-蓝 红-红
21: 红-蓝 蓝-蓝 红-蓝
22: 红-蓝 红-红 蓝-蓝
24: 红-蓝 红-红 红-蓝
25: 红-蓝 红-蓝 蓝-蓝
26: 红-蓝 红-蓝 红-红
27: 红-蓝 红-蓝 红-蓝

得出结果


上面剩下的11中情况都是符合实际的拿牌情况，以及根据A,B,C第一轮都无法判断出自己手中的牌这些条件过滤后的组合。那么再根据最后一个第二轮A就已经知道自己的牌了。说明从上面组合中找出，以B,C组合为关键字的，A只有一种情况的组合。比如情况8中，B,C组合是“红-蓝 红-红”，那么根据这个去找找看，同样是这个条件的A还有没有其他情况。很显然发现了第26号符合。说明这种组合是不符合要求的。而第20号的“蓝-蓝 红-红”只有一种情况，说明符合要求。那用程序怎么实现，我们可以以B+C为关键字组建一个map，value值为这个关键字在上面11情况中出现的次数。这样我们可以得到出现一次的关键字，这样很容易确定是第几号。


public class Problem22 {
    //以BC为关键字，次数为value的MAP
    Map<String,Integer> map = new LinkedHashMap<String,Integer>();
    //以BC为关键字，组合为value的MAP
    Map<String,String> map1 = new LinkedHashMap<String,String>();

    public void group() {
        String[] arg = { "蓝-蓝", "红-红", "红-蓝" };
        int size = arg.length;
        int index = 0;
        for (int i = 0; i < size; i++) {
            String A = arg[i];
            for (int j = 0; j < size; j++) {
                String B = arg[j];
                for (int k = 0; k < size; k++) {
                    String C = arg[k];
                    index++;
                    String groupStr = String.format("%s %s %s", A, B, C);

                    // 条件1
                    String group = String.format("%s-%s-%s", A, B, C);
                    if (!getStrCount(group))
                        continue;
                    // 条件2
                    if (isEveryOneSame(A) && isEveryOneSame(B)
                            && isEveryOneSame(C))
                        continue;
                    // 条件3
                    if (isEveryOneSame(A) && isEveryOneSame(B))
                        continue;

                    if(map.containsKey(B + C)){
                       int num =  map.get(B+C);
                       map.put(B+C,++num);
                    }else{
                        map.put(B+C,1);
                    }
                    map1.put(B+C,index + ": "+groupStr);
                    System.out.print(index + ": ");
                    System.out.println(groupStr);
                }
            }
        }
        Set<Map.Entry<String, Integer>> entrys = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iter = entrys.iterator();
        //找到次数为1的组合
        while(iter.hasNext()){
            Map.Entry<String, Integer> entry= iter.next();
            if(entry.getValue() ==1){
                String answer = map1.get(entry.getKey());
                System.out.println("从上面的组合中找到的符合条件的答案为 ： "+answer);
            }
        }


    }

    // 条件2
    private boolean isEveryOneSame(String one) {
        String[] args = one.split("-");
        if (args[0].equals(args[1])) {
            return true;
        }
        return false;
    }

    // 条件1
    private boolean getStrCount(String str) {
        String[] args = str.split("-");
        int blueCount = 0;
        int redCount = 0;
        for (int i = 0; i < args.length; i++) {
            if (args[i].equals("蓝")) {
                blueCount++;
            } else if (args[i].equals("红")) {
                redCount++;
            }
        }
        if (blueCount > 4 || redCount > 4) {
            return false;
        }
        return true;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Problem22 problem = new Problem22();
        problem.group();
    }

}

结果为 


8: 蓝-蓝 红-蓝 红-红
9: 蓝-蓝 红-蓝 红-蓝
16: 红-红 红-蓝 蓝-蓝
18: 红-红 红-蓝 红-蓝
20: 红-蓝 蓝-蓝 红-红
21: 红-蓝 蓝-蓝 红-蓝
22: 红-蓝 红-红 蓝-蓝
24: 红-蓝 红-红 红-蓝
25: 红-蓝 红-蓝 蓝-蓝
26: 红-蓝 红-蓝 红-红
27: 红-蓝 红-蓝 红-蓝
从上面的组合中找到的符合条件的答案为 ： 20: 红-蓝 蓝-蓝 红-红
从上面的组合中找到的符合条件的答案为 ： 21: 红-蓝 蓝-蓝 红-蓝
从上面的组合中找到的符合条件的答案为 ： 22: 红-蓝 红-红 蓝-蓝
从上面的组合中找到的符合条件的答案为 ： 24: 红-蓝 红-红 红-蓝


有4种情况下，A可以猜出自己的牌。当然需要A能有这么强的逻辑。


总结


有没有发现可能的情况中A  手中的牌都是一样的：红蓝。所以以后你就猜自己是红蓝就行了吧。

Q博士
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法大全-面试题-链表-栈-二叉树-数据结构.docx
09-01
算法大全-面试题-链表-栈-二叉树-数据结构，C#版，主要三大块，一，单链表，二，栈和队列，三，二叉树。 每一大块又有许多新鲜好玩的玩法，你会很喜欢的会上瘾的。 适合玩算法的朋友。
头脑风暴:有4 张红色的牌和4 张蓝色的牌,主持人先拿任意两张
Malj的博客
07-21 2253
本文是作者 看到 一道面试题后的 一点个人思考，如果你在观看本文时，有更多的想法，请不吝赐教，非常感谢。 转载 请注明出处。 题目原文:     有4 张红色的牌和4 张蓝色的牌，主持人先拿任意两张，再分别在A、B、C 三人额头上贴任意两张牌，A、B、C 三人都可以看见其余两人额头上的牌，看完后让他们猜自己额头上是什么颜色的牌，A 说不知道，B 说不知道，C 说不知道，然后A 说知道了。
数据结构c语言纸牌游戏,数据结构 c语言 循环队列实现扑克牌问题
weixin_29784009的博客
05-22 728
题目1：实现扑克牌问题扑克牌原理：有A-K共13张牌摞在一起，不知道其中的顺序，拿出最上面的一张放在最下面，拿出第二张牌放在桌子上，循环操作，直到所有牌放在桌子上，桌子上的牌的顺序是A-K，问牌摞在一起的顺序是什么？#includetypedef struct Queue{int index; //原序号}Queue;Queue qw[10001];int main(){int result[13...
【编程题目】有 4 张红色的牌和 4 张蓝色的牌，主持人先拿任意两张，再分别在 A、B、C 三人额头上贴...
weixin_34104341的博客
09-15 485
第 22 题（推理）：有 4 张红色的牌和 4 张蓝色的牌，主持人先拿任意两张，再分别在 A、B、C 三人额头上贴任意两张牌，A、B、C 三人都可以看见其余两人额头上的牌，看完后让他们猜自己额头上是什么颜色的牌，A 说不知道，B 说不知道，C 说不知道，然后 A 说知道了。请教如何推理，A 是怎么知道的。如果用程序，又怎么实现呢？   推理：设A有x1张红色牌 y1张蓝色牌         ...
魔法师与扑克牌游戏 C++队列题目
QQGUOsiBO的博客
02-07 3530
#include<bits/stdc++.h> using namespace std; queue<int> q; int ans[100010]; int main() { int m; scanf("%d",&m); for(int i=m;i>=2;i--) { q.push(i); fo...
有4张红色的牌和4张蓝色的牌，主持人先拿任意两张，剩余6张再分别在A、B、C三人额头上贴任意两张牌， A、B、C三人都可以看见其余两人额头上的牌，看完后让他们猜自己额头上是什么颜色的牌， A说不知道，
李棚的CSDN专栏
10-13 2764
有4张红色的牌和4张蓝色的牌，主持人先拿任意两张，剩余6张再分别在A、B、C三人额头上贴任意两张牌， A、B、C三人都可以看见其余两人额头上的牌，看完后让他们猜自己额头上是什么颜色的牌， A说不知道，B说不知道，C说不知道，然后A说知道了。 请教如何推理，A是怎么知道的。 如果用程序，又怎么实现呢？ 分析： ABC三人头上的组合有三种：r
算法、数据结构和编程面试示例 - Java - 下载.zip
最新发布
09-15
算法、数据结构和编程面试示例 - Java - 下载.zip
算法大全-面试题-数据结构1
08-08
那就只能从头遍历一次找到倒数第二个节点了。此外，这道题目的一个变身就是将一个环状单链表拆开（即删除其中一个元素），此时，只要使用上面那两行代码就可以了，不需要考
2021数据结构与算法面试题
08-14
2021年最新整合的数据结构与算法的面试题，一共100多页的文档，需要的小伙伴可以拿走，里面有按编程语言区分需要学习的算法知识点，很详细很全面。
java基础算法与数据结构面试题
09-04
java基础算法与数据结构面试题
数据结构--魔术师发牌问题
07-18
c语言实现：创建循环链表,放牌顺序计算
数据结构实验-扑克牌配对快速排序算法
10-26
一、问题描述 根据给定的关键字序列，运用快速排序算法对其进行排序。 输入格式： 8, 10, 5, 6, 3, 13 二、实验目的 掌握快速排序算法。 三、实验内容及要求 1、构造关键字序列的存储结构。 2、实现快速排序算法。
22.有4张红色的牌和4张蓝色的牌，主持人先拿任意两张
游刃有余则成的专栏
10-22 3457
http://blog.csdn.net/v_JULY_v/article/details/6126444 有4张红色的牌和4张蓝色的牌，主持人先拿任意两张， 再分别在A、B、C三人额头上贴任意两张牌， A、B、C三人都可以看见其余两人额头上的牌， 看完后让他们猜自己额头上是什么颜色的牌， A说不知道，B说不知道，C说不知道，然后A说知道了。 请教如何推理，A是怎么知道的。如果用程序，
哈理工OJ 1923 纸牌游戏（贪心算法）
linlinsong—ACM界蒟水！
03-28 852
题目链接：http://acm.hrbust.edu.cn/index.php?m=ProblemSet&a=showProblem&problem_id=1923【思路分析】tom的手牌有m张，而且我们已知了tom的手牌是什么，然后问tom至少能赢多少局，那么我们可以从剩下的牌中找出最大的m张牌作为另外一个人的牌。然后在比较的时候tom每出一张牌，另外的人出手里可以大过tom的最小牌，然后这样子就
洗纸牌算法
weixin_33816821的博客
06-08 105
import java.util.Random; class Card { int Suit; //颜色 char Number; //卡的数量 } public class PokeShow { static Card[] OneCard=new Card[52]; //保存每张扑克的花色、数字 static void Sh...
算法第四版2.1.13纸牌排序
qq_43679056的博客
01-30 1587
算法第四版2.1.13 纸牌排序 题目：将一个扑克牌按照花色排序（花色顺序为黑桃、红桃、梅花和方片） 限制条件为所有牌都是背面朝上排成一列，而你只能翻看或者交换两张牌 首先，我们可以分别设置扑克牌的顺序 设置黑桃为1 红桃为2 梅花为3 而方片就为4 首先设置一个初始数组： Integer[] integers = {1,4,3,4,4,3,1,3,2,3,1,3,3,4,3,4,1,2,1,2...
算法与数据结构面试题(23)-将字符串转化为整形
doctorq
12-31 3291
题目 输入一个表示整数的字符串,把该字符串转换成整数并输出。 例如输入字符串"345",则输出整数 345。 个人理解 这个面试题不太 涉及算法和数据结构，主要考察你的编程习惯，有没有意识去做一些验证，对输入的校验。小问题验证大方面。乘机我们来看看java api中对这个问题的处理 代码 public static int parseInt(Strin
算法与数据结构面试题(6)-腾讯面试题
doctorq
12-12 3134
题目 给你10 分钟时间，根据上排给出十个数，在其下排填出对应的十个数 要求下排每个数都是先前上排那十个数在下排出现的次数。 上排的十个数如下： 【0，1，2，3，4，5，6，7，8，9】 初看此题，貌似很难，10 分钟过去了，可能有的人，题目都还没看懂。 举一个例子， 数值: 0,1,2,3,4,5,6,7,8,9 分配: 6,2,1,0,0,0,1,0,0,0 0 在
每天学一点算法-线性查找算法
doctorq
11-29 2846
线性查找算法 定义 BFPRT 算法解决的问题十分经典，即从某n个元素的序列中选出第k大（第k小）的元素，通过巧妙的分析，BFPRT 可以保证在最坏情况下仍为线性时间复杂度。该算法的思想与快速排序思想相似，当然，为使得算法在最坏情况下，依然能达到o(n)的时间复杂度，五位算法作者做了精妙的处理。 步骤 1.将n个元素每 5 个一组，分成n/5(上界)组。
c++数据结构和算法面试题
05-13
好的，下面是一些常见的C++数据结构和算法面试题： 1. 实现一个单链表，并实现插入、删除和查找操作。 2. 实现一个二叉搜索树，并实现插入、删除和查找操作。 3. 实现一个堆，并实现插入、删除和查找操作。 4. 实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值