化简n分之n-1+n分之n-2+n分之n-3+.+n分之1
昂嗖郖弑篽
(n-1)/n=1-1/n各项都可以这么化那么S=(n-1)/n+(n-2)/n+(n-3)/n+……[n-(n-1)]/n=(1-1/n)+(1-2/n)+(1-3/n)+……+[1-(n-1)/n]=(n-1)*1-[1+2+3+……+(n-1)]/n=(n-1)-[1+(n-1)]*(n-1)/2n=(n-1)-(n-1)/2=(n-1)/2
为您推荐：
其他类似问题
先化简上面的分子:1+2+…+(n-2)+(n-1)=n(n-1)/2分母是n 那么结果就是n-1(至于1+2+…+(n-2)+(n-1)的算法,是数列公式.令A=
+…+(n-2)+(n-1)则A=(n-1)+(n-2)+…+
1这样左边两个A相加是2A,右边相加后得到(n-1)个n即2A=n(n-1) A=n(n-1)/2)
和=n分之(（ n-2)n-(1+2+……+(n-1)))=（n-1)-(n-1)/2=(n-1)/21+2+……+(n-1)=(1+n-1)(n-1)/2
不就是（n-1)/n+(n-2)/n+............+2/n +1/n=
+........+2/n
+.....(n-2)/n
+________________________________...
扫描下载二维码今天从朋友那听说了一道Google的面试题：拿来讨论一下
题目：长度为n的整数数组，找出其中任意(n-1)个乘积最大的那一组，只能用乘法，不可 以用除法。要求对算法的时间复杂度和空间复杂度作出分析，可以写思路也可以写程序。
<dd style="float:cursor:" title="声誉值：
该问题被发起重新开启投票
投票剩余时间：
之前被关闭原因：
该问题被发起删除投票
投票剩余时间：
距离悬赏到期还有：
参与关闭投票者：
关闭原因：
该问题已经被锁定
锁定原因：（）
保护原因：避免来自新用户不合宜或无意义的致谢、跟帖答案。
该问题已成功删除，仅对您可见，其他人不能够查看。
这个问题在网上的讨论已经很多了，比如
但是总的来说，讨论的结果是仁者见仁。之前在&&编程之美&&上看到过这个题目的解法，由于格式问题，粘贴不便，截图分享下：
<dd style="float:cursor:" title="声誉值：
写了个java版的，大致能出结果，不知道有没有bug.
package com.public class Max {
public int symbol = 1;//结果的最终符号
public int minimunP//最小的正数
public int maxNegative = 0;//最大的负数
private boolean zeroFlag =//是否遇到0
//返回应该去掉的那个数
public int calculate(int[] input) {
System.out.println("Calculating!");
this.minimunPositive = input[0];
this.maxNegative = 0;
for(int i = 0; i & input. i++)
if(input[i] & 0)
//最大負數初始化
if(this.maxNegative == 0)
this.maxNegative = input[i];
//如果小于0，改变符号
this.symbol *= -1;
//如果小于0，且大于当前的最大负数，则把当前值赋给最大负数
if(input[i] & this.maxNegative)
this.maxNegative = input[i];
if(input[i] == 0)
this.zeroFlag =
//如果当前值大于0，且小于最小正数，则将该值赋给最小正数
if(input[i] & 0)
if(input[i] & this.minimunPositive)
this.minimunPositive = input[i];
//如果結果符號位負數
if(this.symbol == -1)
if(this.zeroFlag)
return this.maxN
//如果結果符號位正
if(this.symbol == 1)
if(this.zeroFlag)
return this.minimunP
public static void main(String[] args)
Max max = new Max();
int[] input = {1,2,3,4,5,1,1,90, 6,7,8};
System.out.println("Result:" + max.calculate(input));
System.out.println("Symbol" + max.symbol);
System.out.println("Max Negative:" + max.maxNegative);
System.out.println("Min Positive:" + max.minimunPositive);
时间空间复杂度都为O(n)s1[i]：从前往后遍历到i位置的乘积(0&=i&n)s2[j]：从后往前遍历到j位置的乘积(0&=j&n)最后遍历一遍找出s1[k+1]*s2[k-1]的最小值(0&k&n-1),讲结果与s1[1]和s2[n-2]比较大小，最大的那个即为最大值。
提供一个O（N）的解决方案，大家一起来看看。
分析：由于序列中是n个正数，要求n-1个的乘积最大值，那么找出一个合适的值，剩下的就是乘积最大的序列。
下面的各种情况代编号的是基本情况，【case】是基本情况的合并。
【case 1， 全部是正数】1、全部是正数：
Action：找出最小正数；
【case 2-1，含0，负数个数为偶数】2、正数、0：找出0；4、负数、0：6、正数、负数、0
Action：负数的个数为偶数，所有负数乘积是正的，找到0，剩余的结果为正（或为0，原来有多个0）；
【case 2-2， 含0，负数个数为奇数】4、负数、0：6、正数、负数、0：
Action：负数的个数为奇数，所有负数乘积是负的，去掉任一个负数（第一个就OK），结果为0；
【case3-1，不含0，负数个数为奇数】3、全部是负数：5、正数、负数：
负数的个数为奇数，所有负数乘积是负的，找到最大的负数（绝对值最小），剩下的负负得正，绝对值相对大；
【case3-1，不含0，负数个数为偶数】3、全部是负数：5、正数、负数：
负数的个数为偶数，所有负数乘积是正的，找到最小的负数（绝对值最大），剩下的负数乘积为负，绝对值相对小；
因此，针对该序列：第一步，需要获得一下这些值，1、判断是否全是正数；2、判断序列中是否含有0，如果有，还有其位置；3、获得序列中负数的个数；4、获得序列中的最小正数及其位置；5、获得序列中的最大负数和最小负数及其位置；
第二步，根据上面的分析结果，和第一步得出的值确定，要删除的位置；第三步，在数组中删除那个位置数据，并返回数组。
int[] max_projuct_array(int a[], int n) {
// 1, get features of the array
bool isAllPositive =
int posMin = 0;
int posMinPos = -1;
bool hasZero =
int firstZeroPos = -1;
int negCount = 0;
int firstNegPos = -1;
int negMin
int negMinPos = -1;
int negMax = 0;
int negMaxPos = -1;
int theRemovedPos = -1;
for (int i=0; i&n; ++i) {
if (a[i] == 0 && !hasZero) {
firstZero =
} else if (a[i] & 0) {
if (negCount == 1) {firstNeg =}
if (a[i] & negMin) {negMin = a[i]; negMinPos =}
if (a[i] & negMax || negMax == 0) {negMax = a[i]; negMaxPos =}
if (a[i] & posMin || posMin == 0) {posMin = a[i]; posMinPos =}
if (!hasZero && negCount == 0)
isAllPositive =
// 2, find the elimated element according to the features
if (isAllPositive) {
theRemovedPos = posMinP
} else if (hasZero) {
if ((negCount&1) == 1)
theRemovedPos = firstNegP
theRemovedPos = firstZeroP
if ((negCount&1) == 1)
theRemovedPos = negMaxP
theRemovedPos = negMinP
// 3, remove the
for (i=theRemovedP i&n; ++i)
a[i] = a[i+1];}
不是您所需，查看更多相关问题与答案
德问是一个专业的编程问答社区，请
后再提交答案
关注该问题的人
共被浏览 (3902) 次}