编写一简单程序，计算S=A+B+C

这样的程序，几乎太多的东雹慎宴西源银要以实现了！!!!

以c 为孝禅例：

#include <stdio.h>

main()

{

int S,A,B,C

printf("输入A,B,C的值:\n")

scanf("%d%d%d",&A,&B,&C)

S=A+B+C

printf("S=%d",S)

}

当非零整数 a 除另一个整数 b，余数为 0 时，a 称为 b 的因子。 例如，2 是所有 偶数整数的因子。 我们可以编写下面的函数来确定非零整数 a 是否是另一个整数 b 的因子：

>>>def is_factor(a, b): if b % a == 0: return True else: return False

我们使用%运算符来计算余数。 如果你发现自己在问“4 是不 是 1024 的因子”这类问题，可以使用 is_factor()函数得到答案：

>>>is_factor(4, 1024) True

对于任何正整数 n，如何找到其所有的正因子？ 对于 1 和 n 之间的每个整数， 我们检查 n 除以该整数后的余数。 如果余数为 0，那么这个整数就是一个缺升因子。 使 用 range()函数来编写一个程序，它将遍历 1 到 n 之间的每个数字。 在编写完整的程序之前，先来看看 range()如何工作。 range()函数的典型用法如下所示：

>>>for i in range(1, 4): print(i) 1 2 3

在这里，我们设置了一个 for 循环，并给 range()函数传入了两个参数。 range() 函数从第一个整数参数(起始值)开始，一直到第二个整数参数(停止值)截止。 在这个例子中，我们告诉 Python 输出该范围内的数字，从 1 开始，到 4 停止。 注意， 这意味着 Python 不会输出 4，所以后输出的数字是停止值之前的数字 3。 同时也 要注意，range()函数只接收整数作为参数。 你也可以不指定 range()函数的起始值，在这种情况下，起始值被假定为 0。 例如：

>>>for i in range(5): print(i) 0 123 4

由 range()函数产生的两个连续整数之间的差称为步长值(step value)。 默认情 况下，步长值为 1。 要定义其他的步长值，请将其指定为第三个参数(这时，需指 定起始值)。 例如，下面的程序将输出 10 以下的奇数：

>>>for i in range(1,10,2): print(i) 1 3 5 7 9

我们已经了解了 range()函数是如何工作的，接下来考虑一个因子计算程序。 因 为我们将要编写一个相当长的程序，所以在 IDLE 编辑器里编写，而不是在交互式 的 IDLE 界面中。 你可以在 IDLE 中选择 File->New Window(或者 New File)来启 动弊猜编辑器。 请注意，我们首先用三个单引号(')来注释代码，这些引号之间的文本 不会被 Python 作为程序的一部分执行，它们只是我们对程序的注释。

''' Find the factors of an integer ''' def factors(b): for i in range(1, b+1): if b % i == 0: print(i) if __name__ == '__main__': b = input('Your Number Please: ') b = float(b) if b >0 and b.is_integer(): factors(int(b)) else: print('Please enter a positive integer')

factors()函数定义了一个 for 循环，在n处，该循环使用 range()函数对 1 和输入 的数字之间的每个整数迭代一次。 这里，我们要迭代到用户输入的整数 b，所以停 止值被设置为 b+1。 对于每个整数 i，程序检查输入数字 b 除以 i 后是否伏卜老没有余数， 如果没有余数，就输出 i。 当你运行此程序(选择 Run->Run Module)时，它会要求你输入一个数字。 如 果你输入的数字是正整数，程序会输出其因子，例如：

Your Number Please: 25 1 5 25

如果输入的是非整数或负整数，程序会输出一条错误信息，并要求你输入一 个正整数

#【教程】简单计算器算法（一）#

优先级调度算法程序:

#include "stdio.h"

#include "stdlib.h"

#include "string.h"

typedef struct node

{

char name[10] /*进程标识符*/

int prio /*进程优先数*/

int round /*进程时间轮转时间片*/

int cputime/*进程占用CPU时间*/

int needtime/*进程到完成还要的时间*/

int count /*计数器*/

char state/*进程的状态*/

struct node *next/*链指针*/

}PCB

PCB *finish,*ready,*tail,*run/*队列指针*/

int N/*进程数*/

/*将就绪队列中的第一个进程投入运行*/

firstin()

{

run=ready /*就绪队列头指针赋值给运行头指针*/

run->state='R' /*进程状态变为运行态*/

ready=ready->next /*就绪对列头指针后移到下一进程*/

}

/*标题输出函数*/

void prt1(char a)

{

if(toupper(a)=='P') /*优先数法*/

printf(" name cputime needtime priority state\n")

else

printf(" name cputime needtime count round state\n")

}

/*进程PCB输出*/

void prt2(char a,PCB *q)

{

if(toupper(a)=='P') /*优先数法的输出*/

printf(" %-10s%-10d%-10d%-10d %c\n",q->name,

q->cputime,q->needtime,q->prio,q->state)

else/*轮转法的输出*/

printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,

q->cputime,q->needtime,q->count,q->round,q->state)

}

/*输出函数*/

void prt(char algo)

