멋진 제목없는 시퀀스

19

각 숫자가 n 번 반복되는 자연수 [1, ∞) 의 첫 번째 k 항의 합으로 f n (k) 을 정의 해 봅시다 .

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 과 유사합니다 .

도전

음이 아닌 두 정수 n과 k 를 취하고 f n (k)를 출력 하는 프로그램 / 함수 를 작성하십시오 .

명세서

  • 표준 I / O 규칙이 적용됩니다 .
  • 표준 허점 은 금지되어 있습니다.
  • 귀하의 솔루션 은 n 및 / 또는 k에 대해 0 인덱싱되거나 1 인덱싱 될 수 있지만 어느 것을 지정하십시오.
  • 이 과제는 모든 언어에서 가장 짧은 방법을 찾는 것이 아니라 각 언어에서 가장 짧은 방법을 찾는 것입니다 .
  • 달리 지정하지 않는 한 코드는 일반적으로 인코딩 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..]

온라인으로 사용해보십시오!

이 도전은 샌드 박스였습니다.

code-golf  math  number  sequence 
— 완전히 인간적인
소스
내 편집 내용이 형식을 개선한다고 생각합니까, 아니면 내 브라우저에만 있습니까?
— user202729
@ user202729 Heh ... 브라우저에서 보이지만 대부분의 브라우저에서 형식이 잘 보이지 않는 것 같습니다 ... 그런 식으로 유지하면 아무런 의미가 없습니다. 이상해 보인다. : P
— 완전히 인간적인
우리가 사건 처리해야 하는가 f_n(0) = 0에 대한 k인덱스 0을?
— Cinaski
9
" 멋진 제목없는 시퀀스가 ​​중요합니다. "Lol, 내가 만든 시퀀스의 이름을
— 찾는
3
@Fabian 아니요, 첫 번째 k용어가 아닌 반복 된 자연수 목록에서 첫 번째 용어 만 합산합니다 n*k.
— Martin Ender

답변:

12

루비 , 32 28 23 바이트

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

온라인으로 사용해보십시오!

설명

합계를 삼각형의 면적으로 시각화 해 보겠습니다 (예 : n = 3 및 k = 10).

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

그런 다음 행 대신 열을 기준으로 합산합니다. 첫 번째 열은 k, 그런 다음 k-n등 k-2n입니다.

— GB
소스
5

젤리 , 5 바이트

Rxḣ³S

@ Mr.Xcoder의 Jelly 솔루션보다 하나 더 많은 바이트이지만 이것은 Jelly에서 처음 제출 한 것으로 Jelly의 암묵성이 피연산자를 선택하는 방식에 대해 여전히 혼란 스럽습니다. 그래서 나는 여전히 만족합니다. 입력 순서는 k다음과 같습니다 n.

설명

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

자바 스크립트 (ES6),  24  21 바이트

카레 구문으로 입력을 (n)(k)받습니다. false대신에를0 반환 합니다 .

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

테스트 사례

코드 스 니펫 표시

어떻게?

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의 Ruby answer 와 유사합니다 .

문제는 왼쪽에서 오른쪽으로 '계단'을 만드는 방법을 설명하는 반면이 재귀 함수는 아래쪽에서 위쪽으로 만듭니다. 함께 N = 2 및 K = 11 :

계단

— 아르나 울드
소스
3

배치, 34 바이트

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

내가 찾은 폐쇄 형 공식. 첫 번째 인수 n는 1 인덱싱되고 두 번째 인수 k는 0 인덱싱됩니다.

— 닐
소스
3

C, 38 34 바이트

재귀 적 정의.

Steadybox 덕분에 -4 바이트 .

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

온라인으로 사용해보십시오!

Mr. Xcoder 의 GB 별 32 바이트

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

온라인으로 사용해보십시오!

— 콜라 수
소스
— Mr. Xcoder
1
GB의 접근 방식, 32 바이트 사용
— Mr. Xcoder
tio.run/…- > 28 바이트
— GB
1
34 바이트 (재귀 버전) : f(n,k){return k--?1+f(n,k)+k/n:0;} 온라인으로 사용해보십시오!
— Steadybox
3

