关于一道笔试题：java数组求和

算和具体怎么实现呢？用for循环吗？望讲解，谢谢

public static int sum(int[] a, int n){
return n>0?(sum(a,n-1)+a[n]):a[n];
}
int[] a = {1,2,3,4,5,6,7,8,9};
sum(a, 8) //表示计算a[0] --- a[8]
--------------------------------------
如果考虑到n的问题，这样：
return n>0?(n>a.length-1?sum(a,n-1):sum(a,n-1)+a[n]):a[n];sum(a, 100)

jdk1.5里面，有foreach类似于.net里的，
不知道能否用得上．

如果是设n为数组的长度的话int sum(int a[], int n){
return n > 0 ? a[n-1] + sum(a, n - 1) : 0;
}思路：
长度为n的数组求和 = a[n-1] + 长度为n-1的数组求和
当长度n = 0时，数组和为0ps: a[n-1]为长度为n的数组的最大下标的元素

return n>0?(a[n-1]+sum(a,--n)):0;

还是pdvv(我爱花猫)想的全面，考虑到n>a.length的情况。
虽然估计外面调用的时候肯定是写成sum(a, a.length)，也不能排除其他情况。

对，用递归
return n>0?(sum(a,n-1)+a[n-1]):0;1。sum(a,n-1)调用函数本身实现递归
2。n是你想把数组中的几个值求和，如果小于0则返回int 0 以表示忽略执行此函数，实际功能实现中可用if判断一下，if(sum（a,n） != 0)时才做sum（a,n）操作，如：
if(sum（a,n） != 0){
sum（a,n）
}else{
throw new Exception failException("无效参数");
}

n是int型没有lenght属性吧

貌似当你去做if(sum(a,n)!= 0)时就已经作了sum(a,n)

return n>0?(a[n-1]+sum(a,--n)):0;

a[n]+sum(a,n-1):0
Thanks
Hima

嘎嘎..我把它COPY下来了...顶.顶.....

要玩花活吗？看看这个是不是更花一点？  :Dpackage test;
public class Test14 {
    public static void main(String[] args) {
        Test14 o = new Test14();
        int[] a = new int[] {1,2,3,4};
        System.out.println(o.sum(a, a.length));
    }
    int sum(int a[],int n){
        return n>0 ? (n>a.length ? Integer.MAX_VALUE : ( new Test14(){int sum(int a[],int n){int s=0; for (int i=0; i<n; i++) s+=a[i]; return s;}}.sum(a,n) )) : Integer.MIN_VALUE ;
    }
}递归虽好，也只在需要的时候再用。程序员，没事儿玩玩技巧无妨，也有助于学习，千万别走火入魔。出这种面试题，不知道想招什么样的人，误人子弟呀。

return n>0?(a[n-1]+sum(a,--n)):0; 递归

int sum(int a[],int n){ return n>0?return(a[n-1] + sum(a,n-1):0);
}

Sorry “）”错了
int sum(int a[],int n){
return n>0?return(a[n-1] + sum(a,n-1)):0;
}

pdvv(我爱花猫) ( ) ----GOod

public static void main(String[] args)
{   int[] a = {1,2,3,4,5,6,7,8,9};
ABC b=new ABC();

System.out.println(b.sum(a,8));
}

}class ABC
{
   int sum(int a[],int n)
{

    return n>0?(sum(a,n-1)+a[n]):a[n];

}
}

我没有仔细看，几乎全是错的，正解如下：
int sum(int a[],int n){ return n>0?a[n]+sum(a,n-1):a[0];
}这么简单，为什么最后的a[0]都变成0了，莫非a[0]===0（某种语言里的恒等）

原来我楼上也是正解，看到了，他写的是a[n]与a[0]一样了

java 里面数组都是会给默认值的

