Thứ hai Mini-Golf: Một loạt các thử thách golf-code ngắn , được đăng (hy vọng!) Vào mỗi thứ Hai.

Một chuỗi giống như Fibonacci có được bằng cách sử dụng cùng một phương pháp với chuỗi Fibonacci nổi tiếng ; nghĩa là, mỗi số F (n) được tìm thấy bằng cách thêm hai số trước đó vào chuỗi ( F (n) = F (n-1) + F (n-2) ) hoặc bằng cách trừ hai số tiếp theo ( F (n) = F (n + 2) - F (n + 1) ). Sự khác biệt chính là các chuỗi này có thể bắt đầu với hai số bất kỳ. Việc lập chỉ mục bằng không của các chuỗi này là không thể tranh cãi, nhưng hiện tại, chúng tôi sẽ sử dụng quy tắc này:

• Số thứ 0 trong một chuỗi giống như Fibonacci là số cuối cùng nhỏ hơn số trước.

Ví dụ, chuỗi Fibonacci có thể được viết dưới dạng 1, 0, 1, 1, 2, 3, 5..., vì vậy số thứ 0 trong chuỗi là đơn độc 0.

Thử thách

Mục tiêu của thử thách là viết một chương trình hoặc hàm có ba số nguyên, ở bất kỳ định dạng nào:

• A và B , hai số bắt đầu tạo một chuỗi.
• N , độ dài của chuỗi kết quả để đầu ra.

Và xuất ra số N đầu tiên của chuỗi, bắt đầu từ 0.

Chi tiết

• A , B và N có thể được thực hiện theo bất kỳ thứ tự và định dạng nào, miễn là chúng được phân tách rõ ràng. Nếu bạn sử dụng một thứ tự / định dạng khác, vui lòng chỉ định nó là gì.
• Bạn có thể giả sử rằng A , B và N luôn là các số nguyên dương.
• Bạn có thể giả sử rằng N không quá 100 và chuỗi kết quả sẽ không chứa x >= 2^31.
• Nếu A lớn hơn B , thì B là số thứ 0 trong chuỗi.
• Đầu ra phải được phân tách bằng dấu cách, dấu phẩy và / hoặc dòng mới.
• Không gian dấu hoặc dòng mới được cho phép, nhưng không phải là dấu phẩy.

Các trường hợp thử nghiệm

Ví dụ 1:

8 13 10

Làm việc lạc hậu từ 8 13khi chúng tôi tìm thấy một số lớn hơn trước, chúng tôi nhận được 13 8 5 3 2 1 1 0 1. Do đó, 0là số thứ 0 trong chuỗi này. Tiếp tục thực hiện điều này, chúng tôi in ra 0và 9 thành viên tiếp theo:

0 1 1 2 3 5 8 13 21 34

Ví dụ 2:

23 37 5

Một lần nữa làm việc lạc hậu để tìm số 0, chúng tôi tìm thấy 37 23 14 9 5 4 1 3. Số thứ 0 lần này là 1, vì vậy chúng tôi in nó ra, cùng với 4 thành viên tiếp theo:

1 4 5 9 14

Ví dụ 3:

4 3 8

Với cái này, chúng ta không phải làm việc lạc hậu để tìm số thứ 0, vì 3nhỏ hơn 4:

3 7 10 17 27 44 71 115

Ví dụ 4:

29 47 11

Kết quả:

1 3 4 7 11 18 29 47 76 123 199

Chấm điểm

Đây là mã golf , vì vậy mã hợp lệ ngắn nhất tính bằng byte thắng. Tiebreaker đi đến trình gửi trước đó. Người chiến thắng sẽ được chọn vào thứ Hai tới, ngày 28 tháng 9. Chúc may mắn!

Chỉnh sửa: Xin chúc mừng người chiến thắng của bạn, @Jakube, sử dụng Pyth cho 23 byte tuyệt vời !

Bình thường, 23 byte

