扑克游戏(函数规范化，拆分事件)

已于 2024-08-04 00:00:42 修改
阅读量273 收藏 7
点赞数 5
分类专栏： c/c++练习 文章标签： 算法 函数嵌套 c语言
于 2024-08-03 23:59:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengbizhe/article/details/140882652
版权

前言：

题目链接
进入链接后，点击实践项目，以下两道题分别为6.8.15和6.8.16,

这两道题算不上难，特别是第二道在之前某个比赛中遇到过一次，当时没做出来，想着去找的，没找着，现在又看到了不免兴致冲冲（￣︶￣）↗　，狠狠报仇了也是，虽然究到底只是道排序题，不过条件特别多，写起来就会觉得很麻烦了

扑克游戏1

任务描述
老师给X同学留了一个任务：扑克游戏中的牌型判断。

输入格式:

输入的第一行，是一个整数N，表示有N组数据。
接下来的N行是N组数据，每一行数据有3张扑克牌，
例如：5S 6H 12C，其中数字表示点数(2-10分别代表2点到10点的牌，14代表A,11、12、13代表J、Q、K)，
字母表示花色的第一个字符，黑桃(Spade)、红桃(Heart)、梅花(Club)、方块(Diamond)。
以上3张牌为黑桃5、红桃6、方块Q。

输出格式:

输出N行，每一行输出一个单词，表示一组数据三张牌的最大牌型，空格后再输出此牌型的(最大)点数。
所有牌型从大到小排列如下(豹子>同花顺>顺子>同花>对子>花牌)：
(1)豹子(Leopard)：三张牌点数一样，如5S 5H 5C。
(2)同花顺(Flush straight)：三张牌同花色且点数恰好相邻，如5S 6S 7S。
(3)顺子(Straight)：三张牌点数恰好相邻，但不同花色，如10H 11D 12C。
(4)同花(Same kind)：三张牌花色相同，点数不全相同，如8H 5H 11H。
(5)对子(Pair)：花色不全相同，两张牌点数相同，如11H 5C 11D。
(6)花牌(General)：花色不全相同，点数全不相同，如：5D 6C 8H。

输入样例:

6
8H 8D 8C
5S 7S 6S
11C 12D 10S
1C 5C 6C
10C 8D 8H
5D 6H 12C

输出样例:

Leopard 8
Flush straight 7
Straight Q
Same kind 6
Pair 8
General Q

解题思路：

  • 要想方便判断牌型，和找出最大点数，就要先对输入的数据做个处理，用字符数组接收输入数据，提取出点数和花色，
  • 各个牌型的判断写在函数，不然不得把自己写迷糊了，
  • 别忘了还有对点数超过10之后输出的处理
  • 对子输出的点数该是那个相同的点数

参考代码：

这是第一次的思路，有些杂乱，一口气写完，还是很爽的=￣ω￣=

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

