Definamos f _n (k) como la suma de los primeros k términos de los números naturales [1, ∞) donde cada número se repite n veces.

k       | 0    1    2    3    4    5    6    7    8    9
--------+-------------------------------------------------
f_1(k)  | 0    1    3    6    10   15   21   28   36   45
deltas  |   +1   +2   +3   +4   +5   +6   +7   +8   +9
--------+-------------------------------------------------
f_2(k)  | 0    1    2    4    6    9    12   16   20   25
deltas  |   +1   +1   +2   +2   +3   +3   +4   +4   +5
--------+-------------------------------------------------
f_3(k)  | 0    1    2    3    5    7    9    12   15   18
deltas  |   +1   +1   +1   +2   +2   +2   +3   +3   +3

Los anti-diagonales de esto como una matriz cuadrada son similares a la secuencia OEIS A134546 .

Desafío

Escriba un programa / función que tome dos enteros no negativos nyk y produzca f _n (k) .

Especificaciones

• Normas estándar de E / S se aplican .
• Las lagunas estándar están prohibidas .
• Su solución puede estar indexada a 0 o indexada a 1 para n y / o k, pero especifique cuál.
• Este desafío no se trata de encontrar el enfoque más corto en todos los idiomas, sino de encontrar el enfoque más corto en cada idioma .
• Su código se puntuará en bytes , generalmente en la codificación UTF-8, a menos que se especifique lo contrario.
• Las funciones integradas que calculan esta secuencia están permitidas, pero se recomienda incluir una solución que no se base en una función integrada.
• Se alientan las explicaciones, incluso para los idiomas "prácticos" .

Casos de prueba

En estos casos de prueba, n está indexado en 1 yk está indexado en 0.

n   k      fn(k)

1   2      3
2   11     36
11  14     17
14  21     28
21  24     27
24  31     38
31  0      0

En algunos formatos mejores:

1 2
2 11
11 14
14 21
21 24
24 31
31 0

1, 2
2, 11
11, 14
14, 21
21, 24
24, 31
31, 0

Implementación de referencia

Esto está escrito en Haskell .

f n k = sum $ take k $ replicate n =<< [1..]

Pruébalo en línea!

Este desafío fue sandboxed.

Ruby , 32 28 23 bytes

->n,k{k.step(0,-n).sum}

Pruébalo en línea!

Explicación

Visualicemos la suma como el área de un triángulo, por ejemplo con n = 3 yk = 10:

*
*
*
**
**
**
***
***
***
****

Luego sumamos por columna en lugar de fila: la primera columna es k, luego k-n, k-2ny así sucesivamente.

Python 2 , 34 28 bytes

lambda n,k:(k+k%n)*(k/n+1)/2

Pruébalo en línea!

Gracias Martin Ender, Neil y Mr Xcoder por ayudar.

Casco , 4 bytes

Σ↑ṘN

Pruébalo en línea!

Explicación

Esto acaba siendo una traducción directa de la implementación de referencia en el desafío:

   N  Start from the infinite sequence of all natural numbers.
  Ṙ   Replicate each element n times.
 ↑    Take the first k values.
Σ     Sum them.

APL (Dyalog) , 12 10 8 bytes

+/∘⌈÷⍨∘⍳

Pruébalo en línea!

na la izquierda, k(0 indexado) a la derecha.

Mathematica, 40 bytes

