编程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())；这样就好了。场景代码中只是组装一下而已。