int score(char a[], int len) {//提取出每张牌的点数
  int num = 0;
  for (int i = 0; i < len - 1; i++) {
    num = num * 10 + a[i] - '0';
  }
  return num;
}
char flow(int number) {//处理输出时点数大于10
  switch (number) {
    case 11:
      return 'J';
    case 12:
      return 'Q';
    case 13:
      return 'K';
    case 14:
      return 'A';
  }
}
int flow_color(char card_a, char card_b, char card_c) {//结合flush函数，判断牌型是否是同花顺
  return card_a == card_b && card_b == card_c;
}
int max(int a, int b) {//最大
  return a > b ? a : b;
}
int min(int a, int b) {//最小
  return a > b ? b : a;
}
int flush(int number_a, int number_b, int number_c) {//判断三张牌的点数是否相邻，也就是顺子
  int _max = max(max(number_a, number_b), number_c);
  int _min = min(min(number_a, number_b), number_c);
  if ((number_a + number_b + number_c) * 2 == (_max + _min) * (_max - _min + 1)) {
  //判断方式是一个等差数列和公式，（_max - _min + 1）也就是n，
    return _max;

  }
  return 0;
}
int pair(int number_a,int number_b,int number_c)//判断是否是对子,
{
    return number_a==number_b?number_a:number_a==number_c?number_a:number_b==number_c?number_b:0;
}
void print(int number)//最后的输出点数
{
    if(number>10)
    printf("%c",flow(number));
    else
    printf("%d",number);
}
int same_number(int number_a, int number_b, int number_c)//判断是否是豹子
{
    return number_a == number_b && number_b == number_c;
}
void cards(int number_a, int number_b, int number_c, char card_a, char card_b, char card_c) {//判断牌型，并输出结果
  int max_num=max(max(number_a,number_b),number_c);//找出最大点数
  if (same_number(number_a, number_b, number_c)) {//牌型是否为豹子
      printf("Leopard ");
      print(number_a);
      return;//直接返回
  }
  if (flush(number_a, number_b, number_c)) {//判断三张卡牌点数是否相邻
    if (flow_color(card_a, card_b, card_c)) {//判断三张牌花色是否相同，再进入该if后就是同花顺了
        printf("Flush straight ");
    }
    else//反之，就是顺子
    {
        printf("Straight ");
    }
    print(max_num);
    return;
  }
  if (flow_color(card_a, card_b, card_c))//判断三张牌花色是否相同，也就是同花
  {
      printf("Same kind ");
      print(max_num);
      return;
  }
  else
  {
      int same=pair(number_a, number_b, number_c);//返回对子的点数
      if(same)//若有则为对子
      {
          printf("Pair ");
          print(same);
      }
      else//不是的话，那就只有花牌了
      {
          printf("General ");
          print(max_num);
      }
  }

}
int main() {
  int n;
  scanf("%d", & n);
  while (n--) {
  //用a,b,c三个输出存储输入的卡牌
    char a[4] = {
      0
    }, b[4] = {
      0
    }, c[4] = {
      0
    };
    scanf("%s %s %s", a, b, c);
    int len_a = strlen(a), len_b = strlen(b), len_c = strlen(c);
    int number_a = score(a, len_a);//得出每张卡牌的点数，
    int number_b = score(b, len_b);
    int number_c = score(c, len_c);
    char card_a = a[len_a - 1];//得出每张卡牌的花色
    char card_b = b[len_b - 1];
    char card_c = c[len_c - 1];
    cards(number_a, number_b, number_c,card_a, card_b, card_c);//判断牌型并输出
    printf("\n");//最后换行
  }
  return 0;
}

一开始没有想到用结构体，用结构体总体会清晰不少，也不用在函数里传那么多参数了( •̀ ω •́ )✧

#include<stdio.h>
#include<string.h>
struct node
{
    int number[3];//三张卡牌的点数
    char card[3];//三张卡牌的花色
    int flag;//牌型序号
    int max_num;//最大点数
    int id;//最大点数在数组number的序号
    char max_card;//最大点数卡牌的花色
    int max_card_id;//卡牌的花色的优先级，这个变量不必看，这道题还用不着，下一道题要用
}poker;
int max(int a,int b)//最大
{
    return a>b?a:b;
}
int min(int a,int b)//最小
{
    return a>b?b:a;
}
int score(char a[], int len) {//卡牌点数
  int num = 0;
  for (int i = 0; i < len - 1; i++) {
    num = num * 10 + a[i] - '0';
  }
  return num;
}
void print_flower(char card)//补充要输出的花色，这个函数是下一题会用上的，
{
    switch(card)
    {
        case 'S':
        printf("Spade ");
        break;
        case 'H':
        printf("Heart ");
        break;
        case 'C':
        printf("Club ");
        break;
        case 'D':
        printf("Diamond ");
        break;
    }
}
void flow(int number) {//输出卡牌的点数
  switch (number) {
    case 11:
      printf("J");
      break;
    case 12:
      printf("Q");
      break;
    case 13:
      printf("K");
      break;
    case 14:
      printf("A");
      break;
      default:
      printf("%d",number);
      break;
  }
}
int flow_color() {//三张卡牌花色相同
  return poker.card[0] == poker.card[1] && poker.card[1] == poker.card[2];
}
int flush(int max_num) {//三张卡牌点数相邻
  int _min = min(min(poker.number[0], poker.number[1]), poker.number[2]);
  if ((poker.number[0] + poker.number[1] + poker.number[2]) * 2 == (max_num + _min) * (max_num - _min + 1)) 
  {
    return 1;

  }
  return 0;
}
int same_number()//三张卡牌点数相同
{
    return poker.number[0] == poker.number[1] && poker.number[1] == poker.number[2];
}
int pair()//一对卡牌的点数相同
{
    return poker.number[0]==poker.number[1]?1:poker.number[0]==poker.number[2]?2:poker.number[1]==poker.number[2]?1:0;
}
void poker_model()//输出牌型
{
    switch(poker.flag)
    {
        case 1:
        printf("Leopard");
        break;
        case 2:
        printf("Flush straight");
        break;
        case 3:
        printf("Straight");
        break;
        case 4:
        printf("Same kind");
        break;
        case 5:
        printf("Pair");
        break;
        case 6:
        printf("General");
        break;
    }
}

