leetcode1005

 func largestSumAfterKNegations(A []int, K int) int {
     sort.Ints(A)
     var negatives int
     var zeros int
     var positives int
     var negativeAry []int
     var positiveAry []int
     for n := range A {
         if A[n] <  {
             negatives++
             negativeAry = append(negativeAry, A[n])
         } else if A[n] ==  {
             zeros++
         } else {
             positives++
             positiveAry = append(positiveAry, A[n])
         }
     }
     var sum int
     if K <= negatives { //只需要把负数变正数，把最小的（绝对值大的）K个负数变正数
         for i := ; i < K; i++ {
             sum += negativeAry[i] * -
         }
         for i := K; i < negatives; i++ {
             sum += negativeAry[i]
         }
         for i := ; i < positives; i++ {
             sum += positiveAry[i]
         }
     } else { //将全部的负数都变成正数，还不够
         if zeros >  || (K-negatives)% ==  {
             //剩下的变化次数，全变0，或者反复的变偶数次同一个正数（也可以是一个已经变成正数的负数）
             for i := ; i < negatives; i++ {
                 sum += negativeAry[i] * -
             }
             for i := ; i < positives; i++ {
                 sum += positiveAry[i]
             }
         } else {
             //先把负数的绝对值累加
             for i := ; i < negatives; i++ {
                 sum += negativeAry[i] * -
             } //再把正数的绝对值累加
             for i := ; i < positives; i++ {
                 sum += positiveAry[i]
             } //判断全部已经都变成正数的数组中，绝对值最小的数字
             //将绝对值最小的这个数字，减2次
             if (negatives ==  && positives > ) || (positives >  && negatives >  && positiveAry[] <= negativeAry[negatives-]*-) {
                 sum += positiveAry[] * -
                 return sum
             }
             if (positives ==  && negatives > ) || (positives >  && negatives >  && positiveAry[] > negativeAry[negatives-]*-) {
                 sum += negativeAry[negatives-] *
                 return sum
             }
         }

     }
     return sum
 }

上面这个一定觉得很啰嗦，那就来个简单的：

 func largestSumAfterKNegations(A []int, K int) int {
     sort.Ints(A)
     i :=
     for i < len(A) && K >  && A[i] <  {
         A[i] = -A[i]
         i++
         K--
     }
     sum :=
     sort.Ints(A)
     for j := range A {
         sum += A[j]
     }
     if K >  && K% ==  {
         min := A[]
         sum -= min *
     }
     return sum
 }

思想是一样的，但是简洁了很多。而且由于没有使用新数组保存正和负数，所以空间占用更小。

第一部分代码是思维的过程，第二部分代码是提炼之后的。leetcode上面的题目，大部分都可以用20，30行就搞定。如果代码特别长，那应该是没有抓住问题的本质，这样的代码思维可能把自己绕进去，别人看不懂，甚至自己也会看迷糊。

最后，go的效率的确是棒棒的：