由于考研复试的机试需要指定c语言完成，很长时间没有写过c语言的代码，故而用c语言刷了pta上的基础编程题目集，后续会继续更新c语言实现的数据结构。
本题要求实现一个函数，对给定的正整数N，打印从1到N的全部正整数。
#include <stdio.h>
void PrintN ( int N );
int main ()
{
int N;
scanf("%d", &N);
PrintN( N );
return 0;
}
/* 你的代码将被嵌在这里 */void PrintN ( int N ){
for(int i=1;i<=N;i++){
printf("%d\n",i);
}
}本题要求实现一个函数，计算阶数为n，系数为a[0] ... a[n]的多项式f(x)=∑i=0n(a[i]×xi) 在x点的值。
#include <stdio.h>
#define MAXN 10
double f( int n, double a[], double x );
int main()
{
int n, i;
double a[MAXN], x;
scanf("%d %lf", &n, &x);
for ( i=0; i<=n; i++ )
scanf("%lf", &a[i]);
printf("%.1f\n", f(n, a, x));
return 0;
}
/* 你的代码将被嵌在这里 */double f( int n, double a[], double x ){
double sum=0.0;
for(int i=0;i<=n;i++){
sum+=a[i]*pow(x,i);
}
return sum;
}本题要求实现一个函数，求给定的N个整数的和。
#include <stdio.h>
#define MAXN 10
int Sum ( int List[], int N );
int main ()
{
int List[MAXN], N, i;
scanf("%d", &N);
for ( i=0; i<N; i++ )
scanf("%d", &List[i]);
printf("%d\n", Sum(List, N));
return 0;
}
/* 你的代码将被嵌在这里 */
int Sum ( int List[], int N ){
int sum=0;
for(int i=0;i<N;i++){
sum+=List[i];
}
return sum;
}本题要求实现一个函数，求N个集合元素S[]的平均值，其中集合元素的类型为自定义的ElementType。
#include <stdio.h>
#define MAXN 10
int Sum ( int List[], int N );
int main ()
{
int List[MAXN], N, i;
scanf("%d", &N);
for ( i=0; i<N; i++ )
scanf("%d", &List[i]);
printf("%d\n", Sum(List, N));
return 0;
}
/* 你的代码将被嵌在这里 */ElementType Average( ElementType S[], int N ){
ElementType sum=0.0;
for(int i=0;i<N;i++){
sum+=S[i];
}
return sum/N;
}本题要求实现一个函数，求N个集合元素S[]中的最大值，其中集合元素的类型为自定义的ElementType。
#include <stdio.h>
#define MAXN 10
typedef float ElementType;
ElementType Max( ElementType S[], int N );
int main ()
{
ElementType S[MAXN];
int N, i;
scanf("%d", &N);
for ( i=0; i<N; i++ )
scanf("%f", &S[i]);
printf("%.2f\n", Max(S, N));
return 0;
}
/* 你的代码将被嵌在这里 *//* 你的代码将被嵌在这里 */
ElementType Max( ElementType S[], int N ){
ElementType res=S[0];
for(int i=1;i<N;i++){
if(res<S[i]){
res=S[i];
}
}
return res;
}本题要求实现一个函数，求单链表L结点的阶乘和。这里默认所有结点的值非负，且题目保证结果在int范围内。
#include <stdio.h>
#include <stdlib.h>
typedef struct Node *PtrToNode;
struct Node {
int Data; /* 存储结点数据 */
PtrToNode Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */
int FactorialSum( List L );
int main()
{
int N, i;
List L, p;
scanf("%d", &N);
L = NULL;
for ( i=0; i<N; i++ ) {
p = (List)malloc(sizeof(struct Node));
scanf("%d", &p->Data);
p->Next = L; L = p;
}
printf("%d\n", FactorialSum(L));
return 0;
}
/* 你的代码将被嵌在这里 */int FactorialSum( List L ){
int res=0,sum=1;
while(L!=NULL){
sum=1;
for(int i=1;i<=L->Data;i++){
sum=sum*i;
}
res+=sum;
L=L->Next;
}
return res;
}本题要求实现一个函数，判断任一给定整数N是否满足条件：它是完全平方数，又至少有两位数字相同，如144、676等。
#include <stdio.h>
#include <math.h>
int IsTheNumber ( const int N );
int main()
{
int n1, n2, i, cnt;
scanf("%d %d", &n1, &n2);
cnt = 0;
for ( i=n1; i<=n2; i++ ) {
if ( IsTheNumber(i) )
cnt++;
}
printf("cnt = %d\n", cnt);
return 0;
}
/* 你的代码将被嵌在这里 */int IsTheNumber ( const int N ){
int flag=0;
if(N<=0)
return flag;
int x=sqrt(N);
//如果是0或负数直接淘汰
if(x*x==N){
flag=1;
}
//说明是完全平方数
if(flag==1){
int a[10]={0};
int i=0,k=N;
while(k){
a[i]=k%10;
i++;
k=k/10;
}
//存储该数字的各位数
for(int j=0;j<i;j++){
for(int h=j+1;h<i;h++)
{
if(a[j]==a[h])
flag=2;
}
}
//判断该数字是否至少有两位相同
}
if(flag==2){
flag=0;
return 1;
}
else
return 0;
}本题要求实现一个计算非负整数阶乘的简单函数。
#include <stdio.h>
int Factorial( const int N );
int main()
{
int N, NF;
scanf("%d", &N);
NF = Factorial(N);
if (NF) printf("%d! = %d\n", N, NF);
else printf("Invalid input\n");
return 0;
}
/* 你的代码将被嵌在这里 */int Factorial( const int N ){
if(N<0)
return 0;
if(N==0)
return 1;
int sum=1;
for(int i=1;i<=N;i++){
sum=sum*i;
}
return sum;
}#include <stdio.h>
int Count_Digit ( const int N, const int D );
int main()
{
int N, D;
scanf("%d %d", &N, &D);
printf("%d\n", Count_Digit(N, D));
return 0;
}
/* 你的代码将被嵌在这里 */int Count_Digit ( const int N, const int D ){
int sum=0,i=0;
int a[10]={0};
int k=N;
if(k<0) k=-k;
if(k==0&&D==0) return 1;
while(k){
a[i]=k%10;
i++;
k=k/10;
}
for(int j=0;j<i;j++){
if(a[j]==D)
sum++;
}
return sum;
}本题要求实现一个打印非负整数阶乘的函数
#include <stdio.h>
void Print_Factorial ( const int N );
int main()
{
int N;
scanf("%d", &N);
Print_Factorial(N);
return 0;
}
/* 你的代码将被嵌在这里 */本题的难点在于大数的阶乘会造成溢出，我们需要用字符数组来进行存储，手工模拟乘法的过程，然后遍历逆序输出
void Print_Factorial(const int N) {
if (N < 0) {
printf("Invalid input");
} else if (N == 0) {
printf("1");
} else {
// 初始化sum数组为全零
int sum[10001] = {0};
sum[0] = 1; // 阶乘初始为1
// 计算阶乘
for (int i = 2; i <= N; i++) {
int up = 0; // 进位
for (int j = 0; j < 10001; j++) {
int temp = sum[j] * i + up;
sum[j] = temp % 10;
up = temp / 10;
}
}
// 找到最后一个非零位
int lastNonZero = 10000;
while (sum[lastNonZero] == 0) {
lastNonZero--;
}
// 打印阶乘结果
for (int i = lastNonZero; i >= 0; i--) {
printf("%d", sum[i]);
}
}
}本题要求实现一个函数，求N个集合元素A[]的中位数，即序列中第⌊(N+1)/2⌋大的元素。其中集合元素的类型为自定义的ElementType。
#include <stdio.h>
#define MAXN 10
typedef float ElementType;
ElementType Median( ElementType A[], int N );
int main ()
{
ElementType A[MAXN];
int N, i;
scanf("%d", &N);
for ( i=0; i<N; i++ )
scanf("%f", &A[i]);
printf("%.2f\n", Median(A, N));
return 0;
}
/* 你的代码将被嵌在这里 *//*
* 求 N 个集合元素 A[] 的中位数，即序列中第 (N + 1) / 2 大的元素
*/
ElementType Median(ElementType A[], int N) {
// 按 gap 间隔对序列进行分组，直至 gap 为 1
for (int gap = N; gap > 0; gap /= 2) {
// 依次遍历每一组
for (int i = gap; i < N; i++) {
int cur = i;
ElementType waitInsertVal = A[i];
// 向前查找当前待插元素的插入位置（直至找到比当前元素小的元素）
while (cur - gap >= 0 && A[cur - gap] - waitInsertVal > 0) {
// 元素后移，为当前待插元素腾出空位
A[cur] = A[cur - gap];
cur -= gap;
}
A[cur] = waitInsertVal;
}
}
return A[N / 2];
}
本题要求实现判断给定整数奇偶性的函数。
#include <stdio.h>
int even( int n );
int main()
{
int n;
scanf("%d", &n);
if (even(n))
printf("%d is even.\n", n);
else
printf("%d is odd.\n", n);
return 0;
}
/* 你的代码将被嵌在这里 */int even( int n ){
if(n<0)n=-n;
if(n==0)return 1;
if(n%2==0)
{
return 1;
}
else{
return 0;
}
}给一个严格递增数列，函数int Search_Bin(SSTable T, KeyType k)用来二分地查找k在数列中的位置。
#include <iostream>
using namespace std;
#define MAXSIZE 50
typedef int KeyType;
typedef struct
{ KeyType key;
} ElemType;
typedef struct
{ ElemType *R;
int length;
} SSTable;
void Create(SSTable &T)
{ int i;
T.R=new ElemType[MAXSIZE+1];
cin>>T.length;
for(i=1;i<=T.length;i++)
cin>>T.R[i].key;
}
int Search_Bin(SSTable T, KeyType k);
int main ()
{ SSTable T; KeyType k;
Create(T);
cin>>k;
int pos=Search_Bin(T,k);
if(pos==0) cout<<"NOT FOUND"<<endl;
else cout<<pos<<endl;
return 0;
}
/* 请在这里填写答案 */int Search_Bin(SSTable T, KeyType k){
int l=0,r=T.length;
while(l<r){
int mid=(r-l)/2+l;
int temp=T.R[mid].key;
if(temp<k){
l=mid+1;
}else {
r=mid;
}
}
return T.R[l].key==k?l:0;
}如果已知英制长度的英尺foot和英寸inch的值，那么对应的米是(foot+inch/12)×0.3048。现在，如果用户输入的是厘米数，那么对应英制长度的英尺和英寸是多少呢？别忘了1英尺等于12英寸。
输入在一行中给出1个正整数，单位是厘米。
在一行中输出这个厘米数对应英制长度的英尺和英寸的整数值，中间用空格分开。英寸的值应小于12。
#include<stdio.h>
int main()
{
int cm=0;
scanf("%d",&cm);
int foot=cm/30.48;
int inch=(cm/30.48-foot)*12;
printf("%d %d",foot,inch);
return 0;
}有时候人们用四位数字表示一个时间，比如 1106 表示 11 点零 6 分。现在，你的程序要根据起始时间和流逝的时间计算出终止时间。
读入两个数字，第一个数字以这样的四位数字表示当前时间，第二个数字表示分钟数，计算当前时间经过那么多分钟后是几点，结果也表示为四位数字。当小时为个位数时，没有前导的零，例如 5 点 30 分表示为 530；0 点 30 分表示为 030。注意，第二个数字表示的分钟数可能超过 60，也可能是负数。
输入在一行中给出 2 个整数，分别是四位数字表示的起始时间、以及流逝的分钟数，其间以空格分隔。注意：在起始时间中，当小时为个位数时，没有前导的零，即 5 点 30 分表示为 530；0 点 30 分表示为 030。流逝的分钟数可能超过 60，也可能是负数。
输出不多于四位数字表示的终止时间，当小时为个位数时，没有前导的零。题目保证起始时间和终止时间在同一天内。
#include<stdio.h>
int main(){
int time,pass;
scanf("%d" "%d",&time,&pass);
int hour=time/100;
int min=time%100;
min=min+pass;
while(min>=60){
hour=hour+1;min=min-60;
}
while (min<0) {
hour=hour-1;min=min+60;
}
hour=(hour+24)%24;
printf("%d%02d",hour,min);
return 0;
}
程序每次读入一个正3位数，然后输出按位逆序的数字。注意：当输入的数字含有结尾的0时，输出不应带有前导的0。比如输入700，输出应该是7。
每个测试是一个3位的正整数。
输出按位逆序的数。
#include<stdio.h>
int main(){
int m=0;
int a[3]={0};
scanf("%d",&m);
a[2]=m/100;
a[1]=(m-(a[2]*100))/10;
a[0]=m%10;
for(int j=0;j<3;j++){
if(a[j]!=0||a[1]==0&&a[0]!=0)
printf("%d",a[j]);
}
return 0;
}BCD数是用一个字节来表达两位十进制的数，每四个比特表示一位。所以如果一个BCD数的十六进制是0x12，它表达的就是十进制的12。但是小明没学过BCD，把所有的BCD数都当作二进制数转换成十进制输出了。于是BCD的0x12被输出成了十进制的18了！
现在，你的程序要读入这个错误的十进制数，然后输出正确的十进制数。提示：你可以把18转换回0x12，然后再转换回12。
输入在一行中给出一个[0, 153]范围内的正整数，保证能转换回有效的BCD数，也就是说这个整数转换成十六进制时不会出现A-F的数字。
输出对应的十进制数。
#include<stdio.h>
int main()
{
int n;
int a;
scanf("%d",&n);
a=n%16+(n/16)*10;
printf("%d",a);
return 0;
}本题要求编写程序，按照规定格式输出表格。
#include<stdio.h>
int main()
{
printf("------------------------------------\n");
printf("Province Area(km2) Pop.(10K)\n");
printf("------------------------------------\n");
printf("Anhui 139600.00 6461.00\n");
printf("Beijing 16410.54 1180.70\n");
printf("Chongqing 82400.00 3144.23\n");
printf("Shanghai 6340.50 1360.26\n");
printf("Zhejiang 101800.00 4894.00\n");
printf("------------------------------------\n");
}
本题要求编写程序，顺序读入浮点数1、整数、字符、浮点数2，再按照字符、整数、浮点数1、浮点数2的顺序输出。
输入在一行中顺序给出浮点数1、整数、字符、浮点数2，其间以1个空格分隔。
在一行中按照字符、整数、浮点数1、浮点数2的顺序输出，其中浮点数保留小数点后2位。
#include<stdio.h>
int main(){
float a;
int b;
char c;
float d;
scanf("%f %d %c %f",&a,&b,&c,&d);
printf("%c %d %.2f %.2f",c,b,a,d);
return 0;
}编写一个程序，要求用户输入24小时制的时间，然后显示12小时制的时间。
输入在一行中给出带有中间的:符号（半角的冒号）的24小时制的时间，如12:34表示12点34分。当小时或分钟数小于10时，均没有前导的零，如5:6表示5点零6分。
提示：在scanf的格式字符串中加入:，让scanf来处理这个冒号。
在一行中输出这个时间对应的12小时制的时间，数字部分格式与输入的相同，然后跟上空格，再跟上表示上午的字符串AM或表示下午的字符串PM。如5:6 PM表示下午5点零6分。注意，在英文的习惯中，中午12点被认为是下午，所以24小时制的12:00就是12小时制的12:0 PM；而0点被认为是第二天的时间，所以是0:0 AM。
#include<stdio.h>
int main(){
int hour,min;
scanf("%d:%d",&hour,&min);
if(hour>12){
hour=hour-12;
printf("%d:%d PM",hour,min);
}else if(hour==12){
printf("%d:%d PM",hour,min);
}else{
printf("%d:%d AM",hour,min);
}
return 0;
}模拟交通警察的雷达测速仪。输入汽车速度，如果速度超出60 mph，则显示“Speeding”，否则显示“OK”。
输入在一行中给出1个不超过500的非负整数，即雷达测到的车速。
在一行中输出测速仪显示结果，格式为：Speed: V - S，其中V是车速，S或者是Speeding、或者是OK。
#include<stdio.h>
int main(){
int speed;
scanf("%d",&speed);
if(speed>60){
printf("Speed: %d - Speeding",speed);
}else{
printf("Speed: %d - OK",speed);
}
return 0;
}三个球A、B、C，大小形状相同且其中有一个球与其他球重量不同。要求找出这个不一样的球。
输入在一行中给出3个正整数，顺序对应球A、B、C的重量。
在一行中输出唯一的那个不一样的球。
#include<stdio.h>
int main(){
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
if(a==b){
printf("C");
}else if(a==c){
printf("B");
}else{
printf("A");
}
return 0;
}某公司员工的工资计算方法如下：一周内工作时间不超过40小时，按正常工作时间计酬；超出40小时的工作时间部分，按正常工作时间报酬的1.5倍计酬。员工按进公司时间分为新职工和老职工，进公司不少于5年的员工为老职工，5年以下的为新职工。新职工的正常工资为30元/小时，老职工的正常工资为50元/小时。请按该计酬方式计算员工的工资。
输入在一行中给出2个正整数，分别为某员工入职年数和周工作时间，其间以空格分隔。
在一行输出该员工的周薪，精确到小数点后2位。
#include<stdio.h>
int main(){
int year,hour;
float sum;
scanf("%d" "%d",&year,&hour);
if(year<5){
if(hour<=40){
sum=30*hour;
}else{
sum=1200+1.5*30*(hour-40);
}
}else{
if(hour<=40){
sum=50*hour;
}else{
sum=2000+1.5*50*(hour-40);
}
}
printf("%.2f",sum);
return 0;
}为鼓励居民节约用水，自来水公司采取按用水量阶梯式计价的办法，居民应交水费y（元）与月用水量x（吨）相关：当x不超过15吨时，y=4x/3；超过后，y=2.5x−17.5。请编写程序实现水费的计算。
输入在一行中给出非负实数x。
在一行输出应交的水费，精确到小数点后2位。
#include<stdio.h>
int main(){
int x;
float y;
scanf("%d",&x);
if(x<=15){
y=4.0*x/3;
}else{
y=2.5*x-17.5;
}
printf("%.2f",y);
return 0;
}本题要求编写一个简单计算器程序，可根据输入的运算符，对2个整数进行加、减、乘、除或求余运算。题目保证输入和输出均不超过整型范围。
输入在一行中依次输入操作数1、运算符、操作数2，其间以1个空格分隔。操作数的数据类型为整型，且保证除法和求余的分母非零。
当运算符为+、-、*、/、%时，在一行输出相应的运算结果。若输入是非法符号（即除了加、减、乘、除和求余五种运算符以外的其他符号）则输出ERROR。
#include<stdio.h>
int main(){
int a,b;
char c;
scanf("%d %c %d",&a,&c,&b);
int res;
if(c=='+'){
res=a+b;
printf("%d",res);
}else if(c=='-'){
res=a-b;
printf("%d",res);
}else if(c=='*'){
res=a*b;
printf("%d",res);
}else if(c=='/'){
res=a/b;
printf("%d",res);
}else if(c=='%'){
res=a%b;
printf("%d",res);
}else{
printf("ERROR");
}
return 0;
}股票价格涨跌趋势，常用蜡烛图技术中的K线图来表示，分为按日的日K线、按周的周K线、按月的月K线等。以日K线为例，每天股票价格从开盘到收盘走完一天，对应一根蜡烛小图，要表示四个价格：开盘价格Open（早上刚刚开始开盘买卖成交的第1笔价格）、收盘价格Close（下午收盘时最后一笔成交的价格）、中间的最高价High和最低价Low。
如果Close<Open，表示为“BW-Solid”（即“实心蓝白蜡烛”）；如果Close>Open，表示为“R-Hollow”（即“空心红蜡烛”）；如果Open等于Close，则为“R-Cross”（即“十字红蜡烛”）。如果Low比Open和Close低，称为“Lower Shadow”（即“有下影线”），如果High比Open和Close高，称为“Upper Shadow”（即“有上影线”）。请编程序，根据给定的四个价格组合，判断当日的蜡烛是一根什么样的蜡烛。
输入在一行中给出4个正实数，分别对应Open、High、Low、Close，其间以空格分隔。
在一行中输出日K蜡烛的类型。如果有上、下影线，则在类型后加上with 影线类型。如果两种影线都有，则输出with Lower Shadow and Upper Shadow。
#include<stdio.h>
int main(){
float Open,High,Low,Close;
scanf("%f" "%f" "%f" "%f",&Open,&High,&Low,&Close);
int flag=0,count=0;
if(Close<Open){
printf("BW-Solid");
}
if(Close>Open){
printf("R-Hollow");
}
if(Close==Open){
printf("R-Cross");
}
if(Low<Close&&Low<Open){
flag=1;count++;
}if(High>Open&&High>Close){
flag=2;count++;
}
if(flag==1&&count!=2){
printf(" with Lower Shadow");
}else if(flag==2&&count!=2){
printf(" with Upper Shadow");
}else if(count==2){
printf(" with Lower Shadow and Upper Shadow");
}
}给定两个整数A和B，输出从A到B的所有整数以及这些数的和。
输入在一行中给出2个整数A和B，其中−100≤A≤B≤100，其间以空格分隔。
首先顺序输出从A到B的所有整数，每5个数字占一行，每个数字占5个字符宽度，向右对齐。最后在一行中按Sum = X的格式输出全部数字的和X。
#include<stdio.h>
int main(){
int a,b,count=0,sum=0;
scanf("%d" "%d",&a,&b);
for(int i=a;i<=b;i++){
sum+=i;
printf("%5d",i);
count++;
if(count%5==0)
printf("\n");
}
if(count%5!=0){
printf("\n");
}
printf("Sum = %d",sum);
}根据下面关系式，求圆周率的值，直到最后一项的值小于给定阈值。
2π=1+31+3×52!+3×5×73!+⋯+3×5×7×⋯×(2n+1)n!+⋯
输入在一行中给出小于1的阈值。
在一行中输出满足阈值条件的近似圆周率，输出到小数点后6位。
#include <stdio.h>
int main()
{
float eps; scanf("%f", &eps);
float term, sum=0, fz=1, fm=1;
int k = 0;
do{
term = fz / fm;
sum += term;
k++;
fz *= k;
fm *= (2*k+1);
}while (term >= eps);
printf("%.6f\n", sum*2);
return 0;
}
给定不超过6的正整数A，考虑从A开始的连续4个数字。请输出所有由它们组成的无重复数字的3位数。
输入在一行中给出A。
输出满足条件的的3位数，要求从小到大，每行6个整数。整数间以空格分隔，但行末不能有多余空格。
#include <stdio.h>
int main()
{
int a,count=0;
scanf("%d",&a);
int num[4]={a,a+1,a+2,a+3};
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
if(i==j) continue;
for(int k=0;k<4;k++){
if (k == i || k == j) continue;
count++;
printf("%d""%d""%d",num[i],num[j],num[k]);
if(count%6!=0){
printf(" ");
}
}
}
if(i!=3)
printf("\n");
}
}
一条蠕虫长1寸，在一口深为N寸的井的底部。已知蠕虫每1分钟可以向上爬U寸，但必须休息1分钟才能接着往上爬。在休息的过程中，蠕虫又下滑了D寸。就这样，上爬和下滑重复进行。请问，蠕虫需要多长时间才能爬出井？
这里要求不足1分钟按1分钟计，并且假定只要在某次上爬过程中蠕虫的头部到达了井的顶部，那么蠕虫就完成任务了。初始时，蠕虫是趴在井底的（即高度为0）。
输入在一行中顺序给出3个正整数N、U、D，其中D<U，N不超过100。
在一行中输出蠕虫爬出井的时间，以分钟为单位。
#include <stdio.h>
int main()
{
int n,u,d,min=0;
scanf("%d" "%d" "%d",&n,&u,&d);
while(n>0){
min++;
if(min%2!=0)
n=n-u;
else if(min%2==0&&n>0)
n=n+d;
}
printf("%d",min);
}
二分法求函数根的原理为：如果连续函数f(x)在区间[a,b]的两个端点取值异号，即f(a)f(b)<0，则它在这个区间内至少存在1个根r，即f(r)=0。
二分法的步骤为：
本题目要求编写程序，计算给定3阶多项式f(x)=a3x3+a2x2+a1x+a0在给定区间[a,b]内的根。
输入在第1行中顺序给出多项式的4个系数a3、a2、a1、a0，在第2行中顺序给出区间端点a和b。题目保证多项式在给定区间内存在唯一单根。
在一行中输出该多项式在该区间内的根，精确到小数点后2位。
#include <stdio.h>
#include <math.h> // 用于fabs函数,绝对值函数
int main() {
double a3, a2, a1, a0, a, b, epsilon = 1e-5; // epsilon为阈值
scanf("%lf %lf %lf %lf %lf %lf", &a3, &a2, &a1, &a0, &a, &b);
double fa = a3*a*a*a + a2*a*a + a1*a + a0;
double fb = a3*b*b*b + a2*b*b + a1*b + a0;
while (b - a > epsilon) {
double m = (a + b) / 2;
double fm = a3*m*m*m + a2*m*m + a1*m + a0;
if (fabs(fm) < epsilon) { // fm接近0，认为找到根
printf("%.2lf", m);
return 0;
}
if (fa * fm < 0) {
b = m;
fb = fm;
} else {
a = m;
fa = fm;
}
}
printf("%.2lf", (a + b) / 2); // 若未找到精确根，则输出近似根
return 0;
}
一个采购员去银行兑换一张y元f分的支票，结果出纳员错给了f元y分。采购员用去了n分之后才发觉有错，于是清点了余额尚有2y元2f分，问该支票面额是多少？
输入在一行中给出小于100的正整数n。
在一行中按格式y.f输出该支票的原始面额。如果无解，则输出No Solution。
#include<stdio.h>
int main(){
int n;
scanf("%d",&n);
int y,f,flag=0;
for(y=0;y<100;y++){
for(f=0;f<100;f++){
if(98*f-n==199*y){
printf("%d.%d",y,f);
flag=1;
}
}
}
if(flag==0){
printf("No Solution");
}
return 0;
}下面是一个完整的下三角九九口诀表：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
本题要求对任意给定的一位正整数N，输出从1*1到N*N的部分口诀表。
输入在一行中给出一个正整数N（1≤N≤9）。
输出下三角N*N部分口诀表，其中等号右边数字占4位、左对齐。
/*
本题要求对任意给定的一位正整数N，输出从1*1到N*N的部分口诀表。
*/
#include<stdio.h>
int main(){
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++){
for(int j=1;j<=i;j++){
int res=i*j;
printf("%d*%d=%-4d",j,i,res);
}
printf("\n");
}
return 0;
}
本题要求对任意给定的正整数N，求方程X2+Y2=N的全部正整数解。
输入在一行中给出正整数N（≤10000）。
输出方程X2+Y2=N的全部正整数解，其中X≤Y。每组解占1行，两数字间以1空格分隔，按X的递增顺序输出。如果没有解，则输出No Solution。
/*
本题要求对任意给定的正整数N，求方程的全部正整数解。
*/
#include<stdio.h>
int main(){
int n,flag=0;
scanf("%d",&n);
for(int i=0;i<100;i++){
for(int j=0;j<100;j++){
if(i*i+j*j==n&&i<j){
printf("%d"" ""%d\n",i,j);
flag=1;
}
}
}
if(flag==0){
printf("No Solution");
}
return 0;
}
乌龟与兔子进行赛跑，跑场是一个矩型跑道，跑道边可以随地进行休息。乌龟每分钟可以前进3米，兔子每分钟前进9米；兔子嫌乌龟跑得慢，觉得肯定能跑赢乌龟，于是，每跑10分钟回头看一下乌龟，若发现自己超过乌龟，就在路边休息，每次休息30分钟，否则继续跑10分钟；而乌龟非常努力，一直跑，不休息。假定乌龟与兔子在同一起点同一时刻开始起跑，请问T分钟后乌龟和兔子谁跑得快？
输入在一行中给出比赛时间T（分钟）。
在一行中输出比赛的结果：乌龟赢输出@_@，兔子赢输出^_^，平局则输出-_-；后跟1空格，再输出胜利者跑完的距离。
/*
乌龟与兔子进行赛跑，跑场是一个矩型跑道，跑道边可以随地进行休息。
乌龟每分钟可以前进3米，兔子每分钟前进9米；兔子嫌乌龟跑得慢，觉得肯定能跑赢乌龟，
于是，每跑10分钟回头看一下乌龟，若发现自己超过乌龟，就在路边休息，每次休息30分钟，
否则继续跑10分钟；而乌龟非常努力，一直跑，不休息。
假定乌龟与兔子在同一起点同一时刻开始起跑，请问T分钟后乌龟和兔子谁跑得快？
在一行中输出比赛的结果：乌龟赢输出@_@，兔子赢输出^_^，平局则输出-_-；后跟1空格，再输出胜利者跑完的距离。
*/
#include<stdio.h>
int main(){
int T,rab=9,tur=3,rabs,turs,res=0;
scanf("%d",&T);
for(int i=1;i<T+1;i++){
rabs=rab*(i-res);
turs=tur*i;
if(i%10==0){
if(rabs>turs&&T-i>30){
res+=30;
i+=29;
}else if(rabs>turs&&T-i<30){
res+=T-i;
i=T-1;
}
}
}
if(rabs>turs){
printf("^_^ %d",rabs);
}else if(rabs<turs){
printf("@_@ %d",turs);
}else{
printf("-_- %d",rabs);
}
return 0;
}
输入一个整数（位数不超过9位）代表一个人民币值（单位为元），请转换成财务要求的大写中文格式。如23108元，转换后变成“贰万叁仟壹百零捌”元。为了简化输出，用小写英文字母a-j顺序代表大写数字0-9，用S、B、Q、W、Y分别代表拾、百、仟、万、亿。于是23108元应被转换输出为“cWdQbBai”元。
输入在一行中给出一个不超过9位的非负整数。
在一行中输出转换后的结果。注意“零”的用法必须符合中文习惯。
#include<stdio.h>
int main() {
char num[10]={'a','b','c','d','e','f','g','h','i','j'};
int b[10]={0};//存储单个的数字，按位数的从低到高存储
int a=0;
scanf("%d",&a);
int yushu=0,shang=0;
int cnt=0;//统计输入数字的长度
int i=0;
yushu=a%10;
shang=a/10;
b[i]=yushu;
i++;
while(shang!=0)//统计位数
{
yushu=shang%10;
shang=shang/10;
b[i]=yushu;
i++;
}
cnt=i;
//再从高位数到低位数转换
//注意0的用法
{
for(;i>0;i--)
{
if(b[i-1]!=0)
{
//壹拾的那个壹不要输出
if(i==2||i==6)
{
if(b[i-1]!=1)
printf("%c",num[b[i-1]]);
}
else
printf("%c",num[b[i-1]]);
if(i==9)
printf("Y");
if(i==5)
printf("W");
if(i==4||i==8)
printf("Q");
if(i==3||i==7)
printf("B");
if(i==2||i==6)
printf("S");
}
else
{//注意0的用法：什么时候0输出；什么时候0不输出
//首先要判断这个数字后面还有没有数字；再判断是不是非0的
//判断接下来的数字是不是非0数，要是则输出这个0
if(i-2>=0&&i!=5) //万位上的0不要输出
{
if(b[i-2]!=0)
printf("%c",num[b[i-1]]);
}
//要是万位为0；要判断亿位到万位是不是有非0
if(i==5)
{
int j=i+1;
for(;j<cnt;j++)//不要遍历到亿位
{
if(b[j-1]!=0)//万位到亿位有非0数
{
printf("W");//输出这个W
break;
}
}
}
//当只有一个数字，且这个数字是0的时候也要输出
if(cnt==1)
printf("%c",num[b[i-1]]);
}
}
}
return 0;
}
分数可以表示为分子/分母的形式。编写一个程序，要求用户输入一个分数，然后将其约分为最简分式。最简分式是指分子和分母不具有可以约分的成分了。如6/12可以被约分为1/2。当分子大于分母时，不需要表达为整数又分数的形式，即11/8还是11/8；而当分子分母相等时，仍然表达为1/1的分数形式。
输入在一行中给出一个分数，分子和分母中间以斜杠/分隔，如：12/34表示34分之12。分子和分母都是正整数（不包含0，如果不清楚正整数的定义的话）。
提示：
scanf的格式字符串中加入/，让scanf来处理这个斜杠。a,b=map(int, input().split('/'))这样的代码来处理这个斜杠。在一行中输出这个分数对应的最简分式，格式与输入的相同，即采用分子/分母的形式表示分数。如5/6表示6分之5。
/*
分数可以表示为分子/分母的形式。编写一个程序，要求用户输入一个分数，然后将其约分为最简分式。
最简分式是指分子和分母不具有可以约分的成分了。如6/12可以被约分为1/2。
当分子大于分母时，不需要表达为整数又分数的形式，即11/8还是11/8；而当分子分母相等时，仍然表达为1/1的分数形式。
*/
#include<stdio.h>
int main(){
int fz,fm,a,b,r;
scanf("%d""/""%d",&fz,&fm);
a=fz,b=fm;
//辗转相除法求最大公约数
while(b!=0){
r=a%b;
a=b;
b=r;
}
printf("%d/%d",fz/a,fm/a);
return 0;
}输入一个整数，输出每个数字对应的拼音。当整数为负数时，先输出fu字。十个数字对应的拼音如下：
0: ling
1: yi
2: er
3: san
4: si
5: wu
6: liu
7: qi
8: ba
9: jiu
输入在一行中给出一个整数，如：1234。
提示：整数包括负数、零和正数。
在一行中输出这个整数对应的拼音，每个数字的拼音之间用空格分开，行末没有最后的空格。
#include<stdio.h>
int main(){
int n;
scanf("%d",&n);
if(n<0) {
printf("fu ");
n=-n;
}
if(n==0){
printf("ling");
return 0;
}
char a[10]={'*'};
int i=0;
while(n!=0){
a[i]=n%10;
i++;
n=n/10;
}
int flag=0;
for(int i=10;i>=0;i--){
if(a[i]!=0) flag=1;
if(flag==1&&i!=0){
switch(a[i]){
case 0:printf("ling ");break;
case 1:printf("yi ");break;
case 2:printf("er ");break;
case 3:printf("san ");break;
case 4:printf("si ");break;
case 5:printf("wu ");break;
case 6:printf("liu ");break;
case 7:printf("qi ");break;
case 8:printf("ba ");break;
case 9:printf("jiu ");break;
}
}else if(flag==1&&i==0){
switch(a[i]){
case 0:printf("ling");break;
case 1:printf("yi");break;
case 2:printf("er");break;
case 3:printf("san");break;
case 4:printf("si");break;
case 5:printf("wu");break;
case 6:printf("liu");break;
case 7:printf("qi");break;
case 8:printf("ba");break;
case 9:printf("jiu");break;
}
}
}
}你的程序要读入一行文本，其中以空格分隔为若干个单词，以.结束。你要输出每个单词的长度。这里的单词与语言无关，可以包括各种符号，比如it's算一个单词，长度为4。注意，行中可能出现连续的空格；最后的.不计算在内。
输入在一行中给出一行文本，以.结束
提示：用scanf("%c",...);来读入一个字符，直到读到.为止。
在一行中输出这行文本对应的单词的长度，每个长度之间以空格隔开，行末没有最后的空格。
#include<stdio.h>
int main() {
int num = 0; // 当前单词的长度
char ch; // 当前读取的字符
int wordExist = 0; // 用于标记是否已经遇到了至少一个单词
while((ch = getchar()) != '.') { // 直到读取到句子结束的点
if(ch == ' ') { // 遇到空格
if(num > 0) { // 如果当前单词长度大于0，则之前有单词
if (wordExist) printf(" "); // 如果之前已经输出过单词，则在单词之间输出空格
printf("%d", num); // 输出单词长度
wordExist = 1; // 标记已经输出过至少一个单词
num = 0; // 重置单词长度计数器
}
} else { // 非空格字符
num++; // 单词长度加1
}
}
if(num > 0) { // 句子结束时，如果还有未输出的单词长度
if (wordExist) printf(" "); // 如果之前已经输出过单词，则在单词之间输出空格
printf("%d", num); // 输出最后一个单词的长度
}
return 0;
}
将N个整数按从小到大排序的冒泡排序法是这样工作的：从头到尾比较相邻两个元素，如果前面的元素大于其紧随的后面元素，则交换它们。通过一遍扫描，则最后一个元素必定是最大的元素。然后用同样的方法对前N−1个元素进行第二遍扫描。依此类推，最后只需处理两个元素，就完成了对N个数的排序。
本题要求对任意给定的K（<N），输出扫描完第K遍后的中间结果数列。
输入在第1行中给出N和K（1≤K<N≤100），在第2行中给出N个待排序的整数，数字间以空格分隔。
在一行中输出冒泡排序法扫描完第K遍后的中间结果数列，数字间以空格分隔，但末尾不得有多余空格。
/*
将N个整数按从小到大排序的冒泡排序法是这样工作的：从头到尾比较相邻两个元素，如果前面的元素大于其紧随的后面元素，则交换它们。
通过一遍扫描，则最后一个元素必定是最大的元素。
然后用同样的方法对前N?1个元素进行第二遍扫描。依此类推，最后只需处理两个元素，就完成了对N个数的排序。
*/
#include<stdio.h>
int main() {
int k,n;
scanf("%d %d",&k,&n);
int a[k];
for(int i=0;i<k;i++){
scanf("%d",&a[i]);
}
for(int j=0;j<n;j++){
for(int h=0;h<k-j-1;h++){
if(a[h]>a[h+1]){
int temp=a[h+1];
a[h+1]=a[h];
a[h]=temp;
}
}
}
for(int i=0;i<k;i++){
if(i<k-1){
printf("%d ",a[i]);
}else{
printf("%d",a[i]);
}
}
return 0;
}
一群猴子要选新猴王。新猴王的选择方法是：让N只候选猴子围成一圈，从某位置起顺序编号为1~N号。从第1号开始报数，每轮从1报到3，凡报到3的猴子即退出圈子，接着又从紧邻的下一只猴子开始同样的报数。如此不断循环，最后剩下的一只猴子就选为猴王。请问是原来第几号猴子当选猴王？
输入在一行中给一个正整数N（≤1000）。
在一行中输出当选猴王的编号。
//该问题为约瑟夫问题
#include <stdio.h>
int main() {
int n;
scanf("%d", &n);
//定义一个数组，用数组对猴子进行存取
int a[n+1];//1代表继续游戏，0代表退出游戏
a[0]=0;
for(int i=1;i<n+1;i++){
a[i]=1;
}
int count=n;//count代表还存在的猴子
int index=0;//index代表表示的猴子下标
int num=0; //num代表报数的序号
//直到最后只剩下一只猴子
while(count>1){
index++;
num++;
if(index>n){
index=1;
}
while(a[index]!=1){
index++;
if(index>n){
index=1;
}
}
while(num==3&&a[index]==1){
a[index]=0;
count--;
num=0;
}
}
for(int j=1;j<=n;j++){
if(a[j]!=0){
printf("%d",j);
}
}
}
输入2个字符串S1和S2，要求删除字符串S1中出现的所有子串S2，即结果字符串中不能包含S2。
输入在2行中分别给出不超过80个字符长度的、以回车结束的2个非空字符串，对应S1和S2。
在一行中输出删除字符串S1中出现的所有子串S2后的结果字符串。
/*
输入2个字符串S1和S2，要求删除字符串S1中出现的所有子串S2，即结果字符串中不能包含S2。
*/
#include<stdio.h>
#include<string.h>
int main(){
char s1[81],s2[81];
gets(s1);gets(s2);
char *place;
int length2;
length2=strlen(s2);
while(strstr(s1,s2)!=NULL){
place=strstr(s1,s2);
while(*place!='\0'){
*place=*(place+length2);
place++;
}
}
printf("%s",s1);
}我们已经知道了将N个整数按从小到大排序的冒泡排序法。本题要求将此方法用于字符串序列，并对任意给定的K（<N），输出扫描完第K遍后的中间结果序列。
输入在第1行中给出N和K（1≤K<N≤100），此后N行，每行包含一个长度不超过10的、仅由小写英文字母组成的非空字符串。
输出冒泡排序法扫描完第K遍后的中间结果序列，每行包含一个字符串。
/*
我们已经知道了将N个整数按从小到大排序的冒泡排序法。
本题要求将此方法用于字符串序列，并对任意给定的K（<N），输出扫描完第K遍后的中间结果序列。
*/
#include<stdio.h>
#include<string.h>
int main(){
int n,k;
scanf("%d %d",&n,&k);
getchar();// 消费掉scanf后的换行符
char num[n][11];
//输入n个字符串
for(int i=0;i<n;i++){
gets(num[i]);
}
//冒泡排序
for(int a=0;a<k;a++){
for(int b=0;b<n-1;b++){
if(strcmp(num[b],num[b+1])>0){
char temp[11];
strcpy(temp,num[b]);
strcpy(num[b],num[b+1]);
strcpy(num[b+1],temp);
}
}
}
//输出排序以后的字符串
for(int j=0;j<n;j++){
if(j!=n-1)
printf("%s\n",num[j]);
else
printf("%s",num[j]);
}
return 0;
}输入一个字符串和一个非负整数N，要求将字符串循环左移N次。
输入在第1行中给出一个不超过100个字符长度的、以回车结束的非空字符串；第2行给出非负整数N。
在一行中输出循环左移N次后的字符串。
/*
输入一个字符串和一个非负整数N，要求将字符串循环左移N次。
输入在第1行中给出一个不超过100个字符长度的、以回车结束的非空字符串；第2行给出非负整数N。
*/
#include<stdio.h>
#include<string.h>
int main(){
char a[101]={0};
gets(a);
int len=strlen(a);
int n;
scanf("%d",&n);
//处理n大于字符串长度时的情况
if(n>len) n=n%len;
for(int i=0;i<len;i++){
if(i>=n){
printf("%c",a[i]);
}
}
for(int j=0;j<n;j++){
printf("%c",a[j]);
}
return 0;
}给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。
测试输入包含一个测试用例，在一行内给出总长度不超过500 000的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用若干个空格分开。
每个测试用例的输出占一行，输出倒序后的句子，并且保证单词间只有1个空格
#include<stdio.h>
#include<string.h>
int main(){
char s[500002];
gets(s);
int len = strlen(s);
int i, count=0, flag=0;
for(i=len-1; i>=0; i--){
if(s[i] != ' '){
count++;
} else if(count > 0){
// 为下一个单词输出空格，但对于第一个找到的单词（实际上是句子中的最后一个单词），不输出空格
if(flag == 1) {
printf(" ");
}
// 输出当前单词
for(int j=i+1; j<=i+count; j++){
printf("%c", s[j]);
}
count = 0; // 重置单词长度计数
flag = 1; // 标记已输出单词
}
}
// 处理字符串开头的单词（由于循环中不会被处理）
if(count > 0){
if(flag == 1) {
printf(" ");
}
for(int j=0; j<count; j++){
printf("%c", s[j]);
}
}
printf("\n");
return 0;
}
本题要求编写程序，计算两个有理数的和。
输入在一行中按照a1/b1 a2/b2的格式给出两个分数形式的有理数，其中分子和分母全是整形范围内的正整数。
在一行中按照a/b的格式输出两个有理数的和。注意必须是该有理数的最简分数形式，若分母为1，则只输出分子。
/*
本题要求编写程序，计算两个有理数的和。
*/
#include<stdio.h>
int main(){
int a1,b1,a2,b2;
scanf("%d/%d %d/%d",&a1,&b1,&a2,&b2);
a1=a1*b2;
a2=a2*b1;
int temp=b1;
b1=b1*b2;
b2=b2*temp;
int fz=a1+a2;
int fm=b1;
int a=fm,b=fz,r;
while(b!=0){
r=b;
b=a%b;
a=r;
}
if(fm/r!=1)
printf("%d/%d",fz/r,fm/r);
else
printf("%d",fz/r);
return 0;
}通讯录中的一条记录包含下述基本信息：朋友的姓名、出生日期、性别、固定电话号码、移动电话号码。
本题要求编写程序，录入N条记录，并且根据要求显示任意某条记录。
输入在第一行给出正整数N（≤10）；随后N行，每行按照格式姓名 生日 性别 固话 手机给出一条记录。其中姓名是不超过10个字符、不包含空格的非空字符串；生日按yyyy/mm/dd的格式给出年月日；性别用M表示“男”、F表示“女”；固话和手机均为不超过15位的连续数字，前面有可能出现+。
在通讯录记录输入完成后，最后一行给出正整数K，并且随后给出K个整数，表示要查询的记录编号（从0到N−1顺序编号）。数字间以空格分隔。
对每一条要查询的记录编号，在一行中按照姓名 固话 手机 性别 生日的格式输出该记录。若要查询的记录不存在，则输出Not Found。
#include <stdio.h>
typedef struct {
// 注意数组要足够大
char name[11];
char birth[20];
char sex;
char sta[17];
char mobile[17];
} book;
int main(void)
{
int n, k, idx;
scanf("%d", &n);
book lis[11];
int i;
// 读入
for (i=0; i<n; i++){
scanf("%s %s %c %s %s", &lis[i].name, &lis[i].birth, &lis[i].sex, &lis[i].sta, &lis[i].mobile);
}
// 按要求输出
scanf("%d", &k);
for (i=0; i<k; i++){
scanf("%d", &idx);
if (-1 < idx && idx < n){ // 0 ~ n-1
printf("%s %s %s %c %s\n", lis[idx].name, lis[idx].sta, lis[idx].mobile, lis[idx].sex, lis[idx].birth);
} else {
printf("Not Found\n");
}
}
return 0;
} 本题要求编写程序，计算N个有理数的平均值。
输入第一行给出正整数N（≤100）；第二行中按照a1/b1 a2/b2 …的格式给出N个分数形式的有理数，其中分子和分母全是整形范围内的整数；如果是负数，则负号一定出现在最前面。
在一行中按照a/b的格式输出N个有理数的平均值。注意必须是该有理数的最简分数形式，若分母为1，则只输出分子。
#include<stdio.h>
int main()
{
int n,i,m;
//定义成long long int 或者是int 都是可以的：
int a1,b1,a2,b2,c1,c2,p,d1,d2,temp;
scanf("%d",&n);
m=n;
scanf("%d/%d",&a1,&b1);
while(--n)
{
scanf("%d/%d",&a2,&b2);
c1=a1*b2+a2*b1;
c2=b1*b2;
d1=c1;
d2=c2;
//只能用辗转相除法，来求最大公约数；
//不可以用相减法或者是穷举法来求最大公约数；
while(c1%c2!=0)//测试点2：若不随时化简则会溢出；
{
temp=c1%c2;
c1=c2;
c2=temp;
}
//c2是最大公约数；
d1=d1/c2;
d2=d2/c2;
a1=d1;
b1=d2;
}
b1=b1*m;
if(a1>b1) p=b1;
else p=a1;
if(p<0) p=-p;
for(i=p;i>=1;i--)
{
if(a1%i==0&&b1%i==0)
{
a1=a1/i;
b1=b1/i;
}
}
if(a1%b1==0) printf("%d",a1/b1);//只有整数部分；
else if(a1/b1==0&&b1!=0) printf("%d/%d",a1,b1);//没有整数部分，只有分数部分；
return 0;
}
本题要求编写程序，计算2个复数的和、差、积、商。
输入在一行中按照a1 b1 a2 b2的格式给出2个复数C1=a1+b1i和C2=a2+b2i的实部和虚部。题目保证C2不为0。
分别在4行中按照(a1+b1i) 运算符 (a2+b2i) = 结果的格式顺序输出2个复数的和、差、积、商，数字精确到小数点后1位。如果结果的实部或者虚部为0，则不输出。如果结果为0，则输出0.0。
#include<stdio.h>
#include<math.h>
int main()
{
double a,b,c,d,x[5],y[5];
int i,j;
char k[5]={'+','-','*','/'};
scanf("%lf %lf %lf %lf",&a,&b,&c,&d);
x[0]=a+c;y[0]=b+d;
x[1]=a-c;y[1]=b-d;
x[2]=a*c-b*d;y[2]=b*c+a*d;
x[3]=(a*c+b*d)/(c*c+d*d);y[3]=(b*c-a*d)/(c*c+d*d);
for(i=0;i<4;i++){
if(fabs(x[i])<0.05&&fabs(y[i])<0.05){
printf("(%.1f%+.1fi) %c (%.1f%+.1fi) = 0.0\n",a,b,k[i],c,d);
}
else if(fabs(x[i])<0.05){
printf("(%.1f%+.1fi) %c (%.1f%+.1fi) = %.1fi\n",a,b,k[i],c,d,y[i]);
}
else if(fabs(y[i])<0.05){
printf("(%.1f%+.1fi) %c (%.1f%+.1fi) = %.1f\n",a,b,k[i],c,d,x[i]);
}
else {
printf("(%.1f%+.1fi) %c (%.1f%+.1fi) = %.1f%+.1fi\n",a,b,k[i],c,d,x[i],y[i]);
}
}
return 0;
}
将一个正整数N分解成几个正整数相加，可以有多种分解方法，例如7=6+1，7=5+2，7=5+1+1，…。编程求出正整数N的所有整数分解式子。
每个输入包含一个测试用例，即正整数N (0<N≤30)。
按递增顺序输出N的所有整数分解式子。递增顺序是指：对于两个分解序列N1={n1,n2,⋯}和N2={m1,m2,⋯}，若存在i使得n1=m1,⋯,ni=mi，但是ni+1<mi+1,则N1序列必定在N2序列之前输出。每个式子由小到大相加，式子间用分号隔开，且每输出4个式子后换行。
#include<stdio.h>
int book[35]; //用于存放分解的数
int n,sum=0; //sum用于相加的和
int index=0,count=1; //index用于计算一共有多少各解，方便换行。
void dfs(int x)
{
if(sum>n)
return ;
if(sum==n)
{ //如果数组里的数相加等于n，就输出数组里的数
index++;
printf("%d=",n);
for(int i=1;i<count-1;i++)
printf("%d+",book[i]);
if(index%4==0||book[count-1]==n)
printf("%d\n",book[count-1]);
else printf("%d;",book[count-1]);
return ;
}
for(int i=x;i<=n;i++)
{
book[count++]=i; //将该数存进数组
sum+=i; //将该数加起来
dfs(i); //接着递归搜索
sum-=i; //回溯，减去该数
count--; //从数组中删除
}
}
int main()
{
scanf("%d",&n);
dfs(1);
return 0;
}
给定某数字A（1≤A≤9）以及非负整数N（0≤N≤100000），求数列之和S=A+AA+AAA+⋯+AA⋯A（N个A）。例如A=1, N=3时，S=1+11+111=123。
输入数字A与非负整数N。
输出其N项数列之和S的值。
#include<iostream>
using namespace std;
int main() {
int A, N;
cin >> A >> N;
if (!N) { cout << "0"; return 0; } //如果为零
int *Store = new int[N + 2]; //动态创建数组
int Bas = 1, Adv = 0;
for (int i = N; i >= 1; i--) {//从个位开始依次进位思考，注意这里是倒序，先存的是个位
int Temp = i*A + Adv; //在该位得到的值加上较低一级位进位值
Store[Bas] = Temp % 10; //存储本位值
Adv = Temp / 10; //得到本位进位值
if (i > 1) Bas++; //在未达到最高位时
else if (Adv) Store[++Bas] = Adv; //达到最高位时若依旧有进位
}
for (int i = Bas; i >= 1; i--) cout << Store[i]; //倒序存入 则倒序输出
delete[] Store; //释放动态数组
return 0;
}文章浏览阅读2w次，点赞7次，收藏51次。四个步骤1.创建C++ Win32项目动态库dll 2.在Win32项目动态库中添加 外部依赖项 lib头文件和lib库3.导出C接口4.c#调用c++动态库开始你的表演...①创建一个空白的解决方案，在解决方案中添加 Visual C++ , Win32 项目空白解决方案的创建：添加Visual C++ , Win32 项目这......_c#调用lib
文章浏览阅读4.6k次。苹方字体是苹果系统上的黑体，挺好看的。注重颜值的网站都会使用，例如知乎：font-family: -apple-system, BlinkMacSystemFont, Helvetica Neue, PingFang SC, Microsoft YaHei, Source Han Sans SC, Noto Sans CJK SC, W..._ubuntu pingfang
文章浏览阅读159次。表单表单概述表单标签表单域按钮控件demo表单标签表单标签基本语法结构<form action="处理数据程序的url地址“ method=”get|post“ name="表单名称”></form><!--action,当提交表单时，向何处发送表单中的数据，地址可以是相对地址也可以是绝对地址--><!--method将表单中的数据传送给服务器处理，get方式直接显示在url地址中，数据可以被缓存，且长度有限制；而post方式数据隐藏传输，_html表单的处理程序有那些
文章浏览阅读1.2k次。使用说明:开启Google的登陆二步验证（即Google Authenticator服务）后用户登陆时需要输入额外由手机客户端生成的一次性密码。实现Google Authenticator功能需要服务器端和客户端的支持。服务器端负责密钥的生成、验证一次性密码是否正确。客户端记录密钥后生成一次性密码。下载谷歌验证类库文件放到项目合适位置(我这边放在项目Vender下面)https://github.com/PHPGangsta/GoogleAuthenticatorPHP代码示例://引入谷_php otp 验证器
文章浏览阅读4.3k次，点赞5次，收藏11次。matplotlib.plot画图横坐标混乱及间隔处理_matplotlib更改横轴间距
文章浏览阅读2.2k次。①Storage driver 处理各镜像层及容器层的处理细节，实现了多层数据的堆叠，为用户 提供了多层数据合并后的统一视图②所有 Storage driver 都使用可堆叠图像层和写时复制（CoW）策略③docker info 命令可查看当系统上的 storage driver主要用于测试目的，不建议用于生成环境。_docker 保存容器
文章浏览阅读834次，点赞27次，收藏13次。网络拓扑结构是指计算机网络中各组件（如计算机、服务器、打印机、路由器、交换机等设备）及其连接线路在物理布局或逻辑构型上的排列形式。这种布局不仅描述了设备间的实际物理连接方式，也决定了数据在网络中流动的路径和方式。不同的网络拓扑结构影响着网络的性能、可靠性、可扩展性及管理维护的难易程度。_网络拓扑csdn
文章浏览阅读1.8k次，点赞5次，收藏8次。IOS系统Date的坑要创建一个指定时间的new Date对象时，通常的做法是：new Date("2020-09-21 11:11:00")这行代码在 PC 端和安卓端都是正常的，而在 iOS 端则会提示 Invalid Date 无效日期。在IOS年月日中间的横岗许换成斜杠，也就是new Date("2020/09/21 11:11:00")通常为了兼容IOS的这个坑，需要做一些额外的特殊处理，笔者在开发的时候经常会忘了兼容IOS系统。所以就想试着重写Date函数，一劳永逸，避免每次ne_date.prototype 将所有 ios
文章浏览阅读5.3k次。方法一：用PLSQL Developer工具。 1 在PLSQL Developer的sql window里输入select * from test for update; 2 按F8执行 3 打开锁, 再按一下加号. 鼠标点到第一列的列头，使全列成选中状态，然后粘贴，最后commit提交即可。（前提..._excel导入pl/sql
文章浏览阅读83次。Git常用命令速查手册1、初始化仓库git init2、将文件添加到仓库git add 文件名 # 将工作区的某个文件添加到暂存区 git add -u # 添加所有被tracked文件中被修改或删除的文件信息到暂存区，不处理untracked的文件git add -A # 添加所有被tracked文件中被修改或删除的文件信息到暂存区，包括untracked的文件...
文章浏览阅读202次。分享119个ASP.NET源码总有一个是你想要的_千博二手车源码v2023 build 1120
文章浏览阅读1.8k次。版权声明：转载请注明出处 http://blog.csdn.net/irean_lau。目录(?)[+]1、缺省构造函数。2、缺省拷贝构造函数。3、 缺省析构函数。4、缺省赋值运算符。5、缺省取址运算符。6、 缺省取址运算符 const。[cpp] view plain copy_空类默认产生哪些类成员函数