Ⅰ c語言編程問題
編程發現的最長的單詞在字元串中的一個已知的，它假定該字元串只包含字母和空格，空格用來分隔不同的話！
方法：
/ / VC + + 6.0編譯器
包括
無效的主要（） BR /> {
字元STR [] =「世界你好我的名字是曹尋醫！」;
的char * p = STR，* P1;
MAX = 0，計數= 0，我
而（* P）
{
計數= 0;
而（* p ==''）P + +;
（* P！='' && * p）
{/ /我們必須注意的判斷* P！ = 0來判斷，或到最後一個字，它已被添加到背面直到滿足空間，所以將超級部門。
P + +;
計數+ +;
}
（MAX <計數）
{
最大計數;
P1 =對數;
}
}
printf的（「人數最多的是：％d條\ n」）;，最大
printf的（「最大的一句話是：」）;
（* P1 ='' && * P1）/ /這里要判斷* P1！ ='\ 0'，因為結尾的字元串中最長的單詞，如果你不判斷* P1！ ='\ 0'，也界。
{
的putchar（* P1）;
P1 + +;
}
的putchar（'\ n'）;
}
BR /> / *
在字元串中尋找最長的單詞。註：A B.如果在一個循環中循環，以確保不僅在環路B，數組但是行業。
而且裡面的數組A，但也是扇區，以確保循環。像上面的例子。現在提供一個更容易理解的例子。
而（* P）
{
而（* P！='' && * p）
{
P + +;
}
}
外循環和內循環的循環條件沒有必然的，但對於一個指針數組（如果變數標
訪問數組下標減法還要注意），加法和減法應該引起人們的注意，必須確保不流溢。
* /
方法：
/ / VC + + 6.0編譯通過。
＃包括
包括中
無效的主要（）
{
字元STR [] =「我我的學生「;
的char * p = str中，數組[10] [20] = {0};
INT I = 0，J = 0，最大值= 0;
而（ * P）
{
而（* p ==''）* p + +;
（* P && * p！=''）
{
>陣列[I] [J + +] = * p;
P + +;
}
i + +; J = 0;
}
= 0;
最大= strlen的（陣列[I]）;
P =陣列[I];
（strlen的（陣列[I]））
{
（最大的strlen（陣列[I]））
{
最大值= strlen的（ARRAY [I]）;
P =陣列[I];
} <BR /我+ +;
}
printf的（「％e\ n％s的\ n」，最大，P）;
}
/ *
>尋求中最長的單詞的字元串（不區分詞與詞之間包含非字母數字字元），法官的二維數組的形式。
定義了一個兩維數組，每個元素都用於存儲一個字元串（每個分離的字）。
然後判斷的時間最長。
比較第一種方法，這種方法更清楚地了解？一些。但缺點是，你要分配一個二維數組來存儲分離
字，佔用存儲空間。
* /
實現任何十進制將R十六進制數2-16（R）
轉換為二進制：
/ / VC + + 6.0編譯通過
＃包括
包括
無效的主要（）
{ />詮釋A，B [30]，我
scanf的（「％d」，＆A）;
（i = 0;了！= 0;我+ +）
{
B?[我] = 2％;
= A / 2;
}
（ - I I> = 0;我 - ）
{
printf的（「％d」，B [I]）;
}
的putchar（'\ n'）;
}
/ /二進制的轉換，也可以使用位移運算符。一定的數量，如1相的二進制
系統的最低位按位「與」，得到的位移，然後得到的二進制最低位，等等。
轉換為八進制：
/ VC + + 6.0編譯器。
＃包括
＃，包括
無效的主要（）
{
整數A，B [20]我
scanf的（「％d」，＆A）;
為（i = 0;了！= 0; i + +）
{
B [我] = 8％;
= A / 8;
}
（ - I I> = 0; I - ）
{
printf的（「％ D「，B [I]）;
}
的putchar（'\ n'）;
}
/ *
8轉換到那裡沒有十六進制這么大的麻煩，它並不需要定義一個用於存儲
所有的基數十六進制的字元數組，但可以直接輸出。同時保存他和十六進制基數。從0到F
* /
轉換為16進制：
/ / VC + + 6.0編譯通過
stdio.h中>
＃，包括
無效的主要（）
{
整數A，B [20]，我基礎= 16;
字元X [16] = {'0'，'1'，'2'，'3'，'4'，'5'，'6'，'7'，'8'，'9'，'A' ，'B'，'C'，'D'，'E'，'F'};
scanf的（「％d」，＆A）;
（i = 0;了！ 0; i + +）
{
B [我] =％的基礎;
= A /基地;
}
（ - ; = 0; I - ）/ /開始 - 我
{
詮釋J = B [我];
printf的（「％c」的，X [J]）; BR />}
printf的（「\ n」）;
}
/ *
一般其他十六進制數轉換為十進制數更容易，准備乘法公式，我們使用。
十進制數轉換為十六進制數，則要使用除法。的想法？這個問題是明確的，應該是
典型的演算法來解決這些問題。
它的十進制數轉換成二進制數，在除了使用部門，但還帶著幾分算術。
主要的問題是值得理解這兩個詞：
B [我] =％的基礎;
= A /基地;
我們一般採用兩種循環使用，得到一個整數的數字，這也恰好說明我們得到了
整數位的方法，它是一個十進制數轉換為十進制數的演算法
，是，我們得到一個小數位數字的過程，實際上是尋找他的過程中，轉換為十進制
數字（雖然本身無需轉換本身的時候，就已經是一個十進制數）。事實可以預計相同
十進制數轉換成十六進制數的過程中，這是類似的。
然後在第一個輸出的結果，取余數的結果，年底的數字，在低位。
* /
解決方案：
＃包括
包括的
>無效的主要（）
{
詮釋一個[10] = {0,1,2,9,10,5,12,7,8,15};
（INT I = 9;我= 0; I - ）
{
（A [I]> = 10）
開關（[I]）
{
10：printf的（「％c」的，'A'）;突破;
案例11：printf的（「C」，「B」）;
情況下，12：printf（「請％C 「，'C'）;休息;
案例13：printf的（」C「，」D「）;
情況下，14：printf的（」％c「的，'E'）;打破;
情況下，15：printf的（「％c」時，'F'）;休息;
}
其他
printf的（「％d」的，一個[i]）;
}
}
/ *
事實上，二進制的轉換演算法，我們知道的是，我們希望將其轉換成16進制數（如果十六進制） />取余數，剩下的結果存儲在一個數組裡面四捨五入重新分配給他的，那就是扔掉的其餘部分，
相當於外商前面的步驟，然後採取余數，再取整。如此循環，直到0為止。
事實上，上述演算法，它提醒我們一個十進制數轉換成二進制數計算，是不難理解的，
是相通的。
現在的關鍵是，如果這些東西都是好的，那就是，其餘的被放置在一個數組中，現在要做的，
陣列反向輸出就OK了。二進制或八進制，只要它的直接輸出，但如果
十六進制，不能的情況下，也就是說，如果一個元素的數組裡面是14的話，我不能作為輸出/>，則必須輸出E，因為E是十六進制內底，但也有相應的十進制數14。
一個二進制或八進制，可以直接輸出，因為陣列的數量是0,1（二進制）
（0 .... 8），這些數字的二進制和八進制基地。
所面臨的問題在這里是輸出一個整數，這個整數滿足一定的條件下，輸出字
突破，例如：如果該整數等於14'E'字元的輸出。
當然，我們可以使用.. else語句，以確定特殊字元的十六進制數，它是唯一的A，B，C，D，E，F 6
以確定是否...否則太麻煩了。當然，我們也可以使用開關來確定這更有組織。代碼
更清晰。
當然，這是一個十六進制數，我們可以判斷，但如果在現實生活中遇到的問題，這一點
條件或交換機上太麻煩了類似的信件，代碼是不直觀，但也容易出錯。
在這個時候，我們可以定義一個字元數組，分別把字元，我們要輸出的對應關系如下：
10 A
11 B BR /> 12?
13e
14 -
15 F
16?
17 H
18我
19 J
>
該數組，把數字，裡面的字元數組b數組，一個裡面的數字是10，當輸入
'A'，而不是輸出10，等等（見上面的對應）課程我上面的對應關系是連續的，其實
的數字和字元的順序可能不亂，當然，這取決於實際遇到的問題是什麼。
以上，如果...否則以確定它是否會過於繁瑣。因此，我們定義了一個字元數組來存儲
字元。因此，如何接觸數字和字元，如何讓一個[i]，價值10時，但14失去
'E'輸出'A'，我們可以定義b數組：
/>字元B [30] = {0};
B [10] ='A';
B [11] ='B';
B [12] ='C'
B [13] ='D';
B [14] ='E';
...
B [19] ='J';
因此，這意味著，當該元素的值一個[i] 10:00輸出[10] 11輸出[11];這和數字對應
。我們可以使用：
詮釋噸= [];
printf的（「％c」時，B [T]），[i]的值，我們輸出B [多少]
對於上面的例子中，它可以是：
如果（一個[i]> = 10 &&一個[i] <= 19）/ /對應關系是連續的，可以判斷
{
詮釋噸= [];
printf的（「％c」時，B [T]）;
}
其他
{
printf的（「％d」，一個[i]）;/ /如果你不屬於特殊字元的定義相應的輸出。
}
當然，上面是相應的連續十進制和二進制，八進制，十六進制的轉換，是連續的。
相應的連續，即如何做到這一點：
20'A'
25'B'
30'D'
50'G' /> 53「H」
58的'C'
100'Z'
200'W'
以上，沒有規律性，和數目，這些去定義一個數組的200個元素，
有點劃不來。因此，如果是上面這種情況下，有沒有更好的辦法。只有在判斷語句，當然，如果有超過20
字元的對應關系來確定語句是不恰當的，那麼有沒有更好的辦法。同時進一步探討......
* /
這是我的測試計算機等級考試主題碰到哦，演算法相當，一些書，一些擴展。還是自己嚴重的哦。 。 。
由於太多的文字提出的第三個問題不上來，哦。 。抱歉。 。 。
Ⅱ 求助一道C語言的題目. (速度).....
/*一副撲克有52張牌，打升級時應將牌分給四個人。請設計一個程序完成自動發牌的工作。
要求：黑桃用S(Spaces)表示；紅桃用H(Hearts)表示；方塊用D(Diamonds)表示；梅花用C(Clubs)表示。
問題分析與演算法設計
按照打升級的規定，每人應當有13張牌。在人工發牌時，先進行洗牌，然後將洗好的牌按一定的順序發給每一個人。
為了便於計算機模擬，可將人工方式的發牌過程加以修改：先確定好發牌順序：1、2、3、4；將52張牌順序編號
：黑桃2對應數字0，紅桃2對應數字1，方塊2對應數字2，梅花2對應數字3，黑桃3對應數字4，紅桃3對應數字5，…
然後從52 張牌中隨機的為每個人抽牌（也可以採取其它的編號方式）。
這里可以採用C語言庫函數的隨機函數，生成0到51之間的共52個隨機數，以產生洗牌後發牌的效果。
運行示例：
S K J 8
H A J 5 3
D Q 8
C K J 7 5
S A T 6 4 2
H 4 2
D 7 6 4
C Q T 9
S 9 7 5 3
H K Q T 9
D J 3 2
C 8 2
S Q
H 8 7 6
D A K T 9 5
C A 6 4 3
思考題（必須完成）：完成2副牌的自動發牌，每人應當有26張牌，而且需將每家所得的牌進行排序。
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
#define CARD_NUM_OF_A_PACK 52
#define NUM_OF_PLAYERS 4
#define NUM_ONEPACK_OF_PLAYER (CARD_NUM_OF_A_PACK/4)
#define SIZE (sizeof(Card_t)*CARD_NUM_OF_A_PACK)
typedef struct tagCard
{
char value;
char color;
}Card_t;
void CardInit(Card_t **pInCard)
{
Card_t *pCard = *pInCard;
Card_t *pTempCard = NULL;
int i;
int j;
memset(pCard,0,SIZE);
pTempCard = pCard;
for(j = 1;j <= 4;j++)
{
for (i = 1;i <= CARD_NUM_OF_A_PACK/4;i++)
{
if (1 == j)
{
pTempCard->color = 'S';
}
else if (2 == j)
{
pTempCard->color = 'H';
}
else if (3 == j)
{
pTempCard->color = 'D';
}
else if (4 == j)
{
pTempCard->color = 'C';
}
if (i <= 10)
{
pTempCard->value = i;
}
else if(i == 11)
{
pTempCard->value = 'J';
}
else if(i == 12)
{
pTempCard->value = 'Q';
}
else if(i == 13)
{
pTempCard->value = 'K';
}
pTempCard++;
}
}
return;
}
void CardFree(Card_t **pCard)
{
if (*pCard)
{
free(*pCard);
*pCard = NULL;
}
}
void Deal(Card_t **pInCard)
{
Card_t players[NUM_OF_PLAYERS][CARD_NUM_OF_A_PACK/NUM_OF_PLAYERS];
int i;
int j;
int k;
int temp;
long cardUsedNum = 0;
int packOfCard = 0;
int playerNo = 0;
int playerCardNo = 0;
Card_t tempCard = {0};
int CartCount = 0;
Card_t *pCard = *pInCard;
int run = 1;
int cCount[NUM_OF_PLAYERS];
int hCount[NUM_OF_PLAYERS];
int dCount[NUM_OF_PLAYERS];
int sCount[NUM_OF_PLAYERS];
char c[NUM_OF_PLAYERS][CARD_NUM_OF_A_PACK/NUM_OF_PLAYERS];
char h[NUM_OF_PLAYERS][CARD_NUM_OF_A_PACK/NUM_OF_PLAYERS];
char d[NUM_OF_PLAYERS][CARD_NUM_OF_A_PACK/NUM_OF_PLAYERS];
char s[NUM_OF_PLAYERS][CARD_NUM_OF_A_PACK/NUM_OF_PLAYERS];
CartCount = CARD_NUM_OF_A_PACK;
memset(players,0,sizeof(players));
memset(c,0,sizeof(c));
memset(h,0,sizeof(h));
memset(d,0,sizeof(d));
memset(s,0,sizeof(s));
if (NULL == pCard)
{
return;
}
srand((int)time(0));
while(run)
{
temp = (int)(CartCount*rand()/(RAND_MAX+1.0));
players[playerNo][playerCardNo].color = pCard[temp].color;
players[playerNo][playerCardNo].value = pCard[temp].value;
pCard[temp].color = pCard[CartCount-1].color;
pCard[temp].value = pCard[CartCount-1].value;
pCard[CartCount-1].color = players[playerNo][playerCardNo].color;
pCard[CartCount-1].value = players[playerNo][playerCardNo].value;
CartCount-=1;
if (CartCount < 0)
{
packOfCard++;
if(packOfCard >= 1)
{
run = 0;
}
CartCount = CARD_NUM_OF_A_PACK;
}
playerCardNo+=1;
if (playerCardNo >= NUM_ONEPACK_OF_PLAYER)
{
playerNo+=1;
playerCardNo = 0;
}
}
for(i = 0;i < NUM_OF_PLAYERS;i++)
{
sCount[i] = 0;
hCount[i] = 0;
dCount[i] = 0;
cCount[i] = 0;
for (j = 0;j < NUM_ONEPACK_OF_PLAYER;j++)
{
if ('S' == players[i][j].color)
{
s[i][sCount[i]] = players[i][j].value;
sCount[i]++;
}
else if ('H' == players[i][j].color)
{
h[i][hCount[i]] = players[i][j].value;
hCount[i]++;
}
else if ('D' == players[i][j].color)
{
d[i][dCount[i]] = players[i][j].value;
dCount[i]++;
}
else if ('C' == players[i][j].color)
{
c[i][cCount[i]] = players[i][j].value;
cCount[i]++;
}
}
}
for (i = 0;i < NUM_OF_PLAYERS;i++)
{
for (j = 0;j < cCount[i] ;j++)
{
for(k = 1;k < cCount[i]-j;k++)
{
if(c[i][j] > c[i][k])
{
temp = c[i][j];
c[i][j] = c[i][k];
c[i][k] = temp;
}
}
}
}
for (i = 0;i < NUM_OF_PLAYERS;i++)
{
for (j = 0;j < hCount[i] ;j++)
{
for(k = 1;k < hCount[i] -j;k++)
{
if(h[i][j] > h[i][k])
{
temp = h[i][j];
h[i][j] = h[i][k];
h[i][k] = temp;
}
}
}
}
for (i = 0;i < NUM_OF_PLAYERS;i++)
{
for (j = 0;j < dCount[i] ;j++)
{
for(k = 1;k < dCount[i] -j;k++)
{
if(d[i][j] > d[i][k])
{
temp = d[i][j];
d[i][j] = d[i][k];
d[i][k] = temp;
}
}
}
}
for (i = 0;i < NUM_OF_PLAYERS;i++)
{
for (j = 0;j < sCount[i] ;j++)
{
for(k = 1;k < sCount[i] - j;k++)
{
if(h[i][j] > h[i][k])
{
temp = s[i][j];
s[i][j] = s[i][k];
s[i][k] = temp;
}
}
}
}
for (i = 0;i < NUM_OF_PLAYERS;i++)
{
printf("Player:%d\n",i+1);
printf("S:");
for (j = 0;j < sCount[i];j++)
{
if (s[i][j] <= 10)
printf("%d ",s[i][j]);
else
printf("%c ",s[i][j]);
}
printf("\nH:");
for (j = 0;j < hCount[i];j++)
{
if (h[i][j] <= 10)
printf("%d ",h[i][j]);
else
printf("%c ",h[i][j]);
}
printf("\nD:");
for (j = 0;j < dCount[i];j++)
{
if (d[i][j] <= 10)
printf("%d ",d[i][j]);
else
printf("%c ",d[i][j]);
}
printf("\nC:");
for (j = 0;j < cCount[i];j++)
{
if (c[i][j] <= 10)
printf("%d ",c[i][j]);
else
printf("%c ",c[i][j]);
}
printf("\n");
}
}
int main()
{
Card_t *pCard = NULL;
pCard = (Card_t *)malloc(SIZE);
if (NULL == pCard)
{
printf("error");
return;
}
CardInit(&pCard);
Deal(&pCard);
free(pCard);
}
Ⅲ C語言程序設計思考題。救急！！！！
如何實驗驗證實參數組元素和形參數組元素共享同一內存？
可以將實參數組元素的內存地址和形參數組元素的內存地址比較，相同則為同以內存
比如： int x ; x = &FC[0];可以得到第一個元素的內存地址。
2. Average函數內查找最大值和最小值時需要更新pmax和pmin的值還是*pmax和*pmin的值？為什麼？這兩種做法有何區別、對main的影響如何
兩者都可以；因為*pmax和*pmin是數值，pmax和pmin只是指針，指向數據的地址。兩者修改都可以達到效果。對main的沒有影響！
Ⅳ c語言。。12題。寫程序。。後面思考題，寫答案
1 編程
1.1 列印出以下圖案
*
* * *
* * * * *
* * * * * * *
* * * * *
* * *
*
#include<stdio.h>
intmain()
{
inti=0,j;
for(;i<3;i++){
j=0;
for(;j<i*2+1;j++)printf("*");
printf(" ");
}
for(;i>=0;i--){
j=0;
for(;j<i*2+1;j++)printf("*");
printf(" ");
}
return0
}
1.2編寫程序實現輸入整數n，輸出如下所示由數字組成的菱形。（圖中n=5）
1
1 2 1
1 2 3 2 1
1 2 3 4 3 2 1
1 2 3 4 5 4 3 2 1
1 2 3 4 3 2 1
1 2 3 2 1
1 2 1
1
#include<stdio.h>
intmain()
{
inti=0,j,n,k;
scanf("%d",&n);//輸入
for(;i<n-1;i++){
j=0;k=1;
for(;j<=n+i;j++){
if(j<n-i)
printf("");
elseif(j<n)
{
printf("%d",k++);
}
else{
printf("%d",k--);
}
}
printf(" ");
}
for(;i>=0;i--){
j=0;k=1;
for(;j<=n+i;j++){
if(j<n-i)
printf("");
elseif(j<n)
{
printf("%d",k++);
}
else{
printf("%d",k--);
}
}
printf(" ");
}
return0;
}
2 思考題
1．以下不是死循環的語句是 。
A）for (y=1,x=9;x>++y ; x=i++) i=x ;
B）for ( ; ; x++=i ) ;
C）while (1) { x++ ; }
D）for (i=10 ; ; i--) sum+=i ;
A,思路：排除法；
2. 下面程序段的運行結果是 。
x=y=0;
while (x<15) y++,x+=++y ;
printf(「%d,%d」,y,x);
A）20,7 B）6,12 C）20,8 D）8,20
D；運行一下就知道了
3. 以下for循環的執行次數是 。
for (x=0,y=0; (y=123) && (x<4) ; x++) ;
A）無限循環 B）循環次數不定 C）4次 D）3次
C；
4．寫出下面程序運行的結果。
main ( )
{ int i,b,k=0 ;
for (i=1; i<=5 ; i++) {
b=i%2;
while (b--==0) k++ ;
}
printf(「%d,%d」,k,b);
}
答：2,0；
5. 寫出下面程序運行的結果。
main ( )
{ int a,b;
for (a=1,b=1 ; a<=100 ; a++) {
if (b>=20) break;
if (b%3==1) { b+=3 ; continue ; }
b-=5;
}
printf(「%d
」,a);
}
答：8
6. 寫出下面程序運行的結果。
main ( )
{ int k=1,n=263 ;
do { k*= n%10 ; n/=10 ; } while (n) ;
printf(「%d
」,k);
}
答：36
Ⅳ c語言程序設計蘇小紅版第七章課後實驗答案
不知道你說的是不是這一次實驗
2.2.7實驗7：二維數組和函數綜合編程練習
成績排名次
某班期末考試科目為數學（MT）、英語（EN）和物理（PH），有最多不超過30人參加考試。考試後要求：
（1）計算每個學生的總分和平均分；
（2）按總分成績由高到低排出成績的名次；
（3）列印出名次表，表格內包括學生編號、各科分數、總分和平均分；
（4）任意輸入一個學號，能夠查找出該學生在班級中的排名及其考試分數。
【思考題】請讀者思考如下問題。
①如果增加一個要求：要求按照學生的學號由小到大對學號、成績等信息進行排序，那麼程序如何修改呢？
②如果要求程序運行後先列印出一個菜單，提示用戶選擇：成績錄入、成績排序、成績查找，在選擇某項功能後執行相應的操作，那麼程序如何修改呢？
答案
#include <stdio.h>
#define STU 30
#define COURSE 3
void Input(long num[],int score[][COURSE],int n);
void GetSumAver(int score[][COURSE],int n,int sum[],float aver[]);
void Sort(long num[],int score[][COURSE],int n,int sum[],float aver[]);
void Print(long num[],int score[][COURSE],int n,int sum[],float aver[]);
int Search(long num[], int n, long x);
main()
{
int n, score[STU][COURSE], sum[STU], pos;
long num[STU], x;
float aver[STU];
printf("Please enter the total number of the students(n<=30):");
scanf("%d", &n); /*輸入參加考試的學生人數*/
printf("Enter No. and score as: MT EN PH ");
Input(num, score, n); /*輸入學生成績*/
GetSumAver(score, n, sum, aver); /*計算總分和平均分*/
printf("Before sort: ");
Print(num, score, n, sum, aver);
Sort(num, score, n, sum, aver); /*排名次*/
printf("After sort: ");
Print(num, score, n, sum, aver);
printf("Please enter searching number:");
scanf("%ld", &x); /*以長整型格式輸入待查找學生的學號*/
pos = Search(num, n, x); /*名次查詢*/
if (pos != -1)
{
printf("position: NO MT EN PH SUM AVER ");
printf("%8d %4ld %4d %4d %4d %5d %5.0f ",
pos+1,num[pos], score[pos][0],score[pos][1],
score[pos][2], sum[pos],aver[pos]);
}
else
{
printf("Not found! ");
}
}
/* 函數功能：輸入某班學生期末考試三門課程成績
函數參數：長整型數組num，存放學生學號
整型數組score，存放學生成績
整型變數n，存放學生人數
函數返回值：無
*/
void Input(long num[], int score[][COURSE], int n)
{
int i, j;
for (i=0; i<n; i++)
{
scanf("%ld", &num[i]);
for (j=0; j<COURSE; j++)
{
scanf("%d", &score[i][j]);
}
}
}
/* 函數功能：計算每個學生的總分和平均分
函數參數： 整型數組score，存放學生成績
整型變數n，存放學生人數
整型數組sum，計算得到的每個學生的總分
實型數組aver，計算得到的每個學生的平均分
函數返回值：無
*/
void GetSumAver(int score[][COURSE], int n, int sum[], float aver[])
{
int i, j;
for (i=0; i<n; i++)
{
sum[i] = 0;
for (j=0; j<COURSE; j++)
{
sum[i] = sum[i] + score[i][j];
}
aver[i] = (float)sum[i] / COURSE;
}
}
/* 函數功能：按總分成績由高到低排出成績的名次
函數參數：長整型數組num，存放學生學號
整型數組score，存放學生成績
整型變數n，存放學生人數
整型數組sum，存放每個學生的總分
實型數組aver，存放每個學生的平均分
函數返回值：無
*/
void Sort(long num[],int score[][COURSE], int n, int sum[], float aver[])
{
int i, j, k, m;
int temp1;
long temp2;
float temp3;
for (i=0; i<n-1; i++)
{
k = i;
for (j=i+1; j<n; j++)
{
if (sum[j] > sum[k]) k = j;
}
if (k != i)
{
temp1 = sum[k]; sum[k] = sum[i]; sum[i] = temp1;
temp2 = num[k]; num[k] = num[i]; num[i] = temp2;
temp3 = aver[k]; aver[k] = aver[i]; aver[i] = temp3;
for (m=0; m<COURSE; m++)
{
temp1 = score[k][m];
score[k][m] = score[i][m];
score[i][m] = temp1;
}
}
}
}
/* 函數功能： 列印名次表，表格內包括學生編號、各科分數、總分和平均分
函數參數： 長整型數組num，存放學生學號
整型數組score，存放學生成績
整型變數n，存放學生人數
整型數組sum，存放每個學生的總分
實型數組aver，存放每個學生的平均分
函數返回值：無
*/
void Print(long num[], int score[][COURSE], int n,
int sum[], float aver[])
{
int i, j;
printf(" NO | MT EN PH SUM AVER ");
printf("---------------------------------------------------- ");
for (i=0; i<n; i++)
{
printf("%ld | ", num[i]);
for (j=0; j<COURSE; j++)
{
printf("%4d ", score[i][j]);
}
printf("%5d %5.0f ", sum[i], aver[i]);
}
}
/* 函數功能：在學號數組中順序查找學生的學號
函數參數：長整型數組num，存放學生學號
整型變數n，存放學生人數
長整型變數x，存放待查找學生的學號
函數返回值：找到時，返回學生學號在學號數組中的下標位置，否則返回值-1
*/
int Search(long num[], int n, long x)
{
int i;
for (i=0; i<n; i++)
{
if (num[i] == x) return(i);
}
return (-1);
}