Historia de fondo

^{Descargo de responsabilidad: puede contener información inventada sobre canguros.}

Los canguros atraviesan varias etapas de desarrollo. A medida que crecen y se fortalecen, pueden saltar más alto y más, y pueden saltar más veces antes de tener hambre.

En la etapa 1 , el canguro es muy pequeño y no puede saltar en absoluto. A pesar de esto, constantemente requiere alimentación. Podemos representar un patrón de actividad de canguro de etapa 1 como este.

o

En la etapa 2 , el canguro puede hacer pequeños saltos, pero no más de 2 antes de que tenga hambre. Podemos representar un patrón de actividad de canguro de etapa 2 como este.

 o o
o o o

Después de la etapa 2, el canguro mejora rápidamente. En cada etapa posterior, el canguro puede saltar un poco más alto (1 unidad en la representación gráfica) y el doble de veces. Por ejemplo, el patrón de actividad de un canguro en etapa 3 se ve así.

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

Todo ese salto requiere energía, por lo que el canguro requiere alimentación después de completar cada patrón de actividad. La cantidad exacta requerida se puede calcular de la siguiente manera.

1. Asigne a cada o en el patrón de actividad de una etapa n canguro su altura, es decir, un número del 1 al n , donde 1 corresponde al suelo yn a la posición más alta.

2. Calcule la suma de todas las alturas en el patrón de actividad.

Por ejemplo, el patrón de actividad de un canguro en etapa 3 incluye las siguientes alturas.

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

Tenemos cinco 1 's, ocho 2 ' s y cuatro 3 's; la suma es 5 · 1 + 8 · 2 + 4 · 3 = 33 .

Tarea

Escriba un programa completo o una función que tome un entero positivo n como entrada e imprima o devuelva los requerimientos nutricionales por actividad de una etapa n canguro.

Este es el código de golf ; ¡que gane la respuesta más corta en bytes!

Ejemplos

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

Jalea , 6 bytes

²’æ«’‘

Utiliza la fórmula ( n ² - 1) 2 ^{n - 1} + 1 para calcular cada valor. @ Qwerp-Derp's tuvo la amabilidad de proporcionar una prueba .

Pruébalo en línea! o Verificar todos los casos de prueba.

Explicación

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

Coffeescript, 19 bytes

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

Editar: ¡Gracias a Dennis por cortar 6 bytes!

La fórmula para generar números de canguro es esta:

Explicación de la fórmula:

El número de 1's en K(n)la suma final es 2^(n - 1) + 1.

El número de n's en K(n)la suma final es 2^(n - 1), entonces la suma de todos los n' s es n * 2^(n - 1).

El número de cualquier otro número ( d) en K(n)la suma final es 2^n, entonces la suma de todos los d's sería d * 2^n.

• Por lo tanto, la suma de todos los otros números = (T(n) - (n + 1)) * 2^n, donde T(n)es la función de número de triángulo (que tiene la fórmula T(n) = (n^2 + 1) / 2).

  Sustituyendo eso, obtenemos la suma final

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

Cuando sumamos todas las sumas, obtenemos K(n), que es igual a

  (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

... que es igual a la fórmula anterior.

Java 7, 35 bytes

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

Jalea , 4 bytes

ŒḄ¡S

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

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

Fórmula de millas usadas.

Gracias a Jonathan Allan por -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)

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)

Problema entretenido!

En realidad , 8 bytes

;²D@D╙*u

Pruébalo en línea!

Explicación:

Esto simplemente calcula la fórmula (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@(?*)

Pruébalo en línea!

Gracias Martin Ender (8478) por eliminar 4 bytes.

Explicación:

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

Pruébalo en línea.

Explicación:

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&

No hay un operador de desplazamiento de bits, por lo que necesitamos hacer la exponenciación real, pero luego es más corto dividir por 2 en lugar de disminuir el exponente.

C, 26 bytes

Como una macro:

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

Como una función (27):

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

05AB1E , 7 bytes

n<¹<o*>

Pruébalo en línea!

Explicación

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

C #, 18 bytes

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

Función anónima basada en el excelente análisis matemático de Qwerp-Derp .

Programa completo con casos de prueba:

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

Lote, 30 bytes

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

Bueno, de todos modos supera a Java.

MATL , 7 bytes

UqGqW*Q

Utiliza la fórmula de otras respuestas.

Pruébalo en línea!

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 bytes

2n<mn²<*>

Me sorprende que no haya una función integrada para 2^n .

Pruébalo en línea!

Explicació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

Raqueta 33 bytes

Usando la fórmula explicada por @ Qwerp-Derp

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

Sin golf:

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

Pruebas:

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

Salida:

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

Ruby, 21 bytes

@ Qwerp-Derp básicamente hizo el trabajo pesado.

Debido a la precedencia en ruby, parece que necesitamos algunos parens:

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

Scala, 23 bytes

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

Utiliza bit shift como exponenciación

Pyth, 8 bytes

h.<t*QQt

pyth.herokuapp.com

Explicación:

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

R, 26 bytes

Aplicando descaradamente la fórmula

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

J , 11 bytes

1-<:2&*1-*:

Basado en la misma fórmula encontrada anteriormente .

Pruébalo en línea!

Explicación

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}​

No conserva n, pero usa la misma fórmula que todos los demás en esta competencia. Se guardó 1 byte con decrementos, debido al paréntesis necesario.

Prueba

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

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

JS-Forth, 32 bytes

No es muy corto, pero es más corto que Java. Esta función empuja el resultado a la pila. Esto requiere JS-Forth porque yo uso <<.

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

Pruébalo en línea