Cy语言九宫格

最新推荐文章于 2024-07-25 17:45:03 发布
最新推荐文章于 2024-07-25 17:45:03 发布
阅读量185 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45959526/article/details/108166319
版权

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

#define NAMESIZE 20
#define TRUE 1
#define FLASE 0
//#define EqualFun strcmp
//#define SetValue strcpy
#define MAXSIZE 3 //三个元素
#define ZERO 0 //代表空格
typedef int NODE[MAXSIZE][MAXSIZE]; //图中节点为二维数组
typedef int STATUS;
typedef struct NEIGHBORNODE
{
NODE name;
struct NEIGHBORNODE* next;
}*NEIGHBOR, *PATH;

typedef struct ANODE
{
NODE name;
NEIGHBOR adjacents;
}ANYNODE;

typedef struct GRAPHNODE
{
ANYNODE node;
struct GRAPHNODE* next;
}*GRAPH;

typedef struct PATHS
{
PATH path;
struct PATHS* next;
}*PSTACK, * PATHSET;

NEIGHBOR AddNeibor(NEIGHBOR nb, NODE name); //增加一个邻近节点

NEIGHBOR CopyNeibors(NEIGHBOR adjacents); //复制子节点集

NEIGHBOR ExpandNodes(NODE node, int zero); //扩展节点集

PATH AddNodeToPath(NODE name, PATH path); //在路径中加一个节点形成新的路径

PATH CopyPath(PATH path); //复制一条路径

PATHSET CopyPaths(PATHSET paths); //复制路径集合

void RevPath(PATH path); //路径倒序

void ShowPath(PATH path); //输出路径

PATHSET AddPathToPaths(PATH path, PATHSET paths);//把一条路径加入路经集合

PATH ClearPath(PATH path); //回收路径

PATHSET ClearPaths(PATHSET paths); //回收路径集合

PSTACK PushAPath(PSTACK stack, PATH path); //一条路径进栈

PATHSET PushPaths(PSTACK stack, PATHSET paths);//所有路径进栈

PSTACK PopNode(PSTACK stack, NODE name, PATH* path);
//出栈获取节点和路径

PSTACK ClearPstack(PSTACK stack); //回收栈

STATUS SearchPath(NODE start, NODE end, PATH* path, int zero);
//路径搜索

/回路/
STATUS IsInPath(NODE name, PATH path); //判断节点是否在路径中

NEIGHBOR DeleteNodeInPath(NEIGHBOR adjacents, PATH path);
//从节点集合中删除其在路径中的节点

PATHSET PathSetByNodes(NEIGHBOR adjacents, PATH path, PATHSET paths);
//将每个节点加入路径，以便形成路径集合（删除构成回路节点）

/图操作/

/*
int Equal(NODE n1, NODE n2, int* fun())
{
return (int)fun(n1, n2); //相等为0 不等为1
}

void Set(NODE n1, NODE n2, void* fun())
{
fun(n1, n2); //将n2值赋给n1
}
*/
STATUS equal(NODE node1, NODE node2) //比较两个九宫格是否相等
{
int i, j;
STATUS flag = TRUE; //九宫格相等
for ( i = 0; i < MAXSIZE; i++)
{
for ( j = 0; j < MAXSIZE; j++)
{
if (node1[i][j] != node2[i][j]) //其中有一个元素不相等
{
flag = FLASE;
break;
}

	}
	if (!flag)								//九宫格不相等
	{
		break;
	}
}
return flag;

}

void setvalue(NODE node1, NODE node2) //将九宫格复制
{
int i, j;
for ( i = 0; i < MAXSIZE; i++)
{
for ( j = 0; j < MAXSIZE; j++)
{
node1[i][j] = node2[i][j];
}
}
}

void PriNode(NODE node) //打印九宫格
{
int i, j;
for (i = 0; i < MAXSIZE; i++)
{
for (j = 0; j < MAXSIZE; j++)
{
printf("%5d", node[i][j]);
}
puts("");
}
printf("_______________________________\n");
}

