Monday Mini-Golf : 매주 월요일에 게시 되는 일련의 짧은 코드 골프 과제입니다.

피보나치는 유사 서열 유명한 동일한 방법하여 얻어지는 피보나치 시퀀스 ; 즉, 각 숫자 F (n) 은 시퀀스에서 이전 두 숫자를 더하거나 ( F (n) = F (n-1) + F (n-2) ) 다음 두 숫자를 빼서 ( F (n) = F (n + 2)-F (n + 1) ). 주요 차이점은 이러한 시퀀스는 두 숫자로 시작할 수 있다는 것입니다. 이 시퀀스의 0 인덱스는 논란의 여지가 있지만 지금은이 규칙을 사용합니다.

• 피보나치 유사 시퀀스에서 0 번째 숫자는 마지막 숫자이며 이전 숫자보다 작습니다.

예를 들어, 피보나치 시퀀스는로 쓰여질 수 있으므로 시퀀스 1, 0, 1, 1, 2, 3, 5...의 0 번째 숫자는 고독 0입니다.

도전

도전의 목표는 어떤 형식 으로든 세 개의 정수를 취하는 프로그램이나 함수를 작성하는 것입니다.

• 시퀀스 생성을 시작하는 데 사용되는 두 개의 숫자 A 와 B
• 출력 할 결과 시퀀스의 길이 N

그리고 0부터 시작하여 시퀀스 의 첫 N 번호를 출력합니다 .

세부

• A , B 및 N 은 눈에 띄게 분리되어있는 한 임의의 순서 및 형식으로 취해질 수있다. 다른 주문 / 형식을 사용하는 경우 그 형식을 지정하십시오.
• A , B 및 N 이 항상 양의 정수 라고 가정 할 수 있습니다 .
• N 이 100 이하인 것으로 가정 할 수 있으며 결과 시퀀스에는 포함되지 않습니다 x >= 2^31.
• 경우 A는 보다 큰 B 후, B는 시퀀스의 0 번째 숫자이다.
• 출력은 공백, 쉼표 및 / 또는 줄 바꿈으로 구분해야합니다.
• 후행 공백이나 줄 바꾸기는 허용되지만 후행 쉼표 는 사용할 수 없습니다 .

테스트 사례

예 1 :

8 13 10

8 13이전보다 큰 숫자를 찾을 때까지 거꾸로 작업 하면 얻을 수 13 8 5 3 2 1 1 0 1있습니다. 따라서이 0순서에서 0 번째 숫자입니다. 이것으로부터 앞으로, 우리는 인쇄 0하고 다음 9 명의 멤버를 출력합니다 :

0 1 1 2 3 5 8 13 21 34

예 2 :

23 37 5

다시 0 번째 숫자를 찾기 위해 거꾸로 작업하면을 찾을 수 37 23 14 9 5 4 1 3있습니다. 이번에는 0 번째 숫자가 1이므로 다음 4 명의 멤버와 함께 인쇄합니다.

1 4 5 9 14

예 3 :

4 3 8

이 숫자를 사용하면 0 3보다 작은 숫자를 찾기 위해 뒤로 작업 할 필요가 없습니다 4.

3 7 10 17 27 44 71 115

예 4 :

29 47 11

결과:

1 3 4 7 11 18 29 47 76 123 199

채점

이것은 code-golf 이므로 바이트 단위의 가장 짧은 유효한 코드가 이깁니다. Tiebreaker는 이전에 게시 된 제출물로 이동합니다. 우승자는 다음주 9 월 28 일 월요일에 선발됩니다. 행운을 빌어 요!

편집 : 놀라운 23 바이트를 위해 Pyth를 사용하여 우승자 인 @Jakube에게 축하드립니다 !

Pyth, 23 바이트

AQWgHGA,-HGG)VvwHA,H+GH

온라인으로 사용해보십시오 : 데모 또는 테스트 스위트

Pyth 프로그래밍의 특이한 스타일. 때때로 함수형 프로그래밍에는 단점이 있습니다.

설명:

AQWgHGA,-HGG)VvwHA,H+GH  Q = input list of the two starting numbers
AQ                       G, H = Q (unpacking Q)
  WgHG                   while H >= G:
      A,-HGG                G, H = [H - G, G]
            )            end while
              vw         read a number from input
             V           for N in range(^):
                H           print H
                 A,H+GH     G, H = [H, G + H]

