編程RSLT
#include "stdio.h"
struct stack
{
int length;
struct data *top;
};
struct data
{
char c;
struct data *next;
};
struct stack *InitStack()
{
struct stack *p;
p=(struct stack *)malloc(sizeof(struct stack));
p->早旁簡length=0;
p->top=NULL;
return p;
}
Push(struct stack *p,char a)
{
struct data *t;
t=(struct data *)malloc(sizeof(struct data));
t->next=p->top;
p->top=t;
t->c=a;
p->length++;
return 0;
}
Pop(struct stack *p,char *a)
{
struct data *t;
t=p->top;
p->top=t->啟山next;
*a=t->c;
free(t);
p->length--;
return 0;
}
char change(int n)
{
if(n>9)return 'A'+n-10;
return n+'0';
}
main()
{
int n;
char c;
struct stack *p;
p=InitStack();
scanf("%d",&n);
while(n>0)
{
c=change(n%16);
n/=16;
Push(p,c);
}
while(p->length!=0)
{
Pop(p,&c);
printf("%c",c);
}
return 0;
}
這個應該可以的，首位不為0，所以當輸入0的時候不輸出，如果要改的話只需要判斷一下就可以了
小數部分沒做，只有整數部分，小數部分就是把除-取余的過程改成乘-取整陸褲即可
自己寫的
希望給分
『貳』 c語言編程
#include<stdio.h>
#include<野脊math.h> // for sqrt()
int main() {
int i;
double rslt = 0.0;
for(i = 1; i <殲脊察 200; ++i) {
if(i % 3 == 2) rslt += i;
}
printf("%.6lf "氏茄, sqrt(rslt));
return 0;
}
『叄』 C#怎麼用委託求一組整數的質數
其實委託從編程上來說就是一個方法而已，只不是是執行主體發生變化，類似於C/C++中的友元方式。舉個例子，如果對於橋族派winform開發過程中，子線程無法更改創建線程，換句話來在子線程中直接修改界面（主線程，也叫創建線程）中的某個控制項的值時會發生錯誤（2005以後不允許子線程修改創建線程），這時我們必須使用委託的方式，換句白話理解，你想修改我的某個屬性——不允許，委託就相當於，你修改我的屬於就想當於我自己修改自己的屬性——這樣OK！所以委託與現實中就是一種類似證明或合同的東西。這時要使用的是「證明」就是關鍵詞delegate！這也是委託真正的含義與用法。
當然，還有一種特殊情況就是事件，說白了事件其實就是一種特殊的委託！
然後我們來說一下使用，委託的簽名與被委託的成員方法簽名必須相同，且作用域必須相同！比如 public List<int> GetPrime(int num)，委託的方式必須是 public delegate List<int> PrimeHandler(int num)；這里要注意的是其作用域public需要相同，你不能委託一個低作用域的，返回類型與輸入參數表必須相同（方法名與委託名不用相同）。
這里邊我還沒有介紹到另一個問題，其實委託是一個執行主體的變化問題，所以經常見到委託的成員方法與執行委託的方法並不在一個類中。否則同一個類執行委託的意義不大了——更多的只是學習內容了。
從某些角度上來說，委託執行的片段或說功能是完全相同的，只是執行主體的變換，所以委託看起來更象是函數指針，其實其真實的實現原理是一種編譯時傳址引用，所以我們有說委託其是一個指針——這個說法更偏重於委託的執行片段。如果說委託更象是友元的話，偏生於執行主體的變換，更易說明委託的實際應用場景。
但不管怎麼說，我們可以來試一下如何寫委託：
//求n以內的所有素數，我給一個簡單、性能較高的方法吧
publicList<int>GetPrime(intnum){
List<int>rslt=newList<int>();
//小於2時返回空集合
if(num<2)
returnrslt;
//小於3，其實其中只有2
rslt.Add(2);
if(num<3)
returnrslt;
rslt.Add(3)
if(num<5)
穗輪returnrslt;
//正式進入計算
//小於5的情況都枚舉完了，所以從5開始就可以了
for(inti=5;i<=num;i+=2)
{
inttmp0=(int)Math.Sqrt(i);
foreach(inttmp1inrslt)
if(i%tmp1==0)
break;//如果等於0，則不是素數，跟出循環即可
if(tmp0<i){
rslt.Add(i);//添加新的素數
break;
}
//說一下原理，一個數如果能被其中開方內的所以素數除盡，則其不再是素數，否則一定是素數。
//使用的是雙重循環，正常不少人會從2循環到其開方值之間的每一個數，其實沒有必段，如果他能被2整除，沒有必段再測試4/6/8等2的倍數，如果不好理解的話，我們返回過來說一下，如果一個數能被14整除，則一定能被2/7整除。所以我只測試能否除盡質數就行了。再換一種說法吧，比如121是否為素數，同樣都是測試是11來判定其不是素數，但這種方法只測試了2/3/5/7/11這5個素數的值，若使用2循環到11則執行了10次！除著num的增大，這兩者之前的差別越來越大，比如num為10000時，一種執行了近100次，而另一種只執行了100以前的素數次（25次），越大的數值這種演算法越佔便宜（因素越向後素數越少）。使用篩選法時，越大的數值會導致越多內存佔用。這種演算法是針對較大數值的一種演算法。
}
returnrslt;
}
//建立委託
publicdelegateList<int>PrimeHandler(intnum);
//場景代碼，使用委託
publicvoidClient(){
PrimeHandlerhandler=GetPrime;//知道為什麼要求簽名相同了吧，不同的簽名此處語句是通不過的！
List<敏賀int>rslt=hander(10000000);
foreach(intrsltinrslt)
Consolse.WriteLine(rslt);
}
//可以看出在場景代碼中的調用，就是把委託用的跟正常的事件一樣！所以看起來就象指針一樣，更重要的是指針是可以做參數傳遞的，而方法不行！所以委託的另一個特性就是可以當作參數傳遞（相當於傳遞了一個方法）。
//也正是因為如此，所以在.net內部定義多個泛型的委託原型，那就是Func系列，Func<T,TResult>，Func<T1,T2,TResult>等等，他對應的方法是TResultMethod(Tvar)等相關的，對於無返回的可以使用Active系列的，對應的是void返回的方法。也就是說，我們不必再寫(Tvar);之類的委託了！在泛型基礎上允許我們直接使用這些委託的。且其具體實現也不用再考慮了！
//最後介紹一點委託到底是個什麼東西？說他是委託，其實他更是一個特殊的「類」！所以publicdelegate的定義是可以直接放在usingnamespace結構下的！它與類/結構等是一個級別的東西，當然類中也可以定義類，所以delegate也常見於類內定義。但它其實是和類是同一級別的東西，不要以為它和類成員是一個級別，它不屬於類的（就算你在類中定義，也只是一種特殊化的定義方式，並不表示它屬於這個類，只是類初始化後才能找到其定義而已）。
『肆』 用VB編程求S=1！+2！+3！+……+99！的值
對yhbo的答案作了改進
用sPlus$（num1,num2）代蔽睜替+
用sMultiply$（num1,num2）薯畝代替*
這樣能顯示所有的數字
Function jch$(n As Integer)
'定義一個計算階乘的函數
Dim a As Integer
jch = 1
For a = 1 To n
jch = sMultiply(jch, CStr(a))
Next a
End Function
Private Sub Command1_Click()
Dim s$
Dim b As Integer
s = 0
For b = 1 To 99
s = sPlus(s, jch(b))
Next b
MsgBox s
End Sub
函數部分
Function sMultiply$(ByVal num1$,ByVal num2$)
Dim i1%, i2%, t%, rslt%, a%, b%, n1%, n2%, temRslt$
a = Len(num1)
b = Len(num2)
t = 0
rslt = 0
temRslt = ""
For i1 = 0 To a - 1
n1 = Val(Mid(num1, a - i1, 1))
For i2 = 0 To b - 1
n2 = Val(Mid(num2, b - i2, 1))
rslt = n1 * n2 + t
t = Fix(rslt / 10)
rslt = rslt Mod 10
temRslt = CStr(rslt) + temRslt
Next i2
If t <> 0 Then
temRslt = CStr(t) + temRslt
End If
sMultiply = sPlus(sMultiply, temRslt + String(i1, "0"))
temRslt = ""
t = 0
Next i1
End Function
Function sPlus$(ByVal num1$,ByVal num2$)
If num1 = "" Then num1 = "0"
Dim i%, t As Boolean, rslt%, a%, b%, c%, num3$
a = Len(num1)
b = Len(num2)
t = False
rslt = 0
If a < b Then
c = b: b = a: a = c
num3 = num2: num2 = num1: num1 = num3
End If
For i = 0 To b - 1
rslt = Val(Mid(num1, a - i, 1)) + Val(Mid(num2, b - i, 1))
If t Then
rslt = rslt + 1
t = False
End If
If rslt > 10 Or rslt = 10 Then
t = True
rslt = rslt - 10
End If
sPlus = CStr(rslt) + sPlus
Next i
If t Then
sPlus = CStr(Val(Left(num1, a - b)) + 1) + sPlus
Else
sPlus = Left(num1, a - b) + sPlus
End If
End Function
這樣能數並森算出所有的數字，但會耗費大量CPU
我的電腦算了30秒才算出來
最後結果6528920420940313
修改了一下 兩個函數改成傳值
『伍』 c#問題，謝謝
定義課程圓薯Course
publicclassCourse
{
///<summary>
///課程名稱
///</summary>
publicstringName{get;set;}
橘槐者///<summary>
///課程學分
///</summary>
publicintScore{get;set;}
}
定義學生類：
publicclassStudent
{
#region欄位
///<summary>
///存儲學生課程得分
///</summary>
privateDictionary<Course,int>_Scores=newDictionary<Course,int>();
#endregion欄位
#region屬性
///<summary>
///學號
///</summary>
publicstringId{get;set;}
///<summary>
///姓名
///</summary>
publicstringName{get;set;}
#endregion屬性
#region成員方法
///<summary>
///添加學生課程成績
///</summary>
///<paramname="course">課程信息</param>
///<paramname="score">學生成績</param>
publicvoidAddCourseScore(Coursecourse,intscore)
{
if(course==null)return;
if(_Scores.ContainsKey(course))
_Scores[course]=score;
else
_Scores.Add(course,score);
}
///<summary>
///獲得學生平均分
///</summary>
///<paramname="gpa">計算方式</param>
///<returns>平均分</returns>
publicdoubleGetGPAScore(GPAgpa)
{
gpa.AddScores(_Scores);
returngpa.GetScore();
}
publicvoidDisplay()
{
Console.WriteLine($"學號：{Id},姓名：{Name}");
Console.WriteLine("課程名學分成績");
foreach(varitemin_Scores)
Console.WriteLine($"{item.Key.Name}{item.Key.Score}{item.Value}");
}
#endregion成員方法
}
獲得平均分的地方直接使用了策略演算法，策略演算法的好處就是以後方便你使用其他計算平均分的方式，比如計算每科的平均分等，我會在代碼中給出，以方便你能看到策略演算法的好處，所以明局此會我會定義策略演算法的家族：
publicabstractclassGPA
{
#region屬性
///<summary>
///存儲課程列表
///</summary>
protectedDictionary<Course,int>_Scores=newDictionary<Course,int>();
#endregion屬性
#region成員方法
///<summary>
///獲得平均分
///</summary>
///<returns>平均分數</returns>
///<remark>
///定義演算法家族，由子類實現
///</remark>
publicabstractdoubleGetScore();
///<summary>
///添加演算法必要的參數
///</summary>
///<paramname="scores"></param>
publicvoidAddScores(Dictionary<Course,int>scores){
_Scores=scores;
}
#endregion成員方法
}
當然，以後每種演算法均可以繼承這個抽象類即可：如以下三個演算法的定義：
///<summary>
///計算常見GPA平均分
///</summary>
publicclassGenericGPA
:GPA
{
///<summary>
///計算一般GPA平均分
///</summary>
///<returns>平均分</returns>
publicoverridedoubleGetScore()
{
if(_Scores.Count==0)return0;
doublesum=0,total=0;
foreach(KeyValuePair<Course,int>itemin_Scores){
sum+=item.Key.Score;
total+=item.Key.Score*GetPoint(item.Value);
}
if(sum==0)return0;
returntotal/sum;
}
///<summary>
///計算分值
///</summary>
///<paramname="score">分數</param>
///<returns>級分</returns>
privatedoubleGetPoint(intscore)
{
intrslt=score/10;
rslt-=5;
rslt=Math.Max(0,Math.Min(4,rslt));
returnrslt;
}
}
///<summary>
///計算標准GPA
///</summary>
publicclassStandardGGPA
:GPA
{
///<summary>
///計算平均分
///</summary>
///<returns></returns>
publicoverridedoubleGetScore()
{
if(_Scores.Count==0)return0;
doublesum=0,total=0;
foreach(KeyValuePair<Course,int>itemin_Scores){
sum+=item.Key.Score;
total+=item.Key.Score*item.Value;
}
if(sum==0)return0;
returntotal*4/(sum*100.0);
}
}
/*策略模式的好處就是，如果哪一天你想添加一種新的演算法
這是十分容易，你可以在任何地方繼承GPA，並實現其方法
即可，比如我們不按GPA計算的平均分*/
publicclassAVG
:GPA
{
publicoverridedoubleGetScore()
{
if(_Scores.Count==0)return0;
intsum=_Scores.Sum(_Item=>_Item.Value);
returnsum*1.0/_Scores.Count;
}
}
調用方式（場景代碼）：
classProgram
{
staticvoidMain(string[]args)
{
///<summary>
///初始化學生
///</summary>
Studentstudent=newStudent{Id="1",Name="王華"};
///初始化課程並添加課程分數
Coursecourse=newCourse{Name="課程2",Score=4};
student.AddCourseScore(course,92);//學生在該課程上得到了92分
///逐次添加各科成績
course=newCourse{Name="課程2",Score=3};
student.AddCourseScore(course,80);
//其實我也很懶的，以下變化一下寫法
student.AddCourseScore(newCourse{Name="課程3",Score=2},98);
student.AddCourseScore(newCourse{Name="課程4",Score=6},70);
student.AddCourseScore(newCourse{Name="課程5",Score=3},89);
//顯示學生成績
student.Display();
//計算GPA平均分演算法
GPAgpa=newGenericGPA();
doublegenericScore=student.GetGPAScore(gpa);
gpa=newStandardGGPA();
doublestandardScore=student.GetGPAScore(gpa);
gpa=newAVG();
doubleavgScore=student.GetGPAScore(gpa);
//以上語句你應該看出來這種策略演算法的好處了吧？
//當然有時我們會使用策略+反射的方式進行直接處理
//這樣只需要把策略配置到配置文件中即可。
Console.WriteLine($"常規演算法GPA={genericScore.ToString(".00")},標准演算法GPA={standardScore.ToString(".00")};");
Console.Read();
}
}
嗯，基本上編程就是這樣的，如果你慢慢接觸模式之後，你的代碼將來會修改盡可能的少。比如AVG演算法類就是直接寫一個新類，然後在場景代碼中直接調用即可，目的就是實現OCP(開閉原則），這種寫法會讓你感到代碼是不做更改的。
比如我們想調用AVG的演算法時，double avg = student.GetGPAScore(new AVG())；這樣就好了。場景代碼中只是組裝一下而已。