BUAA_C程序括号匹配检查

2023-11-06

【问题描述】

编写一程序检查C源程序文件中{}、()等括号是否匹配,并输出第一个检测到的不匹配的括号及所对应括号所在的行号(程序中只有一个括号不匹配)。

注意:

1.除了括号可能不匹配外,输入的C源程序无其它语法错误。

2.字符常量、字符串常量及注释中括号不应被处理,注释包括单行注释//和多行/* */注释

3.字符常量和字符串常量中不包含转义字符’和";

4.程序中出现有意义括号的个数不超过200个;

不匹配判断规则:

1.当检测的程序括号为’{‘时,若其前序尚未匹配的括号为’(‘时,输出该’('左括号及所在行号;

2.当遇到一个不匹配的右括号’)‘或’}'时,输出该右括号及所在行号;

3.当程序处理完毕时,还存在不匹配的左括号时,输出该左括号及所在行号。

【输入形式】

打开当前目录下文件example.c,查询其括号是否匹配。该文件中每行字符数不超过200。

【输出形式】

若存在括号不匹配时,应输出首先能判断出现不匹配的括号及其所在的行号。当出现括号不匹配时,按下面要求输出相关信息:

without maching at line

其中为‘{’, ‘}’, ‘(’, ‘)’等符号,为该符号所在的行号。

若整个程序括号匹配,则按下面所示顺序输出括号匹配情况,中间没有空格。

(){(()){}}

【样例输入1】

若当前目录下输入文件example.c中内容如下:

#include<stdio.h>

int main(){

printf(“{ hello world }\n”); // }

)

【样例输出1】

without maching ‘)’ at line 4

【样例输入2】

若当前目录下输入文件example.c中内容如下:

#include<stdio.h>