AQWgHGA,-HGG)VvwHA,H+GH

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Khá phong cách khác thường của lập trình Pyth. Đôi khi lập trình chức năng có nhược điểm của nó.

Giải trình:

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]

Võng mạc , 65 54 byte

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

Ở đây, <empty>đại diện cho một dòng dấu trống. Chạy mã dưới dạng một tệp duy nhất với -scờ.

Định dạng đầu vào là

A,B;N

trong đó các số được biểu diễn trong unary . Đầu ra là một danh sách được phân tách bằng dấu phẩy, cũng trong unary. Ví dụ:

8 13 10

sẽ là

11111111,1111111111111;1111111111

và năng suất

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

Giải trình

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

Đầu tiên, chúng tôi giảm Avà Bxuống phần tử 0 và -1. Lệnh +Retina tiếp tục lặp lại thay thế regex này cho đến khi regex dừng khớp hoặc thay thế không sửa đổi chuỗi. Regex bắt Avào nhóm 1 với (1*), và sau đó đảm bảo rằng Bít nhất là lớn như Atrong khi bắt B-Avới \1(1*)nhóm 2. Điều này đảm bảo rằng vòng lặp này chấm dứt một lần A>B.

Sự thay thế chỉ đơn giản là biến A,Bthành B-A,Abằng cách đặt trận đấu thành $2,$1.

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

Bây giờ chúng ta đã có số đầu ra cần thiết đầu tiên trong chuỗi (cũng như số đầu ra trước nó, chúng ta sẽ cần loại bỏ sau). Sự thay thế này bây giờ thêm một số khác là tổng của hai số cuối trong khi lấy 1từ N. Bởi vì chúng tôi đã có một số, chúng tôi chỉ muốn điều này xảy ra N-1. Chúng tôi làm điều này bằng cách đảm bảo \Brằng vẫn còn ít nhất ;11ở cuối chuỗi. Nếu chúng ta gọi hai giá trị cuối cùng của chuỗi Cvà Dsau đó regex bắt Cvào nhóm 1 và ,Dvào nhóm hai. Chúng tôi viết lại cho $1$2. Sau đó chúng tôi cũng viết $2$1mà dịch sang ,D+C. Lưu ý rằng chúng tôi không viết lại đơn 1mà chúng tôi đã khớpN, do đó giảm dần nó.

^1*,|;1
<empty>

Cuối cùng, chúng ta cần loại bỏ phần tử -1 của chuỗi, cũng như phần còn lại ;1từ Nđó, chúng ta chỉ cần thực hiện bằng cách khớp một trong hai phần tử đó và thay thế nó bằng chuỗi rỗng.

Python 2, 93 87 67 61 60 byte

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

Nhận đầu vào (dưới dạng danh sách python [8,10,13])

Làm việc trong nhiệm kỳ 0

Sau đó in ra chuỗi bổ sung cho đến khi đạt được độ dài

CJam, 26 23 byte

Cảm ơn Dennis vì đã tiết kiệm 3 byte.

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

Đưa đầu vào theo thứ tự N B A(cách nhau bởi bất kỳ loại khoảng trắng). In kết quả dưới dạng danh sách phân tách dòng mới và chấm dứt với một lỗi .

Kiểm tra nó ở đây.

Giải trình

Điều này tiến thêm một bước khi tìm phần tử thứ 0. Đó là, nó chấm dứt một khi một trong các giá trị là âm.

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.

Mê cung , 58 54 49 46 44 byte

Cảm ơn Sp3000 đã đề xuất sử dụng phủ định bitwise, giúp lưu hai byte.

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

Định dạng đầu vào là B A N. Đầu ra là một danh sách mới được phân tách.

Giải trình

(Hơi lỗi thời. Ý tưởng cơ bản vẫn giống nhau, nhưng cách bố trí mã bây giờ đã khác.)

