ลองนิยามf _n (k)เป็นผลรวมของเงื่อนไขkแรกของตัวเลขธรรมชาติ[1, ∞)โดยที่แต่ละตัวเลขซ้ำnครั้ง

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

ป้องกันเส้นทแยงมุมนี้เป็นตารางอาร์เรย์จะคล้ายกับOEIS ลำดับ A134546

ท้าทาย

เขียนโปรแกรม / ฟังก์ชั่นที่ใช้เวลาสอง integers เชิงลบ n และ kและผลฉ_n (k)

ข้อมูลจำเพาะ

• กฎระเบียบมาตรฐาน I / O ใช้
• ช่องโหว่มาตรฐานจะต้องห้าม
• โซลูชันของคุณอาจเป็นดัชนี 0 หรือดัชนี 1 ดัชนีสำหรับ n และ / หรือ kแต่โปรดระบุว่า
• ความท้าทายนี้ไม่ได้เกี่ยวกับการหาวิธีการที่สั้นที่สุดในทุกภาษาค่อนข้างมันเป็นเรื่องเกี่ยวกับการหาวิธีการที่สั้นที่สุดในแต่ละภาษา
• รหัสของคุณจะได้รับคะแนนเป็นไบต์มักจะอยู่ในการเข้ารหัส UTF-8 เว้นแต่จะระบุไว้เป็นอย่างอื่น
• ฟังก์ชันในตัวที่คำนวณลำดับนี้ได้รับอนุญาตแต่รวมถึงการแก้ปัญหาที่ไม่ต้องพึ่งพาในตัว
• คำอธิบายแม้สำหรับภาษา "ปฏิบัติ" จะได้รับการสนับสนุน

กรณีทดสอบ

ในกรณีทดสอบเหล่านี้nคือ 1 ดัชนีและkเป็น 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

ในรูปแบบที่ดีขึ้นไม่กี่:

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

การดำเนินการอ้างอิง

นี้ถูกเขียนในHaskell

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

ลองออนไลน์!

ความท้าทายนี้ถูก sandboxed

Ruby , 32 28 23 ไบต์

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

ลองออนไลน์!

คำอธิบาย

ลองนึกภาพผลรวมเป็นพื้นที่ของรูปสามเหลี่ยมตัวอย่างด้วย n = 3 และ k = 10:

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

แล้วเราสรุปตามคอลัมน์แทนแถว: คอลัมน์แรกเป็นkแล้วk-n, k-2nและอื่น ๆ

Python 2 , 34 28 ไบต์

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

ลองออนไลน์!

ขอบคุณ Martin Ender, Neil และ Mr Xcoder ที่ช่วยเหลือ

Husk , 4 ไบต์

Σ↑ṘN

ลองออนไลน์!

คำอธิบาย

นี่เป็นเพียงการแปลโดยตรงของการดำเนินการอ้างอิงในการท้าทาย:

   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 ไบต์

+/∘⌈÷⍨∘⍳

ลองออนไลน์!

nทางซ้ายk(0 ดัชนี) ทางด้านขวา

Mathematica ขนาด 40 ไบต์

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

ลองออนไลน์!

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

ลองออนไลน์!

Mathematica ขนาด 18 ไบต์

โดย Martin Ender

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

ลองออนไลน์!

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

ลองออนไลน์!

MATL , 12 11 ไบต์

:iY"Ys0h1G)

ลองออนไลน์!

kมีการจัดทำดัชนี 0 รับอินพุตในลำดับย้อนกลับ

บันทึกแล้ว 1 ไบต์ขอบคุณ @Giuseppe

เยลลี่ 5 ไบต์

Rxḣ³S

อีกหนึ่งไบต์มากกว่า @Mayxcoder ของสารละลาย Jelly แต่นี่คือการส่งครั้งแรกของฉันใน Jelly และฉันยังคงสับสนเกี่ยวกับวิธี tacitness ของ Jelly เลือก operand ดังนั้นฉันยังคงพอใจ หมายเหตุการสั่งซื้อของปัจจัยการผลิตที่มีแล้วkn

คำอธิบาย

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

ลองออนไลน์!

เยลลี่ขนาด 4 ไบต์

1 การจัดทำดัชนี

Ḷ:‘S

ลองออนไลน์! หรือดูชุดทดสอบ

JavaScript (ES6),  24  21 ไบต์

(n)(k)จะเข้าในไวยากรณ์ currying ผลตอบแทนแทนfalse0

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

กรณีทดสอบ

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

อย่างไร?

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

นี้จะคล้ายกับ@ GB คำตอบของทับทิม

ความท้าทายอธิบายวิธีสร้าง 'บันได' จากซ้ายไปขวาในขณะที่ฟังก์ชันเรียกซ้ำนี้สร้างจากล่างขึ้นบน ด้วยn = 2และk = 11 :

แบตช์ 34 ไบต์

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

สูตรปิดรูปแบบที่ฉันพบ อาร์กิวเมนต์แรกnคือดัชนี 1 ดัชนีอาร์กิวเมนต์ที่สองkคือ 0 ดัชนี

Python 2 , 29 ไบต์

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

ลองออนไลน์!

ขอบคุณมนุษย์โดยสิ้นเชิงสำหรับ -3 ไบต์!

Python 2 , 30 ไบต์

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

ลองออนไลน์!

Haskell , 28 ไบต์

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

ลองออนไลน์!

