Mari kita mendefinisikan f _n (k) sebagai jumlah dari suku pertama k dari bilangan asli [1, ∞) di mana setiap angka diulang n kali.

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

Anti-diagonal ini sebagai larik persegi mirip dengan urutan OEIS A134546 .

Tantangan

Tulis program / fungsi yang mengambil dua bilangan bulat n-negatif dan k dan keluaran f _n (k) .

Spesifikasi

• Aturan I / O standar berlaku .
• Celah standar yang dilarang .
• Solusi Anda dapat diindeks 0 atau 1 diindeks untuk n dan / atau k tetapi harap tentukan yang mana.
• Tantangan ini bukan tentang menemukan pendekatan terpendek dalam semua bahasa, melainkan tentang menemukan pendekatan terpendek dalam setiap bahasa .
• Kode Anda akan dinilai dalam byte , biasanya dalam pengkodean UTF-8, kecuali ditentukan lain.
• Fungsi built-in yang menghitung urutan ini diperbolehkan tetapi termasuk solusi yang tidak bergantung pada built-in dianjurkan.
• Penjelasan, bahkan untuk bahasa "praktis", dianjurkan .

Uji kasus

Dalam kasus uji ini, n adalah indeks-1 dan k adalah indeks-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

Dalam beberapa format yang lebih baik:

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

Implementasi referensi

Ini ditulis dalam Haskell .

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

Cobalah online!

Tantangan ini dikosongkan.

Ruby , 32 28 23 byte

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

Cobalah online!

Penjelasan

Mari kita bayangkan jumlah sebagai luas segitiga, misalnya dengan n = 3 dan k = 10:

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

Kemudian kita menjumlahkan dengan kolom alih-alih baris: kolom pertama adalah k, lalu k-n, k-2ndan seterusnya.

Python 2 , 34 28 byte

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

Cobalah online!

Terima kasih Martin Ender, Neil, dan Tuan Xcoder karena telah membantu.

Sekam , 4 byte

Σ↑ṘN

Cobalah online!

Penjelasan

Ini akhirnya menjadi terjemahan langsung dari implementasi referensi dalam tantangan:

   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 byte

+/∘⌈÷⍨∘⍳

Cobalah online!

ndi sebelah kiri, k(0 diindeks) di sebelah kanan.

Mathematica, 40 byte

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

Cobalah online!

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

Cobalah online!

Mathematica, 18 byte

oleh Martin Ender

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

Cobalah online!

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

Cobalah online!

MATL , 12 11 byte

:iY"Ys0h1G)

Cobalah online!

kdiindeks 0. Mengambil input dalam urutan terbalik.

Disimpan 1 byte berkat @Giuseppe

Jelly , 5 byte

Rxḣ³S

Satu byte lebih dari solusi Jelly @ Mr.Xcoder tetapi ini adalah pengiriman pertama saya di Jelly dan saya masih bingung tentang bagaimana saksi Jelly memilih operan jadi saya masih puas. Perhatikan urutan input kkemudian n.

Penjelasan

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

Cobalah online!

Jelly , 4 byte

1-diindeks

Ḷ:‘S

Cobalah online! atau lihat test suite .

JavaScript (ES6),  24  21 byte

Mengambil input dalam sintaks currying (n)(k). Mengembalikan falsebukan0 .

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

Uji kasus

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

Bagaimana?

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

Ini mirip dengan jawaban Ruby @ GB .

Tantangannya menggambarkan bagaimana membangun 'tangga' dari kiri ke kanan, sedangkan fungsi rekursif ini membangunnya dari bawah ke atas. Dengan n = 2 dan k = 11 :

Batch, 34 byte

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

Formula bentuk tertutup yang saya temukan. Argumen pertama nadalah 1-diindeks, argumen kedua kadalah 0-diindeks.

Python 2 , 29 byte

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

Cobalah online!

Terima kasih untuk benar-benar manusia untuk -3 byte!

Python 2 , 30 byte

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

Cobalah online!

Haskell , 28 byte

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

