Una leggenda indiana racconta la storia del presunto inventore del gioco degli scacchi, che ha impressionato così tanto l'imperatore dell'India con il suo gioco da essere ricompensato da qualsiasi cosa gli fosse stata chiesta.

L'uomo disse che voleva essere pagato in riso. Voleva un chicco di riso per il primo quadrato della scacchiera, due per il secondo, quattro per il terzo, otto per il quarto e così via, fino al 64 ° quadrato.

L'imperatore fu sorpreso dal fatto che l'uomo avesse chiesto una ricompensa così piccola, ma quando i suoi matematici iniziarono a contare, finì per perdere una delle sue province.

Compito

Data la lunghezza del lato di un'ipotetica scacchiera (che è 8 su una scacchiera predefinita) e il moltiplicatore tra i quadrati (che è 2 nella legenda), calcola il numero di chicchi di riso che l'imperatore deve pagare all'uomo.

Gli appunti

• La lunghezza del lato sarà sempre un numero intero positivo. Il moltiplicatore potrebbe invece essere qualsiasi tipo di numero razionale.

• Se la tua lingua preferita non può visualizzare numeri molto grandi, va bene finché il tuo programma può elaborare correttamente input più piccoli.

• Anche se la tua lingua preferita arrotonda valori più grandi (con notazioni esponenziali), va bene se questi valori sono approssimativamente corretti.

Casi test

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

Si prega di notare che la formula esplicita

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

Si comporta male su multiplier = 1, come

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

punteggio

Questo è code-golf. Vince la risposta più breve in byte.

Gelatina , 4 byte

²b1ḅ

Questo utilizza l'approccio della risposta intelligente APL di @ APLDude .

Provalo online! o verifica tutti i casi di test .

Come funziona

²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 byte

2^:q^s

Provalo online!

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 byte

⎕⊥1+0×⍳⎕*2

⎕viene utilizzato per leggere due volte l'input dell'utente. Se conserviamo la lunghezza del lato di s e il moltiplicatore in m , otteniamo il seguente codice.

m⊥1+0×⍳s*2

Ed ecco come APL analizza questo codice:

Python, 40 byte

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

Genera e valuta una stringa come

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

che codifica la somma come un polinomio Hornerized con n*ntermini.

Molti metodi diversi hanno dato conteggi di byte molto simili:

#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 byte

1 byte salvato grazie a @FryAmTheEggman .

s^Lvz*

Provalo online!

Suite di test.

Haskell, 25 byte

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

Somma l'elenco [m^0, m^1, ..., m^(n*n-1)].

JavaScript (ES2016 / ES7), 31 29 28 byte

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

Solo @Bassdrop Cumberwubwubwub e la versione ES6 di @ Kaizo, ma con operatore esponenziale. :) (Non avevo abbastanza reputazione per commentare invece.)

Modifica: /+(b-1)modificato in /--b(grazie @Neil).

Modifica: ora usa il curry (grazie @MamaFunRoll).

Gelatina, 6 byte

²R’*@S

Provalo online!

MATLAB, 23 byte

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

Provalo qui !

Javascript ES6, 59 37 35 34 byte

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

Grazie a @Kaizo per aver rasato ben 19 byte, @Neil per altri 2 e @gcampbell per altri 1!

Provalo qui

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>

Versioni rotte alternative

32 byte

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

Cause NaNdib==1 .

30 byte

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

Cause Infinitydib==1.5 .

28 byte

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

Uscite 1 per alcune prove valide.

Vecchia versione per 59 byte

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

Java, 132 byte

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

Ungolfed

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

Gli appunti

• Questo funzionerà per output arbitrariamente grandi come richiesto da OP (Peccato che Java supporti numeri grandi, altrimenti sarebbe più corto).

Uscite

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 byte

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

Spiegazione:

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

05AB1E , 5 byte

Codice:

nL<mO

Spiegazione:

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

Provalo online! .

Haskell, 30 byte

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

o ugualmente lungo

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

La prima versione inizia con 1si moltiplica ripetutamente con m. Quindi somma i primi n^2numeri di questa sequenza. La seconda versione è la formula esplicita vista in altre risposte.

J, 10 byte

+/@:^i.@*:

uso

Contrassegno alcuni numeri interi con il xsuffisso per utilizzare numeri interi estesi per ottenere risultati esatti.

   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

Spiegazione

+/@:^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] byte (~ 11)

Utilizza l'operatore di sommatoria incorporato di Mathcad. Dimostra anche la semplificazione del processore simbolico per generare una formula esatta.

Mathcad esegue effettivamente due motori di elaborazione in parallelo: uno un IEEE standard 64/80 bit in virgola mobile e l'altro un processo simbolico di lunghezza numerica arbitraria (MuPad). La valutazione numerica standard è indicata dal segno di uguale (=), mentre una freccia destra indica la valutazione simbolica.

Schema di conteggio Mathcad ancora da determinare, quindi nessun conteggio dei byte indicato.

ctl- $ inserisce l'operatore di sommatoria (Sigma), inclusi segnaposto vuoti per inserire la variabile di sommatoria, il valore iniziale, il valore finale e l'espressione. Conteggio approssimativo equivalente in byte = 11.

PostgreSQL, 67 66 byte

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

SqlFiddleDemo

Ingresso: VALUES(side, multiplier)

MODIFICARE:

Input spostato nella tabella, tutti i casi contemporaneamente:

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

SqlFiddleDemo

Produzione:

╔══════╦══════╦══════════════════════╗
║  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 byte

Sè la lunghezza laterale ed Mè il moltiplicatore.

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

Python, 40 byte

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

Rubino: 39 byte

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

Test:

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 byte

Totalmente nuovo in questa cosa del golf, le critiche sono benvenute!

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

Jolf, 18 15 10 byte

Grazie a Cᴏɴᴏʀ O'Bʀɪᴇɴ per aver salvato 3 byte e mi ha indicato la mappatura

uΜzQjd^JwH

Provalo qui!

 Μ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 byte

q~2#,f#:+

Gli input sono in ordine inverso separati da una nuova riga o uno spazio.

Provalo online!

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 byte

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

Questo utilizza solo la formula di somma per mostrare il valore, dopo aver verificato se il moltiplicatore è 1 (che restituisce NAN nella formula).

Mathematica, 22 byte

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

Crea un intervallo di {1, 2, ... s^2}, sottrae 1 da esso per crearlo {0, 1, ..., s^2-1}. Quindi aumenta ciascuno al potere di mfare{m^0, m^1, ..., m^(s^2-1)} and return the sum of it.

In alternativa, Mathematica può utilizzare la formula esplicita assumendone il limite. Ciò richiede 29 byte.

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

PARI/GP, 25 bytes

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

Longer but faster (35 bytes):

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

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

Run from the command line with the board side length as the first argument and the multiplier as the second.

Thanks to user6245072 for saving 6 bytes, and Katenkyo for saving an additional 1.

Original 54 byte version:

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

𝔼𝕊𝕄𝕚𝕟, 11 chars / 14 bytes

⨭⩥ î²)ⓜⁿ⁽í$

Try it here (Firefox/WebKit Nightly only).

Yes, 𝔼𝕊𝕄𝕚𝕟 now works in WebKit Nightly! Chrome support is next.

Explanation

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

RETURN, 32 bytes

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

Try it here.

Anonymous lambda that leaves result on Stack2. Usage:

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

Explanation

[                              ]!  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