精华内容
下载资源
问答
  • 魔术师的猜牌术

    2017-01-23 15:12:59
    魔术师将最上面的那张牌数为1,把它翻过来正好是黑桃A,将黑桃A放在桌子上,然后按顺序从上到下数手上的余牌,第二次数1、2,将第张牌放在这迭牌的下面,将第二张牌翻过来,正好是黑桃2,也将它放在桌子上,第三...

    魔术师的猜牌术(1)


    魔术师利用一副牌中的13张黑桃,预先将它们排好后迭在一起,牌面朝下。对观众说:我不看牌,只数数就可以猜到每张牌是什么,我大声数数,你们听,不信?你们就看。魔术师将最上面的那张牌数为1,把它翻过来正好是黑桃A,将黑桃A放在桌子上,然后按顺序从上到下数手上的余牌,第二次数12,将第一张牌放在这迭牌的下面,将第二张牌翻过来,正好是黑桃2,也将它放在桌子上,第三次数123,将前面两张依次放在这迭牌的下面,再翻第三张牌正好是黑桃3。这样依次进行将13张牌全翻出来,准确无误。问魔术师手中的牌原始顺序是怎样安排的?


    *问题分析与算法设计
    题目已经将魔术师出牌的过程描述清楚,我们可以利用倒推的方法,很容易地推出原来牌的顺序。
    人工倒推的方法是:在桌子上放13空盒子排成一圈,从1开始顺序编号,将黑桃A放入1号盒子中,从下一个空盒子开始对空的盒子计数,当数到第二个空盒子时,将黑桃2放入空盒子中,然后再从下一个空盒子开始对空盒子计数,顺序放入345…,直到放入全部3张牌。注意在计数时要跳过非空的盒子,只对空盒子计数。最后牌在盒子中的顺序,就是魔术师手中原来牌的顺序。
    这种人工的方法是行之有效的,计算机可以模拟求解。


    #include<stdio.h>
    int a[14];
    int main()
    {
    int i,n,j=1; /*j:数组(盒子)下标,初始时为1号元素*/
    printf("The original order of cards is:");
    for(i=1;i<=13;i++) /*i:要放入盒子中的牌的序号*/
    {
        n=1;
    	do{
    	    if(j>13)
    	      {j=1;}/*由于盒子构成一个圈,j超过最后一个元素则指向1号元素*/
    	    if(a[j]) 
    		  {j++;} /*跳过非空的盒子,不进行计数*/
    	    else{ 
    		if(n==i) 
    		{a[j]=i;} /*若数到第i个空盒子,则将牌放入空盒中*/
    	    j++;n++; /*对空盒计数,数组下标指向下一个盒子*/
    	   } 
    	}while(n<=i); /*控制空盒计数为i*/
    }
    for(i=1;i<=13;i++) /*输出牌的排列顺序*/
    printf("%d ",a[i]);
    printf("\n");
    }

    魔术师的猜牌术(2)


    魔术师再次表演,他将红桃和黑桃全部迭在一起,牌面朝下放在手中,对观众说:最上面一张是黑桃A,翻开后放在桌上。以后,从上至下每数两张全依次放在最底下,第三张给观众看,便是黑桃2,放在桌上后再数两张依次放在最底下,第三张给观众看,是黑桃3。如此下去,观众看到放在桌子上牌的顺序是:
    黑桃 A 2 3 4 5 6 7 8 9 10 J Q K
    红桃 A 2 3 4 5 6 7 8 9 10 J Q K
    问魔术师手中牌的原始顺序是什么?


    *问题分析与算法设计
    本题可在上题的基础上进行编程,不同的在于计数的方法和牌的张数,这些并不影响我们求解题目的思路,仍可按照倒推的方法,得到原来魔术师手中的牌的顺序。



    #include<stdio.h>
    int a[27];
    int main()
    {
    int i,n,j=1;
    a[1]=1; /*初始化第一张牌*/
    printf("The original order of cards is:(r:rad b:block):\n");
    for(i=2;i<=26;i++)
    {
    n=1;
    do{ 
    if(j>26) j=1; /*超过最后一个元素则指向1号元素*/
    if(a[j]) j++; /*跳过非空的盒子,不进行计数*/
    else{
    if(n==3) a[j]=i; /*若数到第3个空盒子,则将牌放入空盒中*/
    j++; n++; /*对空盒计数,数组下标指向下一个盒子*/
    }
    }while(n<=3); /*控制空盒计数为3*/
    }
    for(i=1;i<=26;i++) /*输出牌的排列顺序*/
    {
    printf("%c",a[i]>13? 'r':'b');
    printf("%d ",a[i]>13? a[i]-13:a[i]);
    if(i==13) printf("\n");
    }
    printf("\n");
    }



    展开全文
  • [cocos2dx]斗地主制作之"排序”算法

    千次阅读 2013-12-29 18:54:57
    制作斗地主的时候,发完牌还有个牌的排序是要考虑的问题之,这里的排序并不是一般的简单的冒泡排序,我的思想是将牌成0-51,以13作为个基准分类,例如0-12分别对应的是红桃A-K,13-25对应的是黑桃A-K,26-38...

    制作斗地主的时候,发完牌还有一个牌的排序是要考虑的问题之一,这里的排序并不是一般的简单的冒泡排序,我的思想是将牌排成0-51,以13作为一个基准分类,例如0-12分别对应的是红桃A-K,13-25对应的是黑桃A-K,26-38对应的是方块A-K,39-51是梅花A-K。然后服务器将分给每个玩家的17个数转化成牌的数组进行排序,下面给出算法,这里感谢@灰太龙的指点!

    Code:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace 随机排序
    {
        class Program
        {
            static void Main(string[] args)
            {
                int[] array = { 1, 2, 6, 33, 44, 23, 36, 5, 9, 14,0,14,15 };
                //洗牌从大到小
                //int[] array = { 1, 2, 3, 4, 5, 6,0 };
                BubbleSortFunction(array);
                foreach (int i in array)
                {
                    Console.Write(i + ",");
                }
            }
    
            //冒泡排序(从数组的起始位置开始遍历,以大数为基准:大的数向下沉一位)
            private static void BubbleSortFunction(int[] array)
            {
                int length = array.Length;
                int temp;
                bool hasExchangeAction; //记录此次大循环中相邻的两个数是否发生过互换(如果没有互换,则数组已经是有序的)
    
                for (int i = 0; i < length - 1; i++)    //数组有N个数,那么用N-1次大循环就可以排完
                {
                    hasExchangeAction = false;  //每次大循环都假设数组有序
    
                    for (int j = 0; j < length - i - 1; j++)    //从数组下标0处开始遍历,(length - i - 1 是刨除已经排好的大数)
                    {
                        int p1 = array[j] % 13;
                        int p2 = array[j + 1] % 13;
                        if (p1 == 0) p1 = 14;
                        if (p2 == 0) p2 = 14;
                        if (p1 == 1) p1 = 15;
                        if (p2 == 1) p2 = 15;
                        if (array[j] == 52) p1 = 16;
                        if (array[j + 1] == 52) p2 = 16;
                        if (array[j] == 53) p1 = 17;
                        if (array[j + 1] == 53) p2 = 17;
                        if (p1 < p2)    //相邻两个数进行比较,如果前面的数大于后面的数,则将这相邻的两个数进行互换
                        {
                            temp = array[j];
                            array[j] = array[j + 1];
                            array[j + 1] = temp;
                            hasExchangeAction = true;   //发生过互换
                        }
                    }
                    if (!hasExchangeAction) //如果没有发生过互换,则数组已经是有序的了,跳出循环
                    {
                        break;
                    }
                }
            }
        }
    }
    

    结果:



    说明:按照我上面所说的规则,会发现其实转化成牌其实是从大到小排序的,最左边是红桃2,然后是黑桃2,然后是红桃A,这样依次类推!

    展开全文
  • 排序规则:先按花色,依次为黑桃、红桃、梅花、方片,同花色的按点数从小到大。其中,点数A视作点数1。 输出格式:每人占1行,相邻两张牌之间用1个空格分开。 数组card代表52张不同的扑克,其中10002000...

    题目:
    请设计一个随机洗牌系统,将52张除大小王外的扑克随机发给4个人 ,并对每个人手中的牌进行排序后输出。
    排序规则:先按花色排,依次为黑桃、红桃、梅花、方片,同花色的按点数从小到大排。其中,点数A视作点数1。
    输出格式:每人占1行,相邻两张牌之间用1个空格分开。
    分析:
    数组card代表52张不同的扑克,其中10002000的代表黑桃牌,20003000的代表红桃牌…依题目要求类推,由于篇幅问题,这个数组并没有展示完整。题目中的#include <time.h>的目的是每次随机数组都能根据时间变化使rand函数获得不同的数字,增大随机性,洗牌环节是从52张牌中依次随机取出1000对牌,进行混序,发牌是我是通过4个循环,1个循环变量增加4来代表给四个人发牌,也就是让这打乱的52张牌的第一张发给玩家1,第二张牌发给玩家2……因为刚开始为了区分花色,我们用1000,2000,3000,4000代表了,所以这里排序就相对简单,直接让一位玩家13张牌中的某1张牌分别与其他12张牌依次比较,进行13次即可。打印环节,用if语句通过比较数值的大小区分花色并减去相应的千分位打印出来这张扑克牌,因为要求先打印黑桃牌,然后红桃,然后…,所以对于1位玩家我们设了4个循环,分别打印不同花色的牌。

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #define random(x,y) (rand()%x+y)
    int main()
    {
        int card[52]={1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,
                        2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,
                        3001,3002,3003,3004,3005,3006,3007,3008,3009,3010,3011,3012,3013,
                        4001,4002,4003,4004,4005,4006,4007,4008,4009,4010,4011,4012,4013};
        int i,j,a=1000,tmp;
        int player1[13],player2[13],player3[13],player4[13];
        srand((int)time(NULL));
        while(a)//洗牌
        {
            i=random(25,1);
            j=random(25,27);
            tmp=card[i];
            card[i]=card[j];
            card[j]=tmp;
            a--;
        }
        for(i=0,j=0;i<52,j<13;i+=4,j++)//发给一号玩家的牌
        {
            player1[j]=card[i];
        }
        for(i=1,j=0;i<52,j<13;i+=4,j++)//发给二号玩家的牌
        {
            player2[j]=card[i];
        }
        for(i=2,j=0;i<52,j<13;i+=4,j++)//发给三号玩家的牌
        {
            player3[j]=card[i];
        }
        for(i=3,j=0;i<52,j<13;i+=4,j++)//发给四号玩家的牌
        {
            player4[j]=card[i];
        }
        for(i=0;i<13;i++)//以下4个循环给每个玩家按题目指定排序
        {
            for(j=0;j<13;j++)
            {
                if(player1[i]>player1[j])
                {
                    tmp=player1[i];
                    player1[i]=player1[j];
                    player1[j]=tmp;
                }
            }
        }
    
        for(i=0;i<13;i++)
        {
            for(j=0;j<13;j++)
            {
                if(player2[i]>player2[j])
                {
                    tmp=player2[i];
                    player2[i]=player2[j];
                    player2[j]=tmp;
                }
            }
        }
        for(i=0;i<13;i++)
        {
            for(j=0;j<13;j++)
            {
                if(player3[i]>player3[j])
                {
                    tmp=player3[i];
                    player3[i]=player3[j];
                    player3[j]=tmp;
                }
            }
        }
        for(i=0;i<13;i++)
        {
            for(j=0;j<13;j++)
            {
                if(player4[i]>player4[j])
                {
                    tmp=player4[i];
                    player4[i]=player4[j];
                    player4[j]=tmp;
                }
            }
        }
        printf("玩家一:");//打印玩家的牌
        for(i=0;i<13;i++)
        {
            if(player1[i]>1000&&player1[i]<2000)
                printf("黑桃%d ",player1[i]-1000);
            else if(player1[i]>2000&&player1[i]<3000)
                printf("红桃%d ",player1[i]-2000);
            else if(player1[i]>3000&&player1[i]<4000)
                printf("梅花%d ",player1[i]-3000);
            else
                printf("方块%d ",player1[i]-4000);
        }
        printf("\n");
        printf("玩家二:");//打印玩家的牌
    
        for(i=0;i<13;i++)
        {
            if(player2[i]>1000&&player2[i]<2000)
                printf("黑桃%d ",player2[i]-1000);
            else if(player2[i]>2000&&player2[i]<3000)
                printf("红桃%d ",player2[i]-2000);
            else if(player2[i]>3000&&player2[i]<4000)
                printf("梅花%d ",player2[i]-3000);
            else
                printf("方块%d ",player2[i]-4000);
        }
        printf("\n");
        printf("玩家三:");//打印玩家的牌
        for(i=0;i<13;i++)
        {
            if(player3[i]>1000&&player3[i]<2000)
                printf("黑桃%d ",player3[i]-1000);
            else if(player3[i]>2000&&player3[i]<3000)
                printf("红桃%d ",player3[i]-2000);
            else if(player3[i]>3000&&player3[i]<4000)
                printf("梅花%d ",player3[i]-3000);
            else
                printf("方块%d ",player3[i]-4000);
        }
        printf("\n");
        printf("玩家四:");//打印玩家的牌
        for(i=0;i<13;i++)
        {
            if(player4[i]>1000&&player4[i]<2000)
                printf("黑桃%d ",player4[i]-1000);
            else if(player4[i]>2000&&player4[i]<3000)
                printf("红桃%d ",player4[i]-2000);
            else if(player4[i]>3000&&player4[i]<4000)
                printf("梅花%d ",player4[i]-3000);
            else
                printf("方块%d ",player4[i]-4000);
        }
        printf("\n");
        return 0;
    }
    

    运行结果:
    在这里插入图片描述

    展开全文
  • 每日题-20200405-魔术师

    千次阅读 2020-04-06 01:05:50
    魔术师将最上面的那张牌数为1,把它翻过来正好是黑桃A,将黑桃A放在桌子上,然后按顺序从上到下数手中的余牌,第二次数1、2,将第张牌放在这迭牌下面,将第二张牌翻过来,正好是黑桃2,也将它放在桌子上。...

    魔术师的猜牌术。魔术师利用一副牌中的十三张黑桃,预先将它们排好后迭在一起,牌面朝下。对观众说:我不看牌,只数数就可以猜到每张牌是什么,我大声数数,你们听,不信?你们看看。魔术师将最上面的那张牌数为1,把它翻过来正好是黑桃A,将黑桃A放在桌子上,然后按顺序从上到下数手中的余牌,第二次数1、2,将第一张牌放在这迭牌下面,将第二张牌翻过来,正好是黑桃2,也将它放在桌子上。第三次数1、2、3,将前两张牌依次放在这迭牌下面,将第三张牌翻过来,正好是黑桃3。这样依次进行将13张牌全翻出来,准确无误。问魔术师手中的牌原始次序是怎样安排的?
    **输入格式要求:提示信息:“The original order of cards is:”
    **输出格式要求:"%d "
    程序运行示例如下:
    The original order of cards is:1 8 2 5 10 3 12 11 9 4 7 6 13

    #include<stdio.h>
    
    int main()
    {
    int a[14]={0};
    int i,n,j=1; 
    printf("The original order of cards is:");
    for(i=1;i<=13;i++) 
    {
    n=1;
    do{
    if(j>13) j=1; 
    if(a[j]) j++; 
    else{ 
    if(n==i) a[j]=i;
     
    j++;
    n++; 
    } 
    }while(n<=i); 
    }
    for(i=1;i<=13;i++) 
    printf("%d ",a[i]);
    printf("\n");
    }
    
    

    类型:
    转圈圈的题目。
    思路:

    1. 思考一下,找规律
    2. 第一次给a[0]赋值,第二次a[1]不赋值,给a[2]赋值
    3. +0+1+2+3…
    4. 把每一个初始化为零,把已知的按顺序赋值。
    5. 数组从零开始计数,本题为了方便思考,所以去掉了a[0]
      注意:
      a[13]在全局变量时会自动初始化

    主要就是这个
    1 2 3 4 5 6 7 8 9 10 11 12 13 1 2 3 4
    1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 1 2 3 4 5

    展开全文
  • 魔术师将最上面的那张牌数为1,把它翻过来正好是黑桃A,将黑桃A放在桌子上,然后按顺序从上到下数手中的余牌,第二次数1、2,将第张牌放在这迭牌下面,将第二张牌翻过来,正好是黑桃2,也将它放在桌子上。...
  • 魔术师将最上面的那张牌数为1,把它翻过来正好是黑桃A,将黑桃A放在桌子上,然后按顺序从上到下数手中的余牌,第二次数1、2,将第张牌放在这迭牌下面,将第二张牌翻过来,正好是黑桃2,也将它放在桌子上。...
  • 魔术师将最上面的那张牌数为1,把它翻过来正好是黑桃A,将黑桃A放在桌子上, 然后按顺序从上到下数手中的余牌,第二次数1,2,将第张牌放在这迭牌的下面, 将第二张牌翻过来,正好是黑桃2,也将它
  • ''' 返回人类可读的纸牌名称,例如“黑桃a”,适合包含在游戏控制台输出中 ''' ''' <returns>Name of the card Public ReadOnly Property Description As String Get ' Return mRank + " of" + mSuit ...
  • 随机洗牌系统c++

    2020-02-03 11:23:11
    排序规则:先按花色,依次为黑桃、红桃、梅花、方片,同花色的按点数从小到大。其中,点数A视作点数1。 输出格式:每人占1行,相邻两张牌之间用1个空格分开。 分析 1.要用到函数rand(),生成随机数。 2,...
  • 随机洗牌系统

    2020-02-03 17:15:43
    排序规则:先按花色,依次为黑桃、红桃、梅花、方片,同花色的按点数从小到大。其中,点数A视作点数1。 输出格式:每人占1行,相邻两张牌之间用1个空格分开。 #include <iostream> #include<stdlib....
  • 洗牌

    2020-02-03 18:13:32
    题目描述 请设计个随机洗牌系统,将52...排序规则:先按花色,依次为黑桃、红桃、梅花、方片,同花色的按点数从小到大。其中,点数A视作点数1。 输出格式:每人占1行,相邻两张牌之间用1个空格分开。 ...
  • 魔术师发牌问题

    2019-12-23 00:10:15
    ”魔术师将最上面的那张牌数为1,把他翻过来正好是黑桃A1,将黑桃A放在桌子上,第二次数1,2,将第张牌放在这些牌的下面,将第二张牌翻过来,正好是黑桃2,也将它放在桌子上这样依次进行将13张牌全部翻出,准确无误...
  • 花色:黑桃,红桃,梅花,方块(♠,♥,♣,♦) 点数:A,2,3,4,5,6,7,8,9,10,J,Q,K 王牌:小王、大王 2.洗牌 新牌是按照从小到大好的,为保证游戏公平,所以要把牌的顺序洗乱 3.发牌 把洗好的...
  • CSP-S 复习总结 ---- DP

    2019-10-17 20:35:33
    题意:副不含王的扑克牌由52张牌组成,由红桃、黑桃、梅花、方块4组牌组成,每组13张不同的面值。现在给定 52 张牌中的若干张,请计算将它们列,相邻的牌面值不同的方案数 计数 dpdpdp 考虑到剩 1 张花色,...
  • “魔术师将最上面的那张牌数为1,把他翻过来正好是黑桃A1,将黑桃A放到桌子上,第二次数1,2,将第张牌放在这些牌的下面,将第二张牌翻过来,正好时黑桃2,也将他放在桌子上这样依次进行将13张牌全部翻出,准确...
  • 副扑克牌按花色排序(花色顺序是黑桃、红桃、梅花和方片),限制条件是所有牌都是背面朝上列,而你次只能翻看两张牌或者交换两张牌(保持背面朝上)。 不妨设黑桃=1,红桃=2,梅花=3,方片=4。 初始个...
  • 人工倒推的方法是:在桌子上放13个空盒子圈,从1开始顺序编号,将黑桃A放入1号盒子中,从下个空盒子开始对空的盒子计数,当数到第二个空盒子时,将黑桃2放入空盒子中,然后再从下个空盒子开始对空盒子计数...
  • ”魔术师将牌堆最上面的那张数为1,把他翻过来正好是黑桃A,将黑桃A从牌堆抽出放在桌子上,第二次数1、2,将第张放在牌堆最下面,第二张翻开,正好是黑桃2,也将它抽出放在桌子上。这样依次进行将13将牌全部翻出...
  • 魔术师翻牌:魔术师把扑克中的13张黑桃预先好后,牌面朝下放在手中。第次数一张牌,翻过来恰好是A,放在桌面上,第二次数两张牌,数1的那张放在手中牌的下面,数2的那张牌翻过来恰好是2,也放在桌面上,再数三张...
  • 循环链表之魔术扑克

    2018-09-21 20:48:50
    13 张黑桃扑克(A 2 3 4 5 6 7 8 9 10 J Q K),预先好,正面朝下拿在魔术师的手里,从最上面开始,第次数一张牌翻过来放在桌面上,正好是“A”;第二次数两张牌,数1 的那张放在手中扑克的最下面,数2 的那张翻...
  • 浅入浅出---基数排序

    2018-02-24 10:11:50
    作为个没有学过算法的小白,说一下自己对基数排序的了解(可能理解不到位,以后深入理解的话再...黑桃面值:A&lt;2&lt;3&lt;.......&lt;J&lt;Q&lt;K高位优先:先把所有的按照花色优先级...
  • ”魔术师将牌堆最上面的哪张数为1,把他翻过来正好是黑桃A,将黑桃A从牌堆抽出放在桌子上,第二次数1、2,将第张放在牌堆最下面,第二张翻开,正好是黑桃2,也将它抽出放在桌子上。这样依次进行将13将牌全部翻出...
  • hihoCoder #1159 : 扑克牌

    2017-09-25 19:40:00
    副不含王的扑克牌由52张牌组成,由红桃、黑桃、梅花、方块4组牌组成,每组13张不同的面值。现在给定52张牌中的若干张,请计算将它们列,相邻的牌面值不同的方案数。 牌的表示方法为XY,其中X为面值,为2、3...
  • hihocoder #1159 : 扑克牌

    2017-09-25 22:32:00
    副不含王的扑克牌由52张牌组成,由红桃、黑桃、梅花、方块4组牌组成,每组13张不同的面值。现在给定52张牌中的若干张,请计算将它们列,相邻的牌面值不同的方案数。 牌的表示方法为XY,其中X为面值,为2、3...
  • 1231: 趣味程序设计_猜牌术(-) 时间限制: 1 Sec 内存限制: 128 MB 提交: 177 解决: 72 [提交][状态][讨论版] ...你们就看,魔术师将最上面的那张牌数为1,把它翻过来正好是黑桃A,将黑桃A话在桌
  • 你们就看,魔术师将最上面的那张牌数为1,把它翻过来正好是黑桃A,将黑桃A话在桌子上,然后按顺序从上到下数手中的余牌,第二次数1、2,将第张牌放在这迭牌的下面,将第二张牌翻过来,正好是黑桃2,也将它放在桌子...
  • 魔术

    2017-06-14 22:12:39
    魔术师将最上面的那张牌数为1,把它翻过来正好是黑桃A,将黑桃A放在桌子上,然后按顺序从上到下数手上的余牌,第二次数1、2,将第张牌放在这迭牌的下面,将第二张牌翻过来,正好是黑桃2,也将它放在桌子上,第三...

空空如也

空空如也

1 2 3 4
收藏数 67
精华内容 26
关键字:

一排黑桃a