创建一个采用自然数（从0开始，包括0）的函数，并返回一对正整数，分别是分子和分母。使用对角线遍历。必须跳过以前计算的数字。（您可以记住跳过的值集）

图解：

红色是跳过的值

值：

• f（0）= 1、1
• f（1）= 2，1
• f（2）= 1、2
• f（3）= 1、3
• f（4）= 3，1（注意跳过）
• f（5）= 4，1
• f（6）= 3，2
• f（7）= 2，3
• f（8）= 1、4
• f（9）= 1、5
• f（10）= 5、1（请注意跳过）

您可以使用Rational数据结构及其操作（如果存在）。最短的代码获胜。

J，41 36个字符

取一个整数并返回一个包含两个整数的向量。我的第一个解决方案既不是完全默认的，也不是完全明确的。

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

这是在适当位置插入空格的解决方案：

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

一个解释：

1. x (, % +.) y–长度为2的向量，表示分子x和分母均y减小为最小分母的分数
2. 1 + i. 1 + y–从1到的整数向量y + 1
3. (, % +.)"0/~ 1 + i. 1 + y与来自未还原分子和分母中的范围内的所有降低馏分-a矩阵1来y + 1。
4. <`(<@|.)/. y–矩阵斜对角线的数组y，彼此对角线翻转
5. ~. ; y–对角线阵列折叠成元素的向量，并删除了重复项
6. x { y–位置x中的项目y
7. (u v) y–与相同y u v y。在此特定用例中，uis {和vis3 : '~. ; <`(<@|.)/. (, % +.)"0/~ 1 + i. 1 + y'

Haskell，78个字符

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

样品运行：

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

• 编辑：（100→87）愚蠢的我，只需测试gcd就足够了！
• 编辑：（87→85）巧妙的把戏cycle和功能可替换行顺序
• 编辑：（85→82）替换cycle为手工构建的无限列表d
• 编辑：（82→78）gcdMatías建议的应用身份

Python，144个字符

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]

红宝石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]}

OCaml +电池，182168个字符

这在Haskell中是很自然的，但是在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))

编辑：对角线是不必要的

Perl 6，75个字节

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

测试一下

这基本上会生成有理值的整个序列，只有在生成索引值后才停止。

（根据我对高尔夫的另一个挑战。）

展开：

{  # 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}…*)生成分子的无限序列（|(…)在上面用于展平）

(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}…*) 生成分母的无限序列

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