Définissons f _n (k) comme la somme des k premiers termes des nombres naturels [1, ∞) où chaque nombre est répété n fois.

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

Les anti-diagonales de cette forme de réseau carré sont similaires à la séquence OEIS A134546 .

Défi

Écrivez un programme / une fonction qui prend deux entiers non négatifs n et k et produit f _n (k) .

Caractéristiques

• Les règles d'E / S standard s'appliquent .
• Les failles standard sont interdites .
• Votre solution peut être indexée 0 ou indexée 1 pour n et / ou k, mais veuillez préciser laquelle.
• Ce défi ne consiste pas à trouver l'approche la plus courte dans toutes les langues, mais plutôt à trouver l' approche la plus courte dans chaque langue .
• Votre code sera noté en octets , généralement dans le codage UTF-8, sauf indication contraire.
• Les fonctions intégrées qui calculent cette séquence sont autorisées, mais l'inclusion d'une solution qui ne repose pas sur une séquence intégrée est encouragée.
• Des explications, même pour les langues "pratiques", sont encouragées .

Cas de test

Dans ces cas de test, n est indexé 1 et k est indexé 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

Dans quelques meilleurs formats:

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

Implémentation de référence

Ceci est écrit en Haskell .

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

Essayez-le en ligne!

Ce défi a été mis en bac à sable.

Rubis , 32 28 23 octets

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

Essayez-le en ligne!

Explication

Visualisons la somme comme l'aire d'un triangle, par exemple avec n = 3 et k = 10:

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

Ensuite, nous additionnons par colonne au lieu de ligne: la première colonne est k, puis k-n, k-2net ainsi de suite.

Python 2 , 34 28 octets

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

Essayez-le en ligne!

Merci à Martin Ender, Neil et M. Xcoder pour leur aide.

Husk , 4 octets

Σ↑ṘN

Essayez-le en ligne!

Explication

Cela finit par être une traduction directe de l'implémentation de référence dans le défi:

   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 octets

+/∘⌈÷⍨∘⍳

Essayez-le en ligne!

nà gauche, k(0 indexé) à droite.

Mathematica, 40 octets

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

Essayez-le en ligne!

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

Essayez-le en ligne!

Mathematica, 18 octets

par Martin Ender

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

Essayez-le en ligne!

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

Essayez-le en ligne!

MATL , 12 11 octets

:iY"Ys0h1G)

Essayez-le en ligne!

kest indexé 0. Prend la saisie dans l'ordre inverse.

1 octet enregistré grâce à @Giuseppe

Gelée , 5 octets

Rxḣ³S

Un octet de plus que la solution @ Mr.Xcoder Jelly mais c'est ma toute première soumission dans Jelly et je suis toujours confus quant à la façon dont le tacitness de Jelly choisit les opérandes, donc je suis toujours satisfait. Notez que l'ordre des entrées est kalors n.

Explication

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

Essayez-le en ligne!

Gelée , 4 octets

1 indexé

Ḷ:‘S

Essayez-le en ligne! ou consultez une suite de tests .

JavaScript (ES6),  24  21 octets

Prend une entrée dans la syntaxe de curry (n)(k). Renvoie falseau lieu de0 .

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

Cas de test

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

Comment?

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

Ceci est similaire à la réponse Ruby de @ GB .

Le défi décrit comment construire «l'escalier» de gauche à droite, alors que cette fonction récursive le construit de bas en haut. Avec n = 2 et k = 11 :

Lot, 34 octets

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

Une formule sous forme fermée que j'ai trouvée. Le premier argument nest indexé 1, le deuxième argument kest indexé 0.

Python 2 , 29 octets

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

Essayez-le en ligne!

Merci à totalement humain pour -3 octets!

Python 2 , 30 octets

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

Essayez-le en ligne!

Haskell , 28 octets

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

Essayez-le en ligne!

Une approche que j'ai trouvée juste en vissant avec quelques paramètres de plage. Ce n'est certainement pas le plus court, mais c'est assez cool de voir à quel point il existe de nombreuses approches différentes.

C, 38 34 octets

Définition récursive.

-4 octets grâce à Steadybox .

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

Essayez-le en ligne!

32 octets par M. Xcoder , GB

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

Essayez-le en ligne!

R , 37 33 31 octets

-6 octets grâce à Giuseppe

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

Essayez-le en ligne!

Rien d'extraordinaire. Le [0:k]gère le cas lorsque k = 0.

C ++, 53 octets

Utilisez simplement la formule. nest indexé 1 et indexé k0.

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

Essayez-le en ligne!

J , 13 octets

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

Comment ça fonctionne:

L'argument de gauche est n, celui de droite est k.

i. génère une liste 0..k-1

1+ ajoute un à chaque numéro de la liste, yealding 1,2, ..., k

# forme un crochet avec ce qui précède, donc n copies de chaque élément de la liste sont copiées.

]{. prendre les n premiers

1#. trouver leur somme par conversion de base.

Essayez-le en ligne!

Rétine , 29 26 octets

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

Essayez-le en ligne! Link inclut des cas de test et un en-tête pour les reformater en son entrée préférée (0 indexé en kpremier, 1 indexé en nsecond). J'ai été inspiré par la réponse Ruby de @ GB. Explication:

\d+
$*

Convertissez en unaire.

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

Faites correspondre chaque chaîne de l' nintérieur ket remplacez la correspondance par tout ce qui suit la correspondance. Ceci est k-n, k-2n, k-3nmais nest également après le match, de sorte que vous obtenez k, k-n,k-2n etc. Cela correspond aussi n, ce qui est tout simplement supprimé (il est plus nécessaire).

1

Additionnez les résultats et reconvertissez en décimal.

Pyth , 5 octets

s%_ES

Essayez-le ici!

Réponse Ruby du port de GB. Un port de ma Jelly serait de 6 octets:+s/Rvz

Perl 6 , 39 octets

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

Essaye-le

n et k sont tous deux basés sur 1

Étendu:

-> \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 octets

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

Essayez-le en ligne!

Java (OpenJDK 8) , 23 octets

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

Essayez-le en ligne!

Réponse de Python 2 du port de GB .

05AB1E , 9 octets

FL`}){I£O

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Python 2 , 38 octets

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

Essayez-le en ligne!

Clojure, 54 octets

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

Le deuxième argument kest indexé sur 0, tout (f 14 20)comme 28.

APL + WIN, 13 octets

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

Invite à saisir l'écran pour n, puis pour k. Origine de l'indice = 1.

Brain-Flak , 78 octets

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

Essayez-le en ligne!

Je suis certain que cela peut être mieux fait, mais c'est un début.

Japt , 7 6 octets

Inspiré à l'origine par la solution de GB et évolué vers un port!

Prend kcomme première entrée et ncomme seconde.

õ1Vn)x

Essayez-le

Explication

Saisie implicite d'entiers U=k& V=n. Générez un tableau d'entiers ( õ) de 1à Uavec une étape de Vnegated ( n) et réduisez-le par addition ( x).

R , 27 octets

Fonction anonyme qui prend ketn dans cet ordre. Crée une liste de longueur k(troisième argument rep) qui est composée de 1travers k(premier argument rep), en répétant chaque élément de nfois (quatrième argument rep). Prend ensuite la somme de cette liste.

nest indexé 1 et indexé k0. Renvoie une erreur pour n<1.

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

Essayez-le en ligne!

Befunge, 27 octets

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

Essayez-le en ligne

Prend k puis n comme entrée. Utilise la réponse de GB comme base mathématique.