24点游戏-去除重复结果

最新推荐文章于 2022-04-22 22:05:53 发布
最新推荐文章于 2022-04-22 22:05:53 发布
阅读量952 收藏
点赞数
分类专栏： 算法 c/c++ 文章标签： 游戏 tree list input struct types
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Brunie/article/details/6850406
版权

game.c

/*
 * game.c
 *
 *  Created on: 2011-9-27
 *      Author: brunie
 */

#include "game.h"
#include "stack.h"

Node* standardize_tree(Node* root);
int save_unique(Game *game, Node *root);
void get_expression(Node *root, char *exp);
Node *copy_tree(Node *root);
void destroy_tree(Node *root);

int operate(Node *left, Node *right, Node *result, int type)
{
    switch (type)
    {
        case ADD:
            result->res = left->res + right->res;
            result->op = '+';
            result->left = left;
            result->right = right;
            break;

        case SUB:
            result->res = left->res - right->res;
            result->op = '-';
            result->left = left;
            result->right = right;
            break;

        case MUL:
            result->res = left->res * right->res;
            result->op = '*';
            result->left = left;
            result->right = right;
            break;

        case DIV:
            if (right->res != 0)
            {
                result->res = left->res / right->res;
                result->op = '/';
                result->left = left;
                result->right = right;
            }
            break;

        case RSUB:
            result->res = right->res - left->res;
            result->op = '-';
            result->left = right;
            result->right = left;
            break;

        case RDIV:
            if (left->res != 0)
            {
                result->res = right->res / left->res;
                result->op = '/';
                result->left = right;
                result->right = left;
            }
            break;
    }
    return 1;
}

int calculate(Node **node_list, int len, Game *game)
{
    int i, j, k, tmp, type;
    if (len == 1)
    {
        if (fabs(node_list[0]->res - FINAL_RESULT) < PRECISION)
        {
            save_unique(game, node_list[0]);
            game->success = OK;
        }
    }
    else
    {
        Node **next = (Node **) malloc((len - 1) * sizeof(pNode));
        pNode tmp_result = (pNode) malloc(sizeof(Node));
        next[0] = tmp_result;
        for (i = 0; i < len; i++)
        {
            for (j = i + 1; j < len; j++)
            {

                tmp = 1;
                for (k = 0; k < len; k++)
                {
                    if (k != i && k != j)
                    {
                        next[tmp++] = node_list[k];
                    }
                }

                for (type = 0; type < OPERATOR_TYPES; type++)
                {
                    operate(node_list[i], node_list[j], tmp_result, type);

                    calculate(next, len - 1, game);
                }
            }
        }// for i

        free(next);
        free(tmp_result);

    }//else
    return 1;
}

void Game_execute(Game *game)
{
    calculate(game->node_list, N_FIGURES, game);
}

int priority(char operator)
{
    if (operator == 0)
        return 3;
    else if (operator == '+' || operator == '-')
        return 1;
    else
        return 2;
}

Node* copy_tree(Node *root)
{
    if (0 == root)
        return 0;

    Node *new_root = (Node *)malloc(sizeof(Node));
    *new_root = *root;

    new_root->left = copy_tree(root->left);
    new_root->right = copy_tree(root->right);

    return new_root;
}

void destroy_tree(Node *root)
{
    if (root->left)
        destroy_tree(root->left);
    if (root->right)
        destroy_tree(root->right);

    free(root);

}

void sort_node(pNode *pnodes, int len)
{
    int i,j;
    int flag = 1;
    for (i = 0; i < len - 1 && flag; i++)
    {
        flag = 0;
        for (j = 0; j < len - i - 1; j++)
        {
            if (pnodes[j]->res > pnodes[j + 1]->res)
            {
                pNode tmp = pnodes[j];
                pnodes[j] = pnodes[j + 1];
                pnodes[j + 1] = tmp;
                flag = 1;
            }
        }
    }

    /*for (i = 0; i < len; i++)
        printf("%f ", (*pnodes[i])->res);
    printf("\n");*/
}