Tr@Sort[Join@@Range@#2~Table~#][[;;#2]]&

Pruébalo en línea!

Tr[Range@(s=⌊#2/#⌋)]#+#2~Mod~#(s+1)&

Pruébalo en línea!

Mathematica, 18 bytes

por Martin Ender

Tr@Range[#2,0,-#]&

Pruébalo en línea!

n~Sum~{n,#2,0,-#}&

Pruébalo en línea!

MATL , 12 11 bytes

:iY"Ys0h1G)

Pruébalo en línea!

kestá indexado a 0. Toma la entrada en orden inverso.

Guardado 1 byte gracias a @Giuseppe

Jalea , 5 bytes

Rxḣ³S

Un byte más que la solución Jelly de @ Mr.Xcoder, pero esta es mi primera presentación en Jelly y todavía estoy confundido acerca de cómo la tacidez de Jelly elige operandos, así que todavía estoy satisfecho. Tenga en cuenta el orden de las entradas son kentonces n.

Explicación

Rxḣ³S
R           Range: [1,2,...,k]
 x          Times: repeat each element n times: [1,1,1,2,2,2,...,n,n,n]
  ḣ³        Head: take the first k elements. ³ returns the first argument.
    S       Sum

Pruébalo en línea!

Jalea , 4 bytes

1 indexado

Ḷ:‘S

Pruébalo en línea! o ver un conjunto de pruebas .

JavaScript (ES6),  24  21 bytes

Toma entrada en la sintaxis de curry (n)(k). Devoluciones en falselugar de0 .

n=>g=k=>k>0&&k+g(k-n)

Casos de prueba

let f =

n=>g=k=>k>0&&k+g(k-n)

console.log(f(1 )(2 )) // 3
console.log(f(2 )(11)) // 36
console.log(f(11)(14)) // 17
console.log(f(14)(21)) // 28
console.log(f(21)(24)) // 27
console.log(f(24)(31)) // 38

¿Cómo?

n =>             // main unamed function taking n
  g = k =>       // g = recursive function taking k
    k > 0 &&     // if k is strictly positive:
      k +        //   add k to the final result
      g(k - n)   //   subtract n from k and do a recursive call

Esto es similar a la respuesta de Ruby de @ GB .

El desafío describe cómo construir la 'escalera' de izquierda a derecha, mientras que esta función recursiva la construye de abajo hacia arriba. Con n = 2 y k = 11 :

Lote, 34 bytes

@cmd/cset/a(%2+%2%%%1)*(%2/%1+1)/2

Una fórmula de forma cerrada que encontré. El primer argumento nestá indexado en 1, el segundo argumento kestá indexado en 0.

Python 2 , 29 bytes

lambda n,k:sum(range(k,0,-n))

Pruébalo en línea!

¡Gracias a totalmente humano por -3 bytes!

Python 2 , 30 bytes

f=lambda n,k:k>0and k+f(n,k-n)

Pruébalo en línea!

Haskell , 28 bytes

n#k|m<-k`mod`n=sum[m,m+n..k]

Pruébalo en línea!

Un enfoque que encontré simplemente jugando con algunos parámetros de rango. Definitivamente no es el más corto, pero es genial cómo hay tantos enfoques diferentes.

C, 38 34 bytes

Definición recursiva.

-4 bytes gracias a Steadybox .

f(n,k){return k--?1+f(n,k)+k/n:0;}

Pruébalo en línea!

32 bytes por el Sr. Xcoder , GB

f(n,k){return(k+k%n)*(k/n+1)/2;}

Pruébalo en línea!

R , 37 33 31 bytes

-6 bytes gracias a Giuseppe

function(n,k)sum(rep(1:k,,k,n))

Pruébalo en línea!

Nada sofisticado. El [0:k]maneja el caso cuando k = 0.

C ++, 53 bytes

Solo usa la fórmula. nestá indexado en 1 y kestá indexado en 0.

[](int n,int k){return k/n*(k/n+1)/2*n+k%n*(k/n+1);};

Pruébalo en línea!

J , 13 bytes

1#.]{.(#1+i.)

Cómo funciona:

El argumento izquierdo es n, el derecho es k.

i. genera una lista 0..k-1

1+ agrega uno a cada número de la lista, yealding 1,2, ..., k

# forma un gancho con lo anterior, por lo que se copian n copias de cada elemento de la lista.

]{. toma el primero de ellos

1#. encuentre su suma por conversión de base.

Pruébalo en línea!

Retina , 29 26 bytes

\d+
$*
(?=.*?(1+)$)\1
$'
1

Pruébalo en línea! El enlace incluye casos de prueba y encabezado para volver a formatearlos a su entrada preferida ( kprimero indexado 0 , nsegundo indexado 1 ). Me inspiró la respuesta Ruby de @ GB. Explicación:

\d+
$*

Convierte a unario.

(?=.*?(1+)$)\1
$'

Haga coincidir cada secuencia ninterna ky reemplace la coincidencia con todo después de la coincidencia. Esto es k-n, k-2n, k-3n, pero ntambién después del partido, para que pueda obtener k, k-n, k-2netc. Esto también partidos n, que se elimina simplemente (que ya no es necesario).

1

Suma los resultados y convierte de nuevo a decimal.

Pyth , 5 bytes

s%_ES

Pruébalo aquí!

La respuesta de Ruby del puerto de GB. Un puerto de mi Jelly one sería de 6 bytes:+s/Rvz

Perl 6 , 39 bytes

->\n,\k{(0,{|($_+1 xx n)}...*)[^k].sum}

Pruébalo

n y k son ambos 1 basado

Expandido:

-> \n, \k { # pointy block lambda with two parameters ｢n｣ and ｢k｣

  ( # generate the sequence

    0,         # seed the sequence (this is why ｢k｣ is 1-based)

    {          # bare block lambda with implicit parameter ｢$_｣
      |(       # slip this into outer sequence
        $_ + 1 # the next number
        xx n   # repeated ｢n｣ times (this is why ｢n｣ is 1-based)
      )
    }

    ...        # keep doing that until

    *          # never stop

  )[ ^k ]      # get the first ｢k｣ values from the sequence
  .sum         # sum them
}

Kotlin , 40 bytes

{n:Int,k:Int->Array(k,{i->i/n+1}).sum()}

Pruébalo en línea!

Java (OpenJDK 8) , 23 bytes

n->k->(k+k%n)*(k/n+1)/2

Pruébalo en línea!

Puerto de la respuesta Python 2 de GB .

05AB1E , 9 bytes

FL`}){I£O

Pruébalo en línea!

Explicación

F           # n times do
 L`         # pop top of stack (initially k), push 1 ... topOfStack
   }        # end loop
    )       # wrap stack in a list
     {      # sort the list
      I£    # take the first k elements
        O   # sum

Python 2 , 44 bytes

f=lambda n,k:sum(sorted(range(1,k+1)*n)[:k])

Pruébalo en línea!

Python 2 , 38 bytes

lambda n,k:sum(i/n+1for i in range(k))

Pruébalo en línea!

Clojure, 54 bytes

#(nth(reductions +(for[i(rest(range))j(range %)]i))%2)

El segundo argumento kestá indexado a 0, por lo que (f 14 20)es 28.

APL + WIN, 13 bytes

+/⎕↑(⍳n)/⍳n←⎕

Solicita la entrada de pantalla para n y luego para k. Origen del índice = 1.

Brain-Flak , 78 bytes

(({}<>)<{<>(({})<>){({}[()]<(({}))>)}{}({}[()])}{}<>{}>)({<({}[()])><>{}<>}{})

Pruébalo en línea!

Estoy seguro de que esto se puede hacer mejor, pero es un comienzo.

Japt , 7 6 bytes

¡Originalmente inspirado en la solución de GB y evolucionado a un puerto!

Toma kcomo la primera entrada y ncomo la segunda.

õ1Vn)x

Intentalo

Explicación

Entrada implícita de enteros U=ky V=n. Genere una matriz de enteros ( õ) desde 1hasta Ucon un paso de Vnegado ( n) y reduzca mediante la suma ( x).

R , 27 bytes

Función anónima que toma ky nen ese orden. Crea una lista de longitud k(tercer argumento para rep) que se compone de 1through k(primer argumento para rep), repitiendo cada elemento nveces (cuarto argumento para rep). Luego toma la suma de esa lista.

nestá indexado en 1 y kestá indexado en 0. Devuelve un error para n<1.

pryr::f(sum(rep(1:k,,k,n)))

Pruébalo en línea!

Befunge, 27 Bytes

&::00p&:10p%+00g10g/1+*2/.@

Pruébalo en línea

Toma k y luego n como entrada. Utiliza la respuesta de GB como su base matemática.