求助C 语言 已知30个数，其中取20个数进行求和 的问题！ 请直接把源代码写上！

Posted 2023-04-11

已知某文件的30个数字，（用fread读取），然后取20个数字求和。要将所有求和小於某个定值（例如1）的组合打印出来（只看组合，数字间的排列顺序不同都算同一种组合）
20个数字是文件中随便20个不同的数字
还有，组合就是数学里的组合（所以不是排列），不用想太多
30个数字读到a[i]阵列

这个读取文件就不写了，给一个测试数组的代码，你按照你的具体要求改一下就行了，哪里不懂给我信息

#include<stdio.h>
#include<string.h>
#define N_L 30 //数组长度
#define MAX 120 // 某定值
#define F_L 10 //本例中取20个数，则N_L-20 = F_L

int numi[N_L]= 11,2,3,4,5,6,7,8,9,9, //测试数组，假设数组元素为正整数，其他情况则做相应改动
1,2,3,4,5,6,7,8,9,9,
1,22,23,24,25,26,27,28,29,20;

int find(int *p) //测试当前取值是否匹配，成功则输出
int i=0,sum=0;
for(i=0;i<N_L;i++)
sum+=numi[i];
if(sum>=MAX) return 0;
for(i=0;i<N_L;i++)
printf("%2d",numi[i]);
printf("=%d<%d\n\n",sum,MAX);
return 1;


int test(int *num_t,int deptemp,int site,char first)
/*递归查找，num_t为数组首地址，deptemp记录递归次数，site为数组当前位置，first标记是否第一层递归*/
int nback=0;
while(site<N_L)
if('s'==first && site>N_L-F_L) return 0; /* 第一层递归的特殊判断 */
if(num_t[site]==0) site++; continue; /* 当前位置的值已经去掉，则去掉下一个值 */
nback=num_t[site]; num_t[site]=0; /* 将当前值设为零并保存以便恢复，为零表示去掉当前位置的值 */
if(deptemp<F_L-1) test(num_t,deptemp+1,site+1,'n'); /* 去掉的个数还不到10个，继续*/
else find(num_t); /*递归到第十层，即去掉10个数，测试是否匹配 */

num_t[site]=nback; site++; /*恢复当前位置的值，以便测试其他的情况*/

return 1;

void main()
test(numi,0,0,'s') ;

参考技术A 很想帮忙 可是这个真的不太懂 就不捣乱了 参考技术B //完整的出来了
//已经调ok

//老大，组合可是很多很多哦
//还好不是排列
//但是组合中元素的值要不同，也是增加了难度
//为了减轻你的调试难度,在你没有文件的时候写一组随即数到文件
//你只要看结果就行了
//随即数范围在-99~99，要改范围，自己调下
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <conio.h>

#define Num 30 //共30个元素
#define Get 20 //取30个元素
#define Lim 1 //设置求和结果小于Lim则输出

int main()

system("mode con: cols=125 lines=32");
srand( (unsigned)time(NULL) );

int a[Num];
int b[Get];
int sum=0; //求和
int same=0; //判断是否元素的值有相同
int i,j,k;

FILE *fp;
fp=fopen( "save.bin" , "rb" );
//不存在数据文件则产生随即数
//存在数据文件则从文件读取数据
if ( fp==NULL )

for (i=0;i<Num;i++)

a[i]=rand()%200-100;


else

fread( a, 4, Num, fp );
fclose(fp);


//把随机数保存
fp=fopen( "save.bin" , "wb" );
fwrite( a, 4, Num, fp );
fclose(fp);

//开始运算:
k=0;
printf("第%d页:\n",k+1);
for ( b[0]=0; b[0]<=10; b[0]++ )
for ( b[1]=b[0]+1; b[1]<=11; b[1]++ )
for ( b[2]=b[1]+1; b[2]<=12; b[2]++ )
for ( b[3]=b[2]+1; b[3]<=13; b[3]++ )
for ( b[4]=b[3]+1; b[4]<=14; b[4]++ )
for ( b[5]=b[4]+1; b[5]<=15; b[5]++ )
for ( b[6]=b[5]+1; b[6]<=16; b[6]++ )
for ( b[7]=b[6]+1; b[7]<=17; b[7]++ )
for ( b[8]=b[7]+1; b[8]<=18; b[8]++ )
for ( b[9]=b[8]+1; b[9]<=19; b[9]++ )
for ( b[10]=b[9]+1; b[10]<=20; b[10]++ )
for ( b[11]=b[10]+1; b[11]<=21; b[11]++ )
for ( b[12]=b[11]+1; b[12]<=22; b[12]++ )
for ( b[13]=b[12]+1; b[13]<=23; b[13]++ )
for ( b[14]=b[13]+1; b[14]<=24; b[14]++ )
for ( b[15]=b[14]+1; b[15]<=25; b[15]++ )
for ( b[16]=b[15]+1; b[16]<=26; b[16]++ )
for ( b[17]=b[16]+1; b[17]<=27; b[17]++ )
for ( b[18]=b[17]+1; b[18]<=28; b[18]++ )
for ( b[19]=b[18]+1; b[19]<=29; b[19]++ )