Node* create_tree(pNode *left_nodes, int left_len,
        pNode *right_nodes, int right_len, char op)
{
    sort_node(left_nodes, left_len);
    sort_node(right_nodes, right_len);
    pNode left_result, right_result;
    int type;
    int i;
    if (op == '+')
        type = ADD;
    else
        type = MUL;
    if (left_len >= 2)
    {
        for (i = 0; i < left_len - 1; i++)
        {
            left_result = (pNode) malloc(sizeof(Node));
            operate(left_nodes[i], left_nodes[i + 1], left_result, type);
            left_nodes[i + 1] = left_result;
        }
    }
    else
    {
        left_result = left_nodes[0];
    }

    if (right_len >= 1)
    {
        for (i = 0; i < right_len; i++)
        {
            right_result = (pNode) malloc(sizeof(Node));
            operate(left_result, right_nodes[i], right_result, type + 1);
            left_result = right_result;
        }
    }

    return left_result;
}

Node* standardize_tree(Node* root)
{
    Node   *tmp, *mid_root;
    istack *open = (istack*)malloc(sizeof(istack));
    pNode left_nodes[N_FIGURES];
    pNode right_nodes[N_FIGURES];
    int left_len = 0, right_len = 0;
    char op_a, op_b, op;

    init_stack(open);
    tmp = root;
    op = tmp->op;
    if (op == '+' || op == '-')
    {
        op = op_a = '+';
        op_b = '-';
    }
    else
    {
        op = op_a = '*';
        op_b = '/';
    }

    do
    {
        if (tmp->op == op_a)
        {
            push(open, tmp);
            tmp = tmp->left;
        }
        else if (tmp->op == op_b)
        {
            push(open, tmp);

            mid_root = tmp->right;
            if (tmp->right->op)
                mid_root = standardize_tree(tmp->right);
            right_nodes[right_len++] = mid_root;
            tmp->right = 0;

            tmp = tmp->left;
        }
        else
        {
            mid_root = tmp;
            if (tmp->op)
                mid_root = standardize_tree(tmp);
            left_nodes[left_len++] = mid_root;

            if (!stack_empty(open))
            {
                pop(open, &tmp);
                while (!tmp->right && !stack_empty(open))
                {
                    free(tmp);
                    pop(open, &tmp);
                }

                mid_root = tmp;
                tmp = tmp->right;
                if (mid_root->op)
                    free(mid_root);
            }
            else
                tmp = 0;
        }
    } while (tmp || !stack_empty(open));

    free(open);

    mid_root = create_tree(left_nodes, left_len, right_nodes, right_len, op);

    return mid_root;
}


int save_unique(Game *game, Node* root)
{
    int i;
    char *exp = (char*) malloc(EXPRESSION_LEN);
    exp[0] = '\0';
    Node *tmp_root = copy_tree(root);
    tmp_root = standardize_tree(tmp_root);
    get_expression(tmp_root, exp);

    //printf("%s\n", exp);

    destroy_tree(tmp_root);
    for (i = 0; i < game->n_solutions; i++)
    {
        if (strcmp(exp, game->unique_expressions[i]) == 0)
        {
            break;
        }
    }

    if (i == game->n_solutions)
    {
        if (game->n_solutions == MAX_N_SOLUTIONS)
        {
            game->unique_expressions = (char **) realloc(
                    game->unique_expressions,
                    (game->n_solutions + MAX_N_SOLUTIONS) * sizeof(char*));
            if (!game->unique_expressions)
                exit(OVERFLOW);
        }
        game->unique_expressions[game->n_solutions++] = exp;
        return TRUE;
    }
    return FALSE;
}