망막 , 65 54 바이트

+`(1*),\1(1*)
$2,$1
+`(1*)(,1*);1\B
$1$2$2$1;
^1*,|;1
<empty>

여기에서 <empty>빈 줄을 나타냅니다. -s플래그를 사용 하여 코드를 단일 파일로 실행하십시오 .

입력 형식은

A,B;N

여기서 숫자는 단항 으로 표시됩니다 . 출력은 쉼표로 구분 된 목록이며 단항입니다. 예를 들어 :

8 13 10

될 것이다

11111111,1111111111111;1111111111

수율

,1,1,11,111,11111,11111111,1111111111111,111111111111111111111,1111111111111111111111111111111111

설명

+`(1*),\1(1*)
$2,$1

첫째, 우리는 감소 A하고 B0 번째와 -1 요소. 는 +어느 정규식 일치를 중지하거나 대체 문자열을 수정하지 않을 때까지이 정규식 대체를 계속 반복하는 망막을 알려줍니다. 정규식 캡처 A와 1 군으로 (1*)하고 있는지하게 B크지로서 적어도하다 A캡처하는 동안 B-A과 \1(1*)그이 루프가 종료되면 2 군 에이를 보장하지만 A>B.

대체는 단순히 회전 A,B로 B-A,A에 경기를 설정하여 $2,$1.

+`(1*)(,1*);1\B
$1$2$2$1;

이제 문자열에 필요한 출력의 첫 번째 숫자와 그 앞의 숫자가 이미 제거되어 있으며 나중에 제거해야합니다. 이 대체는 이제 1from 을 가져 오는 동안 마지막 두 숫자의 합계로 다른 숫자를 추가합니다 N. 우리는 이미 하나의 숫자를 가지고 있기 때문에 우리는 이것이 일어나기를 원합니다 N-1. 우리는 \B적어도 ;11문자열의 끝에 여전히 있음 을 보장 함으로써이 작업을 수행 합니다. 우리는 순서의 마지막 두 값을 호출하는 경우 C와 D, 다음 정규식 캡처 C그룹 1로와 ,D그룹이로. 우리는 그것들을 다시 쓴다 $1$2. 그리고 우리는 $2$1로 번역합니다 ,D+C. 주 우리는 하지 않는 하나의 다시 쓰기 1에 일치하는 우리를N따라서 감소합니다.

^1*,|;1
<empty>

마지막으로 시퀀스의 -1st 요소를 제거하고 ;1from 의 남은 부분을 제거해야합니다.이 N중 하나를 일치시키고 빈 문자열로 바꾸면됩니다.

파이썬 2, 93 87 67 61 60 바이트

i,j,l=input()
while j/i:i,j=j-i,i
exec"i,j=j,i+j;print i;"*l

입력을 얻는다 (리터럴 파이썬리스트 [8,10,13])

0 학기

그런 다음 길이에 도달 할 때까지 추가 순서를 인쇄합니다.

CJam, 26 23 바이트

3 바이트를 절약 해 준 Dennis에게 감사합니다.

q~{_@\-_g)}g\@{_@+_p}*t

입력을 순서대로 취합니다 N B A(모든 종류의 공백으로 구분). 결과를 개행으로 구분 된 목록으로 인쇄하고 error로 종료됩니다 .

여기에서 테스트하십시오.

설명

이것은 0 번째 요소를 찾을 때 한 단계 더 나아갑니다. 즉, 값 중 하나가 음수이면 종료됩니다.

q~      e# Read and evaluate input, pushing N, B and A on the stack.
{       e# do while...
  _@\-  e#   B, A = A, B-A
  _W>   e#   Check if A is still non-negative.
}g
\@      e# Reorder N B A into A B N.
{       e# Run the following N times...
  _@+   e#   A, B = B, A+B
  _p    e#   Print B.
}*
t       e# The last A, B are still on the stack. We remove them by trying to
        e# execute a ternary operator: it pops the first two values but then
        e# terminates the program with an error, because there is no third value.

미로 , 58 54 49 46 44 바이트

비트 단위 무효화 사용을 제안한 Sp3000 덕분에 2 바이트를 절약했습니다.

??#"{=
  ;  -
