java斗地主把手中的牌的牌型显示出来

public static void main(String[] args) {
String[] pai = new String[] { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2" };
// String[] hs = new String[] { "♥", "♠", "♦", "♣" };
HashMap hj = new HashMap<>();
HashMap hy = new HashMap<>();
HashMap hb = new HashMap<>();

List<String> a = new ArrayList<String>();
for (int i = 0; i < pai.length; i++) {
    a.add(pai[i]);
    a.add(pai[i]);
    a.add(pai[i]);
    a.add(pai[i]);
}
a.add("大王");
a.add("小王");

Random rand = new Random();
String temp = null;
for (int k = 0; k < 100; k++) {
    int p = a.size();
    int l = rand.nextInt(p);
    int m = rand.nextInt(p);
    if (l == m)
        continue;
    {
        temp = a.get(l);
        a.set(l, a.get(m));
        a.set(m, temp);
    }
}
// Collections.shuffle(a);

List<String> j = new ArrayList<String>();
List<String> y = new ArrayList<String>();
List<String> b = new ArrayList<String>();
List<String> d = new ArrayList<String>();
for (int i = 0; i < a.size(); i++) {
    if (i >= a.size() - 3) {
        d.add(a.get(i));
    } else if (i % 3 == 0) {
        j.add(a.get(i));
    } else if (i % 3 == 1) {
        y.add(a.get(i));
    } else if (i % 3 == 2) {
        b.add(a.get(i));
    }
}
System.out.println(d);
System.out.println("甲" + j);
System.out.println("乙" + y);
System.out.println("丙" + b);
for (String str : j) {
    if (hj.containsKey(str)) {
        hj.put(str, hj.get(str) + 1);
    } else
        hj.put(str, 1);
}
System.out.println("j" + hj);

for (String str : y) {
    if (hy.containsKey(str)) {
        hy.put(str, hy.get(str) + 1);
    } else
        hy.put(str, 1);
}
System.out.println("y" + hy);

for (String str : b) {
    if (hb.containsKey(str)) {
        hb.put(str, hb.get(str) + 1);
    } else
        hb.put(str, 1);
}
System.out.println("b" + hb);

最好在我已经写出的代码上加代码,要显示出甲、乙、丙手牌的对子、三带、炸弹之类的牌型,求具体的代码!!!!!!!

1

7个回答

@Test
public void testFunction4(){
/*数字*/
String[] pai = new String[] { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2" };
/*花色*/
String[] hs = new String[] { "♥", "♠", "♦", "♣" };
HashMap hj = new HashMap<>();
HashMap hy = new HashMap<>();
HashMap hb = new HashMap<>();
List a = new ArrayList();
for (int i = 0; i < pai.length; i++) {
a.add(hs[0]+pai[i]);
a.add(hs[1]+pai[i]);
a.add(hs[2]+pai[i]);
a.add(hs[3]+pai[i]);
}
a.add("大王");
a.add("小王");

    Random rand = new Random();
    String temp = null;
    for (int k = 0; k < 100; k++) {
        int p = a.size();
        int l = rand.nextInt(p);
        int m = rand.nextInt(p);
        if (l == m) {
            continue;
        }
        {
            temp = a.get(l);
            a.set(l, a.get(m));
            a.set(m, temp);
        }
    }

// Collections.shuffle(a);

    List<String> j = new ArrayList<String>();
    List<String> y = new ArrayList<String>();
    List<String> b = new ArrayList<String>();
    List<String> d = new ArrayList<String>();
    for (int i = 0; i < a.size(); i++) {
        if (i >= a.size() - 3) {
            d.add(a.get(i));
        } else if (i % 3 == 0) {
            j.add(a.get(i));
        } else if (i % 3 == 1) {
            y.add(a.get(i));
        } else if (i % 3 == 2) {
            b.add(a.get(i));
        }
    }
    System.out.println(d);
    System.out.println("甲" + j.toString());
    /*获得有三个的*/
    printPai(j,3,null);
    System.out.println("乙" + y.toString());
    System.out.println("丙" + b.toString());
    for (String str : j) {
        if (hj.containsKey(str)) {
            hj.put(str, hj.get(str) + 1);
        } else {
            hj.put(str, 1);
        }
    }
    System.out.println("j" + hj);

    for (String str : y) {
        if (hy.containsKey(str)) {
            hy.put(str, hy.get(str) + 1);
        } else {

            hy.put(str, 1);
        }
    }
    System.out.println("y" + hy);

    for (String str : b) {
        if (hb.containsKey(str)) {
            hb.put(str, hb.get(str) + 1);
        } else {
            hb.put(str, 1);
        }
    }
    System.out.println("b" + hb);
}

public void printPai(List<String> pai, Integer count ,String name) {
    if (count == null) {
        /*去掉花色,输出手里面的排*/
        pai.forEach(p ->p=p.substring(1,2));
        System.out.println(pai.toString());
    }else if (name !=null && name !=""){
        /*name为大王的时候输出大王,按名字查找,忽略大小写,忽略花色*/
        pai.stream().filter(p -> p.substring(1,2).equalsIgnoreCase(name)).collect(toList());
        System.out.println(name+":"+ pai.size()+"个");
    } else if (count!=null && name ==null || name !=""  ){
        /*查找指定数量的pai,2对子,3三个,4炸等,忽略花色*/
        HashMap<String, Integer> paiCount = new HashMap<>();
        pai.forEach(p->{
            String p2 =  p.substring(1,2);
            if (paiCount.containsKey(p2)) {
                paiCount.put(p2, paiCount.get(p2)+1);
            } else {
                paiCount.put(p2, 1);
            }
        });
        /*输出指定个数的*/
        ArrayList<String> resultPai = new ArrayList<String>();
        paiCount.forEach((k,v)->{
            if (v.equals(count)) {
                resultPai.add(k);
            }
        });
        System.out.println(count+"个的牌有:"+resultPai.toString());
    } else {
        /*如果count是2输出手里面的对子,3数据三个,4输出炸弹,配合name,如name=大王,输出手里面是否有大王*/
        /*由于不能使用int类型变量来自增统计个数,就使用集合来统计个数一样的*/
        ArrayList list = new ArrayList();
        pai.stream().forEach(p ->{
            if (p.substring(1, 2).equalsIgnoreCase(name)) {
                list.add(p);
            }
        });
        System.out.println("是否有"+count+"个"+name+":"+ (list.size()>=count?"是":"否"));
    }
}
    printPai是我写的方法,具体注释在里面,输出想要的,具体可以更具你的需求对代买进行必要的修改,我只是按照我的想法写了一个,下面给出一个输出的结果:
    [♠A, ♦5, ♥9]

甲[♣3, ♥5, ♦6, ♥7, ♦9, ♠2, ♦3, ♠Q, ♣5, ♠9, ♥10, ♦10, ♣K, ♠6, 小王, ♣9, ♥J]
3个的牌有:[9]
乙[♦2, ♣10, ♠4, ♥8, ♥4, ♣J, ♣4, ♥6, ♦J, ♠10, ♣A, ♥2, ♥A, ♦7, 大王, ♦8, ♣2]
丙[♠7, ♣7, ♠5, ♠3, ♦Q, ♣6, ♦4, ♦A, ♥K, ♣Q, ♣8, ♠K, ♥3, ♦K, ♥Q, ♠J, ♠8]
j{♥J=1, ♦3=1, ♣K=1, ♠6=1, ♣9=1, ♣3=1, ♥5=1, ♦6=1, ♥10=1, ♠Q=1, ♦10=1, ♥7=1, ♠2=1, ♣5=1, ♦9=1, 小王=1, ♠9=1}
y{♦J=1, ♣J=1, ♦2=1, ♥2=1, ♥4=1, ♣2=1, ♠10=1, 大王=1, ♠4=1, ♣10=1, ♣4=1, ♥6=1, ♦7=1, ♦8=1, ♥8=1, ♥A=1, ♣A=1}
b{♦K=1, ♥K=1, ♥Q=1, ♦4=1, ♣Q=1, ♥3=1, ♠J=1, ♦Q=1, ♠K=1, ♣7=1, ♠5=1, ♣8=1, ♠7=1, ♠3=1, ♣6=1, ♠8=1, ♦A=1}

1

第二个人回答的答案逻辑应该是对的

0
a761485716
a761485716 我要的是牌型,甲有几张单,几个对,多少三带,有没有炸 然后显示出来
一年多之前 回复

看了楼主的两个相同问题。。都回答一下。。。
这种牌型问题我觉得应该将所有可能的牌型都作为一个map集合,比如34567顺子,map集合就叫34567顺子,然后value为3,4,5,6,7
遍历手中卡牌的时候,只要分别调用map的contain()方法,用&&连接,判断是否同时包含所有value,则可以判断出卡牌为顺子34567
这种方法比较复杂 需要写很多的牌型可能性的map,然后一 一判断,最后输出复合的牌型
方法比较笨,但是应该可以实现楼主的要求。。。
public static void Paixing(List shouPai) {
HashMap px1=new HashMap<>();//判断34567顺子,至于更复杂的可以3456789依次往后判断
px1.put(1, "3");
px1.put(2, "4");
px1.put(3, "5");
px1.put(4, "6");
px1.put(5, "7");
int i=1;

    ArrayList<String> shouPai1=(ArrayList<String>) shouPai;
    while(shouPai1.contains(px1.get(i))) {
        if(i==px1.size()) {
            System.out.println("顺子34567");
            break;//一旦手牌中包含此map集合,则跳出循环,输出牌型
        }
        i++;

    }


}
0

package com.paly;

import java.util.ArrayList;
import java.util.Collections;

public class SetPaly {

public static void main(String[] args) {

    // 花色
    String[] color = { "♠","♥","♣","♦" };
    // 数字
    String[] num = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };
    // 牌盒
    ArrayList<String> box = new ArrayList<>();

    for (int i = 0; i < color.length; i++) {
        for (int j = 0; j < num.length; j++) {
            box.add(color[i] + num[j]);
        }
    }

    box.add("大王");
    box.add("小王");

    // 洗牌
    Collections.shuffle(box);
    //System.out.println(box);

    // 找三个人来打牌
    ArrayList<Object> 小波 = new ArrayList<>();
    ArrayList<Object> 小苍 = new ArrayList<>();
    ArrayList<Object> 小泽 = new ArrayList<>();

    // 发牌
    for (int i = 0; i < box.size() - 3; i++) {
        if (i % 3 == 0) {
            小波.add(box.get(i));
        }
        else if (i % 3 == 1) {
            小苍.add(box.get(i));
        }
        else if (i % 3 == 2) {
            小泽.add(box.get(i));
        }

    }


    System.out.println("小波:"+小波);

    System.out.println("小苍:"+小苍);

    System.out.println("小泽:"+小泽);

    //底牌
    method01(box);
}

public static void method01(ArrayList<String> box) {
    System.out.println("底牌:");
    for (int i =box.size()-3 ; i <box.size() ; i++) {
        System.out.print(box.get(i)+" ");
    }
}
-1
a761485716
a761485716 你这水的过分了啊
一年多之前 回复

public static void main(String[] args) {

// 花色
String[] color = { "♠","♥","♣","♦" };
// 数字
String[] num = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };
// 牌盒
ArrayList<String> box = new ArrayList<>();

for (int i = 0; i < color.length; i++) {
    for (int j = 0; j < num.length; j++) {
        box.add(color[i] + num[j]);
    }
}

box.add("大王");
box.add("小王");

// 洗牌
Collections.shuffle(box);
//System.out.println(box);

// 找三个人来打牌
ArrayList<Object> 小波 = new ArrayList<>();
ArrayList<Object> 小苍 = new ArrayList<>();
ArrayList<Object> 小泽 = new ArrayList<>();

// 发牌
for (int i = 0; i < box.size() - 3; i++) {
    if (i % 3 == 0) {
        小波.add(box.get(i));
    }
    else if (i % 3 == 1) {
        小苍.add(box.get(i));
    }
    else if (i % 3 == 2) {
        小泽.add(box.get(i));
    }

}


System.out.println("小波:"+小波);

System.out.println("小苍:"+小苍);

System.out.println("小泽:"+小泽);

//底牌
method01(box);

}

public static void method01(ArrayList box) {
System.out.println("底牌:");
for (int i =box.size()-3 ; i <box.size() ; i++) {
System.out.print(box.get(i)+" ");
}
}

-1

/*
模拟斗地主的发牌功能(发牌完毕后发到手上的牌是有顺序的)
分析:

A:创建一个HashMap集合
B:创建一个ArrayList集合
C:创建两个字符串,一个是花色,一个是牌的数字 (发牌得有一盒牌)
为了方便以后的排序,创建这两个字符串的时候,按照大小顺序排列(斗地主中的大小顺序)
大小王除外
D:把这两个字符串放进HashMap集合中(拼接一起 花色+牌号) 同时给每个放进去牌进行编码0--52并存储
同时也给ArrayList集合中存储编码,大小王在这些编码完成后再进行编码 53 , 54
E:洗牌
F:发牌,其实发的是编号,由于要排序,所以创建TreeSet集合,斗地主是3人和底牌3张,对应4个集合,
a:利用取模的方法给3个人发牌,x%3=0;x%3=1;x%3=2
b:底牌发开始的3张
G:看牌,因为要使用3次这个功能,所以设定一个方法:
a:返回类型:void
b:参数列表:String name(玩家名字) ; TreeSet i(牌的编号) ; HashMap hm(牌)
*/

package com.htfg.callcenter.portal.common;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class w1 {
public static void main(String[] args) {

    //创建一个HashMap集合
    HashMap<Integer , String> poker = new HashMap<Integer , String>();

    //创建一个ArrayList集合
    ArrayList<Integer> index = new ArrayList<Integer>();

    //创建两个字符串,一个是花色,一个是牌的数字      (发牌得有一盒牌)
    String[] colors = {"♦","♣","♥","♠"};

    String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q",
            "K", "A", "2", };
    //把这两个字符串放进HashMap集合中(拼接一起 花色+牌号)同时给每个放进去牌进行编码0--52并存储
    int count = 0;
    for(String number : numbers){
        for(String color : colors){
            //拼接
            String pk = color.concat(number);
            //把编码和牌存储到HashMap中
            poker.put(count, pk);

            //把编码存到ArrayList中
            index.add(count);

            count ++;
        }
    }
    //给大小王编码并存储
    poker.put(count, "小王");
    index.add(count);
    count ++;
    poker.put(count, "大王");
    index.add(count);

    //洗牌
    Collections.shuffle(index);

    //发牌,由于要排序,所以创建TreeSet集合,斗地主是3人和底牌3张,对应4个集合,
    TreeSet<Integer> player1 = new TreeSet<Integer>();
    TreeSet<Integer> player2 = new TreeSet<Integer>();
    TreeSet<Integer> player3 = new TreeSet<Integer>();
    TreeSet<Integer> dipai = new TreeSet<Integer>();

    //a:利用取模的方法给3个人发牌,x%3=0;x%3=1;x%3=2    b:底牌剩下的3张
    //此时ArrayList中已经存储了0-54的编码
    for(int x = 0 ;x < index.size() ; x ++){
    if(x >= index.size() - 3){    
        dipai.add(index.get(x));//给底牌发ArrayList前3个编号,不能dipai.add(x),这样给底牌的是0,1,2
    }
    else if(x % 3 == 0){
        player1.add(index.get(x));
    }
    else if(x % 3 == 1){
        player2.add(index.get(x));
    }
    else if(x % 3 == 2){
        player3.add(index.get(x));
    }
}

    //看牌
        lookpoker("玩家1", player1, poker);
        lookpoker("玩家2", player2, poker);
        lookpoker("玩家3", player3, poker);
        lookpoker("底牌", dipai, poker);
}

    //创建一个看牌的方法,a:返回类型:void    
    //b:参数列表:String name(玩家名字) ; TreeSet<Integer> i(牌的编号) ; HashMap<Integer,String> hm(牌)
public static void lookpoker(String name,TreeSet<Integer> i ,HashMap<Integer,String> hm) {
        //首先是名字
    System.out.print(name+"的牌是:");
        //其次是牌,遍历
    for(Integer key : i){
        //TreeSet的值就是HashMap的键,所以可以得到对应的值,也就是牌
        String result = hm.get(key);
        //输出看到的牌
        System.out.print(result+"  ");
    }
    System.out.println(" ");

}

}

-1

你遍历你的map value 等于2、3、4 不就是相应的牌型

-1
a761485716
a761485716 能给出具体的代码吗。
一年多之前 回复
a761485716
a761485716 回复wangjin9805: 其他的呢
一年多之前 回复
wangjin9805
wangjin9805 那个帖子发过一个顺子的方法
一年多之前 回复
a761485716
a761485716 代码不会弄啊,头都快晕了
一年多之前 回复
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
斗地主判断牌型源码
这是看着别人的代码写的,这样写虽然很全面,但是毫无条理,我吧牌型打完之后感觉很不好,所以放弃,我给每一段加了注释,贴出代码让大家看一看 using UnityEngine; using System.Collections; using System.Collections.Generic; using System; using System.Linq; /// /// 首先对手
斗地主牌型判断和比较js源码
斗地主的javascript源码,总共200多行,其中牌型判断的代码只有100行,注释详细,用到了一些算法优化技巧,学习价值很高
斗地主算法的设计与实现(二)--如何判断一手牌的类型(单,对子,三不带,三带一,四代二等)
牌的类型共有10种: 1. 单 2.对子 3.3不带 4.3带1 5.炸弹 6.顺子 7.4带2 8.连队 9.飞机 10.对王 单牌:任意一张单牌。 对牌:任意两张点数相同的牌。 三张:任意三张点数相同的牌,如888。 三带一:点数相同的三张牌+一张单牌或一对牌。如:333+6 或 444+99。 单顺:任意五张或五张以上点数相连的牌,如:45678或78910JQK。不包括 2和双王。
斗地主系列之牌型判断
参考资料: 1.
斗地主系列之牌型大小比较
3.比较牌型大小: 1)比较牌型大小总原则: (a) 火箭最大,可以打任意其他的牌。  (b) 炸弹比火箭小,比其他牌大。都是炸弹时按牌的分值比大小。 (c)  除火箭和炸弹外,其他牌必须要牌型相同且总张数相同才能比大小。 相同牌型按牌的分值比大小。 依次是 大王 > 小王 >2>A>K>Q>J>10>9>8>7>6>5>4>3 ,不分花色。  顺牌按最大的一张牌的分值来比大小。 
斗地主算法1判断牌型
using UnityEngine; using System.Collections.Generic; /// &amp;lt;summary&amp;gt; /// 牌型 3 4 5 6 7 8 9 10 11(J) 12(Q) 13(K) 14(A) 15(2) 16(小王) 17(大王) /// &amp;lt;/summary&amp;gt; public class DDZ_CardType { public...
斗地主AI算法——第六章の牌型判断
本章实现了上一章提到的检查当前是否只是一手牌函数ins_SurCardsType /* 检查剩余的牌是否只是一手牌 是: 返回手牌类型数据 不是:返回错误类型(cgERROR) */ CardGroupData ins_SurCardsType(int arr[]); 输入很简单,就是一个状态数组。输出是手牌类型结构 //牌型组合数据结构 struct CardGr
斗地主检测牌型(玩家)
BRANDSTATUS JudgeVOwn()//检测牌型是否合法可出 { List vTemp = SelectedCard;//选择的牌 Sort(vTemp,false);//排序 BRANDSTATUS tempBRANDSTATUS = BRANDSTATUS._NONE; switch (vTemp.Count) {
斗地主-比较牌大小算法
斗地主, 比较牌大小, C++
斗地主之用蚁群算法整理牌型-几个关键点的处理
牌型选择和其它问题的差异性分析蚁群算法是由仿生蚂蚁寻食发展而来,所以其很自然的就以寻找最短路径的旅行家问题为研究对象。而旅行家问题有几个特点: 每一步都是从当前所在城市的所有邻接城市中挑选下一步的目标城市 算法的判优指标(即解评分)是总距离最短 单步择优的启发性信息是两邻接城市之间的路径长度 信息素就是本轮次最优解的路径总长度/路径中的城市数 对照我们的牌型选择问题,就存在一定的差异了: 牌型选择的
斗地主(二)———创建扑克牌基类枚举, 牌库,出牌规则
分析: 扑克牌有规律可循 花色4种:**梅花❀、方块♦、黑桃♠、红桃♥** 牌由 1到13(J、Q、K),加花色加大小猫,共有54张 牌还有大小之分,主和非主(权重) 身份:**地主、农民** 出牌类型 单牌、对、连对、顺子、飞机、炸弹等 接下来定义枚举Enum /// &amp;lt;summary&amp;gt; /// 卡牌花色 /// &amp;lt;/summary&amp;gt; public...
Java 实现斗地主扑克牌排序
package com.yu.go; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; public class Da
斗地主之用蚁群算法整理牌型-如何进行牌力估计
我们在前面讲到过,各牌手的牌力估计就是我们在用蚁群算法构造最优牌型时的启发性知识。启发性知识其实就是我们利用自己的经验对事物做出的判优性评估,或者说就是对事物价值的判断。原则上,应用蚁群算法需要用到两类启发性的知识: 单步择优:用来在单只蚂蚁决定下一步如何走时各选择的加权概率,其决定了优化方向 结构评分:单步最优未必全局最优,所以当单只蚂蚁围绕每轮次的优胜解爬出一个新解时,对这个解的质量需做一个总体
大数据之JAVA基础(十七):集合--模拟斗地主洗牌和发牌
一、案例介绍按照斗地主的规则,完成洗牌发牌的动作。 具体规则:1. 组装54张扑克牌2. 将54张牌顺序打乱3. 三个玩家参与游戏,三人交替摸牌,每人17张牌,最后三张留作底牌。4. 查看三人各自手中的牌(按照牌的大小排序)、底牌 手中扑克牌从大到小的摆放顺序:大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3二、案例需求分析准备一副扑克牌,使用Map,完成数字与字符串的映射洗牌和发...
出牌,用程序判断手中的牌是否能够压过对方出牌
 //规则:出牌牌型有5种   //牌只有1到9,手里拿着已经排好序的牌a,对方出牌b,用程序判断手中牌是否能够压过对方出牌。 //[1]一张 如4 则5...9可压过 //[2]两张 如44 则55,66,77,...,99可压过 //[3]三张 如444 规则如[2] //[4]四张 如4444 规则如[2] //[5]五张 牌型只有12345 23456 345