void get_expression(Node *root, char *exp)
{
    char left_op, right_op, op;

    if (root->left == 0 && root->right == 0)
    {
        sprintf(exp + strlen(exp),"%d", (int)(root->res));
    }
    else
    {
        left_op = root->left->op;
        right_op = root->right->op;
        op = root->op;
        if (priority(op) > priority(left_op))
        {
            sprintf(exp + strlen(exp),"(");
            get_expression(root->left, exp);
            sprintf(exp + strlen(exp),")");
        }
        else
            get_expression(root->left, exp);

        sprintf(exp + strlen(exp), " %c ", op);

        if (priority(op) > priority(right_op)
            || (op == '-' && right_op == '-')
            || (op == '-' && right_op == '+')
            || (op == '/' && right_op == '*')
            || (op == '/' && right_op == '/'))
        {
            sprintf(exp + strlen(exp), "(");
            get_expression(root->right, exp);
            sprintf(exp + strlen(exp), ")");
        }
        else
            get_expression(root->right, exp);
    }
}

void print_results(Game *game)
{
    printf("\nTotal %d unique results:\n", game->n_solutions);
    int i;
    for (i = 0; i < game->n_solutions; i++)
    {
        printf("%s = %d\n", game->unique_expressions[i], FINAL_RESULT);
    }
}

void init_list(Game *game)
{
    int i;
    game->success = 0;
    game->n_solutions = 0;
    for (i = 0; i < N_FIGURES; i++)
    {
        game->node_list[i]->res = game->figures[i];
    }
}

int init_data(Game *game)
{
    int i;
    game->figures = (int *)malloc(N_FIGURES * sizeof (int));
    game->node_list = (pNode *)malloc(N_FIGURES * sizeof (pNode));
    game->unique_expressions = (char **)malloc(MAX_N_SOLUTIONS * sizeof (char *));

    if (!(game->figures && game->node_list && game->unique_expressions))
        exit(OVERFLOW);

    for (i = 0; i < N_FIGURES; i++)
    {
        game->node_list[i] = (pNode)malloc(sizeof(Node));
        if (!game->node_list[i])
            exit(OVERFLOW);
        game->node_list[i]->left = 0;
        game->node_list[i]->right = 0;
        game->node_list[i]->op = 0;
    }

    return TRUE;
}

void destory_data(Game *game)
{
    int i;
    if (game->figures)
    {
        free(game->figures);
        game->figures = 0;
    }
    if (game->node_list)
    {
        for (i = 0; i < N_FIGURES; i++)
        {
            free(game->node_list[i]);
        }
        free(game->node_list);
        game->node_list = 0;
    }
    if (game->unique_expressions)
    {
        for (i = 0; i < game->n_solutions; i++)
        {
            free(game->unique_expressions[i]);
        }
        free(game->unique_expressions);
        game->unique_expressions = 0;
    }

}

game.h 

/*
 * game.h
 *
 *  Created on: 2011-9-27
 *      Author: brunie
 */

#ifndef GAME_H_
#define GAME_H_

#define MAX_INPUT 		13
#define MIN_INPUT 		1
#define N_FIGURES		4
#define OPERATOR_TYPES	6
#define FINAL_RESULT	24
#define EXPRESSION_LEN 	30
#define MAX_N_SOLUTIONS 100
#define PRECISION		(1E-6)

#define TRUE			1
#define FALSE			0
#define OK				1
#define OVERFLOW		(-2)

#include  	<stdlib.h>
#include	<stdio.h>
#include	<math.h>
#include 	<time.h>
#include 	<string.h>

typedef struct Node
{
	double res;
	struct Node *left;
	struct Node *right;
	char op;
}Node, *pNode;

enum Operators {ADD, SUB, MUL, DIV, RSUB, RDIV};

typedef struct Game
{
	int *figures;
	pNode *node_list;
	int success;
	int n_solutions;
	char **unique_expressions;
}Game, *pGame;

void Game_execute(Game *game);

void print_results(Game *game);

void init_list(Game *game);

int init_data(Game *game);

void destory_data(Game *game);

#endif /* GAME_H_ */

