c语言版本a星算法

❶ c语言设计一个递归算法，输出2n行星号。第1行输出1个星号，第2行输出2

#include<stdio.h>
voidfunc(inta,intn)
{
inti;

for(i=0;i<a;i++)
printf("*");
printf("
");
if(a<=n)func(a+1,n);
for(i=0;i<a;i++)
printf("*");
printf("
");

}

intmain()
{
intn;
scanf("%d",&n);
func(1,n);

return0;
}

❷ 急~关于C语言课程设计用星号构成A~Z字母输出~~~！！！

/* 第一题 */

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

#define SCREEN_COLS 80 /* how many columns does terminal have */
#define HORIZONTAL_DISTANCE 4 /* horizontal distance between two characters (列距) */
#define VERTICAL_DISTANCE 1 /* vertical distance between two rows of characters (行距) */
#define BRUSH_CHAR ('*')
#define BLANK_CHAR (' ')

/* ASCII_TAB字模中字体的高度和宽度 */
#define FONT_ROWS 7
#define FONT_COLS 5

/* 屏幕每行最多可以显示的字符个数 */
#define CHAR_PER_LINE (SCREEN_COLS/(FONT_COLS + HORIZONTAL_DISTANCE))
// ASCII_TAB[] contains all ASCII characters from sp (32) to z (122)
static const unsigned char ASCII_TAB[][5]= //5*7
{
{ 0x00, 0x00, 0x00, 0x00, 0x00 }, // sp
{ 0x00, 0x00, 0x2f, 0x00, 0x00 }, // !
{ 0x00, 0x07, 0x00, 0x07, 0x00 }, // "
{ 0x14, 0x7f, 0x14, 0x7f, 0x14 }, // #
{ 0x24, 0x2a, 0x7f, 0x2a, 0x12 }, // $
{ 0xc4, 0xc8, 0x10, 0x26, 0x46 }, // %
{ 0x36, 0x49, 0x55, 0x22, 0x50 }, // &
{ 0x00, 0x05, 0x03, 0x00, 0x00 }, // '
{ 0x00, 0x1c, 0x22, 0x41, 0x00 }, // (
{ 0x00, 0x41, 0x22, 0x1c, 0x00 }, // )
{ 0x14, 0x08, 0x3E, 0x08, 0x14 }, // *
{ 0x08, 0x08, 0x3E, 0x08, 0x08 }, // +
{ 0x00, 0x00, 0x50, 0x30, 0x00 }, // ,
{ 0x10, 0x10, 0x10, 0x10, 0x10 }, // -
{ 0x00, 0x60, 0x60, 0x00, 0x00 }, // .
{ 0x20, 0x10, 0x08, 0x04, 0x02 }, // /

{ 0x3E, 0x51, 0x49, 0x45, 0x3E }, // 0
{ 0x00, 0x42, 0x7F, 0x40, 0x00 }, // 1
{ 0x42, 0x61, 0x51, 0x49, 0x46 }, // 2
{ 0x21, 0x41, 0x45, 0x4B, 0x31 }, // 3
{ 0x18, 0x14, 0x12, 0x7F, 0x10 }, // 4
{ 0x27, 0x45, 0x45, 0x45, 0x39 }, // 5
{ 0x3C, 0x4A, 0x49, 0x49, 0x30 }, // 6
{ 0x01, 0x71, 0x09, 0x05, 0x03 }, // 7
{ 0x36, 0x49, 0x49, 0x49, 0x36 }, // 8
{ 0x06, 0x49, 0x49, 0x29, 0x1E }, // 9

{ 0x00, 0x36, 0x36, 0x00, 0x00 }, // :
{ 0x00, 0x56, 0x36, 0x00, 0x00 }, // ;
{ 0x08, 0x14, 0x22, 0x41, 0x00 }, // <
{ 0x14, 0x14, 0x14, 0x14, 0x14 }, // =
{ 0x00, 0x41, 0x22, 0x14, 0x08 }, // >
{ 0x02, 0x01, 0x51, 0x09, 0x06 }, // ?
{ 0x32, 0x49, 0x59, 0x51, 0x3E }, // @

{ 0x7E, 0x11, 0x11, 0x11, 0x7E }, // A
{ 0x7F, 0x49, 0x49, 0x49, 0x36 }, // B
{ 0x3E, 0x41, 0x41, 0x41, 0x22 }, // C
{ 0x7F, 0x41, 0x41, 0x22, 0x1C }, // D
{ 0x7F, 0x49, 0x49, 0x49, 0x41 }, // E
{ 0x7F, 0x09, 0x09, 0x09, 0x01 }, // F
{ 0x3E, 0x41, 0x49, 0x49, 0x7A }, // G
{ 0x7F, 0x08, 0x08, 0x08, 0x7F }, // H
{ 0x00, 0x41, 0x7F, 0x41, 0x00 }, // I
{ 0x20, 0x40, 0x41, 0x3F, 0x01 }, // J
{ 0x7F, 0x08, 0x14, 0x22, 0x41 }, // K
{ 0x7F, 0x40, 0x40, 0x40, 0x40 }, // L
{ 0x7F, 0x02, 0x0C, 0x02, 0x7F }, // M
{ 0x7F, 0x04, 0x08, 0x10, 0x7F }, // N
{ 0x3E, 0x41, 0x41, 0x41, 0x3E }, // O
{ 0x7F, 0x09, 0x09, 0x09, 0x06 }, // P
{ 0x3E, 0x41, 0x51, 0x21, 0x5E }, // Q
{ 0x7F, 0x09, 0x19, 0x29, 0x46 }, // R
{ 0x46, 0x49, 0x49, 0x49, 0x31 }, // S
{ 0x01, 0x01, 0x7F, 0x01, 0x01 }, // T
{ 0x3F, 0x40, 0x40, 0x40, 0x3F }, // U
{ 0x1F, 0x20, 0x40, 0x20, 0x1F }, // V
{ 0x3F, 0x40, 0x38, 0x40, 0x3F }, // W
{ 0x63, 0x14, 0x08, 0x14, 0x63 }, // X
{ 0x07, 0x08, 0x70, 0x08, 0x07 }, // Y
{ 0x61, 0x51, 0x49, 0x45, 0x43 }, // Z

{ 0x00, 0x7F, 0x41, 0x41, 0x00 }, // [
{ 0x55, 0x2A, 0x55, 0x2A, 0x55 }, // '\'
{ 0x00, 0x41, 0x41, 0x7F, 0x00 }, // ]
{ 0x04, 0x02, 0x01, 0x02, 0x04 }, // ^
{ 0x40, 0x40, 0x40, 0x40, 0x40 }, // _
{ 0x00, 0x01, 0x02, 0x04, 0x00 }, // '

{ 0x20, 0x54, 0x54, 0x54, 0x78 }, // a
{ 0x7F, 0x48, 0x44, 0x44, 0x38 }, // b
{ 0x38, 0x44, 0x44, 0x44, 0x20 }, // c
{ 0x38, 0x44, 0x44, 0x48, 0x7F }, // d
{ 0x38, 0x54, 0x54, 0x54, 0x18 }, // e
{ 0x08, 0x7E, 0x09, 0x01, 0x02 }, // f
{ 0x0C, 0x52, 0x52, 0x52, 0x3E }, // g
{ 0x7F, 0x08, 0x04, 0x04, 0x78 }, // h
{ 0x00, 0x44, 0x7D, 0x40, 0x00 }, // i
{ 0x20, 0x40, 0x44, 0x3D, 0x00 }, // j
{ 0x7F, 0x10, 0x28, 0x44, 0x00 }, // k
{ 0x00, 0x41, 0x7F, 0x40, 0x00 }, // l
{ 0x7C, 0x04, 0x18, 0x04, 0x78 }, // m
{ 0x7C, 0x08, 0x04, 0x04, 0x78 }, // n
{ 0x38, 0x44, 0x44, 0x44, 0x38 }, // o
{ 0x7C, 0x14, 0x14, 0x14, 0x08 }, // p
{ 0x08, 0x14, 0x14, 0x18, 0x7C }, // q
{ 0x7C, 0x08, 0x04, 0x04, 0x08 }, // r
{ 0x48, 0x54, 0x54, 0x54, 0x20 }, // s
{ 0x04, 0x3F, 0x44, 0x40, 0x20 }, // t
{ 0x3C, 0x40, 0x40, 0x20, 0x7C }, // u
{ 0x1C, 0x20, 0x40, 0x20, 0x1C }, // v
{ 0x3C, 0x40, 0x30, 0x40, 0x3C }, // w
{ 0x44, 0x28, 0x10, 0x28, 0x44 }, // x
{ 0x0C, 0x50, 0x50, 0x50, 0x3C }, // y
{ 0x44, 0x64, 0x54, 0x4C, 0x44 } // z
};

static char get_char_xy(char ch, int x, int y)
{
if (ch < ' ' || ch > 'z')
ch = ' ';
ch -= ' ';
return (ASCII_TAB[ch][x] & (1<<y)) ? BRUSH_CHAR : BLANK_CHAR;
}

static void print_row(char ch, int row)
{
int i;
for (i = 0; i < FONT_COLS; i++) {
printf("%c", get_char_xy(ch, i, row));
}
}

int main(int argc, char *argv[])
{
char str[80] = { '\0' };
int i, j, k, len, index = 0;
printf("Please input a string:\n");
scanf("%s", str);
len = strlen(str);
while (index < len) {
for (i = 0; i < FONT_ROWS; i++) {
for (j = 0; j < CHAR_PER_LINE && j + index < len; j++) {
print_row(str[index + j], i);
for (k = 0; k < HORIZONTAL_DISTANCE; k++) {
printf("%c", BLANK_CHAR);
}
}
printf("\n");
}
index += CHAR_PER_LINE;
for (k = 0; k < VERTICAL_DISTANCE; k++) {
printf("\n");
}
}
return 0;
}

/* 第二题 */

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

#define MIN_POINT_NUMBER 3
#define MAX_POINT_NUMBER 100
#define MAX_POINT_COORD 1000.0

typedef struct Point_ {
float x;
float y;
} Point;

typedef struct Circle_ {
Point o; /* centre */
Point p1;
Point p2;
float r; /* radius */
} Circle;

typedef struct {
Point p;
int included;
} Element;

/* return squared distance of points a & b */
#define SQUARE(a) ((a)*(a))
#define SQUARED_DISTANCE(a,b) (SQUARE((a).x-(b).x) + SQUARE((a).y-(b).y))
#define DISTANCE(a,b) (sqrt(SQUARED_DISTANCE((a),(b))))
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#define EQUAL_FLOAT(a,b) (fabs((a)-(b)) < 0.00001)

/* get the circumcircle of a triangle */
static Circle
get_circumcircle(Point a, Point b, Point c)
{
Circle result;
float dx1 = a.x - b.x;
float dx2 = b.x - c.x;
float dy1 = a.y - b.y;
float dy2 = b.y - c.y;
float x1 = (a.x + b.x) / 2.0;
float x2 = (b.x + c.x) / 2.0;
float y1 = (a.y + b.y) / 2.0;
float y2 = (b.y + c.y) / 2.0;

result.o.x = ((dy1*dy2*(y2-y1) + x2*dx2*dy1 - x1*dx1*dy2)) / \
(dx2*dy1 - dx1*dy2);
result.o.y = ((dx1*dx2*(x2-x1) + y2*dy2*dx1 - y1*dy1*dx2)) / \
(dy2*dx1 - dy1*dx2);

result.r = DISTANCE(result.o, a);
result.p1 = a;
result.p2 = c;

return result;
}

/* get the mininal circle that includes three given points
* Note:
* 1) the tree points may be in one line
* or
* 2) the tree points make up a triangle
*/
static Circle
get_min_circle(Point a, Point b, Point c)
{
Circle result;
float ab,bc,ac, max;
ab = DISTANCE(a,b);
bc = DISTANCE(b,c);
ac = DISTANCE(a,c);
max = MAX(ab, MAX(bc,ac));
printf("[%f, %f]\n[%f, %f]\n[%f, %f]\n",a.x,a.y,b.x,b.y,c.x,c.y);
if (EQUAL_FLOAT(max*2, ab+bc+ac)) { /* in the same line */
printf("line\n");
if (EQUAL_FLOAT(max, ab)) {
/* ab is the diameter */
result.o.x = (a.x + b.x) / 2.0;
result.o.y = (a.y + b.y) / 2.0;
result.r = max / 2.0;
result.p1 = a;
result.p2 = b;
} else if (EQUAL_FLOAT(max, bc)) {
/* bc is the diameter */
result.o.x = (b.x + c.x) / 2.0;
result.o.y = (b.y + c.y) / 2.0;
result.r = max / 2.0;
result.p1 = b;
result.p2 = c;
} else {
/* ac is the diameter */
result.o.x = (a.x + c.x) / 2.0;
result.o.y = (a.y + c.y) / 2.0;
result.r = max / 2.0;
result.p1 = a;
result.p2 = c;
}
} else { /* triangle */
/* get the circumcircle of the triangle */
printf("triangle\n");
result = get_circumcircle(a, b, c);
}
printf("The circle's center is [%f, %f], radius is %f\n",
result.o.x, result.o.y, result.r);
return result;
}

int
main(int argc, char *argv[])
{
Circle circle;
Element *elements;
int n = 0, i;

while (n < MIN_POINT_NUMBER || n > MAX_POINT_NUMBER) {
printf("Please input point number (3-100):\n");
scanf("%d", &n);
}
elements = (Element*)malloc(sizeof(Element)*n);
memset(elements, 0, sizeof(Element)*n);
for (i = 0; i < n; i++) {
printf("Please input point (%d in %d):\n", i+1, n);
scanf("%f %f", &elements[i].p.x, &elements[i].p.y);
}

elements[0].included = 1;
elements[1].included = 1;
elements[2].included = 1;
circle = get_min_circle(elements[0].p, elements[1].p, elements[2].p);
for (i = 0; i < n; i++) {
if (elements[i].included)
continue;
if (DISTANCE(elements[i].p, circle.o) - circle.r > 0.00001) {
circle = get_min_circle(circle.p1, circle.p2, elements[i].p);
}
elements[i].included = 1;
}

return 0;
}

❸ C语言中为什么要加星号！

在C语言中使用*号有两种情况。

1 做乘法运算符使用。

在计算机中一般不使用数学的乘号×，而是用更容易打出的*替代。

如果*出现在运算中，且左右都有表达式，那么*就是当做乘号来使用的。

比如

#include<stdio.h>
intmain()
{
printf("%d
",3*4);

return0;
}

这个程序就是简单的计算3*4的输出，会输出12。

2 定义指针时做标识符。

在C语言中有指针的概念，在定义某个类型的指针时，会采用

TYPE *name;的形式。 具体说明在第三部分中一并叙述。

3做取值运算符。

对某个指针变量做*操作，表示取该指针指向地址中的值。

在这种情况下*位于所要取值的指针变量前。如*p。

比如

#include<stdio.h>
intmain()
{
inta=3;
int*p=&a;//&为取地址在这里的*是指针定义标识

printf("a=%d
",a);//输出a的值，为3
printf("*p=%d
",*p);//输出*p的值，这里的*是取值运算符。输出结果同样为3
return0;
}

❹ C语言打星星

#include"stdio.h"
void main()
{
int num,i,j;
printf("please enter a number: ");
scanf("%d",&num);

for(i=1;i<=num;i++)/*控制行*/
{
/*输出列的前面空格*/
for(j=0;j<2*(num-i);j++)
{
printf(" ");
}
/*输出前半段星星*/
for(j=0;j<i;j++)
{
printf("* ");
}
/*输出后半段星星*/
for(j=1;j<i;j++)
{
printf("* ");
}
printf("\n");
}
scanf("%d",&num);
}

❺ c语言中，表达式a+=a％=a％3这个怎么算请给我步骤

+=，%=都为复合运算符。

先算a%3，a%3的意思是a对3取余，得到一个结果。

a%3=a%3的意思是a=a对（a%3）的结果取余，得到一个结果并赋值给a。

a+=a%=a%3的意思是a=a+(a%3=a%3)的结果，就得到了a 的值。

注意：在这个过程中a 值得变化。

(5)c语言版本a星算法扩展阅读：

复合赋值运算符有下列这些：

+= 加法赋值

-= 减法赋值

*= 乘法赋值

/= 除法赋值

%= 模运算赋值

<<= 左移赋值

>>= 右移赋值

&= 位逻辑与赋值

|= 位逻辑或赋值

^= 位逻辑异或赋值

参考资料来源：网络-复合赋值运算符

❻ c语言输出星号是什么意思

#include<stdio.h>
main()
{ int N,a;
scanf("%d",&N);
for(a=0;a<N;a++)
printf("*");
getch();
}
这么写就行了，你前面有很多没用的还有些是程序布恩那个运行的

❼ c语言中带星号的函数叫什么

这个函数在前面加了个*号，代表返回值是指针类型，参数是字符串，返回值是字符的函数指针。调用它的时候就可以用他的指针来调用。在main函数中可以这样做：
char (*pt)(char*);

char a[] ="ashjkl";
pt = strlwr;
var = (*pt)(a)；
C语言是一门通用计算机编程语言，应用广泛。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。

❽ c语言中的星号“*”

这意味着我要定义一个指针，＊未定义时，获取以下地址的内容，输入方法。

1．打开visualc＋＋6．0－File－新建的－File－c＋＋源文件，如下图所示：

❾ 如何用C语言输出星号

C语言输出如题所示图案的代码如下：

#include<stdio.h>

int main( )

{

int x;

int i,j,k;

printf("请输入，需要生成图案的行数（单数）：");

scanf("%d",&x);

k=x/2+1;

for(i=1;i<=k;i++)

{

for(j=0;j<2*i-1;j++)

printf("*");

printf(" ");

}

for(i=k-1;i>=1;i--)

{

for(j=0;j<2*i-1;j++)

printf("*");

printf(" ");

}

}

(9)c语言版本a星算法扩展阅读：

由题，需要输出这样一个图像，可将其看为一个正三角形与倒三角形的组合。

且对于下图：

*
***
*****
*******
*****
***
*

由行数与*号的关系可得，在对于总行数/2+1的部分，行数*2+1，即为*号的数目，因而得到了前半段图形的代码。

而对于后半部分的倒三角形，其行数可记为，倒数总行数/2...3、2、1行，则可利用循环以及2*行数-1，得到下半部分的图像。

❿ 人机交互属于人工智能吗

首先，人工智能并不等于“XX学习”。
人工智能是一个非常古老的名词，在今天看来，是个很抽象的概念。
与“人工智能”这个词距离最近的，是游戏行业。在几年之前，人工智能这个概念并不火，也没听说有别的行业讨论过人工智能。
唯独在游戏行业，人工智能在许多年前，就已经是个烂大街的概念了。我在小学六年级的暑假(1997年)，大舅手把手教我用C语言写出了人生中第一个小游戏(一个控制台飞行棋)。那时候，我就第一次从大舅口中听到了“人工智能”这个词。
以游戏为例，你控制主角的那些操作，就叫做人机交互，比如按W，主角往前跑，按空格，主角就跳起来。而NPC的行为，就是人工智能。
在游戏行业，凡是用来制作NPC寻路，以及战斗相关逻辑的技术，都被称作AI。
比如《英雄联盟》《王者荣耀》等游戏，小兵NPC从出生之后就一路向对方的水晶移动，若途中遇到敌人，就追击敌人，敌人走远，就再次向敌方水晶移动。这就是用游戏行业最常见的WayPoint算法实现的。
再比如战棋类的游戏，简单的就如《中国象棋》、《五子棋》，复杂一点的就如《火焰之纹章》、《三国志》、《超级机器人大战》等。这些棋子或角色在移动之前，通常都会显示出它所能移动的范围。这是使用排序算法实现的，排序算法通常会分成“深度优先算法”和“广度优先算法”两类，但这不是今天要说的主题，故略去不谈。
这些算法，就是游戏行业的人工智能。其中WayPoint(路点算法)，排序算法，另外还有一种A*算法(中文读作A星算法)，是游戏AI算法中最常见的三种。而游戏行业中的AI算法，其实远远不止这些，几十种还是有的。
后来的机器学习、深度学习，其实也只是算法而已。算法是新的，但人工智能这个概念却是早已有之，算法也是多种多样，远非“XX学习”可以代表的。
XX学习也可以用于游戏行业，但对于游戏行业来说，其实并没什么帮助。有了它，做NPC时又多了一些选择。没有它，相关的解决技术也已经足够多了。
最大的不同在于，XX学习把“人工智能”这个名词，扩散到了游戏之外的行业。至少听起来，像个高端大气的新概念似的。。。