วิธีการที่ฉันพบโดยเพียงแค่ขันรอบด้วยพารามิเตอร์บางช่วง แน่นอนที่สุดไม่ใช่สั้นที่สุด แต่ก็ค่อนข้างเจ๋งว่ามีวิธีการมากมายหลายวิธี

C, 38 34 ไบต์

นิยามแบบเรียกซ้ำ

-4 ไบต์ขอบคุณที่Steadybox

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

ลองออนไลน์!

32 bytes by Mr. Xcoder , GB

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

ลองออนไลน์!

R , 37 33 31 ไบต์

-6 ไบต์ขอบคุณ Giuseppe

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

ลองออนไลน์!

ไม่มีอะไรแฟนซี จับกรณีเมื่อ k = 0[0:k]

C ++, 53 ไบต์

เพียงใช้สูตร nได้รับการจัดทำดัชนี 1 และได้รับการจัดทำดัชนีk0

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

ลองออนไลน์!

J , 13 ไบต์

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

มันทำงานอย่างไร:

อาร์กิวเมนต์ซ้ายคือ n, ด้านขวาคือ k

i. สร้างรายการ 0..k-1

1+ เพิ่มหนึ่งรายการไปยังแต่ละหมายเลขของรายการ, Yealding 1,2, ... , k

# จัดรูปแบบของ hook ข้างต้นดังนั้นจึงไม่มีการคัดลอกแต่ละองค์ประกอบของรายการ

]{. ใช้ n แรกของพวกเขา

1#. หาผลรวมโดยการแปลงฐาน

ลองออนไลน์!

Retina , 29 26 ไบต์

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

ลองออนไลน์! ลิงก์ประกอบด้วยกรณีทดสอบและส่วนหัวเพื่อจัดรูปแบบใหม่เป็นอินพุตที่ต้องการ (ดัชนี 0 kก่อน, 1 nวินาทีดัชนี) ฉันได้แรงบันดาลใจจากคำตอบ Ruby ของ @ GB คำอธิบาย:

\d+
$*

แปลงเป็นเอก

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

จับคู่สตริงnภายในkทั้งหมดและแทนที่การแข่งขันด้วยทุกอย่างหลังจากการแข่งขัน แห่งนี้ตั้งk-n, k-2n, k-3nแต่nยังเป็นหลังจากที่การแข่งขันเพื่อให้คุณได้รับk, k-n, k-2nฯลฯ นอกจากนี้ยังตรงnซึ่งจะถูกลบออกเพียง (มันไม่จำเป็น)

1

รวมผลลัพธ์และแปลงกลับเป็นทศนิยม

Pyth , 5 ไบต์

s%_ES

ลองที่นี่!

พอร์ตของคำตอบ Ruby ของ GB พอร์ตของ Jelly ของฉันจะมีขนาด 6 ไบต์:+s/Rvz

Perl 6 , 39 ไบต์

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

ทดสอบมัน

nและ kเป็นทั้ง 1 อย่าง

ขยาย:

-> \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 ไบต์

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

ลองออนไลน์!

Java (OpenJDK 8) , 23 ไบต์

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

ลองออนไลน์!

ท่าเรือGB ของงูหลาม 2 คำตอบ

05AB1E , 9 ไบต์

FL`}){I£O

ลองออนไลน์!

คำอธิบาย

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 ไบต์

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

ลองออนไลน์!

Python 2 , 38 ไบต์

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

ลองออนไลน์!

Clojure, 54 ไบต์

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

อาร์กิวเมนต์ที่ 2 kถูกทำดัชนี 0 ดังนั้น(f 14 20)เท่ากับ 28

APL + WIN, 13 ไบต์

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

แสดงพร้อมต์สำหรับอินพุตหน้าจอสำหรับ n และจากนั้นสำหรับ k ดัชนีกำเนิด = 1

Brain-Flakขนาด 78 ไบต์

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

ลองออนไลน์!

ฉันแน่ใจว่านี่สามารถทำได้ดีกว่า แต่มันเป็นการเริ่มต้น

Japt , 7 6 ไบต์

ตอนแรกได้แรงบันดาลใจจากโซลูชันของ GBและพัฒนาเป็นพอร์ต!

ใช้kเป็นอินพุตแรกและnเป็นวินาที

õ1Vn)x

ลองมัน

คำอธิบาย

อินพุตโดยนัยของจำนวนเต็มU=k& V=n. สร้างอาร์เรย์ของจำนวนเต็ม ( õ) จาก1ถึงUด้วยขั้นตอนVเมื่อตะกี้ ​​( n) และลดลงโดยการเพิ่ม ( x)

R , 27 ไบต์

ฟังก์ชั่นไม่ระบุชื่อที่ใช้kและnในลำดับที่ สร้างรายการความยาวk(อาร์กิวเมนต์ที่สามถึงrep) ที่ประกอบด้วย1ถึงk(อาร์กิวเมนต์แรกถึงrep) โดยทำซ้ำแต่ละองค์ประกอบnเวลา (อาร์กิวเมนต์ที่สี่ถึงrep ) จากนั้นนำผลรวมของรายการนั้น

nได้รับการจัดทำดัชนี 1 และได้รับการจัดทำดัชนีk0 n<1กลับข้อผิดพลาดสำหรับ

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

ลองออนไลน์!

Befunge ขนาด 27 ไบต์

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

ลองใช้ออนไลน์

นำ k แล้ว n เป็นอินพุต ใช้คำตอบของ GB เป็นพื้นฐานทางคณิตศาสตร์