İlk önce paydaya ve daha sonra numaraya göre sıralayarak listeleyerek tüm rasyonların 0 <r ≤ 1 listesini oluşturabilirsiniz:

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

Daha önce gerçekleşmiş olan herhangi bir rasyonel sayıyı atladığımızı unutmayın. Örneğin 2/4 atlandı çünkü zaten 1/2 tane listeledik.

Bu mücadelede sadece pay sahipleriyle ilgileniyoruz. Yukarıdaki listeye baktığımızda, listeden nt payını döndüren n pozitif bir tamsayı alarak bir işlev veya program yazın .

testcases:

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 bayt

:tt!/XR6#uG))

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

Giriş boyutu kayan nokta doğruluğu ile sınırlı olabilir. Tüm test durumları doğru sonucu verir.

açıklama

Bu, tüm fraksiyonlar oluşturur k/mile k, miçinde [1 2 ...n]bir şekilde, nx nmatris. Satır numarayı ve sütun da paydayı gösterir. Aslında, matris girişi m/kyerine ters fraksiyonu içerir k/m, ancak bu konu dışıdır ve açıklamanın geri kalanında göz ardı edilebilir.

Matris girişlerinin dolaylı olarak sütun ana düzenine göre sıralandığı kabul edilir. Bu durumda, bu istenen düzene karşılık gelir: payda, daha sonra pay.

Bu matristen üç tür girişin göz ardı edilmesi gerekir:

1. Girişler k/m, k>m(örneğin, daha önceki bir girdi olarak aynı değere sahip olduğu 2/4bu aynı olduğu için dikkate alınmaz 1/2)
2. Girişler k/k, k>1. Paydağı geçen bir pay sahibi olan girişler
3. Girişler k/m, k<m(bunlar sorunun bir parçası değildir).

Girişleri dikkate almamak unique, yinelenen değerleri kararlı bir şekilde kaldıran ve kalan girişlerin endekslerini çıkaran bir işlevle yapılır . Bununla, yukarıdaki 1 tipi girişler otomatik olarak kaldırılır. Tip 2 ve 3 ile ilgilenmek için, köşegen ve altındaki matris girişleri olarak ayarlanır 0. Bu şekilde, birincisi hariç tüm sıfır girişler kaldırılır (geçerli kesir karşılık gelir 1/1).

4Bir örnek olarak girişi düşünün .

:     % 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

Jöle , 11 9 bayt

gRỊTµ€Fị@

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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 bayt

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

Haskell, 40 bayt

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

Anonim bir işlev. Oldukça basit: tüm numaralar nve göreceli asal paydalar üzerinde döngü, sonsuz bir liste oluşturmak için bir liste anlama kullanır d. Sıfır dizini bir dizine dönüştürmek 0için 4baytları alan bir a hazırlarız.

Pyth, 13 bayt

@smfq1idTUhdh

Çevrimiçi deneyin. Test odası.

Pyth, 11 bayt

@sm.mibdhdS

Çevrimiçi deneyin: Gösteri

Açıklama:

@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

Aslında 15 bayt

Bu cevap Dennis'in Jelly cevabına dayanıyor . HNSonunda 0 indeksleme ile ilgili sorunları önlemek ve n 'i düşürmek ve başlangıçta veya sonunda değiştirmek zorunda kalıyorum . yığın işlemleriyle uğraşmadan sonuçlanan ve bu seçimin son üyesini, yani sayı payını Hilk nalan sayıcı listesinin ilk üyelerini Nalır n. Golf önerileri kabul edilir. Çevrimiçi deneyin!

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

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

Kesir ile temsil edilir x/y. Bağımsız değişken nyeni bir uyum kısmı bulunduğunda indirildiği ( gcdgelen fractionskontroller fraksiyon azaltılabilir). Her döngü tekrarında ise, xeğer, o zaman, artırılır x>=yile fraksiyonların yeni dizi, y+1, başlatıldığında >, çünkü "özel durum" nin (x,y)=(2,1), hiç golfed x>y.

Bunun daha çok golf oynayabileceğinden eminim, ama geliştirebileceğim yeri eksik. Buldum

Kod ve test durumlarına bağlantı

JavaScript (ES6), 95 bayt

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

Tüm oluşturarak çalışır n²gelen numerators ve payda sahip fraksiyonlar 1için nve daha büyük olanlann filtre 1daha sonra alınarak görülebilir önce ya da ninci.

Perl, 82 + 2 ( -plbayrak) = 84 bayt

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

Daha az golf oynadı

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
}

Ölçek

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 bayt

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

Tüm rasyonellerin listesini oluşturmak için liste kavramasını kullanır, sonra sadece farklı olanları elde etmek için filtreler. Alır nthListe öğesini ve paydayı döndürür. Ayrıca, ilk öğe için ayrı bir koşul gereklidir, çünkü Clojure bir tamsayı payını alamaz. (bir tamsayının rasyonel olmadığını düşünen sebeplerden dolayı - https://goo.gl/XETLo2 )

Çevrimiçi görün - https://ideone.com/8gNZEB