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      f_n(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:

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.

— totalmente humano
fuente

¿Crees que mi edición mejora el formato, o es solo en mi navegador?

— usuario202729

@ user202729 Heh ... se ve en mi navegador pero dudo que mi formato se vea bien en la mayoría de los navegadores ... Lo mantendré así, no pierde ningún significado. Solo se ve raro. : P

— totalmente humano

¿Necesitamos manejar el caso f_n(0) = 0de k0 indexado?

— Cinaski

99

" genial secuencia sin título cosita " Lol, no soy el único que tiene dificultades para encontrar nombres para las secuencias que

— inventé,

3

@Fabian No, solo suma los primeros ktérminos de la lista de números naturales repetidos, no los primeros n*ktérminos.

— Martin Ender

12

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.

— GB
fuente

8

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.

— GB
fuente

1

En realidad no necesitas el de k/ntodos modos, k-(k/n)*nes justo k%n. Ver mi respuesta por lotes.

— Neil

28 bytes

— Sr. Xcoder

Gracias. No pensé que pudiera ser tan simple.

— GB

8

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.

— Martin Ender
fuente

5

APL (Dyalog) , 12 10 8 bytes

+/∘⌈÷⍨∘⍳

Pruébalo en línea!

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

— Uriel
fuente

5

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!

— J42161217
fuente

2

Tr@Range[#2,0,-#]&o n~Sum~{n,#2,0,-#}&usando el truco de la respuesta de GB Ruby.

— Martin Ender

5

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

— Cinaski
fuente

5

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!

— dylnan
fuente

4

Jalea , 4 bytes

1 indexado

Ḷ:‘S

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

— Sr. Xcoder
fuente

Puede hacer 0 indexación, así que creo que Ḷ:Stambién funciona

— dylnan

@dylnan En realidad, no creo que eso sea el índice 0 aquí. Retrocedí y veremos

— Sr. Xcoder,

@dylnan Division by zero es un error.

— Erik the Outgolfer

4

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

Mostrar fragmento de código

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

Expandir fragmento

¿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 :

— Arnauld
fuente

3

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.

— Neil
fuente

3

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!

— Sr. Xcoder
fuente

3

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.

— totalmente humano
fuente

3

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!

— Colera Su
fuente

34 bytes en Python , 36 bytes en C

— Sr. Xcoder

1

Usando el enfoque de GB, 32 bytes

— Sr. Xcoder

tio.run/… -> 28 bytes

— GB

1

34 bytes (la versión recursiva): ¡ f(n,k){return k--?1+f(n,k)+k/n:0;} Pruébelo en línea!

— Steadybox

3

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.~~

— NofP
fuente

1

Puedes deshacerte de los frenos aquí. Si usa los argumentos en orden para rep.default, puede deshacerse de ellos [0:k]usando, rep(1:k,,k,n)pero su respuesta es básicamente rturnbull pero con base R en lugar deR + pryr

— Giuseppe

1

¡Aún puedes deshacerte de los frenos! {}

— Giuseppe

la sustitución [0: k] me

— atrapó

2

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!

— Colera Su
fuente

Ahorre un par de bytes abusando del ~operador. [](int n,int k){return-k/n*~(k/n)/2*n-k%n*~(k/n);};

— ceilingcat

2

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!

— Galen Ivanov
fuente

Me gusta el gancho

— cole

2

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

Suma los resultados y convierte de nuevo a decimal.

— Neil
fuente

2

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

— Sr. Xcoder
fuente

2

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
}

— Brad Gilbert b2gills
fuente

2

Kotlin , 40 bytes

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

Pruébalo en línea!

— alves
fuente

2

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 .

— Olivier Grégoire
fuente

1

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

— Emigna
fuente

1

Python 2 , 44 bytes

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

Pruébalo en línea!

— TFeld
fuente

1

Python 2 , 38 bytes

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

Pruébalo en línea!

— varilla
fuente

1

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.

— NikoNyrh
fuente

1

APL + WIN, 13 bytes

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

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

— Graham
fuente

1

Brain-Flak , 78 bytes

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

Pruébalo en línea!

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

— Asistente de trigo
fuente

1

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

— Lanudo
fuente

1

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!

— rturnbull
fuente

1

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.

— Jo King
fuente

cosa fresca sin título cosita

Desafío

Especificaciones

Casos de prueba

Implementación de referencia

Ruby , 32 28 23 bytes

Explicación

Python 2 , 34 28 bytes

Casco , 4 bytes

Explicación

APL (Dyalog) , 12 10 8 bytes

Mathematica, 40 bytes

Mathematica, 18 bytes

MATL , 12 11 bytes

Jalea , 5 bytes

Jalea , 4 bytes

JavaScript (ES6), 24 21 bytes

Casos de prueba

¿Cómo?

Lote, 34 bytes

Python 2 , 29 bytes

Python 2 , 30 bytes

Haskell , 28 bytes

C, 38 34 bytes

R , 37 33 31 bytes

C ++, 53 bytes

J , 13 bytes

Retina , 29 26 bytes

Pyth , 5 bytes

Perl 6 , 39 bytes

Expandido:

Kotlin , 40 bytes

Java (OpenJDK 8) , 23 bytes

05AB1E , 9 bytes

Python 2 , 44 bytes

Python 2 , 38 bytes

Clojure, 54 bytes

APL + WIN, 13 bytes

Brain-Flak , 78 bytes

Japt , 7 6 bytes

Explicación

R , 27 bytes

Befunge, 27 Bytes