C 语言mj普通简单算法

最新推荐文章于 2023-03-16 16:31:57 发布
最新推荐文章于 2023-03-16 16:31:57 发布
阅读量941 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qian782934650/article/details/91324435
版权

#include"a.h"

int main()
{

    int pai[14] = { 0, };
    int i = 0;
    int sum = 0;    //总的分这里默认为三家
    int num = 0;    //应该所得到得分数
    printf("请选择底金:");
    scanf("%d",&DiJ);
    printf("本局底金为:%d\n", DiJ);

    
    /*************************************在此判断牌得张数*************************************/
    printf("------温馨提示：数字0,10,20,30为系统预留空间------\n");
    for (i = 0; i < 14; i++)
    {
        //依次输入手牌
        printf("please you majon ipt:");
        scanf("%d", &pai[i]);
        printf("rand = %d\n", pai[i]);

        
        if ((pai[i] == 0) || (pai[i] == 10) || (pai[i] == 20) || (pai[i] == 30) || (pai[i] > 37))    //在判断牌型时 根据宏定义的数据来进行判断 方便来做判断
        {
            printf("input majon_type is error....quit\n");
            return 0;
        }
    }
    mysort(pai, 14);

    
    for (i = 0; i < 14; i++)    //循环遍历输入的牌型 判断牌型是否成立若输入的手牌牌型大于4 则超出了麻将的牌数故直接退出
    {

        printf("%3d", pai[i]);
        aPAI[pai[i]]++;
        if (aPAI[pai[i]] > 4)
        {
            printf("\n");
            printf("you input pai %d greater than 4.....so...bai\n", pai[i]);
            return 0;

        }

    }
    //Remain(pai);


    /*
    if (h258jiang(pai))
    {
        printf("\n");
        printf("win................258");
        system("pause");
        return 0;
    }
    else
    {
        printf("\n");
        printf("No Win\n");
        system("pause");
    }
    */
    //豪华七对
    if (HHQD(pai))
    {
        printf("\n");
        printf("HHQD......\n");
        //胡牌算分
        Sleep(1000);
        num = DiJ * 15;
        sum = num * 3;
        printf("应得分:%d\n", num);
        Sleep(1000);
        printf("总得分:%d\n", sum);
        system("pause");
        return 0;
    }
    //七对
    if (QiDui(pai))
    {

        printf("\n");
        printf("QiDui...\n");
        //胡牌算分
        num = DiJ * 8;
        sum = num * 3;
        printf("应得分:%d\n", num);
        Sleep(1000);
        printf("总得分:%d\n", sum);
        system("pause");
        return 0;

    }
    //碰碰胡
    if (PPHU(pai))
    {
        printf("\n");
        printf("PPHU......\n");
        //胡牌算分
        num = DiJ * 12;
        sum = num * 3;
        printf("应得分:%d\n", num);
        Sleep(1000);
        printf("总得分:%d\n", sum);
        system("pause");
        return 0;
    }
    
    if (shisanyao(pai))
    {
        printf("\n");
        printf("十三幺\n");
        //胡牌算分
        num = DiJ * 13;
        sum = num * 3;
        printf("应得分:%d\n", num);
        Sleep(1000);
        printf("总得分:%d\n", sum);
        system("pause");
        return 0;
    }

    //平胡
    
    if (Hu(pai))
    {
        printf("\n");
        printf("Win 2333\n");
        //胡牌算分
        num = DiJ * 2;
        sum = num * 3;
        printf("应得分:%d\n", num);
        Sleep(1000);
        printf("总得分:%d\n", sum);
        system("pause");
        return 0;
    }
    else
    {
        printf("\n");
        printf("No Win\n");
        system("pause");
    }
    return 0;
}
//判断七对
int QiDui(int QiDui_Jiag[14])
{
    int i = 0;
    memset(aPAI, 0, sizeof(aPAI));
    for (i = 0; i < 14; i++)
    {
        //循环遍历手牌，将牌型各自+1
        aPAI[QiDui_Jiag[i]]++;
        printf("qidui[%d] = %d ---%d\n", i, QiDui_Jiag[i], aPAI[QiDui_Jiag[i]]);


        //判断牌型是否为将
        if (aPAI[QiDui_Jiag[i]] == 2)
        {
            aPAI[QiDui_Jiag[i]] -= 2;
            QiDui_Jiang++;


        }
        //判断牌型是否为4个 如为四个一样的牌型则QiDui_JIang+2;
        if (aPAI[QiDui_Jiag[i]] == 4 && aPAI[QiDui_Jiag[i]] > 3)    QiDui_Jiang += 2;

    }
    printf("QiDui_Jiang =%d\n", QiDui_Jiang);
    if (QiDui_Jiang == 7)    return 1;
    return 0;
}