斗地主的一种牌力分析模型(脑洞)
对于一种拆牌中每一个牌型(如3334 , 22),定义两个值,一个是承载力,一个是驱动力 承载力: 在某一个条件下,此牌型带出任意另一个牌型的可能性。比如王炸总是可以带出任意的一个牌型,那么它的承载力总是1。 在某些情况下,34567也有0.9的可能性不被打住,那么它在这时候就有0.9的承载力。 驱动力: 在某一个条件下,此牌型可以打住(不管之后会不会被另外的牌打住)一手牌的可能性。王
斗地主手牌最少手数的搜索
基本思路:         1) 先确定火箭:判断是否有大小王。  2) 再确定炸弹:判明是否有四头。          3) 再确定三条和三顺:在已经确定的三条中判断是否包含相邻的三条,如果有,则将其组成三顺。注意,应该使三顺的数量尽可能大。 即如果有444555666,则将其合成一个三顺,而不是分成444555一个三顺和666一个三条。          4) 再确定单顺:判断单顺时
unity开发 斗地主算法—判断手里的牌是否有大于上家的牌(是否显示要不起按钮)
牌型的定义在http://blog.csdn.net/csdn_cjt/article/details/78593140 第一章 这是第二章 下面是代码 #region isShowOutCardBtn public static bool isShowOutCardBtn(List myCards, List lastCards, DD
unity c#斗地主算法计算牌型
斗地主前端核心算法有以下四个 1:计算牌型 2:牌型之间的比较大小 3:是否显示要不起按钮 4:提示出牌AI 今天更新计算牌型 下面是代码 这是牌的所有类型   我这边四带二单 ,四带二个对子合成一个,四带二个对子不算牌型 所有四带2用FourWithSingle  结构是protobuf类型的//单张1,对子2,三张3,三带单4,三带对5,单顺6,双顺7
java中利用数组和单列集合模拟"斗地主"买牌 洗牌 发牌 理牌 展示 的过程
源代码: import java.util.ArrayList; import java.util.Collections; import java.util.LinkedList; public class PokerDemo1 { public static void main(String[] args) { //生成一副扑克牌 System....
牌堆总结和记牌技巧解析
三国杀3v3目前的牌堆一共有106张,红桃黑桃各26张,梅花方片各27张。基本牌是30杀14梅花7黑桃6方片3红桃!15闪是12方片3红桃,8桃是7红桃1方片。装备10武器6马3盾。锦囊5顺手6拆,2借刀2五谷3乐,3决斗3南蛮1万箭,4无懈4无中1桃园。武器花色各色各样。但是锦囊里面方片是最少的,红桃就是无中、五谷、桃园、万箭,梅花和黑桃基本就是攻击锦囊。 认识这些牌的颜色并记住,看似简单,其
斗地主算法之牌的定义及排序
第一次自己写博客,如有没说清楚的地方,请大家多多指出交流。 最近用html5写了个联机斗地主游戏, 做完后总结一下主要的技术要点: 1.牌的定义及排序。 2.牌型大小判断,就是例如上家出了33344479,判断你选中的牌是否大过对方。 3.提示算法,例如上家出了33344479,从你手中的牌中选出能大过对方的牌。 本篇讲的是斗地主算法之牌的定义及排序,牌型大小判断和提示
我心中的智能斗地主AI,而非单纯一个牌型分析算法
我心中的智能斗地主AI,而非单纯一个牌型分析算法作者: 暗夜、Bingo、流潮,转载请注明来源。备注:个人见解 整体思路图:神经网络直观图:实现过程(含部分源代码):1、出牌方式主动出牌,即首发起方,每轮出牌的出牌发起人,可以在现有手牌里任意出牌,主动出牌比被动出牌变量多,因为你出什么牌将影响接下来的牌局走向。  被动出牌,被动出牌有一定的限制性,受制于上线出牌牌型,与主动出牌比较变量想对较少。2...
3人斗地主54张牌拿对王的概率--概率论与数理统计
前两天和同学坐地铁时无聊,就问问同学一个扑克牌游戏中的概率问题,居然吸引来两位年轻的小伙讨论。其实问题本身并不复杂,属于典型的古典型概率问题,感觉还是蛮有意思,训练一下思维也是不错的。   问题1:一副扑克牌54张,3个人每人18张,问对王在一家的概率? 一些应届毕业生在面试时可能会被问到类似的逻辑问题。最开始遇到这个问题时,我也是从单纯的逻辑思维的角度分析结论的。 Solution1逻辑分...
java集合框架实现斗地主的发牌,洗牌和看牌
斗地主的发牌,洗牌和看牌 – 利用ArrayList,TreeSet,HashMap实现斗地主的发牌,洗牌和看牌 import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.TreeSet; /** *斗地主 ...
Java模拟斗地主洗牌、发牌和对牌排序
Java模拟斗地主洗牌、发牌,同时对牌进行排序的代码实现。import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.Iterator; import java.util.List; import java.util.TreeSet;/** * 模拟斗
unity开发 斗地主算法—比较两个手牌的大小
牌型的定义在http://blog.csdn.net/csdn_cjt/article/details/78593140 第一章 这是第二章 下面是代码#region isSelectCardCanPut public static bool isSelectCardCanPut(List myCards,DDZ_POKER_TYPE myCardType, List las
unity中使用C#语言判断斗地主出牌牌型
首先定义一下要出的的牌的类型 /// &amp;amp;lt;summary&amp;amp;gt; /// 出牌的类型 过1,单张1,对子2,三张3,三带单4,三带对5,单顺6,双顺7,飞机8,飞机带单9,飞机带双10,四带两单11,四带对12,炸弹13,火箭14 /// &amp;amp;lt;/summary&amp;amp;gt; public enum SHOW_CARDS_TYPE { /// &amp;amp;lt;summary&amp;amp;gt; /...
Java实现模拟斗地主洗牌发牌
按照斗地主的规则,完成洗牌发牌看牌的动作。最终结果预计为:具体规则:    1.组装54张扑克牌    2.将54张扑克牌顺序打乱    3.三个玩家参与游戏,三人交替摸牌,每人17张,最后三张做底牌    4.查看三人手中各自的牌(按牌的大小排序)、底牌实现代码步骤:1.首先,要修改java文件编码,由GBK修改为UTF-8,因为默认的字符编码GBK没有梅花、方片、黑桃、红桃(♠♥♦♣)等特殊字...
斗地主算法(1)
现在在公司实习用quick-coco2dx引擎写了斗地主,所有代码用lua脚本实现。我把算法封装成了一个lua类(CardUtils)所有代码可以直接拿来使用。 首先先弄清楚有那些牌型: 火箭or王炸:即双王(大王和小王),最大的牌。         炸弹:四张同数值牌(如四个 7 )。         单牌:单个牌(如红桃 5 )。         对牌:数值相同的两张牌(如梅花
按照斗地主的规则,完成洗牌发牌的动作。
知识点: public class ArrayList&amp;amp;lt;&amp;amp;gt;集合:存放大小可变的内容. Collections类的 shuffle()方法: 使用默认随机源对指定列表进行置换。 嵌套for循环: 外循环执行一次,内循环执行一轮。 /* 按照斗地主的规则,完成洗牌发牌的动作。 具体规则: 使用54张牌打乱顺序,三个玩家参与游戏,三人交替摸牌,每人17张牌,后三...
斗地主AI算法——第四章の权值定义
第一章业务逻辑结尾部分我提到了权值的计算方法: ①每个单牌都有一个基础价值②组合牌型的整体价值与这个基础价值有关,但显然计算规则不完全一样。③整手牌可以分成若干个组合牌,但分法不唯一。 当时,我说了①和②可以直接定义,③需要迭代计算。所以本章的主要内容就是确定基础价值&组合牌型的价值定义 对于牌型权值的定义看似简单,实际却需要大量的推敲。这就跟游戏里不同英雄属性、技能反复修改一样
斗地主中,54张牌,农民各17张,地主20张,两方拿到4张2的概率
假设为农民:             P==0.0075      从54张牌中任取17张即。假设已经摸到了四个二,其他的牌变成了随机,也就是(从50张牌中任取13张) 假设为地主: P==0.0153 从54张牌中任取20张即。假设已经摸到了四个二,其他的牌变成了随机,也就是(从50张牌中任取16张)...
最近在写一款斗地主游戏,写了个癞子匹配顺子的算法
在网上看了一些算法 发现似乎没有癞子斗地主的算法 ,于是乎就写了一个, 其他的比如匹配飞机 匹配连对 基本上和这个思路差不多 #include "stdafx.h" #include #include #include #define lai_zi 14 using namespace std; bool find_is_only(std::vector&v) { for
斗地主牌型相关算法
lua实现斗地主中的牌型判断,牌的比较,出牌提示的算法
棋牌游戏判断牌型算法---适合所有的棋牌游戏
斗地主牌型基本算法升级版本                              好久没更新博客了,前段时间和朋友一起开了一个公司 做APP,最后失败了。现在又开始做棋牌游戏了,最近在看网狐的源码,发现里面斗地主的基本算法太强大了,现在想想我原来的算法简直是弱爆了,分享一下 希望能对你有一点点帮助。以下主要涉及到判断牌型,牌型大小比较2块,如果你想了解更多关于棋牌游戏的东西请访问我的 棋牌游
斗地主AI算法实现 一(拆牌)
源代码下载                   ps: 前面已经写了几篇地主游戏的基本算法实现,今天来讲讲单机地主中最重要的,也是开发中最难得AI算法实现。在此声明,本博文只适合像我一样的菜鸟阅读,高手们请别喷呀,欢迎你们留点宝贵的建议和方案,谢谢!                 如果你还对斗地主游戏的其他算法感兴趣欢迎你访问这个地址:棋牌游戏开发专栏                 首先我
斗地主不算花色算大小王,起初发到的17张牌有多少种?
用动态规划算法来求,设dp[j]表示选了j张牌的种类数。 起初dp[j]=0(j>0),dp[0]=1。 第一层枚举牌的种类A−K,第二层倒着枚举当前选了j张(1=<j<=17),第三层dp[j]由dp[j−k]更新而来(1=<k<=4,j−k>=0)。 如果大小王都不在,则有dp[17]种;如果大小王只有一个,则有dp[16]种;如果大小王都在,则有dp[15]种。所以...
Lua 斗地主算法实现
--服务器定义的牌值 16进 Cards = { 0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D, --方块 A - K 0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D, --梅花 A - K 0x21,0x22,0x23,0x...
wdjpqsetup
用于qq斗地主记牌,欢乐斗地主。。。。以及其他的纸牌游戏,能记下已出的牌,剩余的牌,推断玩家手中的牌,是斗地主必备的软件之一。
文章热词 机器学习教程 Objective-C培训 交互设计视频教程 颜色模型 设计制作学习
相关热词 mysql关联查询两次本表 native底部 react extjs glyph 图标 卡牌手游开发教程 卡牌类游戏开发的教程