sum=0;

for (i=0;i<Get;i++)

same=0;
for (j=0;j<i;j++)

if ( a[ b[i] ] == a[ b[j] ] ) same=1;



if ( same==0 )

for (i=0;i<Get;i++)
sum += a[ b[i] ];


if (sum<Lim)

for (i=0;i<Get;i++)

printf("(%d)+",a[ b[i] ]);

printf("\b=%d\n",sum);
k++;
if (k%30==0)

getch();
system("cls");
printf("第%d页:\n",k+1);



return 0;
参考技术C 太麻烦了...
我只编了一部分
这个题实在有点野蛮
...
#include <iostream>
#include <time.h>
using namespace std;
void main()


int array_A[]=;
int array_B[]=;
int array_C[]=;
int array_D[]=;
int array_M[]=;//初始化结果
int *p;
int i,j;
i=rand()%6;
array_M[0]=array_D[i];
do

while((i==j)||(array_D[i]+array_D[j])<4);
array_M[1]=array_D[j];
if(array_D[0]<7||array_D[1]<7)

if(array_D[0]>12||array_D[1]>12)
i=rand()%3;

switch(rand()%2)

case 0:
if(i==0) array_M[2]=array_B[2];
if(i==1) array_M[2]=array_B[3];
if(i==2) array_M[2]=array_C[1];
case 1:
if(i==0)
if(i==1)
if(i==2)

// default:
//statements ;
// break;


else if(array_D[0]<12||array_D[1]<12)

//8 10 11 12 选一个
//或8 10 11 12 选两个

else

//有12 或没有12
//与上面相同





我可以帮助你，你先设置我最佳答案后，我百度Hii教你。 参考技术D 你这个写得不是很清晰，我不太明白，你这个20个数是指前20个数字 吗？
所谓的组合是指什么？
编程，讲究的是一个思维清晰，结构严谨，所以你要是能再描绘清楚些，我就可以写给你！ 第5个回答  2010-12-03 你给我份 我帮你写完整的 要你的邮箱： 不然不想浪费太多的时间 在这上面
真的想要 就 hi我 （没钱 但有技术） 我看啦一下 我需要三四个小时就可以完成 （编译连接执行都通过） 真的想 要速度hi 我 现在hi我 最迟九点前 给你答案 抱你满意……

hi我 速度 第6个回答  2010-12-09 30个数占的内存不太大,先全读到内存里来,然后把这三十个数排下序,

P3373 模板线段树 2 区间求和 区间乘 区间加

题目描述

如题，已知一个数列，你需要进行下面两种操作：

1.将某区间每一个数加上x

2.将某区间每一个数乘上x

3.求出某区间每一个数的和

输入输出格式

输入格式：

第一行包含三个整数N、M、P，分别表示该数列数字的个数、操作的总个数和模数。

第二行包含N个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。

接下来M行每行包含3或4个整数，表示一个操作，具体如下：

操作1： 格式：1 x y k 含义：将区间[x,y]内每个数乘上k

操作2： 格式：2 x y k 含义：将区间[x,y]内每个数加上k

操作3： 格式：3 x y 含义：输出区间[x,y]内每个数的和对P取模所得的结果

输出格式：

输出包含若干行整数，即为所有操作3的结果。

输入输出样例

输入样例#1：

5 5 38
1 5 4 2 3
2 1 4 1
3 2 5
1 2 4 2
2 3 5 5
3 1 4

输出样例#1：

17
2

说明

时空限制：1000ms,128M

数据规模：

对于30%的数据：N<=8，M<=10

对于70%的数据：N<=1000，M<=10000

对于100%的数据：N<=100000，M<=100000

（数据已经过加强^_^）

样例说明：

故输出应为17、2（40 mod 38=2）

 

根据加减法原理，，

好像只能这么解释，

先放乘法标记

再放加法标记