void cards()//判断牌型
{
    int max_num=poker.number[poker.id];
    poker.max_num=max_num;
    poker.max_card=poker.card[poker.id];
    if(same_number())//牌型为豹子
    {
        poker.flag=1;
        return;
    }
    if(flush(max_num))//三张牌点数相邻
    {
        if(flow_color())//牌型为同花顺
        {
            poker.flag=2;
        }
        else//牌型为顺子
        poker.flag=3;
        return;
    }
    if(flow_color())//牌型为同花
    {
        poker.flag=4;
        return;
    }
    int same=pair();
    if(same)//牌型为对子
    {
        poker.flag=5;
        poker.id=same;
        poker.max_num=poker.number[poker.id];
        return;
    }
    
    poker.flag=6;//牌型为花牌
}
void solve()
{

    char a[4] = {
      0
    }, b[4] = {
      0
    }, c[4] = {
      0
    };
    scanf("%s%s%s", a, b, c);
    int len_a = strlen(a), len_b = strlen(b), len_c = strlen(c);
    poker.number[0] = score(a, len_a);
    poker.number[1] = score(b, len_b);
    poker.number[2] = score(c, len_c);
    for(int j=0;j<3;j++)
    {
        if(poker.number[poker.id]<poker.number[j])
        poker.id=j;
        
    }
    poker.card[0] = a[len_a - 1];
    poker.card[1] = b[len_b - 1];
    poker.card[2] = c[len_c - 1];
    cards();

}
int main()
{
    int n;
    scanf("%d",&n);
    while(n--)
    {
        solve();//简化main函数
        poker_model();//输出牌型
        printf(" ");//牌型和点数间有个空格
        flow(poker.max_num);//输出点数   
        printf("\n");
    }
	return 0;
}

扑克游戏2

任务描述
请完成以下任务。

输入格式:

输入的第一行，是一个整数N，表示有N局游戏(N组数据)。
接下来的N行是N组数据，代表N局。
每行有9张扑克牌数据，前3张代表“王要账（Wangyaozhang）”手中的3张牌，中间3张代表“于龙（Yulong）”手中的牌，后3张代表“赵松(Zhaosong)”同学手中的3张牌。
例如某局前3张牌为：5S 6H 12C，其中数字表示点数(2-10代表点数为2-10的牌,11、12、13、14代表J、Q、K、A)，字母表示花色的第一个字符，黑桃(Spade)、红桃(Heart)、梅花(Club)、方块(Diamond)。以上3张牌实际代表的是黑桃5、红桃6、方块Q。
所有可能牌型从大到小排列如下：
(1)豹子(Leopard)：三张牌点数一样，如5S 5H 5C。
(2)同花顺(Flush straight)：三张牌同花色且点数恰好相邻，如5S 6S 7S。
(3)顺子(Straight)：三张牌点数恰好相邻，但不同花色，如10H 11D 12C。
(4)同花(Same kind)：三张牌花色相同，点数不全同，如8H 5H 11H。
(5)对子(Pair)：只两张牌点数相同，如11H 5C 11D。
(6)花牌(General)：花色不全相同，点数全不相同，如：5D 6C 8H。
三人玩牌大小比较规则是：
牌型大则牌大；
牌型相同，则比较代表牌型的最大点数，点数大的牌大；
牌型和点数都相同，则比较花色，花色从大到小按黑桃(Spade)、红桃(Heart)、梅花(Club)、方块(Diamond)排列。
例如：
(1)两手牌都是豹子，点数大的牌大；
(2)两手牌都是同花顺或都是顺子或都是同花或都是花牌，比较点数最大的那张牌。
(3)两手牌都是对子，比较2个对子中各自最大的牌，例如：黑桃10方块10对，红桃10梅花10对，因为黑桃大于红桃而前一个对子大。