我觉得出题者并不是用这题来考你编码是否严谨，所以在此对容错的讨论并无意义，而这题实际应用意义也不大，我想是没有人会用这种方法对数组求和的(递归的局限性和资源占用都太大，呵呵），而出题者正是基于这点来考评受试者是否有突破常规思维的能力，再难的技术只要你去学总可能会的，而这种应变的能力确实没法学到的，这就是灵性吧。佩服wangyujunzhang和所有给出正解的朋友！

用过Lisp/Scheme的基本上每天都会这样写程序。不过现在开发界很少关注这种东西了。大家好像一提到编程语言就想到C/C++/Java/C#……这些主流的命令式语言，但这些只是计算机语言中很小的一个彼此非常相似的子集啊。

int sum(int a[],int n){ return n>0?__________sum(a,n--)+a[n-1],0________________;
}

回：china_qd()
难道真的全是错的吗？？？
int sum(int a[],int n)
这里的n应该是数组的大小吧：就像C++里面定义int a[10]里面的10一样，难道你能这样用吗？
a[10]=20;????
所以我想楼上写的这些才是正解吧
int sum(int a[],int n){ return n>0?__________sum(a,n--)+a[n-1]：0________________;
}

n是是什么无关，考虑从n开始到0 a[0]-a[n] 和能出来就就行了
这里一个式子肯定要递归处理操作，? 处理判断逻辑

回复人：MountLion(闷头睡) ( 一级(初级)) 信誉：99 2006-7-18 13:12:52 得分:0
? 这种题，当游戏玩玩可以，在项目中用的话，就是犯贱
================================================================
何止犯贱！当数组很大时，栈空间一下就不够用了

我看了一下觉得楼上的几乎都有缺陷：
1。没有考虑到n>a.length的情况，即使考虑到都没有给出有效的解决方案。
2。多数人把n<=0时的结果以0盖之，个人觉得不妥，会让人误以为数组长度<=0时，运算结果是零，这是误导，还不如索性让结果出现runtime error。其实最佳的解决方案是：
static int sum(int a[],int n)throws Exception{
return n>0?(sum(a,n-1)+a[n-1]):a[n-1];
}
主动抛出个异常，用户在调用方法时必须catch这个异常。
注意最后是a[n-1]而不是a[n](在n＝0是会出现错误结果)。但由于这是个填空题，不能修改题目部分，所以折中方案是：
static int sum(int a[],int n){
return n>0?(n>a.length?sum(a,a.length-1)+a[a.length-1]:sum(a,n-1)+a[n-1]):0；
}
这样当n>a.length时强制结果为n=a.length 而在n<=0时强制为0

哈哈,大家上当了吧,用递归效率太低,跟大家说个好的方法吧    int sum(final int a[],final int n){    return n>0? new Object(){
        public int sums(){
            int temp = 0;
            for(int i = 0;i<a.length;i++){
                temp += a[i];
            }
            return temp;
        }
    }.sums() : 0 ;写程序最忌讳的就是用递归,所以我使用匿名内不类,但它要求参数为final的,但是我们知道,在能够使用final的地方使用它是个好的习惯

接上贴,
如果这个题拿来考我,我是就这样做,如果你非要说我把int a[]和int n的前面加了一个final,不符和题意思,那么我换一个写法,先在外面写个类,然后在这里用单例模式,即调用相应的静态方法来得到一个实例,在用得到的实例调用求和的方法,反正打死我,也不用递归.

n 是什么? 数组长度?
class sum
{
public static void main(String [] args)
{

  int n;
  long sums;
int a[] = {1,2,3,4,5}; n = 3;
           sums = sum(a,n);
           System.out.println(sums);
}
static int sum(final int a[],final int n)
{    return n>0? new Object()
                          {
                            public int sum()
              {
              int sums = 0;
             for(int i = 0;i<a.length;i++)
             {
                 sums += a[i];
          }
                return sums;
  }
   }.sum() : 0 ;

}
}

TO xiaoqulai(肖曲来):同意你的观点，“递归”这东西，虽然有它的好处，但不能滥用。像给数组求和这种事情也用递归，如果数组大一点的话，岂不很快就“递归到死”了 :)不过，你好像没看到我前面的一个帖子，我给出了一个跟你类似的解决方法，也是定义了一个匿名类，不同之处在于，匿名类里的计算方法是带参数的。这就避免了你说的“把题目中的参数修改为 final”以及“用单例模式”的麻烦。我那个帖子空格里填的是：
(n>a.length ? Integer.MAX_VALUE : ( new Object(){int sum(int a[],int n){int s=0; for (int i=0; i<n; i++) s+=a[i]; return s;}}.sum(a,n) )) : Integer.MIN_VALUE

To maquan：很显然我是看了你的贴子的，所以跟你写得就不一样了，呵呵。
我第一眼看到这个题，就想到，如果不用递归的话，我只能在API中找一个提供静态方法的类（已经存在的）,但一望下看，就看到您的方法了。请原谅我再想不出别的方法了，但我又不甘心，所以我在实现匿名内部类后，有跟了一贴：
------------------------------------------------------------------
接上贴,
如果这个题拿来考我,我是就这样做,如果你非要说我把int a[]和int n的前面加了一个final,不符和题意思,那么我换一个写法,先在外面写个类,然后在这里用单例模式,即调用相应的静态方法来得到一个实例,在用得到的实例调用求和的方法,反正打死我,也不用递归.
-----------------------------------------------------------------------
不同的是，我在这个方法外面在写一个类，提供比较方法，跟你的区别是，你用了Integer类的静态方法，而我是自己写一个类，调用它的静态方法。接触JAVA还不到一个月，有什么问题大家不要骂我！
感觉CSDN上种有些人一天到晚在骂人

接上贴：
To maquan：我理解错了，不过你好象也该了题了：
int sum(int a[],int n){ return n>0?__________________________;
}你在n>0前加了个括号（n>0.....
我的虽然参数要加final，但return 是符合标准的，哈哈

看来看去，觉得Maquan才是真正的高手！佩服

多谢楼上的鼓励！ ^_^TO xiaoqulai(肖曲来):不好意思，你又看错了，我没有改题，下面的内容是 exactly 填在空格里的：
(n>a.length ? Integer.MAX_VALUE : ( new Object(){int sum(int a[],int n){int s=0; for (int i=0; i<n; i++) s+=a[i]; return s;}}.sum(a,n) )) : Integer.MIN_VALUE不过，我很喜欢你的爽快 ^O^ 握个手吧。最近看到你的帖子，总说自己学 JAVA 不久，但我发现你对一些问题理解得挺深的，由衷佩服！

int sum(int a[],int n){    return n>0?__________________________;
}
这是题目,
你添的是:
int sum(int a[],int n){    return (n>0?__________________________;//前面多了一个括号,这样我调了,不报错.
}
还是
int sum(int a[],int n){    return n>0?_(_________________________;
}我刚才又分析了你代码(分了几段,好读,呵呵),不过说实话,我不晓得n是什么意思,起什么作用,
拿你这个例子来说,假如有个树组a[1] = 1,a[2] = 2, a[3] = 3,现在我传如数组a[],n = -1,这样的这个函数好象不起作用啊~~调试程序如下:
public class test { /**
* @param args
*/
public static void main(String[] args) {
// TODO 自动生成方法存根
int a[] = new int[3];
a[0] = 1;
a[1] = 2;
a[2] = 3;
test aTest = new test();
System.out.println(aTest.sum(a,1)); }
int sum(int a[],int n){     return n>0 ? (n>a.length ? Integer.MAX_VALUE : ( new Object(){int sum(int a[],int n){int s=0; for (int i=0; i<n; i++) s+=a[i]; return s;}}.sum(a,n) )) : Integer.MIN_VALUE;
}
}输出结果为1在用我的试试:
public class test { /**
* @param args
*/
public static void main(String[] args) {
// TODO 自动生成方法存根
int a[] = new int[3];
a[0] = 1;
a[1] = 2;
a[2] = 3;
test aTest = new test();
System.out.println(aTest.sum(a,1)); }
/* int sum(int a[],int n){     return n>0 ? (n>a.length ? Integer.MAX_VALUE : ( new Object(){int sum(int a[],int n){int s=0; for (int i=0; i<n; i++) s+=a[i]; return s;}}.sum(a,n) )) : Integer.MIN_VALUE;
}*/

   int sum(final int a[],final int n){     return n>0? new Object(){
        public int sums(){
            int temp = 0;
            for(int i = 0;i<a.length;i++){
                temp += a[i];
            }
            return temp;
        }
    }.sums() : 0 ;
   }
}结果为6,是正确的,哈哈

我明白你的代码的意思啦.
额,你好强.我改进了我代码,兄弟们,最终版出来拉:
int sum(int a[],int n){     return n>0? new Object(){
        public int sums(int a[],int n){
            int temp = 0;
            for(int i = 0;i<=n; i++){
                temp += i;
            }
            return temp;
        }
    }.sums(a,n) : -1;
   }

请问maquan('ma:kju),我现在学了JAVA的IO,集合,了解了swing和线程,接下来,我该学什么啊?

maquan，不用谢，以后遇到疑难问题希望能向你请教

> 请问maquan('ma:kju),我现在学了JAVA的IO,集合,了解了swing和线程,接下来,我该学什么啊?承蒙垂询，惶恐！实在不敢妄加“指点”，恐误人子弟。说说我自己的体会吧。我觉得，“学什么”可能不太好决定，想想“做什么”也许更容易些。“学游泳都是在水里学会的”，这句话我是最近才听说的，但感觉好像说的是我多年来的体会。如果能在实际工作中参加到一个开发项目里面，实实在在做一些东西出来，回头看的时候，会发现又学会了很多东西，而且，原来以为比较清楚的东西，可能也会有更深的理解。如果工作中没有这样的机会，不妨自己给自己出一些题目，做一些 mini-project 来练练手。最简单的方法，就是在这个论坛里找找有价值的题目，然后深入做下去，这样即能帮助别人，也能提高自己。

maquan('ma:kju) ,谢谢啦，好人

调试易

关于一道笔试题：java数组求和

解决方案 »