main.c 

/*
 * main.c
 *
 *  Created on: 2011-9-27
 *      Author: brunie
 */

#include "twenty_four.h"

int main()
{
	setbuf(stdout,0);
	int status;
	status = play_game();

	if (status)
		printf("Successful!\n");
	else
		printf("Not exist!\n");

	return 0;
}

stack.c 

/*
 * stack.c
 *
 *  Created on: 2011-10-5
 *      Author: brunie
 */
#include "stack.h"

int init_stack(istack *stack)
{
	stack->base = (pNode *)malloc(STACK_INIT_SIZE * sizeof(pNode));
	if (!stack->base)
		exit (-1);
	stack->top = stack->base;
	stack->stack_size = STACK_INIT_SIZE;
	return 1;
}

void destory_stack(istack *stack)
{
	if(!stack->base)
		free(stack->base);
	stack->base = 0;
}

int stack_empty(istack *stack)
{
	if (stack->top == stack->base)
		return TRUE;
	else
		return FALSE;
}

int stack_length(istack *stack)
{
	return stack->top - stack->base;
}

int get_top(istack *stack, pNode *pnode)
{
	if (stack->top == stack->base)
		return 0;
	*pnode = *(stack->top - 1);
	return 1;
}

int push(istack *stack, pNode pnode)
{
	if (stack->top - stack->base >= stack->stack_size)
	{
		stack->base = (pNode *) realloc(stack->base,
				(stack->stack_size + STACK_INCREMENT) * sizeof(pNode));
		if (!stack->base)
			exit(-1);
		stack->top = stack->base + stack->stack_size;
		stack->stack_size += STACK_INCREMENT;
	}
	*stack->top++ = pnode;
	return 1;
}

int pop(istack *stack, pNode *pnode)
{
	if (stack->top == stack->base)
		return 0;
	*pnode = * --stack->top;
	return 1;
}

stack.h 

/*
 * stack.h
 *
 *  Created on: 2011-10-5
 *      Author: brunie
 */

#ifndef STACK_H_
#define STACK_H_

#include "game.h"

#define	STACK_INIT_SIZE	50
#define	STACK_INCREMENT	10

typedef struct
{
	pNode	*base;
	pNode	*top;
	int		stack_size;
}istack;

int init_stack(istack *stack);

void destory_stack(istack *stack);

int stack_empty(istack *stack);

int stack_length(istack *stack);

int get_top(istack *stack, pNode *pnode);

int pop(istack *stack, pNode *pnode);

int push(istack *stack, pNode pnode);

#endif /* STACK_H_ */

twenty_four.c 

/*
 * twenty_four.c
 *
 *  Created on: 2011-10-5
 *      Author: brunie
 */

#include "twenty_four.h"

void input(Game *game)
{
	int digit;
	int c;
	int i;

	while(1)
	{
		printf("Please input %d figures, each figure in the range of [%d,%d]:\n",N_FIGURES, MIN_INPUT, MAX_INPUT);
		digit = 0;
		i = 0;

		while ((c = getchar()) == ' ');

		do
		{
			if (c <= '9' && c >= '0')
				digit = digit * 10 + c - '0';
			else if (c == ' ')
			{
				if (digit > MAX_INPUT || digit < MIN_INPUT)
					break;
				game->figures[i++] = digit;
				//printf("%d ",digit);

				if (i == N_FIGURES)
					break;

				while((c = getchar()) == ' ');
				if(c > '9' || c < '0')
					break;
				digit = c - '0';
			}
			else
			{
				if (c == '\n')
				{
					game->figures[i++] = digit;
					//printf("%d ",digit);
				}
				break;
			}

		}while ((c = getchar()) != EOF);

		if (c != '\n')
			while ((c = getchar()) != '\n');

		if (i == N_FIGURES)
			break;

		printf("Illegal input!\n");
	}

}


