Tạo một hàm lấy số tự nhiên (bắt đầu từ 0), và trả về một cặp số nguyên dương, tương ứng là tử số và mẫu số. Sử dụng đường chéo. Các số đếm trước phải được bỏ qua. (bạn có thể ghi nhớ tập hợp các giá trị bị bỏ qua)

Biểu đồ:

Màu đỏ được bỏ qua

Giá trị:

• f (0) = 1, 1
• f (1) = 2, 1
• f (2) = 1, 2
• f (3) = 1, 3
• f (4) = 3, 1 (chú ý bỏ qua)
• f (5) = 4, 1
• f (6) = 3, 2
• f (7) = 2, 3
• f (8) = 1, 4
• f (9) = 1, 5
• f (10) = 5, 1 (chú ý bỏ qua)

Bạn có thể sử dụng cấu trúc dữ liệu Rational và các hoạt động của chúng nếu chúng tồn tại. Mã ngắn nhất sẽ thắng.

J, 41 36 ký tự

Lấy một số nguyên và trả về một vectơ gồm hai số nguyên. Giải pháp đầu tiên của tôi không hoàn toàn ngầm và cũng không hoàn toàn rõ ràng.

{3 :'~.;<`(<@|.)/.(,%+.)"0/~1+i.1+y'

Đây là giải pháp với khoảng trắng được chèn khi thích hợp:

{ 3 : '~. ; <`(<@|.)/. (, % +.)"0/~ 1 + i. 1 + y'

Một lời giải thích:

1. x (, % +.) yVectơ vectơ có độ dài 2 biểu thị phân số có tử số xvà mẫu số ygiảm xuống mẫu số nhỏ nhất
2. 1 + i. 1 + yVectơ vectơ của số nguyên từ 1đếny + 1
3. (, % +.)"0/~ 1 + i. 1 + yMa trận đơn giản của tất cả các phân số giảm với mẫu số và tử số chưa được xác định trong phạm vi từ 1đến y + 1.
4. <`(<@|.)/. yMảnganan của các đường chéo xiên của ma trận y, các đường chéo khác lật
5. ~. ; yMảng của các đường chéo được thu gọn thành một vectơ của các phần tử với các bản sao được loại bỏ
6. x { yMục ở vị trí xtrongy
7. (u v) yGiống như y u v y. Trong trường hợp sử dụng cụ thể này, ulà {và vlà3 : '~. ; <`(<@|.)/. (, % +.)"0/~ 1 + i. 1 + y'

Haskell, 78 ký tự

q(r,f)=[(r-b,b)|b<-f[1..r-1],r`gcd`b==1]
d=reverse:id:d
f=((zip[2..]d>>=q)!!)

Chạy mẫu:

> map f [0..10]
[(1,1),(2,1),(1,2),(1,3),(3,1),(4,1),(3,2),(2,3),(1,4),(1,5),(5,1)]
> f 100
(17,1)
> f 1000
(3,55)

• Chỉnh sửa: (100 → 87) tôi ngớ ngẩn, chỉ cần kiểm tra gcd là đủ!
• Chỉnh sửa: (87 → 85) mẹo thông minh với cyclevà các chức năng để thay thế thứ tự hàng
• Chỉnh sửa: (85 → 82) thay thế cyclebằng danh sách vô hạn được tạo bằng tayd
• Chỉnh sửa: (82 → 78) gcddanh tính được áp dụng theo đề xuất của Matías

Con trăn, 144 ký tự

def F(i):
 r,d,z=[1],1,[]
 while z[:i]==z:z+=[(x,y)for x,y in zip(r[::d],r[::-d])if all(x%j+y%j for j in r[1:])];d=-d;r+=[r[-1]+1]
 return z[i]

Hồng ngọc 1.9, 109 106

F=->n{x=y=d=1
e=0
n.times{(x+=d).gcd(y+=e)>1&&redo
x<2?d<0?d=0:(d,e=1,-1):y<2?e<0?e=0:(d,e=-1,1):0}
[x,y]}

Pin OCaml +, 182 168 ký tự

Đây là những gì sẽ là tự nhiên ở Haskell nhưng chỉ có thể có ở OCaml:

open LazyList
let rec r(i,j)=lazy(let a,b=if(i+j)mod 2=0then i,j else j,i in
Cons((a,b),filter(fun(c,d)->a*d<>c*b)(r(if j=1 then 1,i+1else i+1,j-1))))
let f=nth(r(1,1))

Chỉnh sửa: Đường chéo là không cần thiết

Perl 6 , 75 byte

{(({|(1…($+=2)…1)}…*)Z/(1,{|(1…(($||=1)+=2)…1)}…*)).unique[$_]}

Kiểm tra nó

Điều này về cơ bản tạo ra toàn bộ chuỗi các giá trị hợp lý, chỉ dừng lại khi giá trị được lập chỉ mục được tạo.

(Dựa trên golf của tôi để thử thách khác.)

Mở rộng:

{  # bare block lambda with implicit parameter $_

  (
      ( # sequence of numerators

        {
          |( # slip into outer sequence (flatten)

            1      # start at one
            …
            (
              $    # state variable
              += 2 # increment it by two each time this block is called
            )
            …
            1      # finish at one
          )

        }
        … * # never stop generating values
      )


    Z/   # zip using &infix:« /  » (generates Rats)


      ( # sequence of denominators

        1,  # start with an extra one

        {
          |( # slip into outer sequence (flatten)

            1
            …
            (
              ( $ ||= 1 ) # state variable that starts with 1 (rather than 0)
              += 2        # increment it by two each time this is called
            )
            …
            1
          )
        }
        … * # never stop generating values
      )


  ).unique                # get only the unique values
  .[ $_ ]                 # index into the sequence
}

({1…($+=2)…1}…*)tạo ra chuỗi tử số vô hạn ( |(…)được sử dụng ở trên để làm phẳng)

(1 2 1)
(1 2 3 4 3 2 1)
(1 2 3 4 5 6 5 4 3 2 1)
(1 2 3 4 5 6 7 8 7 6 5 4 3 2 1)
(1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1)
…

(1,{1…(($||=1)+=2)…1}…*) tạo ra chuỗi mẫu số vô hạn

1
(1 2 3 2 1)
(1 2 3 4 5 4 3 2 1)
(1 2 3 4 5 6 7 6 5 4 3 2 1)
(1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1)
(1 2 3 4 5 6 7 8 9 10 11 10 9 8 7 6 5 4 3 2 1)
…