STATUS Locate(NODE node, int* row, int* col, int zero)
{ //确定空格位置
int i, j;
STATUS flag = FLASE;
for (i = 0; i < MAXSIZE; i++)
{
for (j = 0; j < MAXSIZE; j++)
{
if (node[i][j] == zero)
{
*row = i;
*col = j;
flag = TRUE;
break;
}
}
if (flag)
{
break;
}
}
return flag;
}

void Exchange(NODE node, int r1, int c1, int r2, int c2)
{ //交换九宫格两个位置
int tp;
tp = node[r1][c1];
node[r1][c1] = node[r2][c2];
node[r2][c2] = tp;
}

NEIGHBOR ExpandNodes(NODE node, int zero)
{
NEIGHBOR adjacents = NULL;
int r, c;
NODE tp;
if (!Locate(node, &r, &c, zero))
{
return adjacents;
}
if (r0 && c0)
{
setvalue(tp, node); //对九宫格赋值
Exchange(tp, r, c, r + 1, c); //交换位置
adjacents = AddNeibor(adjacents, tp); //收集新的节点

	setvalue(tp, node);
	Exchange(tp, r, c, r, c + 1);
	adjacents = AddNeibor(adjacents, tp);
}

else if (r==0 && c==1)
{
	setvalue(tp, node);
	Exchange(tp, r, c, r, c - 1);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r, c + 1);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r + 1, c);
	adjacents = AddNeibor(adjacents, tp);
}

else if (r==0 && c==2)
{
	setvalue(tp, node);
	Exchange(tp, r, c, r, c - 1);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r + 1, c);
	adjacents = AddNeibor(adjacents, tp);
}

else if (r==1 && c==0)
{
	setvalue(tp, node);
	Exchange(tp, r, c, r - 1, c);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r + 1, c);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r, c + 1);
	adjacents = AddNeibor(adjacents, tp);
}

else if (r==1 && c==1)
{/*
	setvalue(tp, node);
	Exchange(tp, r, c, r + 1, c);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r - 1, c);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r, c + 1);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r, c - 1);
	adjacents = AddNeibor(adjacents, tp);
	 */
	setvalue(tp, node);
	Exchange(tp, r, c, r - 1, c);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r + 1, c);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r, c - 1);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r, c + 1);
	adjacents = AddNeibor(adjacents, tp);
	
}

else if (r==1 && c==2)
{
	setvalue(tp, node);
	Exchange(tp, r, c, r - 1, c);
	adjacents = AddNeibor(adjacents, tp);
	

	setvalue(tp, node);
	Exchange(tp, r, c, r + 1, c);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r, c - 1);
	adjacents = AddNeibor(adjacents, tp);
}

else if (r==2 && c==0)
{
	

	setvalue(tp, node);
	Exchange(tp, r, c, r - 1, c);
	adjacents = AddNeibor(adjacents, tp);
	setvalue(tp, node);
	Exchange(tp, r, c, r, c + 1);
	adjacents = AddNeibor(adjacents, tp);
}

else if (r==2 && c==1)
{
	setvalue(tp, node);
	Exchange(tp, r, c, r - 1, c);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r, c - 1);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r, c + 1);
	adjacents = AddNeibor(adjacents, tp);
}

else if (r==2 && c==2)
{
	setvalue(tp, node);
	Exchange(tp, r, c, r - 1, c);
	adjacents = AddNeibor(adjacents, tp);

	setvalue(tp, node);
	Exchange(tp, r, c, r, c - 1);
	adjacents = AddNeibor(adjacents, tp);
}

return adjacents;

}

long LengthOfPath(PATH path) //统计路径长度
{
PATH p = path;

long count = 0;
while (p)
{
	count++;
	p = p->next;
}

return count;

}

