扑克牌不同花色分出来！

我做过j2me斗地主还有麻将的游戏；我的做法是:

创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都网站建设、做网站、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的怀安网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

1. 首先需要定义好数据结构

牌类型

public class Card{

int value;// 有1~15 种可能

//1~13分别代表 A~K 14代表小王， 15代表大王

int color;//花色, 0~3种可以代表黑红梅方

public Card(int v,int c){

value=v;color=c;

}

}

2. 定义好初始化牌堆（一幅新牌，没切洗过）

Card[][] cards=new Card[15][4];

并初始化好它们，

for(int i=0;icards.length;i++)

for(int j=0;j4;j++)

Cards[i][j]=new Card(i,j);

当然还要做例外处理，因为第14个元素存的是大小王，所以里面只包含两个元素，要保证其cards[14][2]和cards[14][3]为NULL

3。如果随机发牌？

策略一：

如果发N张牌；

int counter=0

Card[] myCards=new Card[n];//我想得到的随机牌组

while(counter n){

a.每次生成0~14随机数 i;

b.再生成 0~3 随机数 j;

c. 判断 如果 cards[i][j]==null,继续循环

continue;

d. 判断 如果 cards[i][j]!=null，得到一张随机牌！

myCard[counter]=cards[i][j];

counter++; //并且~~~~~ 一定要~~~

cards[i][j]=null; //置空，以保证不会重复

}

策略二：

另一种可以效率更高的随机产生牌的策略：

for(int i=0;icards.length;i++)

for(int j=0;j4;j++)

a.随机生成 0~14 的数字 X;

b.随机生成 0~3 的数字 Y;

c.让 cards[i][j] 与cards[x][y]交换数据

然后再用循环将 cards[][]中的牌按顺利发N张到 myCards[]中

如果第二个人需要，又可以发N张

另外： 由于牌的大小和花色都是按数字值表示的，所以可以很容易对cards数组进行排序！

同时给玩家发完牌后，玩家也可以随时进行牌的排序。可以按大小排，也可以按花色牌，非常方便，整个代码写下来一共才一两百行就搞定！

我还有连连看的消去两张同样牌的寻路算法。

泡泡龙碰撞反弹的轨迹算法。

麻将的胡牌算法

中国象棋行棋规律算法

等等。欢迎感兴趣的朋友，有需要的立个贴，给分就贴

唉，如今赚个分不容易啊，好吧，代码送上

public static class Card{

int value;// 有1~15 种可能

int color;//花色, 0~3种可以代表黑红梅方

public Card(int v,int c){

value=v;color=c;

}

}

public static Card[][] initCards(){

Card[][] cards=new Card[15][4];

for(int i=0;icards.length;i++) {

for(int j=0;j4;j++) {

cards[i][j]=new Card(i,j);

}

}

cards[14][2]=null;

cards[14][3]=null;

//打印生成结果

for(int i=0;icards.length;i++) {

for(int j=0;j4;j++) {

if(cards[i][j]!=null){

System.out.print(cards[i][j].value+","+cards[i][j].color);

System.out.print(" ");

}

}

System.out.println();

}

return cards;

}

//随机洗乱牌

public static Card[][] randomCards( Card[][] cards){

Random random=new Random();

for(int i=0;icards.length;i++) {

for(int j=0;j4;j++) {

if(cards[i][j]!=null){

int x=random.nextInt(14);

int y=random.nextInt(4);

Card tmp=cards[i][j];

cards[i][j]=cards[x][y];

cards[x][y]=tmp;

}

}

}

//打印随机结果

for(int i=0;icards.length;i++) {

for(int j=0;j4;j++) {

if(cards[i][j]!=null){

System.out.print(cards[i][j].value+","+cards[i][j].color);

System.out.print(" ");

}

}

System.out.println();

}

return cards;

}

public static Card[] getCards(int num,Card[][] cards){

Card[] myCards=new Card[num];

int counter=0;

for(int i=0;icards.length;i++) {

for(int j=0;j4;j++) {

if(counter=num){

break;

}

myCards[counter]=cards[i][j];

cards[i][j]=null;

counter++;

}

if(counter=num){

break;

}

}

System.out.println("");

System.out.println("打印发牌结果:");

for(int j=0;jmyCards.length;j++) {

if(myCards[j]!=null){

System.out.print(myCards[j].value+","+myCards[j].color);

System.out.print(" ");

}

}

return myCards;

}

