Backstory

^{Avis de non-responsabilité: peut contenir des informations sur les kangourous.}

Les kangourous traversent plusieurs stades de développement. À mesure qu'ils vieillissent et deviennent plus forts, ils peuvent sauter plus haut et plus longtemps, et ils peuvent sauter plus de fois avant d'avoir faim.

Dans l'étape 1 , le kangourou est très petit et ne peut pas sauter du tout. Malgré cela, il a constamment besoin de nourriture. Nous pouvons représenter un modèle d'activité de kangourou de stade 1 comme celui-ci.

o

Au stade 2 , le kangourou peut faire de petits sauts, mais pas plus de 2 avant d'avoir faim. Nous pouvons représenter un modèle d'activité de kangourou de stade 2 comme celui-ci.

 o o
o o o

Après l'étape 2, le kangourou s'améliore rapidement. À chaque étape suivante, le kangourou peut sauter un peu plus haut (1 unité dans la représentation graphique) et deux fois plus de fois. Par exemple, le schéma d'activité d' un kangourou de stade 3 ressemble à ceci.

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

Tout ce saut nécessite de l'énergie, donc le kangourou a besoin de nourriture après avoir terminé chaque modèle d'activité. Le montant exact requis peut être calculé comme suit.

1. Attribuez à chaque o dans le modèle d'activité d'un stade n kangourou sa hauteur, c'est-à-dire un nombre de 1 à n , où 1 correspond au sol et n à la position la plus élevée.

2. Calculez la somme de toutes les hauteurs dans le modèle d'activité.

Par exemple, le modèle d'activité d' un kangourou de stade 3 comprend les hauteurs suivantes.

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

Nous avons cinq 1 , huit 2 et quatre 3 ; la somme est 5 · 1 + 8 · 2 + 4 · 3 = 33 .

Tâche

Écrivez un programme complet ou une fonction qui prend un entier positif n comme entrée et imprime ou renvoie les besoins nutritionnels par activité d'un kangourou de stade n .

C'est du golf de code ; que la réponse la plus courte en octets gagne!

Exemples

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

Gelée , 6 octets

²’æ«’‘

Utilise la formule ( n ² - 1) 2 ^{n - 1} + 1 pour calculer chaque valeur. @ Qwerp-Derp a eu la gentillesse de fournir une preuve .

Essayez-le en ligne! ou Vérifiez tous les cas de test.

Explication

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

Coffeescript, 19 octets

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

Edit: Merci à Dennis d'avoir coupé 6 octets!

La formule pour générer des nombres Kangourou est la suivante:

Explication de la formule:

Le nombre de 1s dans K(n)la somme finale est de 2^(n - 1) + 1.

Le nombre de ns dans K(n)la somme finale est 2^(n - 1), donc la somme de tous les ns est n * 2^(n - 1).

Le nombre de tout autre nombre ( d) dans K(n)la somme finale de est 2^n, donc la somme de tous les dserait d * 2^n.

• Ainsi, la somme de tous les autres nombres = (T(n) - (n + 1)) * 2^n, où T(n)est la fonction numérique triangulaire (qui a la formule T(n) = (n^2 + 1) / 2).

  En remplaçant cela en, nous obtenons la somme finale

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

Lorsque nous additionnons toutes les sommes, nous obtenons K(n), ce qui équivaut à

  (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

... qui est égal à la formule ci-dessus.

Java 7, 35 octets

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

Gelée , 4 octets

ŒḄ¡S

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça marche

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

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

Formule de miles utilisée.

Merci à Jonathan Allan pour -2 octets.

Lua, 105 octets

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-golfé:

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)

Problème divertissant!

En fait , 8 octets

;²D@D╙*u

Essayez-le en ligne!

Explication:

Cela calcule simplement la formule (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 octets

~.2?(2@(?*)

Essayez-le en ligne!

Merci à Martin Ender (8478) d'avoir supprimé 4 octets.

Explication:

            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 octets

ri_2#(\(m<)

Essayez-le en ligne.

Explication:

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 octets

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

Il n'y a pas d'opérateur de décalage de bits, nous devons donc faire l'exponentiation réelle, mais il est ensuite plus court de diviser par 2 au lieu de décrémenter l'exposant.

C, 26 octets

En macro:

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

En fonction (27):

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

05AB1E , 7 octets

n<¹<o*>

Essayez-le en ligne!

Explication

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

C #, 18 octets

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

Fonction anonyme basée sur l' excellente analyse mathématique de Qwerp-Derp .

Programme complet avec cas de test:

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

Lot, 30 octets

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

Eh bien, il bat de toute façon Java.

MATL , 7 octets

UqGqW*Q

Utilise la formule des autres réponses.

Essayez-le en ligne!

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 

Oasis , 9 octets

2n<mn²<*>

Je suis surpris qu'il n'y ait pas de fonction intégrée pour 2^n .

Essayez-le en ligne!

Explication:

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

Raquette 33 octets

Utilisation de la formule expliquée par @ Qwerp-Derp

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

Non golfé:

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

Essai:

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

Sortie:

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

Rubis, 21 octets

@ Qwerp-Derp a essentiellement fait le gros du travail.

En raison de la priorité en rubis, il semble que nous ayons besoin de quelques parens:

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

Scala, 23 octets

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

Utilise le décalage de bits comme exponentiation

Pyth, 8 octets

h.<t*QQt

pyth.herokuapp.com

Explication:

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

R, 26 octets

Appliquer sans vergogne la formule

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

J , 11 octets

1-<:2&*1-*:

Basé sur la même formule que celle trouvée précédemment .

Essayez-le en ligne!

Explication

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

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

Ne conserve pas n, mais utilise la même formule que toutes les autres dans cette compétition. 1 octet enregistré avec des décréments, en raison de parenthèses nécessaires.

Tester

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

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

JS-Forth, 32 octets

Pas super court, mais c'est plus court que Java. Cette fonction pousse le résultat sur la pile. Cela nécessite JS-Forth car j'utilise <<.

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

Essayez-le en ligne