int   Hu(int   PAI[14])
{    
    static   int   JIANG = 0;                                    //   将牌标志，即牌型“三三三三二”中的“二”    
    int i;      
    if (!Remain(PAI))   return   1;                                //   递归退出条件：如果没有剩牌，则和牌返回。    

    for (i = 0; !aPAI[PAI[i]] && i<14; i++);                    //   找到有牌的地方，i就是当前牌,   aPAI[PAI[i]]是个数    

    printf("i   =   %d\n", i);                                    //   跟踪信息    
    
                                                                //   4张组合(杠子)    
    if (aPAI[PAI[i]] == 4)                                        //   如果当前牌数等于4张    
    {
        aPAI[PAI[i] ] = 0;                                         //  除开全部4张牌    
        if (Hu(PAI))   return   1;                                //   如果剩余的牌组合成功，和牌    
        aPAI[PAI[i]] = 4;                                        //   否则，取消4张组合    
    }

    //   3张组合(大对)    
    if (aPAI[PAI[i]] >= 3)                                        //   如果当前牌不少于3张    
    {
        aPAI[PAI[i]] -= 3;                                      //   减去3张牌    
        if (Hu(PAI))   return   1;                              //   如果剩余的牌组合成功，和牌    
        aPAI[PAI[i]] += 3;                                   //   取消3张组合    
    }

    //   2张组合(将牌)    
    if (!JIANG   &&   aPAI[PAI[i]] >= 2)                    //   如果之前没有将牌，且当前牌不少于2张    
    {
        JIANG = 1;                                             //   设置将牌标志    
        aPAI[PAI[i]] -= 2;                                   //   减去2张牌    
        if (Hu(PAI))   return   1;                             //   如果剩余的牌组合成功，和牌    
        aPAI[PAI[i]] += 2;                                   //   取消2张组合    
        JIANG = 0;                                            //   清除将牌标志    
    }


    if (PAI[i]   >   JIUTONG_MAJIANG)         return   0;                  //   “东南西北中发白”没有顺牌组合，不和    

                                                                            //   顺牌组合，注意是从前往后组合！    
    if (PAI[i] % 10 != 8 && PAI[i] % 10 != 9 &&                                 //   排除数值为8和9的牌    
        aPAI[PAI[i+1]] && aPAI[PAI[i+2]])                                      //   如果后面有连续两张牌    
    {
        aPAI[PAI[i]]--;
        PAI[PAI[i+ 1] ]--;
        aPAI[PAI[i+ 2] ]--;                                                        //   各牌数减1    
        if (Hu(PAI))   return   1;                                                //   如果剩余的牌组合成功，和牌    
        PAI[i]++;
        PAI[PAI[i+ 1] ]++;
        aPAI[PAI[i+ 2] ]++;                                                         //   恢复各牌数    
    }

    //   无法全部组合，不和！    
    return   0;
}

