Créez une fonction qui prend un nombre naturel (à partir de 0 inclus) et renvoie une paire d'entiers positifs, qui sont respectivement le numérateur et le dénominateur. Utilisez la traversée diagonale. Les nombres comptés précédemment doivent être ignorés. (vous pouvez mémoriser l'ensemble des valeurs ignorées)

Diagramme:

Les valeurs rouges sont ignorées

Valeurs:

• f (0) = 1, 1
• f (1) = 2, 1
• f (2) = 1, 2
• f (3) = 1, 3
• f (4) = 3, 1 (remarquez le saut)
• f (5) = 4, 1
• f (6) = 3, 2
• f (7) = 2, 3
• f (8) = 1, 4
• f (9) = 1, 5
• f (10) = 5, 1 (remarquez le saut)

Vous pouvez utiliser la structure de données Rational et leurs opérations si elles existent. Le code le plus court gagne.

J, 41 36 caractères

Prend un entier et retourne un vecteur comprenant deux entiers. Ma première solution qui n'est ni entièrement tacite ni entièrement explicite.

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

Voici la solution avec des espaces insérés le cas échéant:

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

Une explication:

1. x (, % +.) y–Un vecteur de longueur 2 représentant la fraction avec numérateur xet dénominateur yréduit au plus petit dénominateur
2. 1 + i. 1 + y–Un vecteur d'entiers de 1ày + 1
3. (, % +.)"0/~ 1 + i. 1 + y–Une matrice de toutes les fractions réduites avec dénominateur et numérateur non réduits dans la plage de 1à y + 1.
4. <`(<@|.)/. y–Un tableau des diagonales obliques de la matrice y, mutuellement inversées en diagonale
5. ~. ; y–Un tableau de diagonales réduites en un vecteur d'éléments dont les doublons ont été supprimés
6. x { y-Le point à la position xdansy
7. (u v) y–Le même que y u v y. Dans ce cas d'utilisation particulier, uest {et vest3 : '~. ; <`(<@|.)/. (, % +.)"0/~ 1 + i. 1 + y'

Haskell, 78 caractères

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

Exemple d'exécution:

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

• Edit: (100 → 87) idiot moi, il suffit de tester le gcd!
• Edit: (87 → 85) astuce astucieuse avec cycleet fonctions pour alterner l'ordre des lignes
• Modifier: (85 → 82) remplacer cyclepar la liste infinie construite à la maind
• Edit: (82 → 78) gcdidentité appliquée comme suggéré par Matías

Python, 144 caractères

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]

Rubis 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 + Batteries, 182 168 caractères

C'est ce qui serait naturel dans Haskell mais n'est à peine possible que dans 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))

Edit: la diagonale n'est pas nécessaire

Perl 6 , 75 octets

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

Essaye-le

Cela génère essentiellement la séquence entière de valeurs rationnelles, ne s'arrêtant qu'une fois la valeur indexée générée.

(Basé sur mon golf à un autre défi.)

Étendu:

{  # 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}…*)génère la séquence infinie de numérateurs ( |(…)est utilisé ci-dessus pour aplatir)

(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}…*) génère la séquence infinie de dénominateurs

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