Una leyenda india cuenta la historia del supuesto inventor del juego de ajedrez, que impresionó tanto al emperador de la India con su juego que sería recompensado con todo lo que se le pidiera.

El hombre dijo que quería que le pagaran en arroz. Quería un grano de arroz para el primer cuadro del tablero de ajedrez, dos para el segundo, cuatro para el tercero, ocho para el cuarto, y así sucesivamente, hasta el cuadrado 64.

El emperador se sorprendió de que el hombre pidiera una recompensa tan pequeña, pero a medida que sus matemáticos comenzaron a contar, terminó perdiendo una de sus provincias.

Tarea

Dada la longitud del lado de un tablero de ajedrez hipotético (que es 8 en un tablero de ajedrez predeterminado) y el multiplicador entre cuadrados (que es 2 en la leyenda), calcule la cantidad de granos de arroz que el emperador debe pagar al hombre.

Notas

• La longitud del lado siempre será un número entero positivo. El multiplicador podría ser cualquier tipo de número racional.

• Si su idioma de elección no puede mostrar números muy grandes, está bien siempre que su programa pueda procesar correctamente entradas más pequeñas.

• Además, si su idioma de elección redondea valores más grandes (con anotaciones exponenciales), está bien si esos valores son aproximadamente correctos.

Casos de prueba

Input (side length, multiplier) => Output
8, 2                            => 18446744073709551615
3, 6                            => 2015539
7, 1.5                          => 850161998.2854
5, -3                           => 211822152361
256, 1                          => 65536
2, 2                            => 15
2, -2                           => -5

Tenga en cuenta que la fórmula explícita

result = (multiplier ^ (side ^ 2) - 1) / (multiplier - 1)

Realiza mal en multiplier = 1, como

1 ^ (side ^ 2) - 1 = 0
1 - 1 = 0
0 / 0 != side ^ 2 (as it should be)

Tanteo

Este es el código de golf. La respuesta más corta en bytes gana.

Jalea , 4 bytes

²b1ḅ

Esto utiliza el enfoque de la inteligente respuesta APL de @ APLDude .

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

Cómo funciona

²b1ḅ  Main link. Arguments: x (side length), y (multiplier)

²     Square; yield x².
 b1   Convert to base 1 (unary), yielding a list of x² ones.
   ḅ  Convert from base y to real number.
      This yields y^(x²-1) + ... + y + 1.

MATL , 6 bytes

2^:q^s

Pruébalo en línea!

2^   % Take implicit input, say N, and square it: N^2
:q   % Generate array [0 1 ... N^2-1]
^    % Take implicit input, M, and compute [M^0 M^1 ... M^(N^2-1)]
s    % Sum of the array. Implicit display

APL, 10 bytes

⎕⊥1+0×⍳⎕*2

⎕se usa para leer la entrada del usuario dos veces. Si almacenamos la longitud del lado en sy el multiplicador en m , obtenemos el siguiente código.

m⊥1+0×⍳s*2

Y así es como APL analiza este código:

Python, 40 bytes

lambda n,m:eval('1+m*('*n*n+'0'+')'*n*n)

Genera y evalúa una cadena como

1+m*(1+m*(1+m*(1+m*(0))))

que codifica la suma como un polinomio Hornerizado con n*ntérminos.

Muchos métodos diferentes dieron recuentos de bytes muy similares:

#String evaluation
lambda n,m:eval('1+m*('*n*n+'0'+')'*n*n)   #40

#Direct summation
lambda n,m:sum(m**i for i in range(n*n))   #40
lambda n,m:sum(map(m.__pow__,range(n*n)))  #41

#Direct formula
lambda n,m:n*n*(1==m)or(m**n**2-1)/(m-1)   #40

#Iterative sequence
f=lambda n,m,j=0:j<n*n and 1+m*f(n,m,j+1)  #41
def f(n,m):s=0;exec"s=s*m+1;"*n*n;print s  #41

#Recursive expression
#Fails due to float imprecision of square root
f=lambda n,m:n and 1+m*f((n*n-1)**.5,m)    #39*