//   检查剩余牌数    
int   Remain(int   PAI[14])
{
    int   sum = 0;
    
    for (int i = 0; i<14; i++)
        sum += aPAI[PAI[i]];
    return   sum;
}
/*
int   Hu(int   PAI[38])
{
    static   int   JIANG = 0;                         //   将牌标志，即牌型“三三三三二”中的“二”    
    int i = 0;
    if (!Remain(PAI))   return   1;           //   递归退出条件：如果没有剩牌，则和牌返回。    

    for ( i = 1; !PAI[i] && i<38; i++);     //   找到有牌的地方，i就是当前牌,   PAI[i]是个数    
    printf("i   =   %d\n", i);                         //   跟踪信息                                                      //   4张组合(杠子)    
    if (PAI[i] == 4)                               //   如果当前牌数等于4张    
    {
        PAI[i] = 0;                                     //   除开全部4张牌    
        if (Hu(PAI))   return   1;             //   如果剩余的牌组合成功，和牌    
        PAI[i] = 4;                                     //   否则，取消4张组合    
    }

    //   3张组合(大对)    
    if (PAI[i] >= 3)                               //   如果当前牌不少于3张    
    {
        PAI[i] -= 3;                                   //   减去3张牌    
        if (Hu(PAI))   return   1;             //   如果剩余的牌组合成功，和牌    
        PAI[i] += 3;                                   //   取消3张组合    
    }

    //   2张组合(将牌)    
    if (!JIANG   &&   PAI[i] >= 2)           //   如果之前没有将牌，且当前牌不少于2张    
    {
        JIANG = 1;                                       //   设置将牌标志    
        PAI[i] -= 2;                                   //   减去2张牌    
        if (Hu(PAI))   return   1;             //   如果剩余的牌组合成功，和牌    
        PAI[i] += 2;                                   //   取消2张组合    
        JIANG = 0;                                       //   清除将牌标志    
    }


    if (i   >   30)         return   0;               //   “东南西北中发白”没有顺牌组合，不和    

                                                      //   顺牌组合，注意是从前往后组合！    
    if (i % 10 != 8 && i % 10 != 9 &&       //   排除数值为8和9的牌    
        PAI[i + 1] && PAI[i + 2])             //   如果后面有连续两张牌    
    {
        PAI[i]--;
        PAI[i + 1]--;
        PAI[i + 2]--;                                     //   各牌数减1    
        if (Hu(PAI))   return   1;             //   如果剩余的牌组合成功，和牌    
        PAI[i]++;
        PAI[i + 1]++;
        PAI[i + 2]++;                                     //   恢复各牌数    
    }

    //   无法全部组合，不和！    
    return   0;
}

//   检查剩余牌数    
int   Remain(int   PAI[38])
{
    int   sum = 0;
    for (int i = 1; i<38; i++)
        sum += PAI[i];
    return   sum;
}
*/
//豪华七对
int HHQD(int HHQD[14])
{
    int i = 0;
    int HH_QD = 0;
    int jiang = 0;
    //由于aPAI[38]为全局变量，则每次都需要把该数组内所有数据初始化为0；
    memset(aPAI, 0, sizeof(aPAI));
    for (i = 0; i < 14; i++)
    {    //循环遍历手牌，将牌型各自+1；
        aPAI[HHQD[i]]++;
        //当该牌型为4 则+1
        if (aPAI[HHQD[i]] == 4)
        {
            HH_QD++;
        }
        //判断该牌型是否有将
        if (!jiang && aPAI[HHQD[i]] == 2)
        {
            jiang++;
        }
    }
    if (HH_QD == 3 && jiang == 1)    return 1;
    return 0;
}

//PPH
int PPHU(int PPH[14])
{
    int i = 0;
    int PP_H = 0;
    int jiang = 0;
    //由于aPAI[38]为全局变量，则每次都需要把该数组内所有数据初始化为0；
    memset(aPAI, 0, sizeof(aPAI));
    for (i = 0; i<14; i++)
    {
        //循环遍历手牌，将牌型各自+1
        aPAI[PPH[i]]++;
        //当该牌型为2 则+1
        if (aPAI[PPH[i]] == 3)
        {
            aPAI[PPH[i]] -= 3;
            PP_H++;
        }
        //判断该牌型是否有将
        if (!jiang && aPAI[PPH[i]] == 2)
        {
            jiang++;
        }
    }
    //在这里判断该手牌是否有十四张牌....r如果没有则直接退出

    printf("PPH = %d,jiang = %d\n", PP_H, jiang);
    if (PP_H == 4 && jiang == 1)    return 1;

    return 0;
}

//十三幺
int shisanyao(int shisan[14])
{
    int i = 0;
    int majon = 0;
    int jiang = 0;
    memset(aPAI,0,sizeof(aPAI));
    
    for (i = 0; i < 14; i++)
    {
        aPAI[shisan[i]]++;
        //用条件语句来限制牌型
        if ((shisan[i] == YITIAO_MAJIANG) || (shisan[i] == JIUTIAO_MAJIANG) || (shisan[i] == YIWAN_MAJIANG) || \
            (shisan[i] == JIUWAN_MAJIANG)||(shisan[i] == YITONG_MAJIANG) || (shisan[i] == JIUTONG_MAJIANG) || (shisan[i]) > JIUTONG_MAJIANG)
        {        
            if (aPAI[shisan[i]] == 1)
            {
                
                continue;
            }
        }
        else if (aPAI[shisan[i]] == 2)
        {
            jiang++;    
        }
        else
        {
            return 0;
        }
        //在这里判断该手牌是否有十四张牌....r如果没有则直接退出
        if (jiang != 1)    return 0;
        printf("%d", jiang);
    }
    return 1;
}


