먼저 모든 분모 0 <r ≤ 1을 분모로 정렬 한 다음 분자별로 나열하여 목록을 작성할 수 있습니다.

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

이전에 이미 발생한 합리적인 숫자는 건너 뜁니다. 예를 들어 이미 1/2을 나열했기 때문에 2/4를 건너 뜁니다.

이 도전에서 우리는 분자에만 관심이 있습니다. 위의 목록을보고 목록 에서 n 번째 분자 를 리턴 하는 양의 정수 n 을 취하는 함수 또는 프로그램을 작성하십시오.

테스트 케이스 :

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 바이트

:tt!/XR6#uG))

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

부동 소수점 정확도에 의해 입력 크기가 제한 될 수 있습니다. 모든 테스트 사례가 올바른 결과를 제공합니다.

설명

, in을 × 행렬 로 사용하여 모든 분수 k/m를 생성합니다 . 행은 분자를 나타내고 열은 분모를 나타냅니다. 실제로 행렬 항목에는 역 분수가 포함됩니다.km[1 2 ...n]nnm/k 대신에k/m 있지만 이는 관련이 없으며 나머지 설명에서는 무시할 수 있습니다.

행렬 항목은 암시 적으로 열 주요 순서로 정렬 된 것으로 간주됩니다. 이 경우에는 필요한 순서 (분모, 분자)에 해당합니다.

이 매트릭스에서는 세 가지 유형의 항목을 무시해야합니다.

1. 이전 항목과 동일한 값을 가진 Entries k/m, k>m예를 들어2/4 는 동일하기 때문에 무시 1/2)
2. 출품작 k/k , k>1. 분자가 분모를 초과하는 항목
3. 항목 k/m, k<m(이 문제의 일부가 아닌).

항목 무시 unique는 중복 값을 안정적으로 제거하고 생존 항목의 색인을 출력 하는 함수 로 수행됩니다 . 이를 통해 위의 유형 1 항목이 자동으로 제거됩니다. 유형 2와 3을 처리하기 위해 대각선과 아래의 행렬 항목이로 설정됩니다 0. 이런 식으로 첫 번째 항목을 제외한 모든 0 항목이 제거됩니다 (유효 분수에 해당 1/1).

4예를 들어 입력 을 고려하십시오 .

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

젤리 , 11 9 바이트

gRỊTµ€Fị@

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

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.

수학, 53 바이트

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

하스켈, 40 바이트

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

익명의 기능. 매우 간단합니다 :리스트 이해를 사용하여 무한리스트를 생성하여 모든 분자 n와 상대적으로 분모를 반복 d합니다. 0 인덱스를 1 인덱스로 변환하려면 바이트를 사용 0하는 앞에 붙 4입니다.

Pyth, 13 바이트

@smfq1idTUhdh

온라인으로 사용해보십시오. 테스트 스위트.

Pyth, 11 바이트

@sm.mibdhdS

온라인으로 사용해보십시오 : 데모

설명:

@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

실제로 15 바이트

이 답변은 Dennis 'Jelly 답변을 기반으로 합니다. 나는 HN0 인덱싱 문제를 피하기 위해 끝에 사용 하고 시작 또는 끝에서 n을 줄이고 스왑해야합니다. 결과로 생성 된 분자 목록의 H첫 번째 n멤버를 N가져오고 n스택 선택을 방해하지 않고 해당 선택의 마지막 멤버, 즉 분자를 가져옵니다 . 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

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

언 골핑

          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.

파이썬, 111 바이트

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

분수는로 표시됩니다 x/y. n새로운 피팅 분수가 발견되면 인수 가 감소합니다 ( gcdfrom fractionscheck에서 분수를 줄일 수 있음). 루프의 각 반복에서, x경우, 다음, 증가 x>=y분수의 새로운 시리즈로, y+1시작, >때문에 "특별한 경우"의 (x,y)=(2,1)에 golfed,x>y .

나는 이것이 더 골프를 칠 수 있다고 확신하지만 그것을 향상시킬 수있는 곳이 없습니다.그것을 발견.

코드 및 테스트 사례에 연결

자바 스크립트 (ES6), 95 바이트

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

모든 생성하여 작동 n²에서의 분자와 분모를 가진 분수 1로 n하고보다 그 이상을 필터링 1한 후 복용 보이는 이전 또는 n토륨.

Perl, 82 + 2 ( -pl플래그) = 84 바이트

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

언 골프 드 :

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

자바 스크립트 (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")

덜 골프

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
}

테스트

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

클로저, 85 바이트

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

list comprehension을 사용하여 모든 합리적 목록을 생성 한 다음 필터링하여 별개의 것만 얻습니다. 소요nth 목록의 항목을 그 분자를 반환합니다. Clojure는 정수의 분자를 사용할 수 없으므로 첫 번째 요소에 대해 별도의 조건이 필요합니다. (이유가 아닌 정수를 고려하는 어떤 이유로 든 – https://goo.gl/XETLo2 )

온라인으로보십시오 – https://ideone.com/8gNZEB