int main(){

printf(“{ hello world }d\n”); /* }*/

【样例输出2】

without maching ‘{’ at line 2

【样例输入3】

若当前目录下输入文件example.c中内容如下:

#include<stdio.h>

int main(){

printf(“{ hello world }d\n”); /* }*/

}

【样例输出3】

(){()}

【样例说明】

样例1:在注释部分和字符串中的括号不考虑,在将程序处理之后得到的括号序列是(){()),遇到右括号时与最近的左括号匹配,发现最后一个小括号和大括号不匹配。

样例2:处理之后的括号序列是(){(),在最后缺少了右大括号,那么应该输出与之相对应的左括号不匹配。

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

char a[210], b[210], temp[300];

int main()
{
    FILE *fp;
    fp = fopen("example.c", "r");

    int i = 0, j = 0, len = 0, flag = 0, n, w, fuck = 0; //len是行数

    while (fgets(temp, 205, fp) != NULL)
    {
        if (fuck == 1)
        {
            break;
        }

        len++;
        flag = 0;
        n = strlen(temp);
        for (int k = 0; k < n; k++)
        {
            if (temp[k] == '(' || temp[k] == '{')
            {
                a[i++] = temp[k];
                b[j++] = temp[k];
            }
            else if (temp[k] == '/' && temp[k + 1] == '/')
            {
                break;
            }
            else if (temp[k] == '/' && temp[k + 1] == '*')
            {
                for (w = k + 2; w < n; w++)
                {
                    if (temp[w] == '*' && temp[w + 1] == '/')
                    {
                        flag = 1;
                        break;
                    }
                }
                while (flag == 0)
                {
                    strcpy(temp, "\0");
                    fgets(temp, 205, fp);
                    len++;
                    flag = 0;
                    n = strlen(temp);
                    for (w = 0; w < n; w++)
                    {
                        if (temp[w] == '*' && temp[w + 1] == '/')
                        {
                            flag = 1;
                            break;
                        }
                    }
                }
                k = w;
                // 后面接着判断括号
            }
            if (temp[k] == ')')
            {
                b[j++] = temp[k];
                if (a[i - 1] == '(')
                {
                    a[--i] = '\0';
                }
                else
                {
                    printf("without maching '%c' at line %d", temp[k], len);
                    fuck = 1;
                    break;
                }
            }

            if (temp[k] == '}')
            {
                b[j++] = temp[k];
                if (a[i - 1] == '{')
                {
                    a[--i] = '\0';
                }
                else
                {
                    printf("without maching '%c' at line %d", temp[k], len);
                    fuck = 1;
                    break;
                }
            }
            strcpy(temp, "\0");
        }
    }
    /*if (fuck == 0 || strlen(a) != 0)
    {
        printf("%c", a[strlen(a) - 1]);
    }*/
    if (fuck == 0 && strlen(a) != 0)
    {
        printf("%s", b);
    }

    fclose(fp);
    return 0;
}

方法二

#include <stdio.h>
#include <string.h>
#define MAX 202

struct one
{
    char a;
    int position;
} pos[202];

struct opstack
{
    struct one pos[202];
    int top;
} s;

int i, j, line;
char buffer[202], all[202];
typedef struct opstack stack;

void initstack(stack *s) { s->top = -1; }

void push_stack(stack *s, char c, int line)
{
    s->pos[++s->top].a = c;
    s->pos[s->top].position = line;
}

void pop_stack(stack *s)
{
    s->pos[s->top].a = '\0';
    s->pos[s->top].position = 0;
    s->top--;
}

int main(void)
{
    FILE *open = fopen("example.c", "r");
    initstack(&s);
    while (fgets(buffer, 201, open) != NULL)
    {
        line++;
        int length = strlen(buffer), type = 0;
        for (i = 0; i < length; i++)
        {
            if (type == 4)
                continue;
            if (buffer[i] != '(' && buffer[i] != ')' && buffer[i] != '{' &&
                buffer[i] != '}' && buffer[i] != '"' && buffer[i] != '*' &&
                buffer[i] != '/')
                continue;
            if (type != 3 && type != 5 &&
                (buffer[i] == '(' || buffer[i] == '{'))
                type = 1;
            if (type != 3 && type != 5 &&
                (buffer[i] == ')' || buffer[i] == '}'))
                type = 2;
            if (type != 3 && type != 5 &&
                (buffer[i] == '/' && buffer[i + 1] == '*'))
                type = 3;
            if (type != 3 && type != 5 &&
                (buffer[i] == '/' && buffer[i + 1] == '/'))
                type = 4;
            if (type == 5 && buffer[i] != '"')
                continue;
            if (type != 5 && buffer[i] == '"')
            {
                type = 5;
                continue;
            }
            if (type == 5 && buffer[i] == '"')
            {
                type = 0;
                continue;
            }
            if (type == 3 && buffer[i] == '*' && buffer[i + 1] == '/')
                type = 0;
            if (buffer[i] == '{' && s.pos[s.top].a == '(')
            {
                type = -1;
                break;
            }
            if (buffer[i] == ')' && s.pos[s.top].a == '{')
            {
                push_stack(&s, buffer[i], line);
                type = -1;
                break;
            }
            if (type == 3)
                continue;
            if (type == 1 || type == 2)
            {
                all[j++] = buffer[i];
                if (buffer[i] == ')' && s.pos[s.top].a == '(')
                {
                    pop_stack(&s);
                }
                else if (buffer[i] == '}' && s.pos[s.top].a == '{')
                {
                    pop_stack(&s);
                }
                else
                    push_stack(&s, buffer[i], line);
                type = 0;
            }
        }
        if (type == -1)
            break;
        for (i = 0; i < length; i++)
            buffer[i] = '\0';
    }
    if (s.top == -1)
        printf("%s", all);
    if (s.top != -1)
        printf("without maching '%c' at line %d", s.pos[s.top].a,
               s.pos[s.top].position);
}

方法三

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#define isbracket buff[i]=='('||buff[i]==')'||buff[i]=='{'||buff[i]=='}'
char buff[210];
struct stack
{
	int line;
	char b;
}sbracket[300];
char brackets[250];
int main()
{
	FILE*fp;
	int i,j,k,cnt=0,cnt1=1,n=1;
	fp=fopen("example.c","r");
	while(fgets(buff,202,fp)!=NULL)
	{
		cnt++;
		for(i=0;buff[i]!='\0';i++)
		{
			int flag=0;
			if(buff[i]=='/'&&buff[i+1]=='/')
			break;
			if(buff[i]=='"')
			{
				do
				{
					i++;
				}while(buff[i]!='"');
			}
			if(buff[i]=='\'')
			{
				do
				{
					i++;
				}while(buff[i]!='\'');
			}
			if(buff[i]=='/'&&buff[i+1]=='*')
			{
				while(!flag)
				{
				while(!(buff[i]=='*'&&buff[i+1]=='/'))
				{
					i++;
					if(buff[i]=='\0')
					break;
				}
				if(buff[i]!='\0')
				flag=1;
				else
				{
					memset(buff,0,210);
					fgets(buff,202,fp);
					i=0;
				}
				}
			}
			char match;
			if(isbracket)
			{
				brackets[n++]=buff[i];
					switch(buff[i])
					{
						case('('):
							match=')';
							break;
						case(')'):
							match='(';
							break;
						case('{'):
							match='}';
							break;
						case('}'):
							match='{';
							break;
					}
				for(j=cnt1-1;j>0;j--)
				{
					if(sbracket[j].b=='('&&match=='}')
					{
					printf("without maching '(' at line %d",sbracket[j].line);
					return 0;
					}
					if(sbracket[j].b==match)
					{
						for(k=j+1;k<=cnt1;k++,j++)
							sbracket[j]=sbracket[k];
						cnt1--;
						break;
					}
				}
				if(j==0)
				{
					if(buff[i]==')'||buff[i]=='}')
					{
					printf("without maching '%c' at line %d",buff[i],cnt);
					return 0;
					}
					sbracket[cnt1].b=buff[i];
					sbracket[cnt1].line=cnt;
					cnt1++;
				}
			}
		}
		memset(buff,0,210);
	}
	if(cnt1==2)
	printf("without maching '%c' at line %d",sbracket[1].b,sbracket[1].line);
	else
	{
		for(i=1;i<n;i++)
		printf("%c",brackets[i]);
	}
	return 0;
}

方法四

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

#define max 250
#define item 10

int STACK_0[max][item] , STACK[max][item] , top , TOP , count_line , flag_note , judge;
char line[max];

void func();
void SEEK();
void push(int element);
int isnote_1(int x);
int isnote_2(int x);
int isnote_2_end(int x);

int main()
{
	FILE *fp = fopen( "example.c" , "r" );
	count_line = 0 ; 
	flag_note = 0;
	while(fgets(line, max-1, fp) != NULL)
	{
		count_line++;
		SEEK();	
	}

	func();
	
	fclose(fp);
	return 0; 
}

void push(int element){
	STACK_0[++top][0] = element;
	STACK_0[top][1] = count_line;
}

int isnote_1(int x){
	
	if(line[x] == '/' && line[x+1] == '/')	return 1;		
	return 0;
} 

int isnote_2(int x){
	if( line[x+1] != '\0');
		if(line[x] == '/' && line[x+1] == '*')	return 1;	
	return 0;
}

int isnote_2_end(int x){
	if( line[x+1] != '\0');
		if(line[x] == '*' && line[x+1] == '/')	return 1;
	return 0;
}
void SEEK()
{
	int x;
	for (x = 0 ; line[x] != '\0' ; x++)
	{
		if( isnote_1(x) )	break;
		if( isnote_2(x) ) 	flag_note = 1;
		if( line[x] == '\"' ) flag_note = 2;
		if( line[x] == '\'' ) flag_note = 3;
		
		if(flag_note == 1)
		{
			int j = 0 ;
			for(j = x ; line[j] != '\0' ; j++){
				if( isnote_2_end(j) ){
					x = j+1 ;
					flag_note = 0;
				}
			}
			if(flag_note == 1)	break;
		}
		
		if(flag_note == 2)
		{
			int j = 0 ;
			for(j = x ; line[j] != '\0' ; j++){
				if( line[j] == '\"' ){
					x = j ;
					flag_note = 0;
				}
			}
			if(flag_note == 2)	break;
		}
		
		if(flag_note == 3)
		{
			int j = 0 ;
			for(j = x ; line[j] != '\0' ; j++){
				if( line[j] == '\'' ){
					x = j ;
					flag_note = 0;
				}
			}
			if(flag_note == 3)	break;
		}
		
		if(flag_note == 0)
		{
			if(line[x] == '(')	push(1);
			else if(line[x] == ')')	push(2);
			else if(line[x] == '{')	push(-1);
			else if(line[x] == '}')	push(-2);
		}
	}
}
void func()
{
	int i , flag_1 = 0;
	char c = '\0';
	for(i = 1 ; i <= top ; i++ )
	{
		if(STACK_0[i][0] == 1)
		{
			STACK[++TOP][0] = STACK_0[i][0];
			STACK[TOP][1] = STACK_0[i][1];
		}
		
		else if(STACK_0[i][0] == -1)
		{
			if(STACK[TOP][0] == 1 )
			{
				printf("without maching \'(\' at line %d\n" ,  STACK[TOP][1]);
				flag_1 = 1;
				break;
			}
			else
			{
				STACK[++TOP][0] = STACK_0[i][0];
				STACK[TOP][1] = STACK_0[i][1];
			}
		}
		
		else if(STACK_0[i][0] == 2)
		{
			if(STACK[TOP][0] == 1 )
			{
				STACK[TOP][0] = 0; 
				STACK[TOP][1] = 0; 
				TOP--;
			}
			else 
			{
				if(STACK_0[i][0] == 1) c = '(';
				else if(STACK_0[i][0] == 2) c = ')';
				else if(STACK_0[i][0] == -1) c = '{';
				else if(STACK_0[i][0] == -2) c = '}';
				
				printf("without maching \'%c\' at line %d\n" ,c ,  STACK_0[i][1]);
				flag_1 = 1;
				break;
			}
		}
		else if(STACK_0[i][0] == -2)
		{
			if(STACK[TOP][0] == -1 )
			{
				STACK[TOP][0] = 0; 
				STACK[TOP][1] = 0; 
				TOP--;
			}
			else 
			{
				if(STACK_0[i][0] == 1) c = '(';
				else if(STACK_0[i][0] == 2) c = ')';
				else if(STACK_0[i][0] == -1) c = '{';
				else if(STACK_0[i][0] == -2) c = '}';
				
				printf("without maching \'%c\' at line %d\n" , c ,  STACK_0[i][1]);
				flag_1 = 1;
				break;
			}
		}
	}
	if(flag_1 == 0)
	{
		if(TOP == 0)
		{
			for(i = 1 ; i<= top ; i++)
			{
				if(STACK_0[i][0] == 1) c = '(';
				else if(STACK_0[i][0] == 2) c = ')';
				else if(STACK_0[i][0] == -1) c = '{';
				else if(STACK_0[i][0] == -2) c = '}';
				
				printf("%c" , c);
			}
		} 
		else for(i = 1 ; i <= TOP ; i++ )
		{
			if(STACK[i][0] == 1 || STACK[i][0] == -1 ) 
			{
				if(STACK[i][0] == 1) c = '(';
				else if(STACK[i][0] == 2) c = ')';
				else if(STACK[i][0] == -1) c = '{';
				else if(STACK[i][0] == -2) c = '}';
				
				printf("without maching \'%c\' at line %d\n" ,c,  STACK[i][1]);
				break;
			}
		}	
	}
}
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)

BUAA_C程序括号匹配检查 的相关文章

  • 一文带你了解 MQTT 协议(连接 ONE-NET平台)

    MQTT 协议连接 ONE NET 详解 写在前面 本文采用 网络调试助手 发送MQTT协议报文 16进制 连接 ONE NET 平台 采用的 为 MQTT v3 1 1 标准协议 带你直接 学会 MQTT 协议 一 ONE NET 端创建
  • Ubuntu20.04安装vscode打开出现花屏

    目录 前言 出现原因 解决方法 探索 最终方案 前言 最近在Ubuntu20 04安装vscode打开后出现了花屏的情况 在网上查找各种方法后终于解决 在这里记录一下 希望对大家有所帮助 出现原因 出现这样的问题是因为vscode开了GPU
  • idea中创建git分支

    1 使用idea打开项目 点击项目右下方的分支按钮 2 选择New Branch 3 输入分支名称后 create即可 4 提交和推送 注意 如果没有修改代码 就不需要提交 只需推送即可创建分支

随机推荐

  • 数据结构--双链表的c/c++实现(超详细注释/实验报告)

    数据结构 双链表的c c 实现 超详细注释 实验报告 知识小回顾 如果希望从表中快速确定某一个结点的前去 其中一个解决方法就是在单链表的每个结点再增加一个指向其前去的指针域prior 这样形成的链表中就有两条方向不同的链 称之为双向链表 D
  • 100天精通Python(数据分析篇)——第57天:Pandas读写Excel(read_excel、to_excel参数说明+代码实战)

    文章目录 1 read excel 读取Excel文件 io sheet name header names index col usecols squeeze skiprows 2 to excel 写入Excel文件 excel wri
  • Unity Android 真机调试 + 夜神模拟器调试 + ADB Logcat

    备注 调试前需要先检测java和SDK的环境变量是否OK 在CMD中输入java和adb检测 官方文档 https docs unity3d com Manual AttachingMonoDevelopDebuggerToAnAndroi
  • Python+unittest+requests+HTMLTestRunner 完整的接口自动化测试框架搭建过程实战

    目录 前言 第一讲 框架结构简解 第二讲 测试接口服务 第三讲 配置文件读取 第四讲 读取Excel中的case 第五讲 发送requests请求 第六讲 参数动态化 第七讲 使用unittest断言 第八讲 HTMLTestRunner源
  • spring事件发布

    最近一个需求 接口监控异常 需要进行一连串逻辑处理 又新加需要给运维人员发短信 异步处理 不能影响源代码逻辑 因此用到事件发布器 在事件驱动中有三个比较重要的组件 Event 发布的事件对象 EventPublisher 事件发布对象 Ev
  • 姓名 抽奖 ppt 模板_PPT中制作姓名滚动抽奖小动画

    想看视频教程的直接拉到文章尾部观看 本次教程教大家如何简单制作姓名滚动抽奖的小动画 效果如下 进入幻灯片播放界面后 在页面任意位置单击鼠标即可开始抽奖 再单击一次鼠标暂停 再单击一次鼠标还可以重新开始 下面来看一下如何制作 制作过程中主要使
  • k8s之Ingress篇七层代理

    Ingress介绍 Ingress官网定义 Ingress可以把进入到集群内部的请求转发到集群中的一些服务上 从而可以把服务映射到集群外部 Ingress 能把集群内Service 配置成外网能够访问的 URL 流量负载均衡 提供基于域名访
  • Unity 连接WebSocket(ws://)服务器

    Unity 连接ws 不用任何插件 忙活了一天终于搞定了 一直连接不上 原来是没有添加header 代码比较简单 直接贴出来普度众生 using System using System Net WebSockets using System
  • 爬虫学习心得

    在python环境中对小说进行爬取 一般需要安装爬虫所需的第三方库 目前我所使用的为BS4和Requests BS4库安装 Beautiful Soup 简称 BS4 其中 4 表示版本号 是一个 Python 第三方库 它可以从 HTML
  • 图解通信原理与案例分析-13:无线对讲机案例--频率调制实现语音点对点无线通信

    前言 在 无线调幅广播案例 中 拆解了通过幅度调制AM实现点对多点广播通信的基本原理 本文 将通过无线对讲机的案例 拆解了通过频率调制FM实现点对多点广播通信的基本原理 本文的重点在 1 频率调制与解调的基本原理 2 频率调制与幅度调制的本
  • nvm常用命令有哪些?nvm如何切换node版本?nvm如何下载node?nvm安装包

    之前公司有很多老项目 需要切换node低版本才能正常使用 但是还有使用node高版本新项目 总不能每次更换项目就卸载重装对应版本的node 所以就使用了nvm来管理node版本 每次使用时 nvm命令就记得很清楚 可是长时间不使用 就会有点
  • Java方法的重载

    方法的重载 函数名相同 形式参数不同 方法重载的规则 1 方法名称必须相同 2 参数列表必须不同 个数 或者 参数类型 或者 排列顺序 3 方法的返回类型可以相同也可以不相同 4 仅仅返回类型不同不足以成为方法的重载 方法名称相同时 编译器
  • C++实践之Qt学习(五):Qt设计器介绍、信号和槽机制

    文章目录 Qt设计器 对象树 信号和槽 信号和槽机制 设计器上添加信号与槽 方式1 方式2 Qt设计器 分为几个区域 控件 部件区 界面编辑区 动作编辑 信号槽编辑区 对象区 对象属性区 部件区又分为几类 Layouts 布局 Spacer
  • 图像综合处理小设计实验—opencv背景分割,硬币检测

    图像综合处理小设计 opencv背景分割 硬币检测 一 机器视觉图像的目标与背景的分割与提取 1 主要要求 对输入图像可以达到目标和背景的分割 建议方法 1 将已知图像进行消噪处理 2 对彩色图像进行目标和背景分析 3 通过阈值法将图像进行
  • 【Vue2.0源码学习】模板编译篇-模板解析(代码生成阶段)

    文章目录 1 前言 2 如何根据AST生成render函数 3 回归源码 3 1 元素节点 3 2 文本节点 3 3 注释节点 4 总结 1 前言 经过前几篇文章 我们把用户所写的模板字符串先经过解析阶段解析生成对应的抽象语法树AST 接着
  • VMware Workstation 17 Pro的下载&&安装&&使用

    目录 一 下载 二 安装 三 检查网络连接 方式一 简便版 方式二 麻烦版 四 使用 创建虚拟机 使用命令 快照的使用 拍摄快照 恢复快照 克隆虚拟机 移除虚拟机 一 下载 下载地址 Windows 虚拟机 Workstation Pro
  • 14-堆排序

    堆 Heap 是一种常见的数据结构 常用于存储数据 其本质上是一棵完全二叉树 下面我们来看看如何用数组实现堆结构及其相关功能 堆的定义 首先来看一下堆的存储结构 堆可以看成是一颗完全二叉树 首先什么是二叉树 借助百度中的解释 二叉树 bin
  • arXiv是个什么东西?

    arXiv只是个提交论文预印本 preprint 的平台 而且里面的论文都没有经过同行评审 peer review 所以文章质量参差不齐 比较有名的计算机检索数据库DBLP数据库可以检索arXiv里的文章 DBLP把arXiv归类为非正式发
  • opencv 学习:reshape函数

    在opencv中 reshape函数比较有意思 它既可以改变矩阵的通道数 又可以对矩阵元素进行序列化 非常有用的一个函数 函数原型 C Mat Mat reshape int cn int rows 0 const 参数比较少 但设置的时候
  • BUAA_C程序括号匹配检查

    问题描述 编写一程序检查C源程序文件中 等括号是否匹配 并输出第一个检测到的不匹配的括号及所对应括号所在的行号 程序中只有一个括号不匹配 注意 1 除了括号可能不匹配外 输入的C源程序无其它语法错误 2 字符常量 字符串常量及注释中括号不应