//将258将牌单独用一个函数来存放
int isJiangPai(int pai)
{

    //将258将牌单独用一个函数来存放 如果该牌型里是否有258将
    if (pai == ERTIAO_MAJIANG) return 1;
    if (pai == WUTIAO_MAJIANG) return 1;
    if (pai == BATIAO_MAJIANG) return 1;

    if (pai == ERTONG_MAJIANG) return 1;
    if (pai == WUTONG_MAJIANG) return 1;
    if (pai == BATONG_MAJIANG) return 1;

    if (pai == ERWAN_MAJIANG) return 1;
    if (pai == WUWAN_MAJIANG) return 1;
    if (pai == BAWAN_MAJIANG) return 1;

    return 0;
}
//对输入的手牌进行排序(顺序)
void mysort(int * aa, int l)
{
    int tmp;
    int i = 0;
    int j = 0;
    for (i = 0; i<l; i++)
    {
        for (j = i + 1; j<l; j++)
        {
            if (aa[i] > aa[j])
            {
                tmp = aa[j];
                aa[j] = aa[i];
                aa[i] = tmp;
            }
        }
    }

}


int PAI_Type(int PAI[38])    //PAI[38]1-9表示tiao 11-19表示万.........
{
    int begin = YITIAO_MAJIANG;
    int end = BAIBAN_MAJIANG;    //表示麻将最后一张
    int len = 0;    //表示麻将的长度
    int i = 0;
    int i_pai[38];
    memset(i_pai,0,sizeof(i_pai));
    memcpy(i_pai,PAI,sizeof(int)* 38);

    //遍历牌型
    for (i = YITIAO_MAJIANG; i < 38; i++)    
    {
        while (i > JIUTONG_MAJIANG)
        {
            if (PAI[i] < 2)    return 0;                    //由于在有风的情况下如果不为刻字和将则不能胡牌直接返回0;
            continue;
        }
        if (PAI[i] == 2)
        {
            PAI[i] -= 2;
        }
        
        //if (PAI[DONGFENG_MAJIANG] < 2)    return 0;    //由于在有风的情况下如果不为刻字和将则不能胡牌直接返回0;


    }
}

 

 

///

............h文件

#include <stdio.h>
#include<string.h>
#include<stdlib.h>
#include<windows.h>

#define YITIAO_MAJIANG      1                                     
#define ERTIAO_MAJIANG      2                                        
#define SANTIAO_MAJIANG     3                                          
#define SITIAO_MAJIANG      4                                          
#define WUTIAO_MAJIANG      5                                          
#define LIUTIAO_MAJIANG     6                                         
#define QITIAO_MAJIANG      7                                          
#define BATIAO_MAJIANG      8                                         
#define JIUTIAO_MAJIANG     9   

#define YIWAN_MAJIANG       11                                    
#define ERWAN_MAJIANG       12                                       
#define SANWAN_MAJIANG      13                                          
#define SIWAN_MAJIANG       14                                         
#define WUWAN_MAJIANG       15                                        
#define LIUWAN_MAJIANG      16                                          
#define QIWAN_MAJIANG       17                                          
#define BAWAN_MAJIANG       18                                          
#define JIUWAN_MAJIANG      19 

#define YITONG_MAJIANG      21                                         
#define ERTONG_MAJIANG      22                                         
#define SANTONG_MAJIANG     23                                         
#define SITONG_MAJIANG      24                                          
#define WUTONG_MAJIANG      25                                          
#define LIUTONG_MAJIANG     26                                          
#define QITONG_MAJIANG      27                                          
#define BATONG_MAJIANG      28                                          
#define JIUTONG_MAJIANG     29

#define DONGFENG_MAJIANG    31                                           
#define NANFENG_MAJIANG     32                                           
#define XIFENG_MAJIANG      33                                          
#define BEIFENG_MAJIANG     34                                           
#define HONGZHONG_MAJIANG   35                                           
#define FACAI_MAJIANG       36                                           
#define BAIBAN_MAJIANG      37 

