Hintergrundgeschichte

^{Haftungsausschluss: Kann erfundene Informationen über Kängurus enthalten.}

Kängurus durchlaufen mehrere Entwicklungsstufen. Je älter und stärker sie werden, desto höher und länger können sie springen, und desto öfter können sie springen, bevor sie hungrig werden.

In Stufe 1 ist das Känguru sehr klein und kann überhaupt nicht springen. Trotzdem bedarf es ständig der Ernährung. Wir können das Aktivitätsmuster eines Kängurus der Stufe 1 so darstellen.

o

In Stufe 2 kann das Känguru kleine Sprünge machen, aber nicht mehr als 2, bevor es hungrig wird. Wir können das Aktivitätsmuster eines Kängurus der Stufe 2 so darstellen.

 o o
o o o

Nach Stufe 2 bessert sich das Känguru schnell. In jeder weiteren Phase kann das Känguru etwas höher (1 Einheit in der grafischen Darstellung) und doppelt so oft springen. Das Aktivitätsmuster eines Kängurus der Stufe 3 sieht beispielsweise so aus.

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

All das Springen erfordert Energie, so dass das Känguru nach Abschluss jedes Aktivitätsmusters Nahrung benötigt. Der genaue Betrag kann wie folgt berechnet werden.

1. Ordnen Sie jedem o im Aktivitätsmuster eines Stage n- Kängurus seine Höhe zu, dh eine Zahl von 1 bis n , wobei 1 dem Boden und n der höchsten Position entspricht.

2. Berechnen Sie die Summe aller Höhen im Aktivitätsmuster.

Zum Beispiel umfasst das Aktivitätsmuster eines Kängurus der Stufe 3 die folgenden Höhen.

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

Wir haben fünf 1 's, acht 2 ' s und vier 3 ‚s; die Summe ist 5 · 1 + 8 · 2 + 4 · 3 = 33 .

Aufgabe

Schreiben Sie ein vollständiges Programm oder eine Funktion, die eine positive ganze Zahl n als Eingabe verwendet und den Nährstoffbedarf pro Aktivität eines Stufe- n- Kängurus ausgibt oder zurückgibt .

Das ist Code-Golf ; möge die kürzeste Antwort in Bytes gewinnen!

Beispiele

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

Gelee , 6 Bytes

²’æ«’‘

Verwendet die Formel ( n ² - 1) 2 ^{n - 1} + 1, um jeden Wert zu berechnen. @ Qwerp-Derp's war so freundlich, einen Beweis zu erbringen .

Probieren Sie es online! oder Überprüfen Sie alle Testfälle.

Erläuterung

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

Kaffeeskript, 19 Bytes

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

Edit: Danke an Dennis für das Abhacken von 6 Bytes!

Die Formel zum Generieren von Känguru-Zahlen lautet:

Erklärung der Formel:

Die Anzahl von 1's in K(n)' s Endsumme ist 2^(n - 1) + 1.

Die Anzahl der n's in K(n)der Endsumme ist 2^(n - 1), also ist die Summe aller n' s n * 2^(n - 1).

Die Zahl jeder anderen Zahl ( d) in K(n)der Endsumme ist 2^n, also die Summe aller dwürde sein d * 2^n.

• Somit ist die Summe aller anderen Zahlen = (T(n) - (n + 1)) * 2^n, wobei T(n)das Dreieck die Zahlenfunktion ist (welche die Formel hat T(n) = (n^2 + 1) / 2).

  Ersetzen wir dies, erhalten wir die endgültige Summe

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

Wenn wir alle Summen addieren, erhalten wir K(n), was gleich ist

  (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

... was der obigen Formel entspricht.

Java 7, 35 Bytes

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

Gelee , 4 Bytes

ŒḄ¡S

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

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

Verwendete Meilenformel.

Vielen Dank an Jonathan Allan für -2 Bytes.

Lua, 105 Bytes

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)

Entgolft:

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)

Unterhaltsames Problem!

Eigentlich 8 Bytes

;²D@D╙*u

Probieren Sie es online!

Erläuterung:

Dies berechnet einfach die Formel (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 Bytes

~.2?(2@(?*)

Probieren Sie es online!

Vielen Dank an Martin Ender (8478) für das Entfernen von 4 Bytes.

Erläuterung:

            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 Bytes

ri_2#(\(m<)

Probieren Sie es online.

Erläuterung:

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 Bytes

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

Da es keinen Bitverschiebungsoperator gibt, müssen wir die tatsächliche Exponentiation durchführen, aber dann ist es kürzer, durch 2 zu teilen, anstatt den Exponenten zu dekrementieren.

C 26 Bytes

Als Makro:

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

Als eine Funktion (27):

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

05AB1E , 7 Bytes

n<¹<o*>

Probieren Sie es online!

Erläuterung

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

C #, 18 Bytes

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

Anonyme Funktion basierend auf der hervorragenden mathematischen Analyse von Qwerp-Derp .

Volles Programm mit Testfällen:

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

Batch, 30 Bytes

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

Nun, es schlägt Java sowieso.

MATL , 7 Bytes

UqGqW*Q

Verwendet die Formel aus anderen Antworten.

Probieren Sie es online!

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 

Oase , 9 Bytes

2n<mn²<*>

Ich bin überrascht, dass es kein eingebautes für gibt 2^n.

Probieren Sie es online!

Erläuterung:

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

Schläger 33 Bytes

Mit der von @ Qwerp-Derp erläuterten Formel

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

Ungolfed:

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

Testen:

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

Ausgabe:

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

Ruby, 21 Bytes

@ Qwerp-Derp hat im Grunde das schwere Heben gemacht.

Aufgrund des Vorrangs von Ruby brauchen wir anscheinend einige Parens:

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

Scala, 23 Bytes

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

Verwendet Bitverschiebung als Potenzierung

Pyth, 8 Bytes

h.<t*QQt

pyth.herokuapp.com

Erläuterung:

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

R, 26 Bytes

Schamlos die Formel anwenden

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

J , 11 Bytes

1-<:2&*1-*:

Basierend auf der gleichen Formel wie zuvor .

Probieren Sie es online!

Erläuterung

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

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

Bewahrt nicht n, sondern verwendet die gleiche Formel wie alle anderen in diesem Wettbewerb. 1 Byte mit Dekrementen aufgrund erforderlicher Klammern gespeichert.

Prüfung

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

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

JS-Forth, 32 Bytes

Nicht sehr kurz, aber kürzer als Java. Diese Funktion schiebt das Ergebnis auf den Stapel. Dies erfordert JS-Forth, weil ich benutze <<.

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

Probieren Sie es online aus