뒷이야기

^{면책 조항 : 캥거루에 대한 정보를 포함 할 수 있습니다.}

캥거루는 여러 단계의 개발을 거칩니다. 나이가 들수록 강해지면서 점점 더 높이 올라갈 수 있으며 배가 고파지기 전에 더 많은 시간을 뛰어 넘을 수 있습니다.

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 1 , 8 2 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 바이트

²’æ«’‘

공식 ( n ^2-1 ) 2 ^{n -1} + 1을 사용하여 각 값을 계산합니다. @ Qwerp-Derp 's는 증거 를 제공 할만큼 친절했습니다 .

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오.

설명

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

커피 스크립트, 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모든의 합 있도록, ds는 것 ' 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

... 위의 공식과 같습니다.

자바 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.

파이썬 2, 25 23 바이트

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

사용 된 마일의 공식.

-2 바이트의 Jonathan Allan에게 감사합니다.

루아, 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@(?*)

온라인으로 사용해보십시오!

4 바이트를 제거해 주셔서 감사합니다. Martin Ender (8478).

설명:

            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)

루비, 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

그루비 (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+ ;

온라인으로 사용해보십시오