Cobalah online!

Suatu pendekatan yang saya temukan hanya dengan bermain-main dengan beberapa parameter rentang. Jelas bukan yang terpendek tetapi cukup keren bagaimana ada begitu banyak pendekatan yang berbeda.

C, 38 34 byte

Definisi rekursif.

-4 Bytes berkat Steadybox .

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

Cobalah online!

32 byte oleh Mr. Xcoder , GB

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

Cobalah online!

R , 37 33 31 byte

-6 byte terima kasih kepada Giuseppe

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

Cobalah online!

Tidak ada yang mewah. The [0:k]menangani kasus ketika k = 0.

C ++, 53 byte

Cukup gunakan formula. n1-diindeks dan k0-diindeks.

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

Cobalah online!

J , 13 byte

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

Bagaimana itu bekerja:

Argumen kiri adalah n, kanan adalah k.

i. menghasilkan daftar 0..k-1

1+ menambahkan satu ke setiap nomor dalam daftar, dengan 1,2, ..., k

# membentuk kait dengan yang di atas, jadi n salinan dari setiap elemen daftar disalin.

]{. ambil n pertama dari mereka

1#. temukan jumlah mereka dengan konversi basis.

Cobalah online!

Retina , 29 26 byte

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

Cobalah online! Tautan mencakup test case dan header untuk memformatnya menjadi input yang disukai (0-diindeks kpertama, 1-diindeks nkedua). Saya terinspirasi oleh jawaban Ruby @ GB. Penjelasan:

\d+
$*

Konversikan ke unary.

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

Cocokkan setiap string di ndalam k, dan ganti kecocokan dengan semuanya setelah pertandingan. Ini adalah k-n, k-2n, k-3n, tapi njuga setelah pertandingan, sehingga Anda mendapatkan k, k-n, k-2ndll Hal ini juga cocok n, yang hanya dihapus (itu tidak lagi diperlukan).

1

Jumlahkan hasilnya dan konversikan kembali ke desimal.

Pyth , 5 byte

s%_ES

Coba di sini!

Port of the Ruby menjawab. Port Jelly saya akan menjadi 6 byte:+s/Rvz

Perl 6 , 39 byte

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

Menguji

n dan k keduanya berbasis 1

Diperluas:

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

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

Cobalah online!

Java (OpenJDK 8) , 23 byte

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

Cobalah online!

Port jawaban Python 2 GB .

05AB1E , 9 byte

FL`}){I£O

Cobalah online!

Penjelasan

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 byte

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

Cobalah online!

Python 2 , 38 byte

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

Cobalah online!

Clojure, 54 byte

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

Argumen 2 kadalah 0-diindeks, demikian (f 14 20)juga 28.

APL + WIN, 13 byte

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

Meminta input layar untuk n dan kemudian untuk k. Indeks asal = 1.

Brain-Flak , 78 byte

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

Cobalah online!

Saya yakin ini bisa dilakukan lebih baik, tapi ini awal.

Japt , 7 6 byte

Awalnya terinspirasi oleh solusi GB dan berkembang menjadi sebuah port!

Dibawa ksebagai input pertama dan nsebagai input kedua.

õ1Vn)x

Cobalah

Penjelasan

Input bilangan bulat implisit U=k& V=n. Hasilkan array bilangan bulat ( õ) dari 1hingga Udengan langkah Vnegated ( n) dan menguranginya dengan penambahan ( x).

R , 27 byte

Fungsi anonim yang mengambil kdan ndalam urutan itu. Membuat daftar panjang k(argumen ketiga ke rep) yang terdiri dari 1through k(argumen pertama ke rep), mengulangi setiap elemen nkali (argumen keempat ke rep). Kemudian ambil jumlah dari daftar itu.

n1-diindeks dan k0-diindeks. Mengembalikan kesalahan untuk n<1.

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

Cobalah online!

Befunge, 27 Bytes

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

Cobalah secara Online

Mengambil k lalu n sebagai input. Menggunakan jawaban GB sebagai dasar matematisnya.