注意查询的时候ll和rr是不变的

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<cstring>
  4 #include<cmath>
  5 #define LLI long long 
  6 using namespace std;
  7 const LLI MAXN=400001;
  8 LLI read(LLI & n)
  9 {
 10     char p=‘+‘;LLI x=0;
 11     while(p<‘0‘||p>‘9‘)
 12         p=getchar();
 13     while(p>=‘0‘&&p<=‘9‘)
 14     x=x*10+p-48,p=getchar();
 15     n=x;
 16 }
 17 LLI n,m,mod,wl,wr,wv,ans;
 18 struct node
 19 {
 20     LLI l,r,w,fc,fj;
 21 }a[MAXN];
 22 void update(LLI k)
 23 {
 24     a[k].w=(a[k<<1].w+a[k<<1|1].w)%mod;
 25 }
 26 void build_tree(LLI k,LLI ll,LLI rr)
 27 {
 28     a[k].l=ll;a[k].r=rr;
 29     a[k].fc=1;
 30     a[k].fj=0;
 31     if(a[k].l==a[k].r)
 32     {
 33         read(a[k].w);
 34         return ;
 35     }
 36     LLI mid=(ll+rr)/2;
 37     build_tree(k<<1,ll,mid);
 38     build_tree(k<<1|1,mid+1,rr);
 39     update(k);
 40 }
 41 void pushdown(LLI k,LLI ll,LLI rr,LLI mid)
 42 {
 43     a[k<<1].w*=a[k].fc;a[k<<1|1].w*=a[k].fc;
 44     a[k<<1].w+=a[k].fj*(mid-ll+1);a[k<<1|1].w+=a[k].fj*(rr-mid);
 45     a[k<<1].fc*=a[k].fc;a[k<<1|1].fc*=a[k].fc;
 46     a[k<<1].fj*=a[k].fc;a[k<<1|1].fj*=a[k].fc;
 47     a[k<<1].fj+=a[k].fj;a[k<<1|1].fj+=a[k].fj;
 48     a[k].fc=1;a[k].fj=0;
 49     a[k<<1].w%=mod;a[k<<1].fj%=mod;a[k<<1].fc%=mod;
 50     a[k<<1|1].w%=mod;a[k<<1|1].fj%=mod;a[k<<1|1].fc%=mod;
 51 }
 52 void interval_add(LLI k,LLI ll,LLI rr,LLI v)
 53 {
 54     if(a[k].l>rr||a[k].r<ll)
 55         return ;
 56     if(ll<=a[k].l&&rr>=a[k].r)
 57     {
 58         a[k].w=(a[k].w+v*(a[k].r-a[k].l+1))%mod;
 59         a[k].fj=(a[k].fj+v)%mod;
 60         return ;
 61     }
 62     LLI mid=(a[k].l+a[k].r)/2;
 63     pushdown(k,a[k].l,a[k].r,mid);
 64     //if(ll<=mid)
 65     interval_add(k<<1,ll,rr,v);
 66     //if(rr>mid)
 67     interval_add(k<<1|1,ll,rr,v);
 68     update(k);
 69 }
 70 void interval_mul(LLI k,LLI ll,LLI rr,LLI v)
 71 {
 72     if(a[k].l>rr||a[k].r<ll)
 73         return ;
 74     if(ll<=a[k].l&&rr>=a[k].r)
 75     {
 76         a[k].w*=v%mod;
 77         a[k].fc*=v%mod;
 78         a[k].fj*=v%mod;
 79         return ;
 80     }
 81     LLI mid=(a[k].l+a[k].r)/2;
 82     pushdown(k,a[k].l,a[k].r,mid);
 83     //if(ll<=mid)
 84     interval_mul(k<<1,ll,rr,v);
 85     //if(rr>mid)
 86     interval_mul(k<<1|1,ll,rr,v);
 87     update(k);
 88 }
 89 void interval_sum(LLI k,LLI ll,LLI rr)
 90 {
 91     if(a[k].l>rr||a[k].r<ll)
 92         return ;
 93     if(ll<=a[k].l&&rr>=a[k].r)
 94     {
 95         ans=(ans+a[k].w)%mod;
 96         return ;
 97     }
 98     LLI mid=(a[k].l+a[k].r)/2;
 99     pushdown(k,a[k].l,a[k].r,mid);
100     //if(ll<=mid)
101         interval_sum(k<<1,ll,rr);
102     //if(rr>mid)
103         interval_sum(k<<1|1,ll,rr);
104 }
105 int main()
106 {
107     read(n);read(m);read(mod);
108     build_tree(1,1,n);
109     for(LLI i=1;i<=m;i++)
110     {
111         LLI p;
112         read(p);
113         if(p==1)
114         {
115             read(wl);read(wr);read(wv);
116             interval_mul(1,wl,wr,wv);
117         }
118         else if(p==2)
119         {
120             read(wl);read(wr);read(wv);
121             interval_add(1,wl,wr,wv);
122         }
123         else if(p==3)
124         {
125             ans=0;
126             read(wl);read(wr);
127             interval_sum(1,wl,wr);
128             //cout<<ans%mod<<endl;
129             printf("%lld\n",ans%mod);
130         }
131     }
132     return 0;
133 }