Urutan keren tanpa judul thingy

19

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.

code-golf  math  number  sequence 
— benar-benar manusiawi
sumber
Apakah menurut Anda edit saya meningkatkan pemformatan, atau hanya pada browser saya?
— user202729
@ user202729 Heh ... kelihatannya tidak aktif di browser saya tapi saya ragu format saya terlihat bagus di sebagian besar browser ... Saya hanya akan membiarkannya seperti itu, tidak ada artinya. Terlihat aneh. : P
— totallyhuman
Apakah kita perlu menangani case f_n(0) = 0untuk k0-diindeks?
— Cinaski
9
" Urutan keren tanpa judul thingy " Lol, aku bukan satu-satunya yang mengalami kesulitan membuat nama untuk urutan yang kubuat, aku mengerti ..;)
— Kevin Cruijssen
3
@Fabian Tidak, Anda hanya menjumlahkan kistilah pertama dari daftar bilangan alami berulang, bukan n*kistilah pertama .
— Martin Ender

Jawaban:

12

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.

— GB
sumber
8

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.

— GB
sumber
1
Anda sebenarnya tidak memerlukannya k/n- k-(k/n)*nhanya saja k%n. Lihat jawaban Batch saya.
— Neil
— Mr. Xcoder
Terima kasih. Saya tidak berpikir itu bisa menjadi sangat sederhana.
— GB
8

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.
— Martin Ender
sumber
5

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!

— dylnan
sumber
4

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

Tampilkan cuplikan kode

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 :

tangga

— Arnauld
sumber
3

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.

— Neil
sumber
3

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.

— benar-benar manusiawi
sumber
3

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.

— NofP
sumber
1
Anda dapat menyingkirkan kawat gigi di sini. Jika Anda menggunakan argumen in-order untuk rep.default, Anda dapat menyingkirkan [0:k]dengan menggunakan rep(1:k,,k,n)tetapi kemudian jawaban Anda pada dasarnya adalah rturnbull tetapi dengan basis R daripadaR + pryr
— Giuseppe
1
Anda masih bisa menyingkirkan kawat gigi! {}
— Giuseppe
substitusi [0: k] membuat saya dan saya lupa tentang kawat gigi :)
— NofP
2

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!

— Colera Su
sumber
Simpan beberapa byte dengan menyalahgunakan ~operator. [](int n,int k){return-k/n*~(k/n)/2*n-k%n*~(k/n);};
— ceilingcat
2

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!

— Galen Ivanov
sumber
Saya suka kailnya.
— cole
2

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.

— Neil
sumber
2

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
}
— Brad Gilbert b2gills
sumber
1

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
— Emigna
sumber
1

Clojure, 54 byte

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

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

— NikoNyrh
sumber
1

APL + WIN, 13 byte

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

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

— Graham
sumber
1

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

— Shaggy
sumber
1

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!

— rturnbull
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.