Điều này sử dụng ý tưởng tương tự như câu trả lời CJam của tôi (vì vậy các khoản tín dụng vẫn thuộc về Dennis): khi quay lại chuỗi, chúng tôi không dừng lại cho đến khi chúng tôi nhận được giá trị âm (khiến chúng tôi có yếu tố -1 và -2 của chuỗi). Sau đó, chúng tôi bắt đầu thêm chúng trước khi in giá trị đầu tiên.

Điều này sử dụng một vài thủ thuật chơi golf Labyrinth tiện lợi. Chúng ta hãy đi qua mã trong các phần:

?"
}

IP bắt đầu ở ?bên phải (đọc A). Trên "(không có), nó đi vào ngõ cụt, vì vậy nó quay lại, thực hiện ?lại (đọc B). Cuối cùng, }di chuyển Bđến ngăn xếp phụ trợ. Ngõ cụt tiết kiệm một byte trên ngây thơ

?
?
}

Bây giờ vòng lặp tìm thấy phần đầu của chuỗi:

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

Các )((tăng-giảm) là một không-op, nhưng đó là cần thiết để đảm bảo rằng phía trên cùng của ngăn xếp là tích cực đến ngã ba (như vậy mà chỉ IP biến đông). :trùng lặp A, {di chuyển Btrở lại ngăn xếp chính, -tính toán A-B. Những gì chúng tôi thực sự muốn là B-Amặc dù, vì vậy `phủ nhận giá trị.

Đây là một ngã ba đường. Đối với kết quả âm tính, IP rẽ trái về phía ?, đọc Nvà di chuyển đến phần tiếp theo của chương trình. Nếu kết quả bằng 0, IP sẽ tiếp tục di chuyển về phía nam, rẽ vào góc và vẫn ở trong vòng lặp. Nếu kết quả là dương, IP sẽ rẽ phải (hướng tây), rẽ vào góc và rẽ phải (hướng tây một lần nữa) để nó cũng nằm trong vòng lặp. Tôi nghĩ rằng điều này có thể trở thành một mô hình phổ biến, để phân biệt các giá trị âm với các giá trị không âm (hoặc dương với không dương):

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

Ít nhất tôi chưa thể tìm thấy một bố cục nhỏ gọn / hữu ích hơn cho trường hợp này.

Dù sao, trong khi Akhông âm, vòng lặp tiếp tục, }di chuyển Ađến ngăn phụ và =hoán đổi Avà B.

Một lần Alà âm, ?đọc Nvà chúng ta chuyển sang vòng lặp thứ hai:

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

Chúng tôi biết điều đó Nlà tích cực, vì vậy chúng tôi có thể dựa vào IP rẽ trái (phía bắc). Phần thân vòng lặp bây giờ chỉ đơn giản là:

}}:=+:!\{{(

Trong các từ: di chuyển cả Nvà Alên ngăn xếp phụ trợ. Sao y B, hoán đổi bản sao với Avà thêm Avào bản sao khác của B. Nhân đôi nó một lần nữa để in giá trị hiện tại của B. In một dòng mới. Di chuyển Bvà Ntrở lại ngăn xếp chính và giảm dần N.

Mặc dù Nlà tích cực, IP sẽ rẽ phải (phía bắc) tiếp tục vòng lặp. Khi Nđạt đến 0, mã kết thúc theo một cách khá lạ mắt:

IP tiếp tục di chuyển thẳng về phía trước (phía tây). Các ?cố gắng đọc một số nguyên khác, nhưng chúng tôi đã đạt đến EOF, vì vậy nó thực sự đẩy 0thay thế. `cố gắng phủ nhận điều đó, nhưng đó vẫn là con số không. Vì vậy, IP vẫn di chuyển về phía tây, rẽ vào một góc, và sau đó tiếp tục di chuyển xuống phía dưới @để kết thúc chương trình.

Tôi tự hỏi liệu tôi có thể đặt nó @ở một vị trí thậm chí rẻ hơn không (hiện tại nó có giá 3 ký tự khoảng trắng) bằng cách biến ba "xung quanh `thành hợp chất không (như )(), nhưng tôi chưa thể làm cho nó hoạt động được.

C, 105 102 100 byte

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);}