main()方法里的调用{

Card[][] cards=initCards();//初始化牌

cards=randomCards(cards);//洗牌，随机

Card[] mycards= getCards(17,cards);//发17张牌出来

}

这总可以了吧？ 总不会连main方法怎么用的也不知道吧？ 哈

PHP 数据结构 算法 三元组 Triplet

复制代码

代码如下:

?php

/**

*

三元组

Triplet

*

*/

class

Triplet

{

private

$_data

=

null;

//

初始化三元组

public

function

init($val1,$val2,$val3)

{

$this-_data[0]

=

$val1;

$this-_data[1]

=

$val2;

$this-_data[2]

=

$val3;

return

true;

}

//

销毁三元组

public

function

destroy()

{

unset($this-_data);

return

true;

}

//

返回第$key的值

public

function

get($key)

{

if($key

1

||

$key

3)

return

false;

return

$this-_data[$key

-

1];

}

//

设置第$key元的值为$val

public

function

put($key,$val)

{

if($key

1

||

$key

3)

return

false;

$this-_data[$key

-

1]

=

$val;

return

true;

}

//

是否按升序排序

public

function

isAscending()

{

return

($this-_data[0]

=

$this-_data[1])

($this-_data[1]

=

$this-_data[2]);

}

//

是否按降序排序

public

function

isDescending()

{

return

($this-_data[0]

=

$this-_data[1])

($this-_data[1]

=

$this-_data[2]);

}

//

获取最大值

public

function

max()

{

return

($this-_data[0]

=

$this-_data[1])?

($this-_data[0]

=

$this-_data[2])?

$this-_data[0]

:

$this-_data[2]

:

($this-_data[1]

=

$this-_data[2])?

$this-_data[1]

:

$this-_data[2];

}

//

获取最小值

public

function

min()

{

return

($this-_data[0]

=

$this-_data[1])?

($this-_data[0]

=

$this-_data[2])?

$this-_data[0]

:

$this-_data[2]

:

($this-_data[1]

=

$this-_data[2])?

$this-_data[1]

:

$this-_data[2];

}

}

//

$objTriplet

=

new

Triplet();

echo

"init:";var_dump($objTriplet-init(1,2,3));

echo

"br/";

echo

"get

1:";var_dump($objTriplet-get(1));

echo

"br/";

echo

"get

4:";var_dump($objTriplet-get(4));

echo

"br/";

//

false

echo

"put

3,4:";var_dump($objTriplet-put(3,4));

echo

"br/";

echo

"max:";var_dump($objTriplet-max());

echo

"br/";

echo

"min:";var_dump($objTriplet-min());

echo

"br/";

echo

"isAscending:";var_dump($objTriplet-isAscending());

echo

"br/";

echo

"isDescending:";var_dump($objTriplet-isDescending());

echo

"br/";

?

C语言编程题：扑克牌排序问题

#include stdlib.h

#include stdio.h

#include time.h

#define Color short

#define Red 0

#define Green 1

#define Blue 2

#define White 3

#define Pink 4

#define Purple 5

#define Suit short

#define Spades 1

#define Hearts 0

#define Diamonds 2

#define Clubs 3

#define J 11

#define Q 12

#define K 13

#define A 1

#define SmallJoker 14

#define BigJoker 15

typedef struct {

int ranking;

Color color;

Suit suit;

} Card;

void create_cards(Card cards[], int size) {

int i, j;

Card temp;

for (i = 0; i  size; i++) {

cards[i].color = i / 54;

cards[i].suit = i % 54 % 4;

cards[i].ranking = i % 54 = 52 ? i % 54 - 53 + BigJoker : i % 54 / 4 + 1;

}

for (i = 0; i  size; i++) {

j = rand() % (size - i) + i;

if (j != i) {

temp = cards[i];

cards[i] = cards[j];

cards[j] = temp;

}

}

}