{

PCB *p

prt1(algo) /*输出标题*/

if(run!=NULL) /*如果运行指针不空*/

prt2(algo,run)/*输出当前正在运行的PCB*/

p=ready /*输出就绪队列PCB*/

while(p!=NULL)

{

prt2(algo,p)

p=p->next

}

p=finish /*输出完成队列的PCB*/

while(p!=NULL)

{

prt2(algo,p)

p=p->next

}

getch() /*压任肆慎意键继续*/

}

/*优先数的插入算法*/

insert1(PCB *q)

{

PCB *p1,*s,*r

int b

s=q /*待插入的PCB指针*/

p1=ready/*就绪队列头指针*/

r=p1/*r做p1的前驱指针*/

b=1

while((p1!=NULL)&&b) /*根据优先数确定插入位置*/

if(p1->prio>=s->prio)

{

r=p1

p1=p1->next

}

else

b=0

if(r!=p1) /*如果条件成立说明插入在r与p1之间*/

{

r->next=s

s->next=p1

}

else

{

s->next=p1 /*否则插入在就绪队列的头*/

ready=s

}

}

/*轮转法插入函数*/

insert2(PCB *p2)

{

tail->next=p2 /*将新的PCB插入在当前就绪队列的搭斗尾*/

tail=p2

p2->知雹磨next=NULL

}

/*优先数创建初始PCB信息*/

void create1(char alg)

{

PCB *p

int i,time

char na[10]

ready=NULL/*就绪队列头指针*/

finish=NULL /*完成队列头指针*/

run=NULL/*运行队列指针*/

printf("Enter name and time of process\n")/*输入进程标识和所需时间创建PCB*/

for(i=1i<=Ni++)

{

p=malloc(sizeof(PCB))

scanf("%s",na)

scanf("%d",&time)

strcpy(p->name,na)

p->cputime=0

p->needtime=time

p->state='w'

p->prio=50-time

if(ready!=NULL) /*就绪队列不空调用插入函数插入*/

insert1(p)

else

{

p->next=ready/*创建就绪队列的第一个PCB*/

ready=p

}

}

clrscr()

printf(" output of priority:\n")

printf("************************************************\n")

prt(alg) /*输出进程PCB信息*/

run=ready/*将就绪队列的第一个进程投入运行*/

ready=ready->next

run->state='R'

}

/*轮转法创建进程PCB*/

void create2(char alg)

{

PCB *p

int i,time

char na[10]

ready=NULL

finish=NULL

run=NULL

printf("Enter name and time of round process\n")

for(i=1i<=Ni++)

{

p=malloc(sizeof(PCB))

scanf("%s",na)

scanf("%d",&time)

strcpy(p->name,na)

p->cputime=0

p->needtime=time

p->count=0/*计数器*/

p->state='w'

p->round=2 /*时间片*/

if(ready!=NULL)

insert2(p)

else

{

p->next=ready

ready=p

tail=p

}

}

clrscr()

printf(" output of round\n")

printf("************************************************\n")

prt(alg) /*输出进程PCB信息*/

run=ready /*将就绪队列的第一个进程投入运行*/

ready=ready->next

run->state='R'

}

/*优先数调度算法*/

priority(char alg)

{

while(run!=NULL) /*当运行队列不空时，有进程正在运行*/

{

run->cputime=run->cputime+1

run->needtime=run->needtime-1

run->prio=run->prio-3/*每运行一次优先数降低3个单位*/

if(run->needtime==0) /*如所需时间为0将其插入完成队列*/

{

run->next=finish

finish=run

run->state='F' /*置状态为完成态*/

run=NULL /*运行队列头指针为空*/

if(ready!=NULL) /*如就绪队列不空*/

firstin()/*将就绪对列的第一个进程投入运行*/

}

else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/

if((ready!=NULL)&&(run->prio<ready->prio))

{

run->state='W'

insert1(run)

firstin()/*将就绪队列的第一个进程投入运行*/

}

prt(alg)/*输出进程PCB信息*/

}

}

/*时间片轮转法*/

roundrun(char alg)

{

while(run!=NULL)

{

run->cputime=run->cputime+1

run->needtime=run->needtime-1

run->count=run->count+1

if(run->needtime==0)/*运行完将其变为完成态，插入完成队列*/

{

run->next=finish

finish=run

run->state='F'

run=NULL

if(ready!=NULL)

firstin()/*就绪对列不空，将第一个进程投入运行*/

}

else

if(run->count==run->round) /*如果时间片到*/

{

run->count=0 /*计数器置0*/

if(ready!=NULL) /*如就绪队列不空*/

{

run->state='W'/*将进程插入到就绪队列中等待轮转*/

insert2(run)

firstin()/*将就绪对列的第一个进程投入运行*/

}

}

prt(alg)/*输出进程信息*/

}

}

/*主函数*/

main()

{

char algo /*算法标记*/

clrscr()

printf("type the algorithm:P/R(priority/roundrobin)\n")

scanf("%c",&algo)/*输入字符确定算法*/

printf("Enter process number\n")

scanf("%d",&N)/*输入进程数*/

if(algo=='P'||algo=='p')

{

create1(algo)/*优先数法*/

priority(algo)

}

else

if(algo=='R'||algo=='r')

{

create2(algo)/*轮转法*/

roundrun(algo)

}

}