@"~~:}
~""
?
"}}:=
(   +
{{\!:

입력 형식은 B A N입니다. 출력은 개행으로 구분 된 목록입니다.

설명

(약간 구식입니다. 기본 아이디어는 여전히 동일하지만 코드 레이아웃이 다릅니다.)

이것은 내 CJam 답변과 같은 아이디어를 사용합니다 (그래서 크레딧은 여전히 ​​Dennis에게갑니다) : 시퀀스를 역 추적 할 때 음수 값을 얻을 때까지 멈추지 않습니다 (이는 시퀀스의 -1 및 2 번째 요소를 남깁니다). 그런 다음 첫 번째 값을 인쇄 하기 전에 추가를 시작 합니다.

이것은 몇 가지 멋진 미로 골프 트릭을 사용합니다. 섹션의 코드를 살펴 보겠습니다.

?"
}

IP는 ?오른쪽 에서 시작합니다 ( A). 상의 "는 막 다른 골목 안타 (무 연산), 그래서 그것은을 실행, 돌아 서서 ?(읽기 다시 B). 마지막으로 보조 스택 으로 }이동 B합니다. 막 다른 골목은 순진한 바이트를 절약합니다

?
?
}

이제 시퀀스의 시작 부분을 찾는 루프 :

)(:{
"  -
" "`?...
=}""

)((증가 - 감소)가 무 조작 없지만 스택 상단합니다 (IP 동쪽으로 회전하도록) 접합부에 긍정적 확인 것이 필요하다. :중복 A, {이동 B메인 스택으로 다시 -계산하여이 A-B. B-A그러나 우리가 정말로 원하는 것은 `그 가치를 부정하는 것입니다.

이것은 이제 4 방향 접합입니다. 부정적인 결과를 얻으려면 IP는 왼쪽 방향으로 돌아가서 프로그램의 다음 부분으로 ?읽고 N이동합니다. 결과가 0이면 IP는 계속 남쪽으로 이동하고 코너를 돌면서 루프에 남아 있습니다. 결과가 양수이면 IP는 우회전 (서쪽)을하고 코너에서 돌아 오며 또 다른 우회전 (서쪽으로 다시)을 취하므로 루프에도 남아 있습니다. 음수가 아닌 값과 음수가 아닌 값을 구별하기 위해 이것이 일반적인 패턴이 될 수 있다고 생각합니다.

                v
                "
               """>negative
non-negative <"""

적어도이 경우에는 더 작고 유용한 레이아웃을 찾을 수 없었습니다.

여하튼, 잠시는 A음이 아닌 루프가 계속된다 }동작 A보조 스택에 =스왑 A및 B.

일단 A, 음수 ?읽고 N우리는 두 번째 루프로 이동 :

 }:=+:
 }   !
?"({{\