R , 37 33 31 바이트

주세페 덕분에 -6 바이트

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

온라인으로 사용해보십시오!

멋진 것은 없습니다. 처리하는 경우 K = 0.[0:k]

— NofP
소스
1
여기서 버팀대를 제거 할 수 있습니다. 당신의에서 주문 인수를 사용하는 경우 rep.default, 당신은 제거 할 수 [0:k]사용 rep(1:k,,k,n)하지만 당신의 대답은 기본적으로 rturnbull의하지만 기본 R과보다는이다R + pryr
— 주세페
1
여전히 버팀대를 제거 할 수 있습니다! {}
— 주세페
[0 : k] 대체는 나를
— 가져 왔고
2

C ++, 53 바이트

공식을 사용하십시오. n1 인덱싱되고 k0 인덱싱됩니다.

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

온라인으로 사용해보십시오!

— 콜라 수
소스
~연산자 를 남용하여 몇 바이트를 저장하십시오 . [](int n,int k){return-k/n*~(k/n)/2*n-k%n*~(k/n);};
— ceilingcat
2

J , 13 바이트

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

작동 방식 :

왼쪽 인수는 n이고 오른쪽 인수는 k입니다.

i. 목록 0..k-1을 생성합니다

1+ 1,2, ..., k를 예리하게하여 목록의 각 번호에 하나씩 추가

# 위와 함께 후크를 형성하므로 목록의 각 요소에 대해 n 개의 사본이 복사됩니다.

]{. 처음 n 개를 가져 가라

1#. 기본 전환으로 합계를 찾습니다.

온라인으로 사용해보십시오!

— 갈렌 이바노프
소스
나는 고리를 좋아한다.
— cole
2

망막 , 29 26 바이트

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

온라인으로 사용해보십시오! Link에는 테스트 케이스와 헤더가 포함되어 선호하는 입력으로 다시 형식화합니다 (0- 인덱스 된 k첫 번째, 1- 인덱스 된 n두 번째). @GB의 Ruby 답변에서 영감을 받았습니다. 설명:

\d+
$*

단항으로 변환합니다.

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

n내의 모든 문자열을 k일치시키고 일치 후 일치하는 모든 항목을 대체하십시오. 이것은 k-n, k-2n, k-3n, 그러나 n또한 경기 후, 당신이 얻을 수 있도록이다 k, k-n, k-2n등이 또한 일치 n, 단순히 (그것은 더 이상 필요한)이 삭제된다.

1

결과를 합산하고 다시 10 진수로 변환합니다.

— 닐
소스
2

펄 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
}
— 브래드 길버트 b2gills
소스
1

클로저, 54 바이트

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

두 번째 인수 k는 0- 인덱싱되므로 (f 14 20)28입니다.

— 니코 니르
소스
1

APL + WIN, 13 바이트

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

n을 입력 한 다음 k를 입력하라는 메시지를 표시합니다. 인덱스 원점 = 1

— 그레이엄
소스
1

Japt , 7 6 바이트

원래 영감을 얻은 GB의 솔루션에서 포트로 진화했습니다!

걸리는 k제 입력으로하고 n두 번째로.

õ1Vn)x

시도 해봐

설명

정수 U=k& 의 암시 적 입력 V=n. 음수 단계 ( õ)를 사용 1하여 정수 배열 ( )을 생성하고 덧셈 ( )으로 줄 입니다.UVnx

— 얽히고 설킨
소스
1

R , 27 바이트

k그리고 n그 순서대로 익명 함수 . through (첫 번째 인수 to ) 로 구성된 길이 목록 k(세 번째 인수 to rep)을 작성하고 각 요소 시간을 반복합니다 (네 번째 인수1krepnrep ). 그런 다음 해당 목록의 합계를 가져옵니다.

n1 인덱싱되고 k0 인덱싱됩니다. 에 대한 오류를 반환합니다 n<1. 

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

온라인으로 사용해보십시오!

— 루 턴불
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.