Cảm ơn @ C0deH4cker vì đã chơi golf 2 byte!

Hãy thử trực tuyến trên Ideone .

Matlab / Octave, 115 125 byte

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

Hàm nên được gọi là f([8 13],10).

Ví dụ (Matlab):

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

Hoặc thử trực tuyến (Octave) .

Haskell, 67 65 56 byte

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

Cảm ơn @nimi đã góp ý

Điều này định nghĩa một hàm infix ternary %, được gọi trong định dạng (n%a)b, ví dụ:

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

Giải trình

Chức năng ghi vào nhị phân #, được xác định trên dòng đầu tiên, mất trong hai số nguyên avà bvà trả về vô hạn Fibonacci giống như chuỗi nơi avà bxảy ra như các yếu tố liên tiếp.

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.

Hàm %chỉ đơn giản là lấy các nphần tử đầu tiên của a#b.

> <>, 33 31 + 1 cho -v = 32 byte

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

Đầu vào phải được đẩy lên ngăn xếp bằng cách sử dụng -v vì phân tích số thập phân là không tầm thường trong> <>.

Giải trình :

Tôi sẽ đại diện cho ngăn xếp sau mỗi (nhóm) hoạt động. Nó bắt đầu bằng [F (n), F (n + 1), N]

Các dòng đầu tiên đi xuống serie đến nhiệm kỳ thứ 0 của nó:

& 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]

Dòng thứ hai đi lên serie cho đến khi nó đã in N điều khoả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)]

Java, 113 78 76 byte

Tín dụng vào ETHproduction để cung cấp thuật toán tôi sử dụng trong câu trả lời này.

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

Hãy thử ở đây .

Giải trình:

(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
}

Cách tiếp cận ban đầu, 113 93 byte

Trông golf hơn;)

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):"";}

Hãy thử nó ở đây .

Giải trình:

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.
    ;
}

Javascript (ES6), 83 73 63 byte

Điều này có thể đã được đánh golf đến mức tối đa. Chúng ta sẽ thấy.

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

Ung dung:

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
  }
}

Toán học 112

Sẽ chơi golf cuối cùng

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 byte

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

Bước chân em bé. Đây là chương trình CJam đầu tiên của tôi từ trước đến nay, vì vậy tôi tự hào rằng nó hoạt động tốt.

Nó nhận đầu vào ở dạng tương tự như trong các ví dụ.

Bây giờ tôi đã thấy tôi có thể giảm nó xuống còn 33 byte bằng cách sử dụng { ... }*cấu trúc.

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

Và tôi thậm chí có thể giảm nó thêm một lần nữa bằng cách sử dụng toán tử ternary để dọn sạch ngăn xếp và tạo ra lỗi.

Ruby, 141 byte

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 

Chấp hành

Hàm f tạo đầu ra mong muốn, tên đối số khớp với tên biến từ câu hỏi

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

Không có gì thông minh:

• Hàm u ( up ) tính n phần tử trong chuỗi Wikipedia bắt đầu bằng a, b bằng cách sử dụng đệ quy
• Hàm d ( xuống ) tìm phần tử thứ 0 và 1 cho hai phần tử kết thúc bằng cách sử dụng đệ quy
• Hàm f ( Dailymotion ) đặt hai cái lại với nhau

Toán học, 59 byte

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

Ruby, 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}

Được rút ngắn 6 byte khi thay thế vòng lặp for bằng Range.map

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}

Đã lưu thêm 2 byte bằng cách di chuyển câu lệnh in

Pyke, 24 byte (không cạnh tranh)

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

Hãy thử nó ở đây!

Thạch , 14 byte

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

Hãy thử trực tuyến!

Lisp thông thường, 91 byte

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

Hãy thử trực tuyến!