#define NOTYPE_MAJIANG            0    //    牌型不成立
#define HAVETYPE_MAJIANG        1    //  牌型成立
#define NULL_MAJIANG            10    //    空麻将
#define AA_MAJIANG              2   //    判断将（不一定是2，5，8将）  
#define AAA_MAJIANG             3   //    判断三刻                                                             
#define ABC_MAJIANG             1   //    判断三顺                                                             
#define MAX_HAND_CARD_MAJIANG   14  //    手上的牌，最多时候的张数 


//int Hu(int PAI[38]);
//int h258jiang(int PAI[14]);                        //判断胡牌
int PPHU(int PPH[14]);                        //判断碰碰胡
int Remain(int PAI[14]);                    //判断手牌剩余的牌
int QiDui(int QiDui_PAI[14]);                //判断七对
int Hu(int PAI[14]);
int HHQD(int HHQD[14]);                        //判断豪华七对
int shisanyao(int shisan[14]);
void mysort(int *aa, int l);                //将输入的手牌进行排序
int isJiangPai(int pai);                    //存放将牌
int aPAI[38];                                //保存牌型的数组
int DiJ = 0;                                //底金
int QiDui_Jiang = 0;                        //判断七对将 是否是七对
 

NoCodeNoBiBi
关注
芯片 Chip 制造技术之：深紫外光刻 Lithography 与极紫外 Lithography 光刻
AI天才研究院
09-24 3366
在当今数字时代,芯片已成为现代电子设备的核心组件,支撑着从智能手机到超级计算机的各种应用。芯片制造技术的进步直接影响着电子产品的性能、功耗和成本。其中,光刻技术作为芯片制造的关键环节,一直是半导体行业研究和投资的重点领域。光刻技术的本质是利用光学成像原理,将集成电路设计图形通过光学系统投影到涂有光刻胶的晶圆上,从而实现纳米级精度的图形转移。随着摩尔定律的不断推进,传统光刻技术面临着分辨率极限的挑战。
麻将胡牌判定的判定算法
pyb的博客
01-13 7951
麻将胡牌判定的判定算法 问题背景 : 简化了麻将规则,给定[1s-9s],[1b-9b],[1t-9t]一共27种牌,每种牌都有4张。需要判断给定的牌是不是胡牌。 胡牌的定义为: 14张牌里面由一个对子,四个坎组成。其中对子代表两张一样的牌,坎代表三张一样的牌,或者三张连续的牌(连续指: 1s,2s,3s | 4t,5t,6t) 举例： 1s,1s,2t,3t,4
MJ系列之算法汇总
m0_52458664的博客
09-28 399
快排 冒泡 const array = [1, 3, 2, 6, 4, 5, 9, 8, 7]; const sort = (arr) => { let result = [...arr]; let temp; for(let i = 0; i < result.length - 1; i++){ for(let j = 0; j < result.length - 1 -i; j++){ if(result[j] > result[j + 1]){
(dfs)mj回溯算法
focus-unchanged-thing
12-31 303
/** * 基本思路: * 回溯法: 先挑选中将,再依次拆接出3个,3个的...直到结束,那么说明当前可以胡牌 */ let mahjong = [ "1T", "2T", "3T", "4T", "5T", "6T", "7T", "8T", "9T", // 桶 "1S", "2S", "3S", "4S", "5S", "6S", "7S", "8S", "9S", // 条 "1W", "2W", "3W", "4W", "5W", "6W", "7W", "8.
IOS基础---C语言学习之补充一些MJ没讲的字符和字符串常用处理函数
02-01 332
一、字符处理函数 下面介绍的两个字符处理函数都是在stdio.h头文件中声明的。   1.字符输出函数putchar putchar(65); // A putchar('A'); // A int a = 65; putchar(a); // A 上面的3种用
mj_ai:麻将AI算法（包含全概率估算、局部概率估算、深度学习版本）
05-13
mj_ai 麻将AI算法 基于多种方式实现麻将ai算法 1、one_color_knn基于knn算法，选择与听牌表差异最小的目标进行凑牌 2、probability基于概率计算与胡牌表，选择打出后胡牌概率最大的牌打出 a、当前包含lua版和c语言版本。 b、判断万筒条三色的14张麻将，C语言版本单线程需要6秒，lua版本需要900秒。 c、下一步思路，根据花色拆分，分别求取概率，再进行汇总。 3、part knn算法 1、根据去掉每张牌以后，胡牌概率进行排序。选择最优打出的牌 2、概率采用局部估算的方式，分别计算各种麻将的分配形式下牌的得分 3、目前没有加入字牌以及吃碰杠的判断
C语言学习入门 (四) 字符串、字符串数组、字符和字符串相关函数
12-03 1423
字符串简介 * 在Java中，一个字符串可以用String类型来存储 String s = "MJ"; C语言中没有String这种类型。其实字符串就是字符序列，由多个字符组成，所以在C语言中，我们可以用字符数组来存储字符串。 * 字符串可以看做是一个特殊的字符数组，为了跟普通的字符数组区分开来，应该在字符串的尾部添加了一个结束标志'\0'。 '\0'是一个ASCII
C/C++编程学习：MD5算法代码实现
C语言C++学习俱乐部：765860056
02-21 2435
我们在计算算法的时候，通常都会使用MD5加密算法，而一般实现这些操作都以来函数，下面是C/C++MD5算法的实现代码，希望能为你带来帮助。 md5简介 消息摘要算法第五版（英语：Message-Digest Algorithm 5，缩写为MD5），是当前计算机领域用于确保信息传输完整一致而广泛使用的散列算法之一（又译哈希算法、摘要算法等），主流编程语言普遍已有MD5的实现。 将数据 （如一段文字）运算变为另一固定长度值，是散列算法的基础原理，MD5的前身有MD2、MD3和MD4。MD5由MD4、M..
C语言程序设计题目汇总（不断更新中）
林辰的博客
12-14 4172
判断三角形类型并输出该三角面积 #include<stdio.h> #include<math.h> #define T(x) (x)*(x) int main() { float a,b,c,zc,mj; scanf("%f %f %f",&a,&b,&c); if(a*b>c||a*c>b||b*c>a) //判断三角形类型 { if(a==b&&b==c&&c==a) printf("等边三
专升本C语言——资料复习大全（需要完整版请私信作者）
Cherry的博客
03-16 9602
【解析】结构化程序主要由3种基本控制结构组成，顺序结构是最基本的算法结构，当执行由这些语句构成的程序时，将按这些语句在程序中的先后顺序逐条执行，没有分支，没有转移，没有步骤之间的相互约束，没有对某一步骤的多次使用，完全按照步骤的原有次序依次执行，B选项叙述正确。【解析】C编译程序把文件后缀为C的源程序文件编译成文件后缀为.obj的二进制文件，链接将一个或多个目标文件与程序用到的库文件连接起来，形成一个可以在操作系统直接运行的执行程序.exe，故排除B、C、D项，答案选择A选项。故选项A、D说法正确。
C++实现md5加密算法
04-08
消息摘要算法第五版（英语：Message-Digest Algorithm 5，缩写为MD5），是当前计算机领域用于确保信息传输完整一致而广泛使用的散列算法之一（又译哈希算法、摘要算法等），主流编程语言普遍已有MD5的实现。...
（笔记）如何快速攻破传统算法和数据结构
sesiria的博客
01-01 6842
知乎上的SimonS大神的讲座，给想学习算法的童鞋的一些建议： https://www.zhihu.com/lives/795264798257479680 一，QA部分： 1. 985 大二 专业软工 没有oi经历。如何一年时间拿到ACM区预赛银牌？ 主要参考后续的live，实际是有可能的。只需要选择对的方法 2. 如何高效刷算法题（算法面试题）呢？坚持不看
C语言学习入门
Black_黑色的博客
12-25 799
C语言
中国能源互联网行业市场现状分析-发展状况良好(附-政策汇总).docx
最新发布
06-11
中国能源互联网行业市场现状分析-发展状况良好(附-政策汇总).docx
中国互联网人身保险行业市场现状与发展趋势-寿险、年金险、意外险出现不同程度下滑.docx
06-11
中国互联网人身保险行业市场现状与发展趋势-寿险、年金险、意外险出现不同程度下滑.docx
Dyna-Q 算法 PyTorch版
06-11
Dyna-Q 算法 PyTorch版
springboot533图书管理系统900pf.zip
06-11
java+vue+springboot源代码+数据库+配套文档+教程
中国产业互联网发展指数报告.docx
06-11
中国产业互联网发展指数报告.docx
springboot459客户管理系统--论文pf.zip
06-11
java+vue+Springboot+源代码+数据库+配套文档+教程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值