Sie können eine Liste aller Rationen 0 <r ≤ 1 erstellen, indem Sie sie zuerst nach Nenner und dann nach Zähler sortieren:

1  1  1  2  1  3  1  2  3  4  1  5  1  2  3  4  5
-  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
1  2  3  3  4  4  5  5  5  5  6  6  7  7  7  7  7

Beachten Sie, dass wir alle rationalen Zahlen überspringen, die bereits zuvor vorkamen. ZB 2/4 wird übersprungen, weil wir bereits 1/2 aufgelistet haben.

In dieser Herausforderung interessieren uns nur die Zähler. Schreiben Sie in der obigen Liste eine Funktion oder ein Programm mit einer positiven Ganzzahl n , die den n-ten Zähler aus der Liste zurückgibt .

Testfälle:

1 -> 1
2 -> 1
3 -> 1
4 -> 2
5 -> 1
6 -> 3
7 -> 1
8 -> 2
9 -> 3
50 -> 4
80 -> 15

MATL , 17 13 Bytes

:tt!/XR6#uG))

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Die Eingabegröße kann durch die Gleitkommagenauigkeit begrenzt sein. Alle Testfälle liefern das richtige Ergebnis.

Erläuterung

Dies erzeugt alle Brüche k/mmit k, min [1 2 ...n], als n× nMatrix. Die Zeile gibt den Zähler und die Spalte den Nenner an. Tatsächlich enthält der Matrixeintrag m/kstattdessen den inversen Bruch , k/mwas jedoch irrelevant ist und in der weiteren Erläuterung ignoriert werden kann.

Matrixeinträge gelten implizit als in der Reihenfolge des Spaltenhauptteils sortiert. In diesem Fall entspricht dies der erforderlichen Reihenfolge: Nenner, dann Zähler.

Drei Arten von Einträgen müssen in dieser Matrix nicht berücksichtigt werden:

1. Einträge k/m, k>mdie den gleichen Wert haben wie ein vorheriger Eintrag (wird beispielsweise 2/4ignoriert, weil es der gleiche ist wie 1/2)
2. Einträge k/k, k>1. Einträge, deren Zähler den Nenner überschreitet
3. Einträge k/m, k<m(diese sind nicht Teil des Problems).

Das Ignorieren von Einträgen erfolgt mit einer uniqueFunktion, die doppelte Werte stabil entfernt und die Indizes der überlebenden Einträge ausgibt. Einträge vom Typ 1 werden dabei automatisch entfernt. Für die Typen 2 und 3 werden die Matrixeinträge in der Diagonale und darunter auf gesetzt 0. Auf diese Weise werden alle Null-Einträge mit Ausnahme des ersten entfernt (entsprechend dem gültigen Bruch 1/1).

Betrachten Sie die Eingabe 4als Beispiel.

:     % Input n implicitly. Push range [1 2 ...n]
      % STACK: [1 2 3 4]
t     % Duplicate
      % STACK: [1 2 3 4], [1 2 3 4]
t!    % Duplicate and transpose
      % STACK: [1 2 3 4], [1 2 3 4], [1; 2; 3; 4]
/     % Divide element-wise with broadcast: gives matrix with all pairs
      % STACK: [1 2 3 4], [1       2       3       4;
                           0.5000  1       1.5000  2;
                           0.3333  0.6667  1       1.3333;
                           0.2500  0.5000  0.7500  1     ]
XR    % Upper triangular part above the diagonal. This sets to 0 all entries
      % corresponding to fractions that equal or exceed 1. (Since the matrix
      % actually contains the inverse fractions, nonzero entries will contain
      % values greater than 1)
      % STACK: [1 2 3 4], [0       2       3       4;
                           0       0       1.5000  2;
                           0       0       0       1.3333;
                           0       0       0       0     ]
6#u   % Indices of first appearance of unique elements
      % STACK: [1 2 3 4], [1; 5; 9; 10; 13; 15]
G     % Push input n again
      % STACK: [1 2 3 4], [1; 5; 9; 10; 13; 15], 4
)     % Index: get the n-th entry from the array of indices of unique elements
      % STACK: [1 2 3 4], 10
)     % Index (modular): get the corresponding real part. Display implicitly
      % STACK: 2

Jelly , 11 9 Bytes

gRỊTµ€Fị@

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

gRỊTµ€Fị@  Main link. Argument: n

    µ€     Map the monadic chain to the left over [1, ..., n]; for each k:
 R           Range; yield [1, ..., k].
g            Compute the GCD of k and each j in [1, ..., k].
  Ị          Insignificant; yield 1 for 1; 0 for 2, ..., k.
   T         Truth; yield all indices of 1's, i.e., all coprimes with k.
      F      Flatten the resulting 2D array.
       ị@    At-index swapped; return the n-th element.

Mathematica, 53 Bytes

