নবম সংখ্যা

Question

আপনি প্রথমে ডিনমিনেটর এবং তারপরে অঙ্ক দ্বারা নির্দেশিত তালিকাভুক্ত করে সমস্ত যুক্তি 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

নোট করুন যে আমরা ইতিমধ্যে ঘটেছে এমন কোনও যুক্তিযুক্ত সংখ্যা এড়িয়ে চলেছি। উদাহরণস্বরূপ 2/4 এড়িয়ে গেছে কারণ আমরা ইতিমধ্যে 1/2 তালিকাভুক্ত করেছি।

এই চ্যালেঞ্জে আমরা কেবলমাত্র সংখ্যাগুলিতে আগ্রহী। উপরের তালিকায় এ খুঁজছি, একটি ফাংশান বা প্রোগ্রাম একটি ধনাত্মক পূর্ণসংখ্যা গ্রহণ লিখতে এন যে আয় n তম লব তালিকা থেকে।

---

Testcases:

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]

— রবার্ট ফ্রেজার

নিবন্ধন করুন

— orlp

Answer 1

এমএটিএল , 17 13 বাইট

:tt!/XR6#uG))

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ভাসমান পয়েন্ট নির্ভুলতার দ্বারা ইনপুট আকার সীমাবদ্ধ হতে পারে। সমস্ত পরীক্ষার কেস সঠিক ফলাফল দেয়।

ব্যাখ্যা

এই সব ভগ্নাংশ উত্পন্ন k/mসঙ্গে k, mমধ্যে [1 2 ...n], একটি হিসাবে n× nম্যাট্রিক্স। সারিটি সংখ্যককে নির্দেশ করে এবং কলামটি ডিনোমিনেটরকে নির্দেশ করে। প্রকৃতপক্ষে ম্যাট্রিক্স এন্ট্রিতে বিপরীত ভগ্নাংশটি m/kপরিবর্তে রয়েছে k/mতবে এটি অপ্রাসঙ্গিক এবং বাকী ব্যাখ্যায়ও তা উপেক্ষা করা যায়।

ম্যাট্রিক্স এন্ট্রিগুলি স্পষ্টভাবে কলাম-প্রধান ক্রমে সাজানো হিসাবে বিবেচিত হয়। এই ক্ষেত্রে এটি প্রয়োজনীয় আদেশের সাথে মিলে যায়: ডিনোমিনেটর, তার পরে অঙ্ক ume

এই ম্যাট্রিক্স থেকে তিন ধরণের এন্ট্রি উপেক্ষা করা দরকার:

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বাইট নেয় takes

Comments

n<-[0..d]শূন্যকে একটি সংক্ষিপ্ত উপায়ে যুক্ত করে এবং 4 বাইট সংরক্ষণ করে

— অ্যাঙ্গস

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

জাভাস্ক্রিপ্ট (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।

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

জাভাস্ক্রিপ্ট (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)
  }
)  

Answer 12

Clojure, 85 বাইট

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

সমস্ত যৌক্তিকের তালিকা তৈরি করতে তালিকান বোধগম্য ব্যবহার করে, তারপরে কেবলমাত্র স্বতন্ত্র বিষয়গুলি পেতে এটি ফিল্টার করে। nthতালিকার আইটেম নেয় এবং তার অঙ্কটি প্রদান করে। এছাড়াও প্রথম উপাদানটির জন্য পৃথক শর্ত প্রয়োজন কারণ Clojure কোনও পূর্ণসংখ্যার অঙ্ক নিতে সক্ষম হয় না। (কোনও পূর্ণসংখ্যাকে যৌক্তিক হিসাবে বিবেচনা না করে যে কোনও কারণে - https://goo.gl/XETLo2 )

এটি অনলাইনে দেখুন - https://ideone.com/8gNZEB