NEIGHBOR AddNeibor(NEIGHBOR nb, NODE name)
{
NEIGHBOR b, pb; //临时兄弟节点变量
b = (NEIGHBOR)malloc(sizeof(struct NEIGHBORNODE));

setvalue(b->name, name);
b->next = NULL;
if (nb == NULL)								//nb为空，b为大兄弟
{
	nb = b;
}
else										//nb不为空找到最后一个兄弟
{
	pb = nb;
	while (pb->next)
	{
		pb = pb->next;
	}
	pb->next = b;
}

return nb;

}

NEIGHBOR ClearNeibors(NEIGHBOR nb)
{
NEIGHBOR b = nb; //临时兄弟
while (nb)
{
b = nb;
nb = nb->next;
free(b);
}
return nb;
}

/路径操作/

PATH AddNodeToPath(NODE name, PATH path)
{
PATH p;
p = (PATH)malloc(sizeof(struct NEIGHBORNODE));
//Set(p->name, name, SetValue);
setvalue(p->name, name);

if (path == NULL)							//路径为空，p为第一个节点
{
	p->next = NULL;
}
else
{
	p->next = path;							//倒序插入
}
path = p;
return path;

}

NEIGHBOR CopyNeibors(NEIGHBOR adjacents)
{
NEIGHBOR pnode, rear, head;
head = NULL; //开始无子节点
while (adjacents)
{
//复制节点
pnode = (NEIGHBOR)malloc(sizeof(struct NEIGHBORNODE));
//Set(pnode->name, children->name, SetValue);
setvalue(pnode->name, adjacents->name);
pnode->next = NULL;

	if (head == NULL)								//第一个节点
	{
		head = pnode;
	}
	else									//与rear = pnode关联，建立链接
	{
		rear->next = pnode;
	}
	rear = pnode;							//rear始终为最后一个节点
	adjacents = adjacents->next;				//开始下一个节点
}
return head;

}

PATH CopyPath(PATH path)
{
PATH tp;
tp = (PATH)CopyNeibors((NEIGHBOR)path); //复用复制兄弟节点；
return tp;
}

PATHSET CopyPaths(PATHSET paths)
{
PATHSET pnode, rear = NULL, head = NULL;
while (paths)
{
pnode = (PATHSET)malloc(sizeof(struct PATHS));
pnode->path = CopyPath(paths->path);
pnode->next = NULL;

	if (head == NULL)						//第一条路径
	{
		head = pnode;
	}
	else									//与rear=pnode关联
	{
		rear->next = pnode;					//尾插法
	}
	rear = pnode;
	paths = paths->next;					//下一条路径
}

return head;

}

void RevPath(PATH path)
{
int count = 0, i;
NODE* nodes;
PATH p = path;

while (p)									//统计路径节点个数
{
	p = p->next;
	count++;
}
nodes = (NODE*)malloc(count * sizeof(NODE));//开辟节点数组
for (i = 0, p = path; p; p = p->next, i++)	//读出来
{
	//Set(names[i], p->name, SetValue);
	setvalue(nodes[i], p->name);
}
for (i = count - 1, p = path; p; p = p->next, i--)
{											//存进去
	//Set(p->name, names[i], SetValue);
	setvalue(p->name, nodes[i]);
}

free(nodes);

}

void PriPath(PATH path)
{
PATH p = path;

if (p == NULL)
{
	printf("为空！");
}
else
{
	while (p)
	{
		PriNode(p->name);
		p = p->next;
	}
}

}

PATHSET AddPathToPaths(PATH path, PATHSET paths)
{
PATH ppath;
PATHSET ps = NULL, p;
if (path == NULL)
{
return paths;
}
ppath = CopyPath(path); //复制路径
ps = (PATHSET)malloc(sizeof(struct PATHS));
ps->path = ppath;
ps->next = NULL;

if (paths == NULL)							//路径集合为空
{
	paths = ps;
}
else										//老套路了
{
	p = paths;
	while (p->next)
	{
		p = p->next;
	}
	p->next = ps;
}

return paths;

}

