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學習把「人工智慧」這個名詞，擴散到了游戲之外的行業。至少聽起來，像個高端大氣的新概念似的。。。