背景故事

^{免责声明：可能包含有关袋鼠的虚假信息。}

袋鼠穿越了几个发展阶段。随着年龄的增长和力量的增强，他们可以跳得更高和更长，并且在饥饿之前可以跳更多次。

在第1阶段，袋鼠很小，根本无法跳跃。尽管如此，还是不​​断需要营养。我们可以这样表示第1阶段袋鼠的活动模式。

o

在阶段2中，袋鼠可以跳一点，但饿之前不能超过2跳。我们可以代表一个阶段2这样袋鼠的活动模式。

 o o
o o o

在第2阶段之后，袋鼠会迅速改善。在随后的每个阶段，袋鼠都可以跳得更高一点（在图形表示中为1个单位），并且是原来的两倍。例如，第3阶段袋鼠的活动模式如下所示。

  o   o   o   o
 o o o o o o o o
o   o   o   o   o

所有这些跳跃都需要能量，所以袋鼠在完成每种活动模式后都需要营养。所需的确切数量可以如下计算。

1. 在阶段n袋鼠的活动模式中为每个o分配高度，即从1到n的数字，其中1对应地面，n对应最高位置。

2. 计算活动模式中所有高度的总和。

例如，阶段3袋鼠的活动模式包括以下高度。

  3   3   3   3
 2 2 2 2 2 2 2 2
1   1   1   1   1

我们有5 个 1、8个2和4个3。总和为5·1 + 8·2 + 4·3 = 33。

任务

编写一个以正整数n为输入并打印或返回阶段n袋鼠活动所需营养的完整程序或函数。

这是代码高尔夫球；以字节为单位的最短答案可能会获胜！

例子

 1 ->     1
 2 ->     7
 3 ->    33
 4 ->   121
 5 ->   385
 6 ->  1121
 7 ->  3073
 8 ->  8065
 9 -> 20481
10 -> 50689

果冻，6个字节

²’æ«’‘

使用公式（Ñ ² - 1）2 ^{ñ - 1} + 1来计算每个值。@ Qwerp-Derp的帮助足以提供证明。

在线尝试！或验证所有测试用例。

说明

²’æ«’‘  Input: n
²       Square n
 ’      Decrement
  æ«    Bit shift left by
    ’     Decrement of n
     ‘  Increment

Coffeescript，19个字节

(n)->(n*n-1<<n-1)+1

编辑：感谢丹尼斯砍掉6个字节！

生成袋鼠数的公式是这样的：

公式说明：

数1的中K(n)的最后总和2^(n - 1) + 1。

数n的中K(n)的最后总和2^(n - 1)，所以所有的总和n的是n * 2^(n - 1)。

任何其他数量（数量d上）K(n)的最后总和2^n，所以所有的的总和d的将是d * 2^n。

• 因此，所有其他数字的总和为= (T(n) - (n + 1)) * 2^n，其中T(n)三角函数（具有公式T(n) = (n^2 + 1) / 2）。

  代入，我们得到最终的总和

    (((n^2 + 1) / 2) - (n + 1)) * 2^n
  = (((n + 1) * n / 2) - (n + 1)) * 2^n
  = ((n + 1) * (n - 2) / 2) * 2^n
  = 2^(n - 1) * (n + 1) * (n - 2)
  

当我们将所有总和相加时，我们得到K(n)，等于

  (2^(n - 1) * (n + 1) * (n - 2)) + (2^(n - 1) + 1) + (n * 2^(n - 1))
= 2^(n - 1) * ((n + 1) * (n - 2) + n + 1) + 1
= 2^(n - 1) * ((n^2 - n - 2) + n + 1) + 1
= 2^(n - 1) * (n^2 - 1) + 1

...等于上述公式。

Java 7，35个字节

int c(int n){return(n*n-1<<n-1)+1;}

果冻，4 字节

ŒḄ¡S

在线尝试！或验证所有测试用例。

怎么运行的

ŒḄ¡S  Main link. Argument: n (integer)

ŒḄ    Bounce; turn the list [a, b, ..., y, z] into [a, b, ..., y, z, y, ..., b, a].
      This casts to range, so the first array to be bounced is [1, ..., n].
      For example, 3 gets mapped to [1, 2, 3, 2, 1].
  ¡   Call the preceding atom n times.
      3 -> [1, 2, 3, 2, 1]
        -> [1, 2, 3, 2, 1, 2, 3, 2, 1]
        -> [1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2, 1]
   S  Compute the sum.

Python 2中，25的23个字节

lambda x:(x*x-1<<x-1)+1

使用英里的公式。

感谢Jonathan Allan提供了-2个字节。

Lua，105个字节

s=tonumber(arg[1])e=1 for i=1,s>1 and 2^(s-1)or 0 do e=e+1 for j=2,s-1 do e=e+j*2 end e=e+s end print(e)

脱胶

stage = tonumber(arg[1])
energy = 1
for i = 1, stage > 1 and 2 ^ (stage - 1) or 0 do
    energy = energy + 1
    for j = 2, stage - 1 do
        energy = energy + j * 2
    end
    energy = energy + stage
end
print(energy)

娱乐问题！

实际上，8个字节

;²D@D╙*u

在线尝试！

说明：

这只是计算公式(n**2 - 1)*(2**(n-1)) + 1。