PATHSET PathSetByNodes(NEIGHBOR adjacents, PATH path, PATHSET paths)
{
PATH tp; //临时节点
adjacents = DeleteNodeInPath(adjacents, path);//删除构成回路节点
while (adjacents) //节点不为空
{
tp = CopyPath(path); //复制路径
tp = AddNodeToPath(adjacents->name, tp);//节点入路径

	paths = AddPathToPaths(tp, paths);		//路径入路径集合
	adjacents = adjacents->next;			//下一个节点
}

return paths;

}

PATH ClearPath(PATH path)
{
path = (PATH)ClearNeibors((NEIGHBOR)path); //复用清理兄弟
return path;
}

PATHSET ClearPaths(PATHSET paths)
{
PATHSET ps = paths;
while (paths)
{
ps = paths;
ClearPath(ps->path);
paths = paths->next;
free(ps);
}

return paths;

}

PSTACK PushAPath(PSTACK stack, PATH path)
{
PATH tp;
PSTACK st;
tp = CopyPath(path); //复制路径
st = (PATHSET)malloc(sizeof(struct PATHS));
st->path = tp;
if (stack == NULL) //以下老套路了
{
st->next = NULL;
}
else
{
st->next = stack;
}
stack = st;
return stack;
}

PATHSET PushPaths(PSTACK stack, PATHSET paths)
{
PATHSET p, head;
head = CopyPaths(paths);
p = head;
if § //将新的路径集加到stack前面，两者链接
{
while (p->next)
{
p = p->next;
}
p->next = stack;
stack = head;
}

return stack;

}

PSTACK PopNode(PSTACK stack, NODE node, PATH* path)
{
PSTACK p = stack;
PATH tp;
if §
{
tp = p->path;
//Set(name, tp->name, SetValue);
setvalue(node, tp->name); //获取名称
*path = CopyPath(tp); //获取路径，已经改变了
stack = p->next;
free§;
}
return stack;
}

PSTACK ClearPstack(PSTACK stack)
{
stack = ClearPaths((PATHSET)stack); //复用清除路径集合
return stack;
}

STATUS IsInPath(NODE node, PATH path)
{
PATH p = path;
STATUS flag = FLASE;

while (p)
{
	if (equal(node, p->name) == 1)
	{
		//Equal(name, p->name, EqualFun)
		flag = TRUE;
		break;
	}
	else
	{
		p = p->next;
	}
}
return flag;

}

NEIGHBOR DeleteNodeInPath(NEIGHBOR adjacents, PATH path)
{
NEIGHBOR n1 = adjacents, n2;
STATUS flag = FLASE;
while (n1) //节点集合每个节点
{
flag = IsInPath(n1->name, path); //节点是否在路径中
if (flag) //节点在路径中
{
if (n1 == adjacents) //n1在在节点集合的第一个
{
adjacents = n1->next; //下一个节点
free(n1); //删除当前节点
n1 = adjacents; //其他节点
}
else //n1不在节点集合第一个
{
n2->next = n1->next; //删除链表节点操作
free(n1);
n1 = n2->next;
}
}
else //节点不在路径中
{
n2 = n1; //下一个节点
n1 = n1->next;
}
}

return adjacents;

}

STATUS SearchPath(NODE start, NODE end, PATH* path, int zero)
{
NODE node; //各种变量的建立
NEIGHBOR adjacents;
PSTACK stack = NULL;
STATUS flag = FLASE;
PATH tp = NULL;
PATHSET paths = NULL;

tp = AddNodeToPath(start, tp);
stack = PushAPath(stack, tp); 
while (stack)
{
	tp = ClearPath(tp);
	stack = PopNode(stack, node, &tp);
	if (equal(end, node) == 1)
	{//Equal(target, name, EqualFun);
		flag = TRUE;
		*path = CopyPath(tp);				//获取路径，方便打印
		break;
	}
	adjacents = ExpandNodes(node,zero);
	paths = PathSetByNodes(adjacents, tp, paths);

	stack = PushPaths(stack, paths);
	paths = ClearPaths(paths);
}

ClearPstack(stack);
return flag;

}

