N n अंश

Question

आप सभी परिमेय ० <r listing १ की सूची बना सकते हैं, उन्हें सूची में बदल कर पहले हर के द्वारा और फिर अंश द्वारा:

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

ध्यान दें कि हम पहले से हुई किसी भी तर्कसंगत संख्या को छोड़ देते हैं। उदाहरण के लिए 2/4 को छोड़ दिया गया है क्योंकि हम पहले से ही 1/2 सूचीबद्ध हैं।

इस चुनौती में हम केवल अंशधारियों में रुचि रखते हैं। उपरोक्त सूची को देखते हुए, एक सकारात्मक पूर्णांक n लेने वाले फ़ंक्शन या प्रोग्राम को लिखें जो सूची से nth अंशांक लौटाता है ।

---

परीक्षण के मामलों:

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

Comments

आंशिक रूप से प्रासंगिक OEIS, सहायक हो सकता है

— Zwei

वास्तव में सिर्फ तर्कसंगतताओं की एक सूची(0,1]

— रॉबर्ट फ्रेजर

@RobertFraser अच्छा बिंदु।

— orlp

Answer 1

MATL , 17 13 बाइट्स

:tt!/XR6#uG))

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

इनपुट आकार फ्लोटिंग पॉइंट सटीकता द्वारा सीमित किया जा सकता है। सभी परीक्षण मामले सही परिणाम देते हैं।

व्याख्या

यह सभी भिन्न उत्पन्न करता है k/mके साथ k, mमें [1 2 ...n], एक के रूप में n× nमैट्रिक्स। पंक्ति अंश को इंगित करती है और स्तंभ भाजक को इंगित करता है। वास्तव में मैट्रिक्स प्रविष्टि में m/kइसके बजाय उलटा अंश होता है k/m, लेकिन यह अप्रासंगिक है और बाकी स्पष्टीकरण में इसे अनदेखा किया जा सकता है।

मैट्रिक्स प्रविष्टियों को स्पष्ट रूप से स्तंभ-प्रमुख क्रम में क्रमबद्ध माना जाता है। इस मामले में यह आवश्यक आदेश से मेल खाती है: भाजक, फिर अंश।

इस मैट्रिक्स से तीन प्रकार की प्रविष्टियों की अवहेलना करने की आवश्यकता है:

1. प्रविष्टियाँ k/m, k>mजिनका पिछली प्रविष्टि के समान मूल्य है (उदाहरण के लिए, 2/4अवहेलना की जाती है क्योंकि यह उसी तरह है 1/2)
2. प्रविष्टियां k/k, k>1। प्रविष्टियाँ जिसमें एक भाजक होता है जो हर से अधिक होता है
3. प्रविष्टियाँ k/m, k<m(ये समस्या का हिस्सा नहीं हैं)।

प्रविष्टियों को अस्वीकृत करना एक uniqueफ़ंक्शन के साथ किया जाता है , जो डुप्लिकेट मानों को हटा देता है और बचे हुए प्रविष्टियों के सूचकांकों को आउटपुट करता है। इसके साथ, ऊपर दिए गए टाइप 1 की प्रविष्टियाँ स्वतः ही हटा दी जाती हैं। प्रकार 2 और 3 से निपटने के लिए, विकर्ण और नीचे मैट्रिक्स प्रविष्टियां निर्धारित की जाती हैं 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

Answer 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.

Answer 3

मैथेमेटिका, 53 बाइट्स

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

Answer 4

हास्केल, 40 बाइट्स

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

एक अनाम फ़ंक्शन। बहुत सरल: एक सूची का उपयोग करता है एक अनंत सूची उत्पन्न करने के लिए, सभी संख्यात्मक nऔर अपेक्षाकृत प्रमुख विभाजकों पर लूपिंग d। शून्य-इंडेक्स को एक-अनुक्रमित में बदलने के लिए, हम एक प्रीपेन्ड करते हैं 0, जो 4बाइट्स लेता है ।

Comments

n<-[0..d]शून्य को छोटे तरीके से जोड़ता है और 4 बाइट्स बचाता है

— 14

Answer 5

पायथ, 13 बाइट्स

@smfq1idTUhdh

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

Answer 6

अजगर, 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

Answer 7

दरअसल , 15 बाइट्स

यह उत्तर डेनिस के जेली उत्तर पर आधारित है । मैं HN0-इंडेक्सिंग के साथ मुद्दों से बचने के लिए अंत में उपयोग करता हूं और शुरुआत में या अंत में एन-स्वैप करने की आवश्यकता होती है। अंकेक्षकों की सूची के Hपहले nसदस्यों को जो परिणाम प्राप्त करता है और Nउस चयन के अंतिम सदस्य को प्राप्त होता है, यानी 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.

Answer 8

पायथन, 111 110 बाइट्स

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जब एक नया फिटिंग अंश पाया जाता है कम कर रहा है ( gcdसे fractionsचेकों अंश कम किया जा सकता है)। लूप के प्रत्येक पुनरावृत्ति में, xवृद्धि होती है, फिर, यदि x>=y, "विशेष मामले" की वजह से भिन्न होने की एक नई श्रृंखला y+1शुरू हो जाती है , तो गोल्फ के लिए ।>(x,y)=(2,1)x>y

मुझे यकीन है कि यह अधिक गोल्फ हो सकता है, लेकिन मुझे याद आ रहा है कि मैं इसे कहां सुधार सकता हूं। मिल गया।

कोड और परीक्षण मामलों के लिए लिंक

Answer 9

जावास्क्रिप्ट (ईएस 6), 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वें।

Answer 10

पर्ल, 82 + 2 ( -plध्वज) = 84 बाइट्स

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

Answer 11

जावास्क्रिप्ट (ईएस 6), 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)
  }
)  

Answer 12

क्लोजर, 85 बाइट्स

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

सभी युक्तियों की सूची बनाने के लिए सूची समझ का उपयोग करता है, फिर इसे केवल अलग-अलग प्राप्त करने के लिए फ़िल्टर करता है। nthसूची का आइटम लेता है और इसके अंश को लौटाता है। पहले तत्व के लिए भी अलग स्थिति की आवश्यकता होती है क्योंकि क्लोजर पूर्णांक के अंश को लेने में सक्षम नहीं होता है। (पूर्णांक को तर्कसंगत नहीं मानने के कारण जो भी हो - https://goo.gl/XETLo2 )

इसे ऑनलाइन देखें - https://ideone.com/8gNZEB