Bạn có thể tạo danh sách tất cả các tỷ lệ 0 <r ≤ 1 bằng cách liệt kê chúng theo thứ tự đầu tiên theo mẫu số và sau đó bằng tử số:

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

Lưu ý rằng chúng tôi bỏ qua bất kỳ số hữu tỷ đã xảy ra trước đó. Ví dụ: 2/4 bị bỏ qua vì chúng tôi đã liệt kê 1/2.

Trong thử thách này, chúng tôi chỉ quan tâm đến các tử số. Nhìn vào danh sách trên, hãy viết một hàm hoặc chương trình lấy số nguyên dương n trả về tử số thứ n từ danh sách.

Testcase:

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 byte

:tt!/XR6#uG))

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Kích thước đầu vào có thể bị giới hạn bởi độ chính xác điểm nổi. Tất cả các trường hợp thử nghiệm cho kết quả chính xác.

Giải trình

Điều này tạo ra tất cả các phân số k/mvới k, mtrong [1 2 ...n], như một ma trận n× n. Hàng biểu thị tử số và cột biểu thị mẫu số. Trên thực tế, mục nhập ma trận chứa phần nghịch đảo m/k, thay vì k/m, nhưng điều này không liên quan và có thể bị bỏ qua trong phần còn lại của lời giải thích.

Các mục ma trận được coi là hoàn toàn được sắp xếp theo thứ tự chính của cột. Trong trường hợp này, điều này tương ứng với thứ tự yêu cầu: mẫu số, sau đó là tử số.

Ba loại mục cần phải được bỏ qua khỏi ma trận này:

1. Các mục nhập k/m, k>mcó cùng giá trị với mục nhập trước đó (ví dụ: 2/4bị bỏ qua vì nó giống như 1/2)
2. Bài dự thi k/k, k>1. Các mục nhập có tử số vượt quá mẫu số
3. Bài dự thi k/m, k<m(đây không phải là một phần của vấn đề).

Bỏ qua các mục được thực hiện với một uniquechức năng, giúp loại bỏ ổn định các giá trị trùng lặp và xuất ra các chỉ số của các mục còn tồn tại. Với điều này, các mục thuộc loại 1 ở trên sẽ tự động bị xóa. Để đối phó với loại 2 và 3, các mục ma trận ở đường chéo và bên dưới được đặt thành 0. Bằng cách này, tất cả các mục nhập bằng 0 sẽ bị xóa trừ phần đầu tiên (tương ứng với phần hợp lệ 1/1).

Hãy xem xét đầu vào 4là một ví dụ.

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

Thạch , 11 9 byte

gRỊTµ€Fị@

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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.

Toán học, 53 byte

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

Haskell, 40 byte

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

Một chức năng ẩn danh. Khá đơn giản: sử dụng một sự hiểu biết danh sách để tạo ra một danh sách vô hạn, lặp qua tất cả các tử số nvà mẫu số tương đối chính d. Để chuyển đổi chỉ mục 0 thành chỉ mục một, chúng tôi thêm một 0, trong đó có 4byte.

Bình thường, 13 byte

@smfq1idTUhdh

Hãy thử trực tuyến. Bộ thử nghiệm.

Bình thường, 11 byte

@sm.mibdhdS

Dùng thử trực tuyến: Trình diễn

Giải trình:

@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

Trên thực tế , 15 byte

Câu trả lời này dựa trên câu trả lời của Dennis 'Jelly . Tôi sử dụng HNở cuối để tránh các vấn đề với lập chỉ mục 0 và cần giảm n và hoán đổi ở đầu hoặc cuối. Hcó được các nthành viên đầu tiên trong danh sách các tử số có kết quả và Ncó được thành viên cuối cùng của lựa chọn đó, tức là ntử số thứ, tất cả mà không lo lắng về các hoạt động ngăn xếp. Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

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

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

Các phần được đại diện với x/y. Đối số nđược giảm đi khi một phần nhỏ phù hợp mới được tìm thấy (các gcdtừ fractionskiểm tra có thể phần được giảm). Trong mỗi lần lặp của vòng lặp, xđược tăng lên, sau đó, nếu x>=y, một loạt phân số mới y+1được bắt đầu, >vì "trường hợp đặc biệt" (x,y)=(2,1), được chơi theo x>y.

Tôi chắc chắn rằng điều này có thể được chơi golf nhiều hơn, nhưng tôi đang thiếu nơi tôi có thể cải thiện nó. Đã tìm thấy nó.

Liên kết đến mã và các trường hợp thử nghiệm

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

Hoạt động bằng cách tạo ra tất cả các n²phân số với tử số và mẫu số từ 1đến nvà lọc ra những phân số lớn hơn 1hoặc đã thấy trước đó, sau đó lấy nthứ.

Perl, 82 + 2 ( -plcờ) = 84 byte

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

Ung dung:

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

Ít chơi gôn

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
}

Kiểm tra

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 byte

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

Sử dụng sự hiểu biết danh sách để tạo danh sách tất cả các lý do, sau đó lọc nó để chỉ nhận những cái khác biệt. Lấy nthmục của danh sách và trả về tử số của nó. Ngoài ra điều kiện riêng là cần thiết cho phần tử đầu tiên vì Clojure không thể lấy tử số của một số nguyên. (vì bất kỳ lý do gì khi xem xét một số nguyên không hợp lý - https://goo.gl/XETLo2 )

Xem trực tuyến - https://ideone.com/8gNZEB