精华内容
下载资源
问答
  • 小明种苹果续

    2020-09-14 17:43:38
    package ncu.edu.ccf; import java.util.Scanner; public class XiaoMingZhongGuoShuXu { public static void main(String[] args) { // TODO Auto-generated method stub ...//苹果最后的总数 int .
    package ncu.edu.ccf;
    
    import java.util.Scanner;
    
    public class XiaoMingZhongGuoShuXu {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		 Scanner sc=new Scanner(System.in);
    		 int N=sc.nextInt();
    		 int T=0;//苹果最后的总数
    		 int []d=new int[N+1];//记录每一棵树是否发生掉落
    		 for(int i=1;i<=N;i++) 
    		 {
    		  int m=sc.nextInt();//输入每一行的第一个数字
    		  int term =sc.nextInt();//输入每一行第二个数字,表示的是最开始的苹果个数
    		  int x;//之后的记录以及操作
    		  for(int j=1;j<m;j++) {
    		   x=sc.nextInt();
    		   if(x<=0) {
    		    term=term+x;
    		   }
    		   else {//从这起就重新记录了第i棵树的数量
    		    if(term>x) 
    		    {
    		    d[i]=1;//说明第i棵树发生了脱落 
    		    }
    		    term = x;
    		   }
    		  }
    		  T=T+term;//对所有数最后的苹果进行求和
    		 }
    		 int D=0;
    		 for(int i=1;i<=N;i++) 
    		 {
    		 if(d[i]==1) {
    		  D=D+1;//统计发生脱落的个数
    		 }
    		 }
    		 int E=0;//统计连续三棵树发生脱落的组数
    		 for(int i=1;i<=(N-2);i++) 
    		 {
    		  if(d[i]==1&&d[i+1]==1&&d[i+2]==1) 
    		  {
    		  E=E+1; 
    		  }
    		 }
    		 //连接处的两种特殊情况
    		 if(d[N-1]==1&&d[N]==1&d[1]==1) 
    		 {
    		  E=E+1;
    		 }
    		 if(d[N]==1&&d[1]==1&&d[2]==1) {
    		  E=E+1;
    		 }
    		 System.out.println(T+" "+D+" "+E);
    		}
    }
    

     

    展开全文
  • CCF 201909小明种苹果续

    2020-08-25 18:08:46
    201909-(2)小明种苹果续 #include <iostream> #define _for(i,a,b) for(int i=a;i<b;i++) using namespace std; int flag[1001]; //连续掉落flag int d[1001]; //掉落flag int main(){ int T=0,D=0,E=...

    201909-(2)小明种苹果续

    #include <iostream>
    #define _for(i,a,b)   for(int i=a;i<b;i++)
    using namespace std;
    int flag[1001];	//连续掉落flag 
    int d[1001];	//掉落flag 
    int main(){
    	int T=0,D=0,E=0;//T=苹果总和,D=掉落数,E=连续三颗苹果树掉果
    	int n,temp,a,b,c,sum=0;	//temp=临时调换,n=苹果棵树,a=操作数,b=第一个操作数,c=第二个操作数 
    	cin>>n;	
    	_for(i,0,n){
    		cin>>a>>b;
    		flag[i]=0;
    		sum=b;
    		_for(j,1,a){
    			cin>>c;			
    			if(c>0){
    				if(sum>c){
    					d[i]=1;
    					flag[i]=1;
    				}
    				sum=c;			
    			}else	sum+=c;	
    		}
    		T+=sum;
    		D+=d[i];
    	}	
    	if(flag[0]+flag[n-1]+flag[n-2]==3)E++;
    	if(flag[0]+flag[1]+flag[n-1]==3)E++;
    	_for(i,1,n){
    		if(flag[i-1]+flag[i]+flag[i+1]==3)E++;		
    	}
    	cout<<T<<" "<<D<<" "<<E;
    	return 0;
    }
    

    应该还可以更省略一点吧!

    展开全文
  • ccf 小明种苹果续

    2020-09-06 17:23:02
    小明种苹果) if __name__ == "__main__": n = int(input()) T = 0 D = 0 E = 0 flag = [0 for _ in range(n)] for i in range(n): s = list(map(int,input().split())) m = s[0] cur = s[1] for ...

    小明种苹果(续)

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    if __name__ == "__main__":
        n = int(input())
        T = 0
        D = 0
        E = 0
        flag = [0 for _ in range(n)]
        for i in range(n):
            s = list(map(int,input().split()))
            m = s[0]
            cur = s[1]
            for j in s[2:]:
                if j>0 :
                    if cur>j:
                        cur = j
                        flag[i]=1
                else:
                    cur+=j
            T+=cur
        #一棵苹果树可能发生多次掉落,如果将D写在上面的话,可能导致同一棵树被多次记录
        for i in range(len(flag)):
            if flag[i]:
                D+=1
            if flag[(i+n)%n] and flag[(i+n+1)%n] and flag[(i+n-1)%n]:
                E+=1
        print(T,D,E)
                    
    
        
    
    
    展开全文
  • CCF-CSP小明种苹果续

    2021-04-04 11:04:14
    2019-09-2小明种苹果) 题目概述】 小明种苹果)相较于第一题难度有了一定的提升,苹果树排列成了一个圆,需要考虑苹果从树上掉落的情况以及处理苹果的疏果操作。 【输入输出】 输入要严格按照题目...

    2019-09-2小明种苹果(续)

    题目概述】

       小明种苹果(续)相较于第一题难度有了一定的提升,苹果树排列成了一个圆,需要考虑苹果从树上掉落的情况以及处理苹果的疏果操作。
    
    
    
       【输入输出】
    
       输入要严格按照题目要求,注意不要输错。最后输出疏果后的剩余的苹果总数T,发生苹果意外掉落的树的棵树D,连续三个树发生苹果掉落情况的组数E。
    
    
    
       【思路】
    
       相较于第一题难度,第二题难度有了一定的提升,需要处理的难点有
    
       1. 正确处理小明重新统计苹果树的情况,并判断是否发生苹果掉落。
    
       这里可以通过比较第二次之后的mi是否大于0来判断小明是否重新统计了苹果树;判断苹果是否掉落可以与之前的疏果后的苹果总数比较,若不一致则发生苹果掉落。
    
       2. 判断连续三个树发生苹果掉落情况的组数。
    
       设置flag,记录所有苹果树发生苹果的掉落情况,然后进行类似flag1^flag2^flag3==1的操作来判断是否连续三个树发生苹果掉落,并记录组数。
    

    满分代码如下

    //注意判断循环连续的条件,每一个元素的前一个表示为(n-1+n)%n,后一个表示为(n+1+n)%n 
    #include<iostream>
    using namespace std;
    struct T//树结构体 
    {
    	int d[1000];//初始+后面的操作序列 
    	int flag=1;//有掉落为0,无掉落为1 
    	int left;//疏果理论上剩下的 
    	int cut=0;//所有疏果操作之和 
    	int left2=0;//实际算上自然掉落后剩下的 
    };
    int main()
    {
    	int n,m,a,sum=0,sum2=0;
    	int count=0;//掉落苹果个数 
    	int exsit=0;//连续三棵个数 
    	cin>>n;//n为树个数 
    	T t[n];//数组存储树结构
    	for(int i=0;i<n;i++)//大循环,每棵树是一个循环体
    	{
    		cin>>m;//m为初始+操作的个数 
    		for(int j=0;j<m;j++)//小循环,每个操作是一个循环体
    		{
    			cin>>a;
    			t[i].d[j]=a;//将操作存入数组
    		}
    		for(int k=0;k<m;k++)
    		{
    			if(t[i].d[k]<0)//判断是操作吗?
    			{
    				t[i].cut+=t[i].d[k];
    			}
    			else
    			{
    				t[i].cut+=0;//如果是统计,表明不是操作
    			}
    		}
    		t[i].left=t[i].d[0]+t[i].cut;//初始+操作=理论剩下的
    		sum+=t[i].left;//测试用,提交时可省略。看结果是否正确
    		
    		for(int l=m-1;l>=0;l--)//倒着找到最后一次统计数目,然后跳出循环
    		{
    			t[i].left2+=t[i].d[l];
    			if(t[i].d[l]>0)
    			break;
    		}
    		sum2+=t[i].left2;//实际剩下数目求和
    		if(t[i].left!=t[i].left2)
    		{
    			t[i].flag=0;
    			count++;
    		}
    	} 
    	for(int i=0;i<n;i++)
    	{
    		if (t[i].flag == 0)//有果子脱落的树,判断前后是否同样有果子脱落
    		{
    		
    			if (t[(i + 1 + n) % n].flag == 0 && t[(i - 1 + n) % n].flag == 0)
    			{
    				exsit++;
    			}
    		}
    	}
    	cout<<sum2<<" ";
    	cout<<count<<" ";
    	cout<<exsit;
    }
    

    未想通问题在于最后一个for循环为什么要单独建立一个i层循环呢?把最后一个循环写入之前的大循环里是错误的!!这个bug困扰了我很久,但是根据编程第一原则做题在于能跑出来代码就不想改了。

    展开全文
  • CCF认证 小明种苹果续

    2020-03-06 16:18:26
    小明种苹果 思路 两大坑点: 一颗苹果树可能进行多次疏果。只要当前苹果树上苹果的值大于输入的那个正数的值,就表示发生了落果。 当苹果树只有三棵时,且均有落果,则E为3,不是1。斯认为这个很不科学,就应该是1。...
  • 小明种苹果续 python

    2020-08-26 19:13:44
    #100分 """ 4 4 74 -7 -12 -5 5 73 -8 -6 59 -4 5 76 -5 -10 60 -2 5 80 -6 -15 59 0 5 4 10 0 9 0 4 10 -2 7 0 2 10 0 4 10 -3 5 0 4 10 -1 8 0 """ N=int(input()) a=[] for i in range(N): ...for i in
  • 小明种苹果) 时间限制: 1.0s 内存限制: 512.0MB 方法1: import java.util.Scanner; public class Main{ public static void main(String[] args){ Scanner in = new Scanner...
  • 思路:每一行数据单独处理,没必要将所有数据都存储起来。用flag数组统计每棵树是否有落果。判断落果方法,先将果数初始化为sum,根据输入的数x判断应该进行的操作,如果x小于等于0,进行疏果,sum-=x;...
  • csp :小明种苹果续

    2020-02-25 13:15:09
    //alldrop 掉落苹果的棵树,E 组数,all所有苹果剩余总数 cin>>n; Tree tree[n]; for(int i =0,rec1;i;i++){ cin>>m; cin>>rec1; tree[i].start = rec1; tree[i].rest = rec1;//初始剩余和一开始一样 for(int ...
  • csp认证 小明种苹果续

    2019-11-18 19:02:51
    错误原因,当一行数字里面有两次掉落,掉落苹果的树的数目就会加两次 正确代码 package csp; import java.util.Arrays; import java.util.Scanner; public class csp20190902 { public static void main...
  • 题目信息:首页 - 计算机软件能力认证考试系统 #include<stdio.h> #include<...//小明种苹果) void appleXM2(){ int n, m, i, n1; int t = 0, d = 0, e = 0, num, tmp;//剩余数 掉落树...
  • //2019-09-02-小明种苹果 //本题的大坑:同一棵树,如果疏多次果,实际上d只加1;(这个错误值 50分!) #include<bits/stdc++.h> using namespace std; int main() { int n; cin>>n; int ans[n...
  • 后来发现,D统计的是掉落苹果数的棵树,而不是苹果掉落的次数,一棵树可能掉落两次苹果,但是D只会增加1… 代码也很简单易懂,,因为本人智商并不高(误 #include<iostream> #include<string.h> using ...
  • //储存苹果个数 for ( int i = 0 ; i < n ; i ++ ) { int linenum ; cin >> linenum ; for ( int j = 0 ; j < linenum ; j ++ ) { if ( j == 0 ) cin >> apple [ i ] ; else { ...
  • = a)//苹果掉落   {  fall[i] = true;  //falls++;   solve[i] = a;  }  }  if(fall[i]== true)falls++;//错误原因:请不要再内层循环重复累加  //printf("%d",solve[i]);  sum += solve[i]; ...
  • 小明种苹果

    2020-09-04 14:23:22
    小明种苹果)第十七次CCF计算机软件能力认证第二题题目描述思路具体代码 题目描述 小明在他的果园里种了一些苹果树,这些苹果树排列成一个圆。为了保证苹果的品质,在种植过程中要进行疏果操作。为了更及时地...
  • ccf小明种苹果

    2019-12-15 10:14:59
    ccf小明种苹果) #ccf小明种苹果) n = int(input()) a, d = [], [] for i in range(n): a.append(list(map(int, input().split()))) t, p, k = 0, 0, 0 for i in range(n): a[i].append(0)...
  • ccf小明种苹果

    2019-12-12 17:55:03
    小明种苹果) 时间限制: 1.0s 内存限制: 512.0MB 问题描述: #include<iostream> #include<cstring> using namesp...
  • 201909-2 小明种苹果) 在这里插入代码片
  • 201909-2 小明种苹果) 试题编号: 201909-2 试题名称: 小明种苹果) 时间限制: 1.0s 内存限制: 512.0MB 问题描述: 思路: 和201909-1 小明种苹果第一题比较,难度没有增加很多,还是用结构体去写...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 442
精华内容 176
关键字:

小明种苹果续