(Join@@Select[Range@a,a~GCD~#==1&]~Table~{a,#})[[#]]&

Haskell, 40 Bytes

((0:[n|d<-[1..],n<-[1..d],gcd n d<2])!!)

Eine anonyme Funktion. Ziemlich einfach: Verwendet ein Listenverständnis, um eine unendliche Liste zu generieren, die alle Zähler nund relativ primitiven Nenner durchläuft d. Um einen Index von Null in einen Index von Eins zu konvertieren, stellen wir ein voran 0, das 4Bytes benötigt.

Pyth, 13 Bytes

@smfq1idTUhdh

Probieren Sie es online aus. Testsuite.

Pyth, 11 Bytes

@sm.mibdhdS

Probieren Sie es online aus: Demonstration

Erläuterung:

@sm.mibdhdSQQ   implicit Qs at the end (Q = input number)
  m       SQ    map each denominator d from [1, 2, ..., Q] to:
   .m   hd        select the numerators b from [0, 1, ..., d]
     ibd             for which gcd(b, d) == 1 (which is the smallest possible gcd)
                  this gives [0, 1] for d=1, [1] for d=2, [1,2] for d=3, ...
 s              combine all lists to a big one
@           Q   print the Qth element

Eigentlich 15 Bytes

Diese Antwort basiert auf Dennis 'Jelly-Antwort . Ich benutze HNam Ende, um Probleme mit der 0-Indizierung zu vermeiden und n zu dekrementieren und am Anfang oder Ende zu tauschen. HRuft die ersten nMitglieder der Liste der Zähler ab, die sich ergeben, und Nruft das letzte Mitglied dieser Auswahl ab, dh den ndritten Zähler, ohne sich um Stapeloperationen zu kümmern. Golfvorschläge sind willkommen. Probieren Sie es online!

;R`;r;)♀┤░`MΣHN

Ungolfing

          Implicit input n.
;         Duplicate n. Leave one n on the stack for getting the nth numerator at the end.
R`...`M   Map the following function over the range [1..n]. Variable m.
  ;         Duplicate m. Leave one m on the stack for checking coprimality later.
  r         Push the range [0...m].
  ;)        Move a duplicate of range [0...m] to BOS.
  ♀┤        Push a list of 0's and 1's where a 1 denotes a number coprime to m (a numerator),
             and 0 denotes a fraction we have counted before.
  ░         Filter the second list (range [0...m]) 
             by the truthy values in the first list (our coprime check).
Σ         Sum all of the lists in the result into one list.
H         Push result[:n] using the duplicate of n from the beginning of the program.
N         Push result[:n][:-1], which is the same as result[n-1], our nth numerator.
          Implicit return.

Python, 111 - 110 Bytes

from fractions import*
def g(n):
 x,y=1,1
 while n>1:
  x+=1
  if x>y:x,y=1,y+1
  if gcd(x,y)<2:n-=1
 return x

Der Bruch ist mit dargestellt x/y. Das Argument nwird dekrementiert, wenn ein neuer passender Bruch gefunden wird (die gcdfrom fractionschecks können den Bruch reduzieren). In jeder Iteration der Schleife xerhöht wird, dann, wenn x>=yeine neue Serie von Fraktionen mit y+1gestartet wird, >wegen des „Sonderfalls“ (x,y)=(2,1), golfed zu x>y.

Ich bin mir sicher, dass man mehr Golf spielen kann, aber ich vermisse, wo ich es verbessern könnte. Fand es.

Link zu Code und Testfällen

JavaScript (ES6), 95 Byte

n=>[...Array(n*n).keys()].filter(i=>i%n<=i/n&g(i%n+1,i/n+1|0)<2,g=(a,b)=>b?g(b,a%b):a)[n-1]%n+1

Erzeugt alle n²Brüche mit Zählern und Nennern von 1bis nund filtert diejenigen heraus, die größer als 1oder zuvor gesehen wurden, und nimmt dann den nth.

Perl, 82 + 2 ( -plFlag) = 84 Bytes

perl -ple '{{$d>$n?($n++,(grep!($n%$_||$d%$_),2..$d)&&redo):($n=1,$d++)}++$i!=$_&&redo;$_=$n}'

Ungolfed:

while (<>) {  # -p flag
    chomp();  # -l flag

    my $i = 0;
    my $n = 0;
    my $d = 0;

    for (;;) {
        for (;;) {
            if ($d <= $n) {
                $n = 1;
                $d++;
                last;
            }
            else {
                $n++;
                last unless grep { !($n % $_) && !($d % $_) } 2 .. $d;
            }
        }
        if (++$i == $_) {
            $_ = $n;
            last;
        }
    }
}
continue {
    print($_, "\n");
}

JavaScript (ES6), 76

x=>eval("for(g=(a,b)=>b?g(b,a%b):a,d=n=0;x;g(n,d)-1||--x)n=++n>d?(++d,1):n")

Weniger golfen

x=>{
  g=(a,b) => b ? g(b,a%b) : a; // gcd
  for (d=n=0; x; )
  {
     ++n;
     if (n > d)
     {
        ++d;
        n=1;
     }
     if (g(n,d) == 1) // if the fraction is irreducible 
        --x;
  }
  return n
}

Prüfung

f=
x=>eval("for(g=(a,b)=>b?g(b,a%b):a,d=n=0;x;g(n,d)-1||--x)n=++n>d?(d++,1):n")

;`1 -> 1
2 -> 1
3 -> 1
4 -> 2
5 -> 1
6 -> 3
7 -> 1
8 -> 2
9 -> 3
50 -> 4
80 -> 15`.split`\n`.forEach(
  r=>{
    var [a,k]=r.match(/\d+/g),r=f(a)
    console.log(r==k?'OK':'KO',a,r)
  }
)  

Clojure, 85 Bytes

#(if(= 1 %)1(numerator(nth(distinct(for[i(range)j(range 1(inc i))](/ j i)))(dec %))))

Verwendet das Listenverständnis, um eine Liste aller Rationalitäten zu erstellen, und filtert sie dann, um nur bestimmte zu erhalten. Nimmt nthden Listeneintrag und gibt seinen Zähler zurück. Für das erste Element ist auch eine separate Bedingung erforderlich, da Clojure den Zähler einer Ganzzahl nicht übernehmen kann. (Aus welchem ​​Grund auch immer, wenn eine Ganzzahl nicht Rational ist - https://goo.gl/XETLo2 )

Sehen Sie es online - https://ideone.com/8gNZEB