求解字谜游戏问题

最新推荐文章于 2023-01-14 20:38:42 发布
最新推荐文章于 2023-01-14 20:38:42 发布
阅读量1k 收藏 3
点赞数 2
分类专栏： 数据结构与算法分析 文章标签： c 结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WJ_1062/article/details/38036741
版权

解决一个流行的字谜。输入是由一些字母和单词的二维数组组成。目标是赵楚字谜中的单词，这些单词可能是水平、垂直或沿着对角线异任何方向放置的。例如求解下图：

图1-1 字谜示例

1234
1 this
2wats
3oahg
4fgdt


书中给出的直观算法：对单词表中的每个单词。我们检查每一个有序三元组（行，列，方向），验证单词的存在。算是直接暴力查找吧。书中后续章节有优化方法， 以后再做研究。现直观算法代码如下：

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

#define WORD_PUZZLE_TABLE_WIDTH 4
#define WORD_PUZZLE_TABLE_HIGHT 4
/** 字谜表 */
const char word_puzzle_table[WORD_PUZZLE_TABLE_WIDTH][WORD_PUZZLE_TABLE_HIGHT] =
{
    {'t', 'h', 'i', 's'},
    {'w', 'a', 't', 's'},
    {'o', 'a', 'h', 'g'},
    {'f', 'g', 'd', 't'}
};

/** 单词表 */
const char *word_table[] = {"this", "two", "fat", "that"};
#define WORD_TABLE_LEN (sizeof(word_table) / sizeof(char*))

/** 点结构体 */
typedef struct point
{
    int x;
    int y;
} point;

/**
 * 查找结果结构体
 * pword    查找结果单词指针
 * begin    单词的开始位置
 * end      单词的结束位置
 * note:约定于坐标轴的方式表示，如：
 *         0 -----> x
 *         |
 *         |
 *         |y
 */
typedef struct result
{
    const char *pword;
    point begin;
    point end;
} result;

/** 定义查找方式宏 */
#define SEARCH_BEG          1
#define LEFT_TO_RIGHT       1
#define RIGHT_TO_LEFT       2
#define TOP_TO_UPPER        3
#define UPPER_TO_TOP        4
#define MAIN_DIAGONAL       5
#define R_MAIN_DIAGONAL     6
#define COUNTER_DIAGONAL    7
#define R_COUNTER_DIAGONAL  8
#define SEARCH_END          8

/**
 * 将字母c追加到字符串arras后面
 * arras    待追加字符串指针
 * c        待追加字母
 */
void append(char *arras, char c)
{
    assert(NULL != arras);

    while(*arras)
        ++arras;
    *arras = c;
}

/**
 * 查找函数
 * presult_set  查找结果集
 */
