Backstory

^{Tuyên bố miễn trừ trách nhiệm: Có thể chứa thông tin tạo thành về kanguru.}

Kanguru đi qua nhiều giai đoạn phát triển. Khi chúng lớn lên và khỏe hơn, chúng có thể nhảy cao hơn và dài hơn, và chúng có thể nhảy nhiều lần hơn trước khi chúng đói.

Ở giai đoạn 1 , chuột túi rất ít và không thể nhảy được. Mặc dù vậy, liên tục đòi hỏi phải nuôi dưỡng. Chúng ta có thể đại diện cho mô hình hoạt động của kangaroo giai đoạn 1 như thế này.

o

Ở giai đoạn 2 , chuột túi có thể thực hiện những cú nhảy nhỏ, nhưng không quá 2 trước khi nó đói. Chúng ta có thể đại diện cho mô hình hoạt động của kangaroo giai đoạn 2 như thế này.

 o o
o o o

Sau giai đoạn 2 , kangaroo cải thiện nhanh chóng. Trong mỗi giai đoạn tiếp theo, kangaroo có thể nhảy cao hơn một chút (1 đơn vị trong biểu diễn đồ họa) và gấp đôi nhiều lần. Ví dụ, mô hình hoạt động của kangaroo giai đoạn 3 trông như thế này.

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

Tất cả những bước nhảy đó đòi hỏi năng lượng, vì vậy chuột túi cần được nuôi dưỡng sau khi hoàn thành từng mô hình hoạt động. Số lượng chính xác cần thiết có thể được tính như sau.

1. Chỉ định mỗi o trong mô hình hoạt động của giai đoạn n kangaroo chiều cao của nó, tức là một số từ 1 đến n , trong đó 1 tương ứng với mặt đất và n ở vị trí cao nhất.

2. Tính tổng của tất cả các độ cao trong mô hình hoạt động.

Ví dụ, mô hình hoạt động của kangaroo giai đoạn 3 bao gồm các độ cao sau.

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

Chúng tôi có năm năm 1 , tám 2 và bốn 3 ; tổng là 5 · 1 + 8 · 2 + 4 · 3 = 33 .

Bài tập

Viết một chương trình đầy đủ hoặc một chức năng mà phải mất một số nguyên dương n như là đầu vào và in hoặc trả về nhu cầu dinh dưỡng cho mỗi hoạt động của một giai đoạn n kangaroo.

Đây là môn đánh gôn ; có thể câu trả lời ngắn nhất trong byte giành chiến thắng!

Ví dụ

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

Thạch , 6 byte

²’æ«’‘

Sử dụng công thức ( n ² - 1) 2 ^{n - 1} + 1 để tính từng giá trị. @ Qwerp-Derp là đủ tốt để cung cấp một bằng chứng .

Hãy thử trực tuyến! hoặc Xác minh tất cả các trường hợp thử nghiệm.

Giải trình

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

Coffeescript, 19 byte

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

Chỉnh sửa: Cảm ơn Dennis vì đã cắt 6 byte!

Công thức để tạo số Kangaroo là:

Giải thích về công thức:

Số 1's trong K(n)' s tổng cuối cùng là 2^(n - 1) + 1.

Số n's trong K(n)' s tổng cuối cùng là 2^(n - 1), vì vậy tổng của tất cả các n's là n * 2^(n - 1).

Số của bất kỳ số nào khác ( d) trong K(n)tổng cuối cùng là 2^n, vì vậy tổng của tất cả các số dsẽ là d * 2^n.

• Do đó, tổng của tất cả các số khác = (T(n) - (n + 1)) * 2^n, trong đó T(n)là hàm số tam giác (có công thức T(n) = (n^2 + 1) / 2).

  Thay vào đó, chúng tôi nhận được số tiền cuối cùng

    (((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)
  

Khi chúng ta cộng tất cả các khoản tiền, chúng ta nhận được K(n), bằng

  (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

... bằng với công thức trên.

Java 7, 35 byte

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

Thạch , 4 byte

ŒḄ¡S

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

ŒḄ¡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 byte

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

công thức được sử dụng dặm của.

Cảm ơn Jonathan Allan cho -2 byte.

Lua, 105 byte

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)

Bỏ chơi gôn:

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)

Vấn đề giải trí!

Trên thực tế , 8 byte

;²D@D╙*u

Hãy thử trực tuyến!

Giải trình:

Điều này chỉ đơn giản là tính toán công thức (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 byte

~.2?(2@(?*)

Hãy thử trực tuyến!

Cảm ơn Martin Ender (8478) vì đã xóa 4 byte.

Giải trình:

            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 byte

ri_2#(\(m<)

Hãy thử trực tuyến.

Giải trình:

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.

Toán học, 15 byte

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

Không có toán tử bithift, vì vậy chúng ta cần thực hiện phép lũy thừa thực tế, nhưng sau đó, nó sẽ ngắn hơn để chia cho 2 thay vì giảm số mũ.

C, 26 byte

Là một vĩ mô:

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

Là một hàm (27):

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

05AB1E , 7 byte

n<¹<o*>

Hãy thử trực tuyến!

Giải trình

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

C #, 18 byte

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

Hàm ẩn danh dựa trên phân tích toán học xuất sắc của Qwerp-Derp .

Chương trình đầy đủ với các trường hợp thử nghiệm:

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
            */
        }
    }
}

Hàng loạt, 30 byte

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

Chà, dù sao nó cũng đánh bại Java.

MATL , 7 byte

UqGqW*Q

Sử dụng công thức từ các câu trả lời khác.

Hãy thử trực tuyến!

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 

Ốc đảo , 9 byte

2n<mn²<*>

Tôi ngạc nhiên không có tích hợp sẵn 2^n.

Hãy thử trực tuyến!

Giải trình:

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

Vợt 33 byte

Sử dụng công thức được giải thích bởi @ Qwerp-Derp

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

Ung dung:

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

Kiểm tra:

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

Đầu ra:

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

Ruby, 21 byte

@ Qwerp-Derp về cơ bản đã làm việc nặng.

Bởi vì sự ưu tiên trong ruby, có vẻ như chúng ta cần một số parens:

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

Scala, 23 byte

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

Sử dụng dịch chuyển bit như lũy thừa

Bình thường, 8 byte

h.<t*QQt

pyth.herokuapp.com

Giải trình:

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

R, 26 byte

Không biết xấu hổ khi áp dụng công thức

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

J , 11 byte

1-<:2&*1-*:

Dựa trên cùng một công thức được tìm thấy trước đó .

Hãy thử trực tuyến!

Giải trình

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 byte)

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

Không bảo tồn n, nhưng sử dụng cùng một công thức như tất cả những người khác trong cuộc thi này. Đã lưu 1 byte với số giảm, do dấu ngoặc đơn cần thiết.

Kiểm tra

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

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

JS-Forth, 32 byte

Không siêu ngắn, nhưng nó ngắn hơn Java. Hàm này đẩy kết quả lên ngăn xếp. Điều này đòi hỏi JS-Forth vì tôi sử dụng <<.

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

Dùng thử trực tuyến