输出格式:

一共有N组输出，每组输出格式如下：
(1)首先单独一行，输出局的序号，后加冒号。
(2)接下来的3行，每行输出三个玩家的姓名，冒号，括号，括号内是该玩家的牌型名称和代表该牌型的最大牌花色和点数，点数为2至10和J、Q、K、A。
(3)每组输出的最后一行输出“Win:”，1个空格，后加上胜出玩家名称。

输入样例:

8
8H 8D 8C 12C 12H 12S 14D 13D 12D
5S 7S 6S 14S 13D 12C 2S 3D 5H
11C 12D 10S 2H 3H 4H 14H 13D 14C
1C 5C 6C 5H 5D 6C 7D 9D 8D
10C 5D 10H 9D 8H 9C 13H 12D 10C
5D 6H 12C 14D 13C 10H 13H 12D 10C
5H 5D 6C 8D 9C 9H 14D 13S 2C
5H 5D 6C 5S 9C 5C 8D 9S 4C

输出样例:

1:
Wangyaozhang:Leopard(Heart 8)
Yulong:Leopard(Spade Q)
Zhaosong:Flush straight(Diamond A)
Win: Yulong
2:
Wangyaozhang:Flush straight(Spade 7)
Yulong:Straight(Spade A)
Zhaosong:General(Heart 5)
Win: Wangyaozhang
3:
Wangyaozhang:Straight(Diamond Q)
Yulong:Flush straight(Heart 4)
Zhaosong:Pair(Heart A)
Win: Yulong
4:
Wangyaozhang:Same kind(Club 6)
Yulong:Pair(Heart 5)
Zhaosong:Flush straight(Diamond 9)
Win: Zhaosong
5:
Wangyaozhang:Pair(Heart 10)
Yulong:Pair(Club 9)
Zhaosong:General(Heart K)
Win: Wangyaozhang
6:
Wangyaozhang:General(Club Q)
Yulong:General(Diamond A)
Zhaosong:General(Heart K)
Win: Yulong
7:
Wangyaozhang:Pair(Heart 5)
Yulong:Pair(Heart 9)
Zhaosong:General(Diamond A)
Win: Yulong
8:
Wangyaozhang:Pair(Heart 5)
Yulong:Pair(Spade 5)
Zhaosong:General(Spade 9)
Win: Yulong

解题思路：

有上面那道题垫着，这道题会轻松一些，在当初这巨长的输入格式，也是把我唬到了

  • 规矩与前面那道题一样，但是加上了要找花色，还有比较三个人谁的牌最大

参考代码：