우리는 그것이 N긍정적 이라는 것을 알고 있으므로 좌회전 (북쪽)을하는 IP에 의존 할 수 있습니다. 루프 바디는 이제 간단합니다 :

}}:=+:!\{{(

즉 , 보조 스택으로 N및 A보조 스택으로 이동합니다 . 복제 B하고 사본을 바꾸고 다른 사본에 A추가 A합니다 B. 의 현재 값을 인쇄하려면 다시 복제하십시오 B. 줄 바꿈을 인쇄하십시오. 메인 스택으로 이동 B하고 N다시 감소 N합니다.

N긍정적 이지만 IP는 루프를 계속 우회전 (북쪽)합니다. 일단 N0에 도달하면 코드는 다소 멋진 방식으로 종료됩니다.

IP는 계속 직진합니다 (서쪽). ?시도는 또 다른 정수를 읽을 수 있지만, 실제로 밀어 그래서 우리는 이미, EOF에 도달했습니다 0대신. `그것을 부정하려고 시도하지만 여전히 0입니다. 따라서 IP는 여전히 서쪽으로 이동하고 모퉁이를 돌린 다음 아래쪽으로 계속 이동 @하여 프로그램을 종료합니다.

@세 개 "를 `겹치지 않는 (예 :와 같이 )() 조합 하여 더 저렴한 위치 (현재 3 개의 공백 문자)를 배치 할 수 있는지 궁금 하지만 아직 그 작업을 수행 할 수 없었습니다.

C, 105 (102) 100 바이트

main(a,b,n,t){for(scanf("%d%d%d",&a,&b,&n);t=b-a,t>=0;a=t)b=a;for(;n--;b=t)t=a+b,printf("%d ",a=b);}

2 바이트를 골라내는 @ C0deH4cker에게 감사합니다!

Ideone에서 온라인으로 사용해보십시오 .

MATLAB / 옥타브 115 125 바이트

function x=f(x,n)
while x(2)>=x(1)
x=[abs(x(1)-x(2)) x];end
x=x([2 1]);for k=1:n-1
x=[x(1)+x(2) x];end
x=x(n:-1:1);

이 함수는로 호출해야합니다 f([8 13],10).

예 (Matlab) :

>> f([8 13],10)
ans =
     0     1     1     2     3     5     8    13    21    34

또는 온라인으로 사용해보십시오 (Octave) .

하스켈, 67 65 56 바이트

a#b|a>b=b:scanl(+)(a+b)(a#b)|1>0=(b-a)#a
n%a=take n.(a#)

제안에 @nimi에게 감사합니다

이것은 다음 %과 같은 형식으로 호출되는 삼항 삽입 함수를 정의합니다 (n%a)b.

> (10%8)13
[0,1,1,2,3,5,8,13,21,34]

설명

이진 중위 함수 #첫 줄에 정의는 두 정수 취하고 a및 b상기 무한 반환 피보나치 유사 서열 a및 b연속적인 요소로서 발생한다.

a#b                                       -- Define a#b:
   |a>b=                                  -- if a>b, then a#b is
        b:                                -- the sequence that starts with b and
          scanl(+)     (a#b)              -- continues with the sums of prefixes of a#b
                  (a+b)                   -- plus the additional term a+b;
                            |1>0=(b-a)#a  -- otherwise, it's (b-a)#a.

이 함수는 %단순히의 첫 번째 n요소를 취합니다 a#b.

> <>, -v = 32 바이트의 경우 33 31 + 1

&:{:@(?v:}-$&
-1;!?:&<$+{oan::$&

> <>에서는 10 진수 구문 분석이 중요하지 않으므로 -v를 사용하여 스택에서 입력을 푸시해야합니다.

설명 :

각 (그룹) 작업 후 스택을 나타냅니다. [F (n), F (n + 1), N]으로 시작합니다

첫 번째 줄은 serie를 0 번째 용어로 내립니다.

& removes N from the stack to put it into a register. [F(n), F(n+1)]
:{:@ move the stack and duplicate items to get [F(n+1), F(n), F(n+1), F(n)]
(?v compares the two top items of the stack and branch to the second line if F(n+1) < F(n) [F(n+1), F(n)]
:} move the stack and duplicate its top to get [F(n), F(n+1), F(n)]
- substracts the two top items and put the result on top of the stack [F(n), F(n+1) - F(n)]
$ switchs the top two values of the stack. [F(n+1) - F(n), F(n)]
& retrieve the value from the register. iteration complete, since [F(n+1) - F(n), F(n), N] can also be read as [F(n-1), F(n), N]

두 번째 줄은 N 항을 인쇄 할 때까지 세리 위로 올라갑니다.

< changes the code pointer direction to the left [F(0), F(-1)]
& retrieves the stored value back from the stack [F(0), F(-1), N]
:?!; copies N to compare it to 0, stops if it is [F(0), F(-1), N]
1- decreases it [F(0), F(-1), N-1]
& stores it back [F(0), F(-1)]
$:: makes the stack [F(-1), F(0), F(0), F(0)]
n{ prints the top of the stack then left shifts it [F(0), F(0), F(-1)]
ao displays a line feed (ascii character 0x0a) [F(0), F(0), F(-1)]
+ adds the two top values [F(0), F(-1) + F(0)]
$ switch the two top values. iteration complete since [F(-1) + F(0), F(0)] which can be read as [F(1), F(0)]

자바, 113 78 76 바이트

크레딧은 내가이 답변에 사용하는 알고리즘 을 제공 한 ETHproduction에갑니다 .

(a,b,n)->{for(;a<=b;b-=a)a=b-a;for(;n-->0;b+=a,a=b-a)System.out.println(b);}

여기를 보십시오 .

설명:

(a,b,n)->{
    for (;a<=b;b=b-a)a=b-a;  //Compute previous terms while a <= b
    for (;n-->0;b=a+b,a=b-a) //Compute and print next terms while n > 0
    System.out.println(b);   //Print term
}

원래 접근 방식, 113 93 바이트

더 골프처럼 보인다;)

String a(int a,int b,int n){return n<0?a+" "+a(b,a+b,n+1):n>0?a>b?a(b,a+b,-n):a(b-a,a,n):"";}

여기서 사용해보십시오 .

설명:

String a(int a, int b, int n){
    return 
    n < 0 ?                           //If n < 0
        a + " " + a(b, a + b, n + 1)  //Return a + next terms and increment n.
    :                                 //Else
        n > 0 ?                       //If n > 0
            a > b ?                   //If a > b
                a(b, a + b, -n)       //Negate n and return terms.
            :                         //If a <= b
                a(b - a, a, n)        //Generate previous term.
        :                             //If n == 0
            ""                        //Return nothing.
    ;
}

자바 스크립트 (ES6), 83 73 63 바이트

이것은 최대로 골프되었을 수 있습니다. 우리는 볼 수 있습니다.

(a,b,n)=>{while(a<=b)b-=a=b-a;for(;n--;console.log(a=b-a))b+=a}

언 골프 드 :

function f(a,b,n) {
  // repeat until we find the 0th item...
  while (a <= b) {  // if a = 5, b = 8:
    a = b - a;      // a = (8 - 5) = 3
    b = b - a;      // b = (8 - 3) = 5
  }
  // repeat n times...
  while (n-- > 0) { // if a = 5, b = 8:
    b += a;         // b = (8 + 5) = 13
    a = b - a;      // a = (13 - 5) = 8
    console.log(a); // print out each item
  }
}

매스 매 티카 112

결국 골프를 할 것인가

z[a_, b_, n_] := (
  f[0] := Min[a, b];
  f[1] := Max[a, b];
  f[x_] := f[x - 1] + f[x - 2];
  f /@ Range[n]
  )

CJam, 40 바이트

l~:A;{_@_@)<}{_@\-\}w\{A(:A0>}{_p_@+}w\;

걸음마. 이 프로그램은 처음으로 CJam 프로그램이므로 전혀 효과가 없습니다.

예제와 같은 형식으로 입력됩니다.

이제 { ... }*구문을 사용하여 33 바이트로 줄일 수 있음을 보았습니다 .

l~:A;{_@_@)<}{_@-z\}w\A{_p_@+}*;;

그리고 삼항 연산자를 사용하여 스택을 청소하고 오류를 생성하여 한 번 더 줄일 수도 있습니다.

루비, 141 바이트

def u a,b,n,z=""
n<1 ? z.chop : u(b,a+b,n-1,z+"#{a} ")
end 
def d a,b,z=0
a.abs>b ? z : d(b-a,a,[a,b]) 
end 
def f a,b,n
x,y=d a,b 
u x,y,n
end 

실행

f 함수는 원하는 출력을 생성하고 인수 이름은 질문의 변수 이름과 일치합니다.

f(8,13,10) # returns => "0 1 1 2 3 5 8 13 21 34"

영리한 것은 없습니다.

• u ( up ) 함수는 재귀를 사용하여 a, b로 시작하는 피보나치 시퀀스에서 n 개의 요소를 계산합니다.
• d ( down ) 함수는 재귀를 사용하여 두 끝 요소가 주어진 0 번째 및 1 번째 요소를 찾습니다.
• f ( 피보나치 ) 함수는 둘을 합칩니다

수학, 59 바이트

If[#>#2,LinearRecurrence[{1,1},#2+{0,#},#3],#0[#2-#,#,#3]]&

루비, 81 75 73

a,b,n=23,37,5;while(c=b-a)<a;b,a=a,c;end;p a;[*2..n].map{b=c+a;c,a=a,b;p b}

for-loop를 range.map으로 교체 할 때 6 바이트 단축

a,b,n=23,37,5;while(c=b-a)<a;b,a=a,c;end;p a;[*2..n].map{p b=c+a;c,a=a,b}

print 문을 이동하여 2 바이트를 더 절약했습니다.

파이크, 24 바이트 (비경쟁)

DA/IDA-],X_r)QVDsRe
R]);

여기 사용해보십시오!

젤리 , 14 바이트

Ḋ;_/Ɗ>/¿+⁹С/Ṗ

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

공통 리스프, 91 바이트

(lambda(a b n)(do((x a(- y x))(y b x))((> x y)(dotimes(k n)(print y)(psetf y(+ y x)x y)))))

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