void search(result *presult_set)
{
    int search_way;
    char str_temp[20];
    int i, j, k;
    int index = 0;
    int flag = 0;
    result temp;

    asser(NULL != presult_set);
    memset(str_temp, '\0', sizeof(str_temp));

    /* 依次从各个方向开始查找 */
    for(search_way=1; search_way<=SEARCH_END; ++search_way)
    {
        switch(search_way)
        {
        case LEFT_TO_RIGHT:
            temp.begin.x = 1;
            for(i=0; i<WORD_PUZZLE_TABLE_HIGHT; ++i)
            {
                temp.begin.y = i + 1;
                for(j=0; j<WORD_PUZZLE_TABLE_WIDTH; ++j)
                {
                    append(str_temp, word_puzzle_table[i][j]);
                    for(k=0; k<WORD_TABLE_LEN; ++k)
                    {
                        if(0 == strcmp(str_temp, word_table[k]))
                        {
                            temp.pword = word_table[k];
                            temp.end.x = j + 1;
                            temp.end.y = i + 1;
                            presult_set[index] = temp;
                            flag = 1;
                            ++index;
                            break;
                        }
                    }
                    if(flag)
                    {
                        flag = 0;
                        break;
                    }

                }
                memset(str_temp, '\0', sizeof(str_temp));
            }
            break;

        case RIGHT_TO_LEFT:
            temp.begin.x = WORD_PUZZLE_TABLE_WIDTH;
            for(i=WORD_PUZZLE_TABLE_HIGHT-1; i>=0; --i)
            {
                temp.begin.y = i + 1;
                for(j=WORD_PUZZLE_TABLE_WIDTH-1; j>=0; --j)
                {
                    append(str_temp, word_puzzle_table[i][j]);
                    for(k=0; k<WORD_TABLE_LEN; ++k)
                    {
                        if(0 == strcmp(str_temp, word_table[k]))
                        {
                            temp.pword = word_table[k];
                            temp.end.x = j + 1;
                            temp.end.y = i + 1;
                            presult_set[index] = temp;
                            flag = 1;
                            ++index;
                            break;
                        }
                    }
                    if(flag)
                    {
                        flag = 0;
                        break;
                    }
                }
                memset(str_temp, '\0', sizeof(str_temp));
            }
            break;

        case TOP_TO_UPPER:
            temp.begin.y = 1;
            for(i=0; i<WORD_PUZZLE_TABLE_WIDTH; ++i)
            {
                temp.begin.x = i + 1;
                for(j=0; j<WORD_PUZZLE_TABLE_HIGHT; ++j)
                {
                    append(str_temp, word_puzzle_table[j][i]);
                    for(k=0; k<WORD_TABLE_LEN; ++k)
                    {
                        if(0 == strcmp(str_temp, word_table[k]))
                        {
                            temp.pword = word_table[k];
                            temp.end.x = i + 1;
                            temp.end.y = j + 1;
                            presult_set[index] = temp;
                            flag = 1;
                            ++index;
                            break;
                        }
                    }
                    if(flag)
                    {
                        flag = 0;
                        break;
                    }
                }
                memset(str_temp, '\0', sizeof(str_temp));
            }
            break;

        case UPPER_TO_TOP:
            temp.begin.y = WORD_PUZZLE_TABLE_HIGHT;
            for(i=0; i<WORD_PUZZLE_TABLE_WIDTH; ++i)
            {
                temp.begin.x = i + 1;
                for(j=WORD_PUZZLE_TABLE_HIGHT-1; j>=0; --j)
                {
                    append(str_temp, word_puzzle_table[j][i]);
                    for(k=0; k<WORD_TABLE_LEN; ++k)
                    {
                        if(0 == strcmp(str_temp, word_table[k]))
                        {
                            temp.pword = word_table[k];
                            temp.end.x = i + 1;
                            temp.end.y = j + 1;
                            presult_set[index] = temp;
                            flag = 1;
                            ++index;
                            break;
                        }
                    }
                    if(flag)
                    {
                        flag = 0;
                        break;
                    }
                }
                memset(str_temp, '\0', sizeof(str_temp));
            }
            break;

        case MAIN_DIAGONAL:
            temp.begin.x = 1;
            temp.begin.y = 1;
            for(i=0; i<WORD_PUZZLE_TABLE_HIGHT; ++i)
            {
                for(j=0; j<WORD_PUZZLE_TABLE_WIDTH; ++j)
                {
                    if(i == j)
                    {
                        append(str_temp, word_puzzle_table[i][j]);
                        for(k=0; k<WORD_TABLE_LEN; ++k)
                        {
                            if(0 == strcmp(str_temp, word_table[k]))
                            {
                                temp.pword = word_table[k];
                                temp.end.x = i + 1;
                                temp.end.y = j + 1;
                                presult_set[index] = temp;
                                flag = 1;
                                ++index;
                                break;
                            }
                        }
                    }
                    if(flag)
                        break;
                }
                if(flag)
                {
                    flag = 0;
                    break;
                }
            }
            memset(str_temp, '\0', sizeof(str_temp));
            break;

        case R_MAIN_DIAGONAL:
            temp.begin.x = WORD_PUZZLE_TABLE_WIDTH;
            temp.begin.y = WORD_PUZZLE_TABLE_HIGHT;
            for(i=WORD_PUZZLE_TABLE_HIGHT-1; i>=0; --i)
            {
                for(j=WORD_PUZZLE_TABLE_WIDTH-1; j>=0; --j)
                {
                    if(i == j)
                    {
                        append(str_temp, word_puzzle_table[i][j]);
                        for(k=0; k<WORD_TABLE_LEN; ++k)
                        {
                            if(0 == strcmp(str_temp, word_table[k]))
                            {
                                temp.pword = word_table[k];
                                temp.end.x = i + 1;
                                temp.end.y = j + 1;
                                presult_set[index] = temp;
                                flag = 1;
                                ++index;
                                break;
                            }
                        }
                    }
                    if(flag)
                        break;
                }
                if(flag)
                {
                    flag = 0;
                    break;
                }
            }
            memset(str_temp, '\0', sizeof(str_temp));
            break;

        case COUNTER_DIAGONAL:
            temp.begin.y = WORD_PUZZLE_TABLE_HIGHT;
            temp.begin.x = 1;
            for(i=WORD_PUZZLE_TABLE_HIGHT-1; i>=0; --i)
            {
                for(j=0; j<WORD_PUZZLE_TABLE_WIDTH; ++j)
                {
                    if(i + j == WORD_PUZZLE_TABLE_WIDTH - 1)
                    {
                        append(str_temp, word_puzzle_table[i][j]);
                        for(k=0; k<WORD_TABLE_LEN; ++k)
                        {
                            if(0 == strcmp(str_temp, word_table[k]))
                            {
                                temp.pword = word_table[k];
                                temp.end.x = j + 1;
                                temp.end.y = i + 1;
                                presult_set[index] = temp;
                                flag = 1;
                                ++index;
                                break;
                            }
                        }
                    }
                    if(flag)
                        break;
                }
                if(flag)
                {
                    flag = 0;
                    break;
                }
            }
            memset(str_temp, '\0', sizeof(str_temp));
            break;

        case R_COUNTER_DIAGONAL:
            temp.begin.y = 1;
            temp.begin.x = WORD_PUZZLE_TABLE_WIDTH;
            for(i=0; i<WORD_PUZZLE_TABLE_HIGHT; ++i)
            {
                for(j=WORD_PUZZLE_TABLE_WIDTH-1; j>=0; --j)
                {
                    if(i + j == WORD_PUZZLE_TABLE_WIDTH - 1)
                    {
                        append(str_temp, word_puzzle_table[i][j]);
                        for(k=0; k<WORD_TABLE_LEN; ++k)
                        {
                            if(0 == strcmp(str_temp, word_table[k]))
                            {
                                temp.pword = word_table[k];
                                temp.end.x = j + 1;
                                temp.end.y = i + 1;
                                presult_set[index] = temp;
                                flag = 1;
                                ++index;
                                break;
                            }
                        }
                    }
                    if(flag)
                        break;
                }
                if(flag)
                {
                    flag = 0;
                    break;
                }
            }
            memset(str_temp, '\0', sizeof(str_temp));
            break;

        default:
            break;
        }
        flag = 0;
    }
}