#include<stdio.h>
#include<string.h>
int i=0;//当前遍历到了那个人
char colors[5]={"SHCD"};//花色的优先级
struct node
{
    int number[3];//三张卡牌的点数
    char card[3];//三张卡牌的花色
    int flag;//牌型序号
    int max_num;//最大卡牌点数
    int id;//最大点数在数组number的序号
    char max_card;//最大点数的卡牌的花色
    int max_card_id;//最大点数的卡牌的花色的优先级
}poker[3];//数组3个变量代表三个人
int max(int a,int b)//最大
{
    return a>b?a:b;
}
int min(int a,int b)//最小
{
    return a>b?b:a;
}
int score(char a[], int len) {//每张牌的点数
  int num = 0;
  for (int i = 0; i < len - 1; i++) {
    num = num * 10 + a[i] - '0';
  }
  return num;
}
void print_flower(char card)//输出花色
{
    switch(card)
    {
        case 'S':
        printf("Spade ");
        break;
        case 'H':
        printf("Heart ");
        break;
        case 'C':
        printf("Club ");
        break;
        case 'D':
        printf("Diamond ");
        break;
    }
}
void flow(int number) {//输出点数
  switch (number) {
    case 11:
      printf("J");
      break;
    case 12:
      printf("Q");
      break;
    case 13:
      printf("K");
      break;
    case 14:
      printf("A");
      break;
      default:
      printf("%d",number);
      break;
  }
}
int flow_color() {//判断三张卡牌花色是否相同
  return poker[i].card[0] == poker[i].card[1] && poker[i].card[1] == poker[i].card[2];
}
int flush(int max_num) {//判断三张卡牌点数是否相邻
  int _min = min(min(poker[i].number[0], poker[i].number[1]), poker[i].number[2]);
  if ((poker[i].number[0] + poker[i].number[1] + poker[i].number[2]) * 2 == (max_num + _min) * (max_num - _min + 1)) 
  {
    return 1;

  }
  return 0;
}
int same_number()//判断三张牌点数是否相同
{
    return poker[i].number[0] == poker[i].number[1] && poker[i].number[1] == poker[i].number[2];
}
int pair()//判断有两张卡牌点数相同
{
    return poker[i].number[0]==poker[i].number[1]?1:poker[i].number[0]==poker[i].number[2]?2:poker[i].number[1]==poker[i].number[2]?1:0;
}
void poker_model()//输出牌型
{
    switch(poker[i].flag)
    {
        case 1:
        printf("Leopard");
        break;
        case 2:
        printf("Flush straight");
        break;
        case 3:
        printf("Straight");
        break;
        case 4:
        printf("Same kind");
        break;
        case 5:
        printf("Pair");
        break;
        case 6:
        printf("General");
        break;
    }
}
void compare_flower(int max_num)//这个函数是用于在牌型为对子的情况下，比较得出卡牌的最大花色
{
    for(int j=0;j<4;j++)
    {
        for(int k=0;k<3;k++)
        {
            if(poker[i].number[k]==max_num)//比较方式是筛出对子那对卡牌
            if(poker[i].card[k]==colors[j])//与数组比对如相同，那么这个就是最大花色，立即跳出
            {
                poker[i].max_card=colors[j];
                return;
            }
        }
    }
}
void compare_flower_color()//这个函数是用于牌型为豹子的，比较得出卡牌的最大花色
{
    for(int j=0;j<4;j++)
    {
        for(int k=0;k<3;k++)
        {
            if(poker[i].card[k]==colors[j])
            {
                poker[i].max_card=colors[j];
                return;
            }
        }
    }
}
void compare_color_id()//得出花色的优先级用于后面比较三个人谁的卡牌大
{
    for(int j=0;j<4;j++)
    {
        if(poker[i].max_card==colors[j])
        {
            poker[i].max_card_id=j;
            return;
        }
    }
}
void cards()
{
    int max_num=poker[i].number[poker[i].id];//三张卡牌的最大点数
    poker[i].max_num=max_num;
    poker[i].max_card=poker[i].card[poker[i].id];
    if(same_number())//牌型为豹子
    {
        poker[i].flag=1;
        compare_flower_color();
        return;
    }
    if(flush(max_num))//三张牌点数相邻
    {
        if(flow_color())//牌型为顺子同花顺
        {
            poker[i].flag=2;
        }
        else//牌型为顺子
        poker[i].flag=3;
        return;
    }
    if(flow_color())//牌型为同花
    {
        poker[i].flag=4;
        return;
    }
    int same=pair();
    if(same)//牌型为对子
    {
        poker[i].flag=5;
        poker[i].id=same;
        poker[i].max_num=poker[i].number[poker[i].id];
        compare_flower(poker[i].max_num);
        return;
    }
    
    poker[i].flag=6;//牌型为花牌
}
void solve()//这个函数主要完成对输入的处理
{

    char a[4] = {
      0
    }, b[4] = {
      0
    }, c[4] = {
      0
    };
    scanf("%s%s%s", a, b, c);
    int len_a = strlen(a), len_b = strlen(b), len_c = strlen(c);
    poker[i].number[0] = score(a, len_a);
    poker[i].number[1] = score(b, len_b);
    poker[i].number[2] = score(c, len_c);
    for(int j=0;j<3;j++)//比较出最大点数的卡牌的序号，
    {
        if(poker[i].number[poker[i].id]<poker[i].number[j])
        poker[i].id=j;
        
    }
    poker[i].card[0] = a[len_a - 1];
    poker[i].card[1] = b[len_b - 1];
    poker[i].card[2] = c[len_c - 1];
    cards();

}
int compare_score(int index,int j)//比较谁的卡牌大
{
    if(poker[index].flag>poker[j].flag)//先比较牌型
    {
        index=j;
    }
    else if(poker[index].flag==poker[j].flag)
    {
        if(poker[index].max_num<poker[j].max_num)//再比较点数
        {
            index=j;
        }
        else if(poker[index].max_num==poker[j].max_num)
        {
            if(poker[index].max_card_id>poker[j].max_card_id)//再比较花色
            {
                index=j;
            }
        }
    }
    return index;
}
int main()
{
    int n;
    scanf("%d",&n);
    char d[4][20]={"Wangyaozhang","Yulong","Zhaosong"};//三个人名称
    int count=1;//当前是第几局
    while(n--)
    {
      printf("%d:\n",count++);  //输出第几局
    for(i=0;i<3;i++)//这一局中三个人的卡牌
    {
        printf("%s:",d[i]);
        solve();//整理输入
        poker_model();//输出牌型
        printf("(");
        print_flower(poker[i].max_card);//输出花色
        flow(poker[i].max_num);//输出点数
        printf(")");        
        printf("\n");
        compare_color_id(); //花色优先级
    }

    printf("Win: ");
    int index=0;
    for(int j=1;j<3;j++)
    {
        index=compare_score(index,j);//返回胜利者的序号
    }
    puts(d[index]);//输出
    }
	return 0;
}

