Definieren wir f _n (k) als die Summe der ersten k Terme der natürlichen Zahlen [1, ∞), wobei jede Zahl n- mal wiederholt wird.

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

Die Antidiagonalen davon als quadratische Anordnung ähneln der OEIS-Sequenz A134546 .

Herausforderung

Schreiben Sie ein Programm / eine Funktion , die zwei nicht negative ganze Zahlen n und k annimmt und f _n (k) ausgibt .

Spezifikationen

• Standard I / O - Regeln gelten .
• Standardlücken sind verboten .
• Ihre Lösung kann entweder 0-indiziert oder 1-indiziert für n und / oder k sein, aber bitte spezifizieren Sie welche.
• Bei dieser Herausforderung geht es nicht darum, den kürzesten Ansatz in allen Sprachen zu finden, sondern darum, den kürzesten Ansatz in jeder Sprache zu finden .
• Ihr Code wird in Bytes bewertet , normalerweise in der Codierung UTF-8, sofern nicht anders angegeben.
• Eingebaute Funktionen, die diese Sequenz berechnen, sind zulässig, es wird jedoch empfohlen, eine Lösung zu verwenden, die nicht auf einer eingebauten basiert.
• Erklärungen, auch für "praktische" Sprachen, sind erwünscht .

Testfälle

In diesen Testfällen ist n 1-indiziert und k ist 0-indiziert.

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

In ein paar besseren Formaten:

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

Referenzimplementierung

Dies ist in Haskell geschrieben .

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

Probieren Sie es online!

Diese Herausforderung war Sandkasten.

Ruby , 32 28 23 Bytes

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

Probieren Sie es online!

Erläuterung

Stellen wir uns die Summe als Fläche eines Dreiecks vor, zum Beispiel mit n = 3 und k = 10:

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

Dann sind wir durch Spalte Summe statt Zeile: Die erste Spalte ist k, dann k-n, k-2nund so weiter.

Python 2 , 34 28 Bytes

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

Probieren Sie es online!

Vielen Dank an Martin Ender, Neil und Mr Xcoder für ihre Hilfe.

Schale , 4 Bytes

Σ↑ṘN

Probieren Sie es online!

Erläuterung

Dies ist nur eine direkte Übersetzung der Referenzimplementierung in der Herausforderung:

   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

+/∘⌈÷⍨∘⍳

Probieren Sie es online!

nlinks k(0 indiziert) rechts.

Mathematica, 40 Bytes

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

Probieren Sie es online!

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

Probieren Sie es online!

Mathematica, 18 Bytes

von Martin Ender

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

Probieren Sie es online!

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

Probieren Sie es online!

MATL , 12 11 Bytes

:iY"Ys0h1G)

Probieren Sie es online!

kist 0-indiziert. Nimmt die Eingabe in umgekehrter Reihenfolge vor.

1 Byte dank @Giuseppe gespeichert

Gelee , 5 Bytes

Rxḣ³S

Ein Byte mehr als die Jelly-Lösung von @ Mr.Xcoder, aber dies ist meine allererste Einsendung in Jelly, und ich bin immer noch verwirrt darüber, wie die Tacitness von Jelly Operanden auswählt, damit ich immer noch zufrieden bin. Beachten Sie, dass die Reihenfolge der Eingaben kdann ist n.

Erläuterung

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

Probieren Sie es online!

Gelee , 4 Bytes

1-indiziert

Ḷ:‘S

Probieren Sie es online! oder sehen Sie sich eine Testsuite an .

JavaScript (ES6),  24  21 Bytes

Übernimmt Eingaben in der Currying-Syntax (n)(k). Rückgabe falsestatt0 .

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

Testfälle

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

Wie?

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

Dies ähnelt der Ruby-Antwort von @ GB .

Die Herausforderung beschreibt, wie die 'Treppe' von links nach rechts gebaut wird, während diese rekursive Funktion sie von unten nach oben baut. Mit n = 2 und k = 11 :

Batch, 34 Bytes

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

Eine geschlossene Formel, die ich gefunden habe. Das erste Argument nist 1-indiziert, das zweite Argument kist 0-indiziert.

Python 2 , 29 Bytes

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

Probieren Sie es online!

Danke an totalhuman für -3 Bytes!

Python 2 , 30 Bytes

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

Probieren Sie es online!

Haskell , 28 Bytes

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

Probieren Sie es online!