int play_game()
{

	int c;
	int flag;

	Game game;

	init_data(&game);

	do
	{
		input(&game);
		init_list(&game);
		Game_execute(&game);
		print_results(&game);

		printf("Do you want to play again(y/n):");
		flag = getchar();
		while ((c = getchar()) != '\n' && c != EOF)
			;
	} while (flag == 'y' || flag == 'Y');

	destory_data(&game);

	return game.success;
}

tweny_four.h 

/*
 * twenty_four.h
 *
 *  Created on: 2011-10-5
 *      Author: brunie
 */

#ifndef TWENTY_FOUR_H_
#define TWENTY_FOUR_H_

#include "game.h"

void input(Game *game);

int play_game();

#endif /* TWENTY_FOUR_H_ */



Brunie
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c语言24点程序,C语言24点问题
weixin_33524659的博客
05-17 695
问题描述在屏幕上输入1〜10范围内的4个整数(可以有重复)，对它们进行加、减、乘、除四则运算后(可以任意的加括号限定计算的优先级)，寻找计算结果等于24的表达式。例如输入4个整数4、5、6、7，可得到表达式：4*((5-6)+7)=24。这只是一个解，要求输出全部的解。要求表达式中数字的顺序不能改变。问题分析本题最简便的解法是应用穷举法搜索整个解空间，筛选出符合题目要求的全部解。因此，关键的问题是...
24点游戏c语言去除重复,C语言解24点游戏程序
weixin_26779013的博客
05-19 238
该楼层疑似违规已被系统折叠隐藏此楼查看此楼前几天在微博上看到24点的游戏，6 6 610。算了很久是在算不出来，最后我想我何不写一个小程序解决它？说做就做，我刚开始的想法很简单，就是列举4个数的所有可能的表达式组合，然后计算表达式是否等于24，如果是的话就找到了答案。但我花了一晚的时间都没有写出程序来…第二天我改变了思路，这也是从一些答案里得到的灵感。例如一个3 8 3 8，它的答案是 3/(3...
24点表达式去重--c++实现
hiluo302的博客
11-08 1027
/* hiluo 2016.10.8 */ #include <iostream> #include <string> #include <vector> #include <algorithm> #include <iterator> #include <cmath>using namespace std;/* 存放解集 */ vector<string> ivec;/* 第1个数和第2个数的值及
C语言24点问题
weixin_43063069的博客
05-14 3549
C语言24点问题 在屏幕上输入1〜10范围内的4个整数（可以有重复），对它们进行加、减、乘、除四则运算后（可以任意的加括号限定计算的优先级），寻找计算结果等于24的表达式。 例如输入4个整数4、5、6、7，可得到表达式：4*((5-6)+7)=24。这只是一个解，要求输出全部的解。要求表达式中数字的顺序不能改变。 解题思路：穷举法 分析： 1.假设输入A,B,C,D四个未知数，在不考虑括号优先...
C语言实现24点程序
acwos42408的博客
01-12 611
一、简介 本程序的思想和算法来自于C语言教材后的实训项目，程序通过用户输入四个整数计算出能够通过加减乘除得到数字24的所有表达式，程序的设计有别于一般通过穷举实现的方式，效率得到提高。算法介绍如下： 如用户输入1,2,3,4四个数字，先将其看成四个集合即{1}，{2}，{3}，{4}，整个叫做第一集群，后通过任...
基于Java的Android应用程序开发-24点游戏源码+详细项目说明.zip
最新发布
08-09
基于Java的Android应用程序开发-24点游戏源码+详细项目说明.zip 基于Java的Android应用程序开发-24点游戏源码+详细项目说明.zip 基于Java的Android应用程序开发-24点游戏源码+详细项目说明.zip 【项目介绍】 该资源...
C++二十四点游戏MFC编写
10-21
C++二十四点游戏 全部结果都有，而且去掉了重复项，而且是可视化的结果。基本算法就是利用数字和运算符的双重递归。代码清晰。任给四个1~9（或1~13）数字，列出计算结果等于24的所有算式。去掉明显的重复算式，比如9...
24点小游戏.zip
10-20
【24点小游戏】是一个基于Python编程语言设计的数学益智游戏，它的目标是通过基本的数学运算（加、减、乘、除）将给定的四张扑克牌的数值组合成24。这个游戏旨在锻炼玩家的逻辑思维和数学运算能力。在Python实现的...
24点游戏的算法及实现
11-08
24点游戏是一种深受人们喜爱的智力挑战游戏，它的目标是通过加、减、乘、除运算，将给出的四个1到13之间的数字组合成24。这个游戏考验玩家的逻辑思维和数学技能。本文将深入探讨24点游戏的算法实现，并提供详细的...
Excel VBA版24点游戏
07-22
利用Excel的VBA编写一个简单的24点游戏。 使用前，需要“启用宏”。 启用宏前，需要将宏安全性调为中。 简单版没有去除重复的答案，也没有考虑太多运算顺序……
24点计算器 含交换律 去重
06-08
简易的24点计算器，可以去重的 例：（不会传图片） 1 2 3 4 case 1: (1 + 2 + 3)x 4 =24 case 2: 1 x 2 x 3 x 4 =24 case 3: (1 + 3)x(2 + 4) =24 case 4: 2 / 1 x 3 x 4 =24 case 5: 2 /(1 /(3 x 4)) =24 3 3 8 8 case 1: 8 /(3 -(8 / 3)) =24 1 1 1 4 NONE
24点程序（没有重复，括号显示完美）
05-18
JAVA版24点程序，能去除重复，括号显示完美。
24点游戏 C语言代码
Goodnight_makaba的博客
04-22 8196
算法分析： 总共4个数字a,b,c,d 那么需要三条算式 运算三次 判断结果是否为24 第一步：循环从 a b c d 取两个数做+ - * / 四次运算 剩下新的 a b c 三个数 第二步：循环从 a b c 取两个数做+ - * / 四次运算 剩下新的 a b c 两个数 第三步：循环从 a b 取两个数做+ - * / 四次运算 判断结果是否为24 算法缺点： 这样出来的解法会有重复的算式，也就是说同一条算式，却出来了不同的解法 举个例子 （a+......
c语言二十四点算法,本文实例为大家分享了C语言经典24点算法的具体实现代码，供大家参考，具体内容如下1、概述　　给定4个整数，其中每个数字只能使用一次；任意使用 + - * /...
weixin_30199703的博客
05-23 1738
本文实例为大家分享了C语言经典24点算法的具体实现代码，供大家参考，具体内容如下1、概述给定4个整数，其中每个数字只能使用一次；任意使用 + - * / ( ) ，构造出一个表达式，使得最终结果为24，这就是常见的算24点的游戏。这方面的程序很多，一般都是穷举求解。本文介绍一种典型的算24点的程序算法，并给出两个具体的算24点的程序：一个是面向过程的C实现，一个是面向对象的java实现。2、基本原...
Java中Set巧用，去掉重复数据
热门推荐
evilcry2012的专栏
12-25 1万+
Java中Set巧用，去掉重复数据 博客分类：  java基础 JavaCC++C#  java中Set有这样一个方法，.addAll( Collection c)，直接加入List集合，去掉重复的数据。   Java代码   public static void main(String[] args) {   Set  set=new
c++输出24点所有情况（1-13）
bluedarker的博客
04-14 1169
一、题目描述 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 二、问题分析 使用枚举就能解决问题，难点在于如何减少重复枚举的条件和输出带括号的表达式，这里使用了枚举来输出。 三、算法设计 四、代码实现 函数实现 int main() { add(); system("pause"); } void ...
去除重复项的算24点代码
06-03
以下是一个简单的 Python 代码实现，可以解决去除重复项的 24 点游戏问题： ```python from itertools import permutations def solve24(nums): for p in permutations(nums): # try all possible orders of ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值