int main()
{
PSTACK stack = NULL;
PATH path = NULL;
STATUS flag;
NODE start =
{
{1, 2, 3},
{8, 4, 0},
{7, 6, 5}
};
NODE end =
{
{1, 2, 3},
{8, 0, 4},
{7, 6, 5}
};
printf(“何以为根：\n”);
PriNode(start);
printf(“何以为结：\n”);
PriNode(end);

flag = SearchPath(start, end, &path, ZERO);

printf("PATH：\n");
RevPath(path);
PriPath(path);

if (flag)
{
	printf("\n路径长度： %ld, %d：成功找到", LengthOfPath(path), flag);
}

return 0;

}

weixin_45959526
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
cy语言五子棋
04-29
cy语言五子棋
C语言基础
m0_59576813的博客
11-25 833
元素类型 数组名[元素个数] = {[下标] = 元素值1,[下标] = 元素值2};元素类型 数组名[] = {[下标] = 元素值1,[下标] = 元素值2};形參变量，属于定义的函数，在实参传递时只能接收值不能接。元素类型 数组名[元素个数] = {元素值1,元素值2,.......};元素类型 数组名[元素个数] = {元素值1,元素值2,.......};返回值类型 函数名(参数类型 变量1,参数类型 变量2,参数类型 变量。在程序的空间中，申请⼀个数据类型的空间作为存储对应类型的数据，由于。
C语言基础学习 - 操作符详解
ChengYuanCY的博客
11-23 349
C语言基础学习 - 操作符详解
单片机c语言cy,单片机c语言基础教程
weixin_33668386的博客
05-22 1128
例 1-1： 让接正在 P1.0 引脚上的LED 照射。图1-1 接有LED 的单片机根本通路P1.0EA/VPPVCCXTAL2XTAL1GNDRST+5V +5V+R1E110K10U27P CY27PPZ1 1KD8D189#include reg51.hsbit P1_0=P1^0;void main(){ P1_1=0;}某个顺序的作用是让接正在P1.0 引脚上的LED 点亮。上面来综合...
EL表达式 c:if 语言打死都不执行
zjutke的专栏
09-21 659
style="display:none"
CY7C68013000
12-14
【CY7C68013】是一款由Cypress Semiconductor公司生产的USB微控制器，常用于USB设备的开发和设计。该控制器集成了USB接口、通用输入输出（GPIO）、通用同步异步接收发送器（UART）等多种功能，适用于各种USB相关的...
完数功能Cy语言实现
09-16
After several functions to achieve, a number exactly equal except if factors outside of its own and, this number is called "complete count", also called "perfect number." For example, 6 = 1 + 2 + 3 ...
CY25562SXC的技术参数
12-11
**CY25562SXC技术参数详解** CY25562SXC是一款高性能、高精度的时钟发生器，广泛应用于各种数字电路系统中，如通信设备、计算机、消费类电子产品等。该器件的主要特点在于其灵活的输入频率范围和精确的输出频率控制...
CY22395FXC的技术参数
12-11
**CY22395FXC技术参数详解** CY22395FXC是一款高性能的时钟发生器，主要用于需要精确频率控制的数字电路设计中。以下将详细解析其主要技术参数： 1. **输出端口**：该器件提供4个LVCMOS输出和1个CMOS输出。LVCMOS...
【转】C语言中 -＞ 是什么意思？
热门推荐
littesss的博客
05-04 21万+
-&gt;是一个整体，它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“-&gt;”. 举个例子： struct Data { int a,b,c; }; /*定义结构体*/ struct Data * p;/*定义结构......
关系运算符、逻辑运算符、if语句
cybcc的博客
01-29 520
关系运算符 小于（<）、大于（>）、小于等于（<=）和大于等于（>=）这几个关系操作符用于对两个值进行比较，规则和数学里面一样。都返回一个布尔值。所有涉及到NaN的比较均返回false。 等于运算符：数值相同即可，哪怕数据类型不同，也会返回true。 全等于运算符： 会去比较数值 和 数据类型。如果有一个不相同，那么就会返回false。 取反运算 !： 只是把true...
cy语言 snprintf使用及注意事项
theresnotomorrow的博客
11-23 363
int snprintf ( char * str, size_t size, const char * format, … ); 参数解析： str 目标字符串 size 拷贝字节数(Bytes) format 格式化成字符串 … 可变参数 需要注意的是参数size是拷贝的“字符串”大小，就是说这个长度是包含了’\0’的， 所以如果size 是6，实际拷贝的字符数是5 再加上’\0’ 例子 #include <stdio.h> int main(int argc
【数据结构】单链表的增删改查
最新发布
2302_78914800的博客
07-25 749
链表是有序的列表，但是它在内存中是如下存储的：①链表以节点的方式进行存储，是链式存储的②每个节点包含 data 域、next 域：指向下一节点③链表的各个节点不一定是连续存放的④链表分为有头节点的链表和没有头节点的链表head节点1.不存放具体数据2.作用就是表示单链表头。
c语言（7.23）
fhgfyrsg的博客
07-23 623
【代码】c语言（7.23）
数据结构：（1）线性表
weixin_71751116的博客
07-24 1053
概念：零个或多个数据元素的有限序列元素之间是有顺序了。如果存在多个元素，第一个元素无前驱最后一个没有后继其他的元素只有一个前驱和一个后继。当线性表元素的个数n（n>=0）定义为线性表的长度，当n=0时，为空表。在非空的表中每个元素都有一个确定的位置，如果a1是第一个元素，那么an就是第n个元素。线性表的常规操作 ADTchar sex;int age;int score;}DATATYPE;//数组名int tlen;
EXT4 数据结构
弥川的博客
07-25 338
结构 ext4_inode 实际使用的超出最初 128 字节 ext2 inode 的字节数记录在每个 inode 的 i_extra_isize 字段中，这使得结构 ext4_inode 可以在新内核中增长，而无需升级所有磁盘上的 inode。ext4 开始，flex_bg 中几个块组被捆绑在一起作为一个 逻辑块组，bitmap 空间和 inode Table 空间 flex_bg 的第一个块组被扩展为包括位图以及 flex_bg 中所有其他块组的 inode 表。没有 inode 0。
数据结构：数据类型与抽象数据类型
Weiki的博客
07-25 1189
数据结构：数据类型与抽象数据类型
数据结构【没头单链表】
qq_67578580的博客
07-22 1436
图中指针变量plist保存的是第⼀个结点的地址，我们称plist此时“指向”第⼀个结点，如果我们希望 plist“指向”第⼆个结点时，只需要修改plist保存的内容为0x0012FFA0。链表中每个结点都是独⽴申请的（即需要插⼊数据时才去申请⼀块结点的空间），我们需要通过指针 变量来保存下⼀个结点位置才能从当前结点找到下⼀个结点。当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数 据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。
【初阶数据结构】复杂度算法题篇
2301_79849925的博客
07-24 349
我们可以先将所有元素翻转，这样尾部的 kmodn 个元素就被移至数组头部，然后我们再翻转 [0,kmodn−1] 区间的元素和 [kmodn,n−1] 区间的元素即能得到最后的答案。该方法基于如下的事实：当我们将数组的元素向右移动 k 次后，尾部 kmodn 个元素会移动至数组头部，其余元素向后移动 kmodn 个位置。时间复杂度：O(n)空间复杂度：O(1)
cy语言怎么输入字符串
05-31
Cy语言没有内置的字符串类型，但可以通过使用字符数组来表示字符串。字符数组是一种固定长度的数组，用于存储一串字符。在Cy语言中，可以使用如下方式定义并初始化一个字符数组： ```cy var str: array[10] of char...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值