Ein Ansatz, den ich gefunden habe, indem ich mit einigen Bereichsparametern herumgeschraubt habe. Auf jeden Fall nicht die kürzeste, aber es ist ziemlich cool, wie viele verschiedene Ansätze es gibt.

C, 38 34 Bytes

Rekursive Definition.

-4 Bytes dank Steadybox .

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

Probieren Sie es online!

32 Bytes von Mr. Xcoder , GB

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

Probieren Sie es online!

R , 37 33 31 Bytes

-6 Bytes dank Giuseppe

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

Probieren Sie es online!

Nichts Außergewöhnliches. Das [0:k]behandelt den Fall, wenn k = 0 ist.

C ++, 53 Bytes

Verwenden Sie einfach die Formel. nist 1-indiziert und kist 0-indiziert.

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

Probieren Sie es online!

J , 13 Bytes

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

Wie es funktioniert:

Das linke Argument ist n, das rechte ist k.

i. Erzeugt eine Liste 0..k-1

1+ addiert eine zu jeder Nummer der Liste, yealding 1,2, ..., k

# bildet einen Haken mit dem oben genannten, so dass n Kopien von jedem Element der Liste kopiert werden.

]{. nimm die ersten n von ihnen

1#. Finden Sie ihre Summe durch Basisumwandlung.

Probieren Sie es online!

Retina , 29 26 Bytes

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

Probieren Sie es online! Link enthält Testfälle und Header, um sie auf die bevorzugte Eingabe umzuformatieren (0-indiziert kzuerst, 1-indiziert nzweitens). Die Ruby-Antwort von @ GB hat mich inspiriert. Erläuterung:

\d+
$*

In Unary konvertieren.

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

Passen Sie zu jeder Zeichenfolge von ninnenk und ersetzen Sie die Übereinstimmung nach dem Match durch alles andere. Dies ist k-n, k-2n, k-3n, aber nauch nach dem Spiel, so dass Sie erhalten k, k-n, k-2netc. Dies paßt auch n, das wird einfach gelöscht (es ist nicht mehr erforderlich).

1

Summieren Sie die Ergebnisse und rechnen Sie sie in Dezimalzahlen um.

Pyth , 5 Bytes

s%_ES

Probieren Sie es hier aus!

Port of GBs Ruby-Antwort. Ein Port meines Jellys wäre 6 Bytes:+s/Rvz

Perl 6 , 39 Bytes

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

Probier es aus

n und k sind beide 1 basierend

Erweitert:

-> \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()}

Probieren Sie es online!

Java (OpenJDK 8) , 23 Byte

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

Probieren Sie es online!

Port of GBs Python 2 Antwort .

05AB1E , 9 Bytes

FL`}){I£O

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Python 2 , 38 Bytes

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

Probieren Sie es online!

Clojure, 54 Bytes

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

Das zweite Argument kist 0-indiziert, das gleiche (f 14 20)gilt für 28.

APL + WIN, 13 Bytes

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

Fordert zur Eingabe des Bildschirms für n und dann für k auf. Indexursprung = 1.

Gehirn-Flak , 78 Bytes

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

Probieren Sie es online!

Ich bin sicher, das kann besser gemacht werden, aber es ist ein Anfang.

Japt , 7 6 Bytes

Ursprünglich inspiriert von GBs Lösung und zu einem Hafen entwickelt!

Nimmt kals erste Eingabe und nals zweite.

õ1Vn)x

Versuch es

Erläuterung

Implizite Eingabe von ganzen Zahlen U=k& V=n. Generieren Sie ein Array von ganzen Zahlen ( õ) von 1bis Umit einem Schritt von Vnegated ( n) und reduzieren Sie es durch Addition ( x).

R , 27 Bytes

Anonyme Funktion, die kund nin dieser Reihenfolge annimmt . Erstellt eine Liste mit der Länge k(drittes Argument bis rep), die sich aus 1bis k(erstes Argument bis rep) zusammensetzt und jedes Element wiederholtn mehrmals (viertes Argument bis rep). Nimmt dann die Summe dieser Liste.

nist 1-indiziert und kist 0-indiziert. Gibt einen Fehler für zurück n<1.

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

Probieren Sie es online!

Befunge, 27 Bytes

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

Probieren Sie es online

Nimmt k dann n als Eingabe. Verwendet die Antwort von GB als mathematische Grundlage.