做来了以前做不来的题，这种感觉还是很爽的

这里就不写C++版本的了，没什么区别，硬要看就直接换头文件吧

在这里插入图片描述

fengbizhe
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
易语言扑克游戏
07-16
《易语言扑克游戏》是一款基于易语言开发的扑克游戏，主要涵盖了扑克游戏的基本流程和功能实现，包括初始化牌局、用户界面的展示、牌的处理逻辑以及胜负判定等多个关键环节。下面将对这些核心知识点进行详细阐述。 ...
python版扑克策略游戏源码
03-04
python版扑克策略游戏源码,python版扑克策略游戏源码
离散事件模拟学习笔记
NOOBSIRSIR1的博客
10-01 510
离散事件模拟学习笔记
实战Flash游戏开发
图灵教育
05-23 5267
<br />作者简介：<br /> 　　Christopher Griffith  Blockdot公司高级游戏开发师，拥有近十年的Flash应用及游戏开发经验，客户包括乐高、微软、美国航空公司、百事等知名企业。<br /><br /> 译者简介：<br /> 　　李鑫  资深CG动画讲师及插画师，深度关切游戏与拉布拉多，喜欢研究小逻辑，最近空闲时在制作原创动画《瑜的门票》。相信交互式媒体的发展如一切美好事物般会在不经意间抹上眉梢，沿路风景比站台重要。<br /><br /> 评论：<br />
通过R语言且只用基础package来制作一个小游戏
qq_44638724的博客
05-27 1218
游戏规则 任意数量的玩家可以加入（包含1）， 多对相通的牌被随机排列在一个网格中，牌面朝下。每个玩家依次选择两张牌，并将其正面朝上，这被认为是一次移动。如果牌面相等，则该玩家赢得这对牌，再进行一次。如果两张牌不同，则再次将牌面朝下，轮到下一个玩家。当最后一对被拿起时，游戏结束。拥有最多对子的玩家获胜。有可能出现并列第一的情况。 实际上这就是我们以前多多少少会玩到的记忆卡片游戏，从逻辑上讲并不复杂，限定了我们只能使用R语言和基础的包，那就稍有难度了 问题分析 我们可以通过将游戏规则拆分，将不同的逻辑部分独
这一年，这些书：2022年读书笔记
热门推荐
Heartsuit的博客
12-31 3万+
Note: 以下 `markdown` 格式文本由 `json2md` 自动转换生成，可参考[JSON转Markdown：我把阅读数据从MongoDB中导出转换为.md了](https://blog.csdn.net/u013810234/article/details/113360229)了解具体的转换过程。2022年读书笔记
【Rust】1、实战：语法、数据结构、生命周期-所有权-借用、自制 CPU、内存: 指针、栈、堆
呆呆的猫的博客
06-23 1060
Rust: 语法、数据结构、生命周期-所有权-借用、自制 CPU、内存: 指针、栈、堆
面试 Notes｜2021 年秋季 Android 弱鸡艰难求职记。。。
静心 Study
11-16 5807
扯犊子之前，先放一张面试图吧： 求职？求生？Start… 说来也怪，从入职的第一天就觉得很不舒服，然后慢慢产生离开的念头，随后转变思想，回去打算按照步骤继续学习，避免下次求职尴尬。奈何。 过去的事儿，不想再说太多了，挺坑的，也挺现实的。 孰是孰非，深究无意，备好行囊，继续出发～ 感兴趣的可以点击查看： 面试｜2021 菜鸟金三银四铜五 Android 被锤历程出炉… 其实上家公司带来的影响蛮大的，可能也算是成长的代价吧，还好。 本来想着，找个工作，然后好好喷喷，将那副丑恶的嘴脸曝光。直到现在确定入职公
小白学python系列————【Day30】软件开发目录规范
DiligentGG的博客
07-14 356
* 绝对导入与相对导入 * 包的概念 * 编程思想的转变 * 软件开发目录规范 * 常见内置模块
包的概念、开发目录规范、常见内置模块知识合集
weixin_55907741的博客
10-19 454
包的概念、开发目录规范、常见内置模块知识合集
iOS开发笔记 - 语言篇之Swift
骆昊的技术专栏
03-20 1万+
2014年的苹果全球开发者大会（WWDC），当Craig Federighi向全世界宣布“We have new programming language”（我们有了新的编程语言）的时候，全场响起了最热烈和持久的掌声，伴随着掌声到来的语言叫Swift。接下来Craig Federighi更是毫不掩饰的告诉大家，Swift将成为主宰iOS和Mac开发的新语言，甚至是整个软件行业中最举足轻重的语言。
翻扑克游戏_翻扑克牌游戏_
10-04
翻扑克游戏，通常被称为“对对碰”或“记忆翻牌”，是一种常见的休闲益智游戏。在这个游戏中，玩家需要在二维的游戏板上翻转一对隐藏的扑克牌，如果它们是相同的图案，则会被消除，直到所有牌都被匹配并消除。这种...
翻扑克牌游戏-uniapp-项目源码
10-27
这是一个uniapp项目源码，翻扑克牌游戏，可使用HBuildeX开发工具选uniapp打开项目，正常编译运行，请放心下载。 相关学习参考文章(https://blog.csdn.net/zs1028/article/details/134083333) 在此游戏能学到什么：...
扑克牌游戏素材开发包JPG
02-15
为了满足不同游戏风格的需求，开发包可能还包含了各种特别设计的扑克牌样式，例如带有独特边框、特殊纹理或者3D效果的牌面，这些都可以让游戏更具个性化和吸引力。此外，可能还会提供背景图片、筹码、桌布等其他相关...
day 9 回溯算法
m0_73924943的博客
08-08 332
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
代码随想录算法训练营day36：动态规划04：1049.最后一块石头的重量II；494.目标和；474.一和零
weixin_65180740的博客
08-07 939
力扣题目链接(opens new window)有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x!= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。输入：[2,7,4,1,8,1]输出：1。
浙大版《C语言程序设计（第3版）》题目集
qq_67330059的博客
08-09 320
其中a和b是用户传入的参数，函数返回的是两者中较大的数。
算法学习day32
最新发布
2301_78191305的博客
08-12 829
2.如果遍历到的数字可以和放一个数字构成一个有效的大写字母的ASCII值，是对dp[i+1]有用的，(这个有用是指多了dp[i-1]种分割方法）那么dp[i+1]+=dp[i-1];现在1有与3，5相乘的资格，2有与2，3，5相乘的资格，但是2×3和2×5是没必要比较的，因为有比它更小的1可以同3，5相乘，所以我们只需要比较1×3，1×5，2×2。即n=2*x+3*y+5*z。如果nums[i]==nums[i-1]&&nums[i-1]==nums[i-2] 那么dp[i]+=dp[i-1]+1;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值