Pyth, 6 bytes

1 byte guardado gracias a @FryAmTheEggman .

s^Lvz*

Pruébalo en línea!

Banco de pruebas.

Haskell, 25 bytes

n%m=sum$(m^)<$>[0..n*n-1]

Suma la lista [m^0, m^1, ..., m^(n*n-1)].

JavaScript (ES2016 / ES7), 31 29 28 bytes

a=>b=>(b**(a*a)-1)/--b||a*a

Solo la versión ES6 de @Bassdrop Cumberwubwubwub y @ Kaizo, pero con operador de exponenciación. :) (No tenía suficiente reputación para comentar en su lugar).

Editar: /+(b-1)cambiado a /--b(gracias @Neil).

Editar: ahora usa curry (gracias @MamaFunRoll).

Jalea, 6 bytes

²R’*@S

Pruébalo en línea!

MATLAB, 23 bytes

@(n,k)sum(k.^(0:n^2-1))

¡Pruébalo aquí !

Javascript ES6, 59 37 35 34 bytes

a=>b=>(Math.pow(b,a*a)-1)/--b||a*a` 

¡Gracias a @Kaizo por reducir 19 bytes, @Neil por otros 2 y @gcampbell por 1 más!

Pruébalo aquí

f=
a=>b=>(Math.pow(b,a*a)-1)/--b||a*a

a.innerHTML='<pre>'+
  [[8,2],
   [3,6],
   [7,1.5],
   [5,-3],
   [256,1],
   [2,2],
   [2,-2]].map(b=>`${b[0]}, ${b[1]} => ${f(b[0])(b[1])}`).join('<br>')+'</pre>'

<div id=a>

Versiones rotas alternativas

32 bytes

(a,b)=>(Math.pow(b,a*a)-1)/(b-1)

Causas NaNpara b==1.

30 bytes

(a,b)=>(Math.pow(b,a*a)-1)/~-b

Causas Infinitypara b==1.5.

28 bytes

(a,b)=>~-Math.pow(b,a*a)/~-b

Salidas 1para algunos casos de prueba válidos.

Versión anterior para 59 bytes

(a,b)=>Array(a*a).fill``.reduce((c,d,i)=>c+Math.pow(b,i),0)

Java, 132 bytes

import java.math.*;Object e(int n,BigDecimal m){BigDecimal r=BigDecimal.ONE,a=r;for(n*=n;n>1;n--)r=r.add(a=a.multiply(m));return r;}

Sin golf

import java.math.*;

Object e(int n, BigDecimal m) {
    BigDecimal r = BigDecimal.ONE, a = r;
    for (n *= n; n > 1; n--)
        r = r.add(a = a.multiply(m));
    return r;
}

Notas

• Esto funcionará para salidas arbitrariamente grandes como lo requiere OP (Lástima que Java admita números grandes, de lo contrario sería más corto).

Salidas

Input:      8 2.0
Expected:   18446744073709551615
Actual:     18446744073709551615

Input:      3 6.0
Expected:   2015539
Actual:     2015539

Input:      7 1.5
Expected:   850161998.2854
Actual:     850161998.285399449204543742553141782991588115692138671875

Input:      5 -3.0
Expected:   211822152361
Actual:     211822152361

Input:      256 1.0
Expected:   65536
Actual:     65536

Input:      2 2.0
Expected:   15
Actual:     15

Input:      2 -2.0
Expected:   -5
Actual:     -5

Input:      263 359.9
Expected:   ?
Actual:     9709...[176798 digits]...7344.7184...[69160 digits]...6291

R, 18 bytes

sum(m^(1:s^2-1))

Explicación:

sum(               # Calculate sum
    m              # Multiplier
     ^             # Exponentiate
      (1:s^2-1))   # Generate sequence from 1 to s(ide)^2-1

05AB1E , 5 bytes

Código:

nL<mO

Explicación:

n      # Compute i ** 2
 L     # Push the list [1, ..., i ** 2]
  <    # Decrement by 1, [0, ..., i ** 2 - 1]
   m   # Power function with implicit input, [0 ** j, ..., (i ** 2 - 1) ** j]
    O  # Sum that all up

Pruébalo en línea! .

Haskell, 30 bytes

n#m=sum$take(n^2)$iterate(*m)1

o igualmente largo

n%1=n^2
n%m=(m**(n*n)-1)/(m-1)

La primera versión comienza con 1multiplicaciones repetidas con m. Luego suma los primeros n^2números de esta secuencia. La segunda versión es la fórmula explícita como se ve en otras respuestas.

J, 10 bytes

+/@:^i.@*:

Uso

Marco algunos enteros con el xsufijo para usar enteros extendidos para obtener resultados exactos.

   f =: +/@:^i.@*:
   2x f 8
18446744073709551615
   3x f 6
75047317648499560
   6x f 3
2015539
   1.5 f 7
8.50162e8
   _3x f 5
211822152361
   1 f 256
65536
   2 f 2
15
   _2 f 2
_5

Explicación

+/@:^i.@*:
        *:  Square the value s to get s^2
     i.@    Make a range from 0 to s^2 exclusive, [0, 1, ..., s^2-1]
    ^       Using m as the base, calculate the power with the range
            [m^0, m^1, ..., m^(s^2-1)]
+/@:        Sum the entire list and return it

Mathcad, [tbd] bytes (~ 11)

Utiliza el operador de suma incorporado de Mathcad. También demuestra la simplificación simbólica del procesador para generar la fórmula exacta.

Mathcad ejecuta efectivamente dos motores de procesamiento en paralelo: uno un punto flotante estándar IEEE de 64/80 bits y el otro un proceso simbólico de longitud de número arbitrario (MuPad). La evaluación numérica estándar se indica con el signo igual (=), mientras que una flecha hacia la derecha indica evaluación simbólica.

El esquema de recuento de Mathcad aún no se ha determinado, por lo que no se proporciona el recuento de bytes.

ctl- $ ingresa el operador de suma (Sigma), incluidos los marcadores de posición vacíos para colocar la variable de suma, el valor inicial, el valor final y la expresión. Recuento aproximado de bytes equivalentes = 11.

PostgreSQL, 67 66 bytes

SELECT SUM(m^v)FROM(VALUES(3,6))t(s,m),generate_series(0,s*s-1)s(v)

SqlFiddleDemo

Entrada: VALUES(side, multiplier)

EDITAR:

La entrada se movió a la tabla, todos los casos a la vez:

SELECT s,m,SUM(m^v)FROM i,generate_series(0,s*s-1)s(v)GROUP BY s,m

SqlFiddleDemo

Salida:

╔══════╦══════╦══════════════════════╗
║  s   ║  m   ║         sum          ║
╠══════╬══════╬══════════════════════╣
║   7  ║ 1.5  ║ 850161998.2853994    ║
║   2  ║ 2    ║ 15                   ║
║   2  ║ -2   ║ -5                   ║
║ 256  ║ 1    ║ 65536                ║
║   5  ║ -3   ║ 211822152361         ║
║   8  ║ 2    ║ 18446744073709552000 ║
║   3  ║ 6    ║ 2015539              ║
╚══════╩══════╩══════════════════════╝

TI-Basic, 19 bytes

Ses la longitud del lado y Mes el multiplicador.

Prompt S,M:Σ(M^I,I,0,S²-1

Python, 40 bytes

lambda l,m:sum(m**i for i in range(l*l))

Rubí: 39 bytes

->s,m{(0...s*s).reduce(0){|a,b|a+m**b}}

Prueba:

f = ->s,m{(0...s*s).reduce(0){|a,b|a+m**b}}

f[8,2]   # 18446744073709551615
f[3,6]   # 2015539
f[7,1.5] # 850161998.2853994
f[5,-3]  # 211822152361
f[256,1] # 65536
f[2,2]   # 15
f[2,-2]  # -5
f[1,1]   # 1

Python, 41 bytes

Totalmente nuevo en esto del golf, ¡las críticas son bienvenidas!

lambda n,m:sum(m**i for i in range(n**2))

Jolf, 18 15 10 bytes

Gracias a Cᴏɴᴏʀ O'Bʀɪᴇɴ por guardar 3 bytes y apuntarme hacia el mapeo

uΜzQjd^JwH

Pruébalo aquí!

 ΜzQj       Map over an array of 1 -> square(side length)
     d^JwH  Set the current array value to multiplier^(current value - 1)
u           Sum the array

CJam , 9 bytes

q~2#,f#:+

Las entradas están en orden inverso separadas por una nueva línea o un espacio.

Pruébalo en línea!

q~    e# Read input. Evaluate: pushes the two numbers, M and N, onto the stack
2#    e# Square: compute N^2
,     e# Range: generates array [0 1 ... N^2-1]
f#    e# Compute M raised to each element of the array [0 1 ... N^2-1]
:+    e# Fold addition: compute sum of the array [M^0 M^1 ... M^(N^2-1)]

PHP, 58 54 bytes

<?function a($n,$m){$n*=$n;echo(1-$m**$n)/(1-$m)?:$n;}

Esto solo usa la fórmula de suma para mostrar el valor, después de verificar si el multiplicador es 1 (que devuelve NAN en la fórmula).

Mathematica, 22 bytes

Tr[#^(Range[#2^2]-1)]&

Crea un rango de {1, 2, ... s^2}, resta 1 sobre él para hacer {0, 1, ..., s^2-1}. Luego eleva cada uno al poder de mhacer {m^0, m^1, ..., m^(s^2-1)}y devuelve la suma de ellos.

Alternativamente, Mathematica puede usar la fórmula explícita tomando su límite. Esto requiere 29 bytes.

Limit[(s^#^2-1)/(s-1),s->#2]&

PARI / GP , 25 bytes

f(s,m)=sum(i=0,s^2-1,m^s)

Más largo pero más rápido (35 bytes):

f(s,m)=if(m==1,s^2,(m^s^2-1)/(m-1))

Lindo (30 bytes):

f(s,m)=vecsum(powers(m,s^2-1))

C #, 56 bytes

double f(int n,double q){return(Math.Pow(q,n*n)-1)/--q;}

Lua, 54 47 bytes

r=0l,m=...for i=0,l^2-1 do r=r+m^i end print(r)

Ejecute desde la línea de comando con la longitud del lado del tablero como primer argumento y el multiplicador como el segundo.

Gracias a user6245072 por guardar 6 bytes, y Katenkyo por guardar 1 adicional.

Versión original de 54 bytes:

a,b=...c=1 d=1 for i=2,a^2 do c=c*b d=d+c end print(d)

𝔼𝕊𝕄𝕚𝕟, 11 caracteres / 14 bytes

⨭⩥ î²)ⓜⁿ⁽í$

Try it here (Firefox/WebKit Nightly only).

Sí, ¡ahora funciona en WebKit Nightly! El soporte de Chrome es el siguiente.

Explicación

⨭⩥ î²)ⓜⁿ⁽í$ // implicit: î = input1, í = input2
   ⩥ î²)       // generate a range [0..î^2)
                     ⓜ      // map over range ($ is mapitem):
        ⁿ⁽í$  //   í^$
⨭            // sum resulting range
              // implicit output

RETORNO , 32 bytes

[a:2^0\
{[$¥][a;\^]#[¤¥][+]#]!

Try it here.

Lambda anónima que deja resultado en Stack2. Uso:

8 2[a:2^0\
{[$¥][a;\^]#[¤¥][+]#]!

Explicación

[                              ]!  lambda
 a:                                store multiplier to a
   2^                              square side-length
     0\␊                           create range [0..result)
        {                          set current stack to range
         [  ][     ]#              while loop
          $¥                         check if TOS is truthy
              a;\^␌                  if so, push a^TOS to Stack2
                     ␁            set current stack to Stack2
                       [¤¥][+]#    sum Stack2