backstory

^{คำเตือน: อาจมีข้อมูลเกี่ยวกับจิงโจ้}

จิงโจ้สำรวจหลายขั้นตอนของการพัฒนา เมื่อพวกเขาโตขึ้นและแข็งแรงขึ้นพวกเขาสามารถกระโดดได้สูงขึ้นเรื่อย ๆ และสามารถกระโดดได้มากขึ้นก่อนที่พวกเขาจะหิว

ในระยะที่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. กำหนดแต่ละoในรูปแบบกิจกรรมของสเตจnจิงโจ้ซึ่งความสูงของมันคือตัวเลขจาก1ถึงnโดยที่1สอดคล้องกับพื้นดินและnไปยังตำแหน่งสูงสุด

2. คำนวณผลรวมของความสูงทั้งหมดในรูปแบบกิจกรรม

ตัวอย่างเช่นรูปแบบกิจกรรมของจิงโจ้ระยะที่3มีความสูงดังต่อไปนี้

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

เรามีห้า1 , แปด2และสี่สาม ; รวมเป็น5 · 1 + 8 · 2 + 4 · 3 = 33

งาน

เขียนโปรแกรมเต็มรูปแบบหรือฟังก์ชั่นที่ใช้เป็นจำนวนเต็มบวกnเป็น input และพิมพ์หรือผลตอบแทนที่ความต้องการทางโภชนาการต่อการทำงานของเวทีnจิงโจ้

นี่คือรหัสกอล์ฟ ; คำตอบสั้นที่สุดอาจเป็นไบต์ชนะ!

ตัวอย่าง

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

เยลลี่ 6 ไบต์

²’æ«’‘

ใช้สูตร ( n ² - 1) 2 ^{n - 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

แก้ไข: ขอบคุณ Dennis สำหรับการตัด 6 ไบต์!

สูตรสำหรับสร้างหมายเลขจิงโจ้คือ:

คำอธิบายของสูตร:

จำนวนของ1'ในK(n)' s 2^(n - 1) + 1ผลรวมสุดท้ายคือ

จำนวนของn'ในK(n)' s ผลรวมสุดท้ายคือ2^(n - 1)เพื่อให้ผลรวมของทั้งหมดก็คือnn * 2^(n - 1)

จำนวนจำนวนอื่น ๆ ( d) ในK(n)'ผลรวมสุดท้ายคือ2^nเพื่อให้ผลรวมของทุกคนd' s 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)

De-แข็งแรงเล่นกอล์ฟ:

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"

มันเต้นจาวาอยู่ดี

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)

Ungolfed:

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

ทับทิม 21 ไบต์

@ Qwerp-Derp โดยทั่วไปแล้วการยกของหนัก

เนื่องจากลำดับความสำคัญในทับทิมดูเหมือนว่าเราต้องการบาง parens:

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

สกาลา, 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+ ;

ลองออนไลน์