int main()
{
    result rlt_set[WORD_TABLE_LEN];
    int i;

    search(rlt_set);

    for(i=0; i<WORD_TABLE_LEN; ++i)
        printf("%s, (%d, %d)-->(%d, %d)\n", rlt_set[i].pword,
               rlt_set[i].begin.x, rlt_set[i].begin.y,
               rlt_set[i].end.x, rlt_set[i].end.y);

    return 0;
}
</span>
运行结果：


winux1062
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编写一个程序求解字谜游戏问题
不要看错一切
07-03 637
问题描述：输入是由一些字母和单词构成的二维数组，目标是找出字谜中的单词，这些单词可以是水平、垂直或沿对角线以任何方向放置。 编写一个程序求解字谜游戏问题 t h i s 找出 this、two、fat、that w a t s o a h g f g d t #include <stdio.h> #include <string.h> #define alphaTableMax (4) typedef enum tableDir{LEFT = 0, .
编写一个程序求解字谜游戏问题。
qq_43132512的博客
06-07 1790
/* 编写一个程序求解字谜游戏问题。 */ class Z_Pra_1_2{ public static final String[] WORDS={"this","two","fat","that"}; public static final char[][] ziMi={{'t','h','i','s'},{'w','a','t','s'},{'o','a','h','g'}...
【数据结构与算法分析1.2】编写一个程序求解字谜游戏问题
中华胡杨的专栏
07-22 6659
问题描述：输入是由一些字母和单词构成的二维数组，目标是找出字谜中的单词，这些单词可以是水平、垂直或沿对角线以任何方向放置。找出二维数组中所有的单词写完这个程序，手都要断掉了，太TM麻烦了，而且效率很低，到底有多少个for循环，自己都数不清。//1.2编写一个程序求解字谜游戏问题 #include <iostream> using namespace std; /** directions:
c 语言编程字谜,C语言猜字谜游戏
weixin_42498003的博客
05-21 543
C语言猜字谜游戏#include#include //getch()函数的头文件void main(){int password=0,i=0,number=0,price=58;printf("======This is a number guess game!======\n");while(password!=1234){if(i>=3){ printf("pleas...
编写一个程序求解字谜游戏
wwj_bupt
03-08 6597
数据结构与算法分析——c语言描述 练习1.2
crossword:Android填字游戏求解器
05-09
Android填字游戏求解器。 该应用程序在和可用。 单词不超过28个字母 110,000字的字典 网络搜索词定义 字谜搜索 解决填字游戏条目 使用下拉菜单设置要查找的单词中的字母数。 如果屏幕上无法容纳插槽数量，请旋转...
《数据结构和问题求解(Java语言版)(第四版)》源码
11-15
《数据结构和问题求解(Java语言版)(第四版)》是一本经典的计算机科学教材，主要探讨了如何使用Java语言来实现和理解各种数据结构以及算法。这本书的源码提供了丰富的实例，帮助读者深入理解数据结构和算法的实际应用...
Anagram:一个 Word Anagram 求解器和两个 Word Anagram 求解器
06-04
本文将深入探讨一个独特的项目——"Anagram"，它包含了两种类型的字谜求解器：单字Anagramsolver和双字Anagramsolver。这个项目以Java编程语言为基础，展示了如何运用算法来解决字谜问题，这对于学习和理解字符串...
letters-and-numbers:ABC节目中数字部分的求解器，字母和数字
03-14
5. **字谜解决**：结合上下文，解决基于单词的谜题，如填字游戏或字谜。 6. **用户输入提示**：允许用户输入自定义的提示或规则，以便于解密特定的谜题。 在实际应用中，这个求解器可能会有一个友好的用户界面，...
brute-force-anagram-solver:一个低效的 anagram 求解器，蛮力猜测 - 用 python 编写
06-16
此外，对于特定的应用场景，如解决字谜游戏，我们还可以使用词典树（Trie）数据结构来存储已知单词，快速地查找潜在的Anagram。 总结来说，这个项目为我们提供了一个了解和实践Python编程以及蛮力算法的机会。尽管...
哈希函数解决字谜问题
12-28
利用三个哈希值，和矩阵的旋转解决字符串问题，已给定部分字符串，求其出现概率
用c语言编写的猜字游戏（含源代码）
06-17
用c语言编写的猜字游戏，附源代码，分享出的好东西，大家共同进步啊！
数据结构与算法分析1.2练习：编写一个程序解决字谜问题
最新发布
m0_74045201的博客
01-14 237
数据结构与算法分析中1.2字谜游戏问题，讨论4行4列情况
【数据结构与算法分析】1.2 编写程序解决字谜问题
BirdMan的广阔天地
10-29 1748
原博:http://blog.csdn.net/u013667086/article/details/49179741 问题描述:       从已知的字谜中找出在字典中的单词 解决思路:        1、用指针数组存放字谜和字典单词        2、将字典单词排序并加上hash索引        3、遍历字谜，每一个在字典中有的字母按八个方向进行遍历找出单词（
数据结构与算法分析第一章第二个习题
小石头会长成大石头么？
12-05 241
下面是我的代码： /* * 编写一个程序求解字谜游戏问题。 */ #include<stdio.h> #include<stdlib.h> #include<string.h> #define LONGEST_LENGTH 4 #define COL_NUM 4 #define RAW_NUM 4 char ** initPuzzleBorad(char ** puzzleBorad, int col_num, int raw_num); void displayPuz
求解字谜游戏java_编写一个程序求解字谜游戏问题。
weixin_30539317的博客
02-28 226
package wulei.test;public class WordPuzzleTest {public static final String[] WORDS = new String[]{"love","lin"};public static final char[][] chars = {{'l','k','n','l'},{'d','o','d','i'},{'h','d','v','...
数据结构与算法书中，字谜游戏java实现
zhangyi162的专栏
07-18 1414
看《数据结构与算法c实现》书中有个字谜游戏的作业，用java写了一份，算是完成书中第一章的课后作业吧。 package test; /**  * 输入时一些字母和单次，输出是找出这些单次  * 可以横竖斜，方向任意  * */ public class PuzzleGame {  public static void main(String[] args) {   char[][]
MATLAB求解高等数学问题
课程内容包括数学问题计算机求解的概述，解析解与数值解的对比，以及数学运算软件包的发展历程。通过实例展示了MATLAB在求解导数和高阶导数问题中的应用，强调了计算机求解在避免复杂计算和减少错误方面的优势。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值