void print_card(Card* card, FILE* file) {

const char* color[] = {"红", "绿", "蓝", "白", "粉", "紫"};

const char* suit[] = {"红心", "黑桃", "方块", "梅花"};

const char* ranking[] = {"dummy", "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "小王", "大王"};

fprintf(file, "%s底的", color[card-color]);

if (card-ranking  SmallJoker) {

fprintf(file, "%s", suit[card-suit]);

}

fprintf(file, "%s\n", ranking[card-ranking]);

}

int cmp(const void* a, const void* b) {

Card* ca = (Card*)a;

Card* cb = (Card*)b;

int ranking[2] = {ca-ranking, cb-ranking}, i;

for (i = 0; i  2; i++) {

if (ranking[i] = SmallJoker) {

ranking[i] += 2;

}

else if(ranking[i] = 2) {

ranking[i] += 13;

}

}

if (ranking[0] != ranking[1]) {

return ranking[0] - ranking[1];

}

if (ca-color != cb-color) {

return ca-color - cb-color;

}

return ca-suit - cb-suit;

}

void sort_all_cards(Card cards[], int size) {

qsort(cards, size, sizeof(cards[0]), cmp);

}

int main() {

const int size = 54 * 6;

int i;

Card cards[size];

FILE *before, *after;

srand((unsigned int)time(NULL));

create_cards(cards, size);

before = fopen("Before.txt", "w");

if (before == NULL) {

printf("Error open Before.txt\n");

exit(-1);

}

for (i = 0; i  size; i++) {

print_card(cards + i, before);

}

fclose(before);

sort_all_cards(cards, size);

after = fopen("After.txt", "w");

if (before == NULL) {

printf("Error open After.txt\n");

exit(-1);

}

for (i = 0; i  size; i++) {

print_card(cards + i, after);

}

fclose(after);

return 0;

}

Before.txt (仅供参考)

白底的方块3

紫底的梅花K

绿底的方块9

红底的梅花10

绿底的黑桃K

白底的方块10

绿底的红心3

紫底的梅花A

蓝底的方块10

粉底的黑桃A

蓝底的黑桃A

蓝底的黑桃8

粉底的梅花7

紫底的黑桃4

紫底的梅花8

紫底的梅花2

白底的梅花K

蓝底的红心2

蓝底的黑桃6

红底的红心Q

粉底的方块K

蓝底的黑桃Q

绿底的红心10

红底的黑桃9

粉底的黑桃K

白底的方块J

紫底的红心10

紫底的梅花Q

红底的黑桃4

绿底的黑桃A

绿底的黑桃9

白底的方块8

蓝底的梅花6

白底的黑桃J

绿底的方块4

紫底的红心2

粉底的黑桃10

紫底的红心Q

红底的黑桃Q

粉底的黑桃6

绿底的梅花2

白底的方块K

蓝底的梅花J

红底的方块A

蓝底的梅花3

粉底的梅花4

紫底的红心4

紫底的红心5

白底的方块5

蓝底的大王

绿底的黑桃8

红底的黑桃5

绿底的红心9

绿底的方块7

白底的小王

蓝底的方块4

紫底的梅花5

绿底的方块J

紫底的梅花10

白底的红心2

紫底的黑桃6

白底的方块9

红底的方块7

绿底的大王

红底的红心5

粉底的红心J

蓝底的黑桃3

蓝底的红心10

白底的红心3

粉底的梅花6

绿底的黑桃7

白底的红心10

绿底的方块5

绿底的黑桃4

蓝底的红心3

白底的梅花8

红底的黑桃7

白底的梅花A

蓝底的方块2

紫底的梅花J

粉底的梅花A

紫底的方块Q

红底的黑桃A

绿底的红心8

绿底的红心J

白底的方块A

蓝底的方块5

粉底的方块2

粉底的黑桃7

蓝底的方块3

白底的方块6

红底的方块8

绿底的梅花A

蓝底的方块A

紫底的方块5

紫底的方块J

粉底的方块10

粉底的梅花8

粉底的梅花10

红底的红心K

白底的大王

粉底的红心Q

紫底的方块4

蓝底的红心Q

蓝底的梅花2

紫底的小王

白底的梅花J

绿底的红心7

蓝底的梅花Q

绿底的梅花10

红底的梅花3

粉底的红心7

紫底的方块10

绿底的黑桃6

红底的梅花4

蓝底的梅花A

红底的黑桃6

蓝底的黑桃9

绿底的小王

紫底的红心7

白底的红心K

粉底的梅花Q

白底的红心9

紫底的方块A

红底的红心4

白底的黑桃9

绿底的梅花4

红底的方块4

绿底的红心4

红底的黑桃8

红底的红心7

紫底的方块2

白底的黑桃3

蓝底的黑桃10

红底的梅花2

红底的方块J

白底的黑桃2

粉底的黑桃5

绿底的黑桃Q

紫底的黑桃8

绿底的红心K

蓝底的黑桃J

粉底的红心9

粉底的梅花J

紫底的黑桃7

白底的梅花4

蓝底的红心8

紫底的方块6

蓝底的黑桃2

蓝底的黑桃K

蓝底的黑桃7

蓝底的黑桃4

红底的方块10

红底的黑桃3

粉底的红心8

红底的梅花7

粉底的梅花5

粉底的红心2

绿底的方块8

红底的黑桃10

红底的梅花6

紫底的梅花7

白底的黑桃A

红底的梅花5

白底的黑桃4

粉底的梅花K

绿底的方块Q

红底的方块K

紫底的方块K

粉底的方块A

紫底的红心6

粉底的梅花3

粉底的黑桃4

绿底的黑桃2

绿底的方块10

绿底的梅花K

红底的红心3

粉底的黑桃8

红底的梅花8

粉底的黑桃Q

红底的大王

紫底的黑桃Q

绿底的黑桃5

蓝底的梅花8

白底的梅花6

红底的方块2

粉底的红心6

红底的黑桃J

绿底的红心5

绿底的红心2

蓝底的红心7

紫底的方块8

蓝底的方块8

白底的黑桃Q

蓝底的红心4

绿底的方块A

粉底的方块5

红底的梅花Q

紫底的黑桃A

粉底的方块9

紫底的梅花9

白底的黑桃5

蓝底的方块K

白底的黑桃7

蓝底的方块6

蓝底的黑桃5

白底的梅花3

粉底的黑桃2

粉底的方块8

绿底的梅花3

白底的黑桃10

紫底的黑桃2

红底的黑桃2

蓝底的梅花4

红底的梅花K

绿底的梅花Q

蓝底的方块Q

蓝底的梅花9

紫底的黑桃J

绿底的红心6

粉底的红心10

蓝底的梅花K

绿底的梅花J

红底的红心2

红底的红心6

粉底的黑桃9

蓝底的红心A

绿底的梅花8

红底的红心A

紫底的方块7

白底的红心4

紫底的大王

蓝底的红心5

绿底的黑桃J

紫底的红心3

粉底的方块Q

白底的红心A

白底的梅花10

蓝底的红心J

绿底的梅花5

白底的梅花7

白底的红心J

紫底的黑桃10

粉底的红心A

红底的红心8

紫底的梅花3

粉底的梅花2

绿底的红心Q

白底的黑桃K

蓝底的方块J

绿底的方块2

白底的梅花Q

绿底的方块K

粉底的黑桃3

绿底的梅花7

红底的方块6

紫底的黑桃9

红底的梅花A

紫底的红心A

粉底的红心5

粉底的红心4

粉底的红心3

蓝底的红心9

紫底的红心K

绿底的黑桃3

绿底的梅花6

红底的红心J

白底的方块Q

粉底的大王

白底的黑桃8

蓝底的梅花5

粉底的小王

白底的红心7

紫底的方块3

紫底的黑桃3

白底的梅花9

白底的方块2

红底的方块3

蓝底的方块9

粉底的方块6

红底的方块9

白底的方块7

紫底的红心9

白底的红心Q

粉底的方块7

绿底的梅花9

白底的方块4

紫底的黑桃5

白底的梅花5

粉底的梅花9

紫底的黑桃K

紫底的红心J

红底的梅花9

红底的方块5

白底的红心5

粉底的方块4

紫底的方块9

绿底的红心A

绿底的方块3

红底的方块Q

粉底的方块3

蓝底的红心K

蓝底的梅花7

红底的黑桃K

绿底的方块6

蓝底的方块7

白底的红心8

蓝底的小王

红底的红心10

白底的红心6

白底的梅花2

红底的梅花J

蓝底的梅花10

红底的红心9

绿底的黑桃10

蓝底的红心6

粉底的方块J

红底的小王

粉底的红心K

紫底的梅花6

白底的黑桃6

紫底的梅花4

粉底的黑桃J

紫底的红心8

After.txt

红底的红心3

红底的黑桃3

红底的方块3

红底的梅花3

绿底的红心3

绿底的黑桃3

绿底的方块3

绿底的梅花3

蓝底的红心3

蓝底的黑桃3

蓝底的方块3

蓝底的梅花3

白底的红心3

白底的黑桃3

白底的方块3

白底的梅花3

粉底的红心3

粉底的黑桃3

粉底的方块3

粉底的梅花3

紫底的红心3

紫底的黑桃3

紫底的方块3

紫底的梅花3

红底的红心4

红底的黑桃4

红底的方块4

红底的梅花4

绿底的红心4

绿底的黑桃4

绿底的方块4

绿底的梅花4

蓝底的红心4

蓝底的黑桃4

蓝底的方块4

蓝底的梅花4

白底的红心4

白底的黑桃4

白底的方块4

白底的梅花4

粉底的红心4

粉底的黑桃4

粉底的方块4

粉底的梅花4

紫底的红心4

紫底的黑桃4

紫底的方块4

紫底的梅花4

红底的红心5

红底的黑桃5

红底的方块5

红底的梅花5

绿底的红心5

绿底的黑桃5

绿底的方块5

绿底的梅花5

蓝底的红心5

蓝底的黑桃5

蓝底的方块5

蓝底的梅花5

白底的红心5

白底的黑桃5

白底的方块5

白底的梅花5

粉底的红心5

粉底的黑桃5

粉底的方块5

粉底的梅花5

紫底的红心5

紫底的黑桃5

紫底的方块5

紫底的梅花5

红底的红心6

红底的黑桃6

红底的方块6

红底的梅花6

绿底的红心6

绿底的黑桃6

绿底的方块6

绿底的梅花6

蓝底的红心6

蓝底的黑桃6

蓝底的方块6

蓝底的梅花6

白底的红心6

白底的黑桃6

白底的方块6

白底的梅花6

粉底的红心6

粉底的黑桃6

粉底的方块6

粉底的梅花6

紫底的红心6

紫底的黑桃6

紫底的方块6

紫底的梅花6

红底的红心7

红底的黑桃7

红底的方块7

红底的梅花7

绿底的红心7

绿底的黑桃7

绿底的方块7

绿底的梅花7

蓝底的红心7

蓝底的黑桃7

蓝底的方块7

蓝底的梅花7

白底的红心7

白底的黑桃7

白底的方块7

白底的梅花7

粉底的红心7

粉底的黑桃7

粉底的方块7

粉底的梅花7

紫底的红心7

紫底的黑桃7

紫底的方块7

紫底的梅花7

红底的红心8

红底的黑桃8

红底的方块8

红底的梅花8

绿底的红心8

绿底的黑桃8

绿底的方块8

绿底的梅花8

蓝底的红心8

蓝底的黑桃8

蓝底的方块8

蓝底的梅花8

白底的红心8

白底的黑桃8

白底的方块8

白底的梅花8

粉底的红心8

粉底的黑桃8

粉底的方块8

粉底的梅花8

紫底的红心8

紫底的黑桃8

紫底的方块8

紫底的梅花8

红底的红心9

红底的黑桃9

红底的方块9

红底的梅花9

绿底的红心9

绿底的黑桃9

绿底的方块9

绿底的梅花9

蓝底的红心9

蓝底的黑桃9

蓝底的方块9

蓝底的梅花9

白底的红心9

白底的黑桃9

白底的方块9

白底的梅花9

粉底的红心9

粉底的黑桃9

粉底的方块9

粉底的梅花9

紫底的红心9

紫底的黑桃9

紫底的方块9

紫底的梅花9

红底的红心10

红底的黑桃10

红底的方块10

红底的梅花10

绿底的红心10

绿底的黑桃10

绿底的方块10

绿底的梅花10

蓝底的红心10

蓝底的黑桃10

蓝底的方块10

蓝底的梅花10

白底的红心10

白底的黑桃10

白底的方块10

白底的梅花10

粉底的红心10

粉底的黑桃10

粉底的方块10

粉底的梅花10

紫底的红心10

紫底的黑桃10

紫底的方块10

紫底的梅花10

红底的红心J

红底的黑桃J

红底的方块J

红底的梅花J

绿底的红心J

绿底的黑桃J

绿底的方块J

绿底的梅花J

蓝底的红心J

蓝底的黑桃J

蓝底的方块J

蓝底的梅花J

白底的红心J

白底的黑桃J

白底的方块J

白底的梅花J

粉底的红心J

粉底的黑桃J

粉底的方块J

粉底的梅花J

紫底的红心J

紫底的黑桃J

紫底的方块J

紫底的梅花J

红底的红心Q

红底的黑桃Q

红底的方块Q

红底的梅花Q

绿底的红心Q

绿底的黑桃Q

绿底的方块Q

绿底的梅花Q

蓝底的红心Q

蓝底的黑桃Q

蓝底的方块Q

蓝底的梅花Q

白底的红心Q

白底的黑桃Q

白底的方块Q

白底的梅花Q

粉底的红心Q

粉底的黑桃Q

粉底的方块Q

粉底的梅花Q

紫底的红心Q

紫底的黑桃Q

紫底的方块Q

紫底的梅花Q

红底的红心K

红底的黑桃K

红底的方块K

红底的梅花K

绿底的红心K

绿底的黑桃K

绿底的方块K

绿底的梅花K

蓝底的红心K

蓝底的黑桃K

蓝底的方块K

蓝底的梅花K

白底的红心K

白底的黑桃K

白底的方块K

白底的梅花K

粉底的红心K

粉底的黑桃K

粉底的方块K

粉底的梅花K

紫底的红心K

紫底的黑桃K

紫底的方块K

紫底的梅花K

红底的红心A

红底的黑桃A

红底的方块A

红底的梅花A

绿底的红心A

绿底的黑桃A

绿底的方块A

绿底的梅花A

蓝底的红心A

蓝底的黑桃A

蓝底的方块A

蓝底的梅花A

白底的红心A

白底的黑桃A

白底的方块A

白底的梅花A

粉底的红心A

粉底的黑桃A

粉底的方块A

粉底的梅花A

紫底的红心A

紫底的黑桃A

紫底的方块A

紫底的梅花A

红底的红心2

红底的黑桃2

红底的方块2

红底的梅花2

绿底的红心2

绿底的黑桃2

绿底的方块2

绿底的梅花2

蓝底的红心2

蓝底的黑桃2

蓝底的方块2

蓝底的梅花2

白底的红心2

白底的黑桃2

白底的方块2

白底的梅花2

粉底的红心2

粉底的黑桃2

粉底的方块2

粉底的梅花2

紫底的红心2

紫底的黑桃2

紫底的方块2

紫底的梅花2

红底的小王

绿底的小王

蓝底的小王

白底的小王

粉底的小王

紫底的小王

红底的大王

绿底的大王

蓝底的大王

白底的大王

粉底的大王

紫底的大王

c语言编程题！！急求！！ 关于扑克牌（要完整代码最好有解释）

#includestdio.h

int asc(char p[][3]);

int isError(char p1[][3],char p2[][3]);

void compare(char p3[][3],char p4[][3]);

int main()

{

char a[3][3],b[3][3],c;

int i,j,resulta,resultb,result,flag=0;

printf("请输入A的扑克牌，扑克牌之间以空格隔开，然后按下回车：\n");

for(i=0;i3;i++)

{

for(j=0;j3;j++)

{

c=getchar();

if(c!=' 'c!=10)

{

if(j==0)

{

if(c=='H'||c=='S'||c=='D'||c=='C')

;

else

{

printf("Input Error!\n");

return 0;

}

}

if(j==1)

{

if(c=='J'||c=='Q'||c=='K'||c=='A'||(c='1'c='9'))

{

if(c=='J')

c=59;

if(c=='Q')

c=60;

if(c=='K')

c=61;

if(c=='A')

c=62;

if(c=='1')

flag=1;

}

else

{

printf("Input Error!\n");

return 0;

}

}

if(j==2)

{

if(c!='0')

{

printf("Input Error!\n");

return 0;

}else

{

flag=0;

c=58;

a[i][1]=c;

break;

}

}

a[i][j]=c;

}else

{

if(flag==1)

{

printf("Input Error!\n");

return 0;

}

if(j==2)

break;

j--;

}

}

}

printf("请输入B的扑克牌，扑克牌之间以空格隔开，然后按下回车：\n");

for(i=0;i3;i++)

{

for(j=0;j3;j++)

{

c=getchar();

if(c!=' 'c!=10)

{

if(j==0)

{

if(c=='H'||c=='S'||c=='D'||c=='C')

;

else

{

printf("Input Error!\n");

return 0;

}

}

if(j==1)

{

if(c=='J'||c=='Q'||c=='K'||c=='A'||(c='1'c='9'))

{

if(c=='J')

c=59;

if(c=='Q')

c=60;

if(c=='K')

c=61;

if(c=='A')

c=62;

if(c=='1')

flag=1;

}

else

{

printf("Input Error!\n");

return 0;

}

}

if(j==2)

{

if(c!='0')

{

printf("Input Error!\n");

return 0;

}else

{

flag=0;

c=58;

b[i][1]=c;

break;

}

}

b[i][j]=c;

}else

{

if(flag==1)

{

printf("Input Error!\n");

return 0;

}

if(j==2)

break;

j--;

}

}

}

resulta=asc(a);

if(resulta==0)

return 0;

resultb=asc(b);

if(resultb==0)

return 0;

result=isError(a,b);

if(result==0)

return 0;

compare(a,b);

for(i=0;i3;i++)

{

a[i][2]='\0';

b[i][2]='\0';

}

printf("A: ");

for(i=0;i3;i++)

{

if(a[i][1]'2'a[i][1]'9')

printf("%s ",a[i]);

else

{

if(a[i][1]==58)

{

printf("%c",a[i][0]);

printf("10 ");

}

if(a[i][1]==59)

{

printf("%c",a[i][0]);

printf("J ");

}

if(a[i][1]==60)

{

printf("%c",a[i][0]);

printf("Q ");

}

if(a[i][1]==61)

{

printf("%c",a[i][0]);

printf("K ");

}

if(a[i][1]==62)

{

printf("%c",a[i][0]);

printf("A ");

}

}

}

printf("\nB: ");

for(i=0;i3;i++)

{

if(b[i][1]'2'b[i][1]'9')

printf("%s ",b[i]);

else

{

if(b[i][1]==58)

{

printf("%c",b[i][0]);

printf("10 ");

}

if(b[i][1]==59)

{

printf("%c",b[i][0]);

printf("J ");

}

if(b[i][1]==60)

{

printf("%c",b[i][0]);

printf("Q ");

}

if(b[i][1]==61)

{

printf("%c",b[i][0]);

printf("K ");

}

if(b[i][1]==62)

{

printf("%c",b[i][0]);

printf("A ");

}

}

}

printf("\n");

return 0;

}

int asc(char p[][3])

{

int m,temp[2];

if(p[0][1]==p[1][1])

{

if(p[0][0]==p[1][0])

{

printf("Input Error!\n");

return 0;

}

}

if(p[1][1]==p[2][1])

{

if(p[1][0]==p[2][0])

{

printf("Input Error!\n");

return 0;

}

}

if(p[0][1]==p[2][1])

{

if(p[0][0]==p[2][0])

{

printf("Input Error!\n");

return 0;

}

}

m=0;

if(p[m][1]p[m+1][1])

{

temp[0]=p[m][0];

temp[1]=p[m][1];

p[m][0]=p[m+1][0];

p[m][1]=p[m+1][1];

p[m+1][0]=temp[0];

p[m+1][1]=temp[1];

}

if(p[m][1]p[m+2][1])

{

temp[0]=p[m][0];

temp[1]=p[m][1];

p[m][0]=p[m+2][0];

p[m][1]=p[m+2][1];

p[m+2][0]=temp[0];

p[m+2][1]=temp[1];

}

m=1;

if(p[m][1]p[m+1][1])

{

temp[0]=p[m][0];

temp[1]=p[m][1];

p[m][0]=p[m+1][0];

p[m][1]=p[m+1][1];

p[m+1][0]=temp[0];

p[m+1][1]=temp[1];

}

return 1;

}

int isError(char p1[][3],char p2[][3])

{

int n;

for(n=0;n3;n++)

{

if(p1[n][0]==p2[0][0]p1[n][1]==p2[0][1])

{

printf("Input Error!\n");

return 0;

}

if(p1[n][0]==p2[n][0]p1[1][1]==p2[1][1])

{

printf("Input Error!\n");

return 0;

}

if(p1[n][0]==p2[n][0]p1[2][1]==p2[2][1])

{

printf("Input Error!\n");

return 0;

}

}

return 1;

}

void compare(char p3[][3],char p4[][3])

{

int x;

for(x=0;x3;x++)

{

if(p3[x][1]==p4[x][1])

continue;

if(p3[x][1]p4[x][1]){

printf("Winner is A!\n");

return;

}

if(p3[x][1]p4[x][1]){

printf("Winner is B!\n");

return;

}

}

printf("Winner is X!\n");

}

这次对了。