;²D@D╙*u
;         duplicate n
 ²        square (n**2)
  D       decrement (n**2 - 1)
   @      swap (n)
    D     decrement (n-1)
     ╙    2**(n-1)
      *   product ((n**2 - 1)*(2**(n-1)))
       u  increment ((n**2 - 1)*(2**(n-1))+1)

GolfScript，11个字节

~.2?(2@(?*)

在线尝试！

感谢Martin Ender（8478）删除了4个字节。

说明：

            Implicit input                 ["A"]
~           Eval                           [A]
 .          Duplicate                      [A A]
  2         Push 2                         [A A 2]
   ?        Power                          [A A^2]
    (       Decrement                      [A A^2-1]
     2      Push 2                         [A A^2-1 2]
      @     Rotate three top elements left [A^2-1 2 A]
       (    Decrement                      [A^2-1 2 A-1]
        ?   Power                          [A^2-1 2^(A-1)]
         *  Multiply                       [(A^2-1)*2^(A-1)]
          ) Increment                      [(A^2-1)*2^(A-1)+1]
            Implicit output                []

CJam，11个字节

ri_2#(\(m<)

在线尝试。

说明：

r           e# Get token.       ["A"]
 i          e# Integer.         [A]
  _         e# Duplicate.       [A A]
   2#       e# Square.          [A A^2]
     (      e# Decrement.       [A A^2-1]
      \     e# Swap.            [A^2-1 A]
       (    e# Decrement.       [A^2-1 A-1]
        m<  e# Left bitshift.   [(A^2-1)*2^(A-1)]
          ) e# Increment.       [(A^2-1)*2^(A-1)+1]
            e# Implicit output.

Mathematica，15个字节

(#*#-1)2^#/2+1&

没有位移位运算符，因此我们需要进行实际的幂运算，但是除以2而不是减小指数，会更短。

C，26个字节

作为宏：

#define f(x)-~(x*x-1<<~-x)

作为功​​能（27）：

f(x){return-~(x*x-1<<~-x);}

05AB1E，7个字节

n<¹<o*>

在线尝试！

说明

n<        # n^2
     *    # *
  ¹<o     # 2^(n-1)
      >   # + 1

C＃，18个字节

n=>(n*n-1<<n-1)+1;

基于Qwerp-Derp的出色数学分析的匿名函数。

带有测试用例的完整程序：

using System;

namespace KangarooSequence
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,int>f= n=>(n*n-1<<n-1)+1;

            //test cases:
            for (int i = 1; i <= 10; i++)
                Console.WriteLine(i + " -> " + f(i));
            /* will display:
            1 -> 1
            2 -> 7
            3 -> 33
            4 -> 121
            5 -> 385
            6 -> 1121
            7 -> 3073
            8 -> 8065
            9 -> 20481
            10 -> 50689
            */
        }
    }
}

批处理，30个字节

@cmd/cset/a"(%1*%1-1<<%1-1)+1"

好吧，无论如何它还是击败了Java。

MATL，7个字节

UqGqW*Q

使用其他答案中的公式。

在线尝试！

U    % Implicit input. Square
q    % Decrement by 1
G    % Push input again
q    % Decrement by 1
W    % 2 raised to that
*    % Multiply
Q    % Increment by 1. Implicit display 

绿洲，9字节

2n<mn²<*>

我很惊讶没有内置的2^n。

在线尝试！

说明：

2n<m        # 2^(n-1) (why is m exponentiation?)
    n²<     # n^2-1
       *    # (2^(n-1))*(n^2-1)
        >   # (2^(n-1))*(n^2-1)+1

拍子33字节

使用@ Qwerp-Derp解释的公式

(+(*(expt 2(- n 1))(-(* n n)1))1)

取消高尔夫：

(define (f n)
  (+ (*(expt 2
            (- n 1))
      (-(* n n)
        1))
    1))

测试：

(for/list((i(range 1 11)))(f i))

输出：

'(1 7 33 121 385 1121 3073 8065 20481 50689)

Ruby，21个字节

@ Qwerp-Derp基本上完成了繁重的工作。

由于红宝石的优先权，似乎我们需要一些赦免：

->(n){(n*n-1<<n-1)+1}

Scala，23个字节

(n:Int)=>(n*n-1<<n-1)+1

使用移位作为幂

Pyth，8个字节

h.<t*QQt

pyth.herokuapp.com

说明：

     Q   Input
      Q  Input
    *    Multiply
   t     Decrement
       t Decrement the input
 .<      Left bitshift
h        Increment

R，26个字节

无耻地运用公式

n=scan();2^(n-1)*(n^2-1)+1

J，11个字节

1-<:2&*1-*:

基于先前发现的相同公式。

在线尝试！

说明

1-<:2&*1-*:  Input: integer n
         *:  Square n
       1-    Subtract it from 1
  <:         Decrement n
    2&*      Multiply the value 1-n^2 by two n-1 times
1-           Subtract it from 1 and return

Groovy（22字节）

{(it--**2-1)*2**it+1}​

不保留n，但使用与所有其他比赛相同的公式。由于需要括号，因此以递减方式保存了1个字节。

测试

(1..10).collect{(it--**2-1)*2**it+1}​

[1，7，33，121，385，1121，3073，8065，20481，50689]

JS-Forth，32个字节

不是超级短，但是比Java短。此函数将结果压入堆栈。这需要JS-Forth，因为我使用<<。

: f dup dup * 1- over 1- << 1+ ;

在线尝试