परिमेय गणना कार्य

Question

एक फ़ंक्शन बनाएं जो एक प्राकृतिक संख्या लेता है (0 समावेशी से शुरू), और सकारात्मक पूर्णांक की एक जोड़ी देता है, जो क्रमशः अंश और भाजक हैं। विकर्ण ट्रैवर्सल का उपयोग करें। पिछली संख्याओं को छोड़ दिया जाना चाहिए। (आप छोड़े गए मूल्यों के सेट को याद कर सकते हैं)

चित्र:

लाल छोड़ दिए गए मूल्य हैं

मान:

• f (0) = 1, 1
• f (1) = 2, 1
• f (2) = 1, 2
• f (3) = 1, 3
• f (4) = 3, 1 (सूचना छोड़ें)
• f (5) = 4, 1
• f (6) = 3, 2
• f (7) = 2, 3
• f (8) = 1, 4
• f (9) = 1, 5
• f (10) = 5, 1 (स्किप को नोटिस करें)

यदि वे मौजूद हैं तो आप तर्कसंगत डेटा संरचना और उनके संचालन का उपयोग कर सकते हैं। सबसे छोटा कोड जीतता है।

Comments

प्रत्येक विकर्ण में गिने हुए परिमेय संख्याओं की संख्या उस विकर्ण के सामान्य योग का कुल कार्य है।

— लीक नून

मुझे पता है कि यह चुनौती पुरानी है, लेकिन स्वीकार किए जाते हैं की तुलना में एक छोटा सा जवाब मौजूद है, इसलिए आप फिर से स्वीकार कर सकते हैं।

— बजे फल

Answer 1

जे, ४१ ३६ अक्षर

एक पूर्णांक बनाता है और एक वेक्टर देता है जिसमें दो पूर्णांक होते हैं। मेरा पहला समाधान जो न तो पूरी तरह से शांत है और न ही पूरी तरह से स्पष्ट है।

{3 :'~.;<`(<@|.)/.(,%+.)"0/~1+i.1+y'

यहाँ उन स्थानों के साथ समाधान डाला गया है जहाँ उपयुक्त हैं:

{ 3 : '~. ; <`(<@|.)/. (, % +.)"0/~ 1 + i. 1 + y'

एक स्पष्टीकरण:

1. x (, % +.) yलंबाई का एक वेक्टर 2 अंश xऔर हर के साथ भिन्न का प्रतिनिधित्व करता yहै सबसे छोटा हर में घटा
2. 1 + i. 1 + yसे पूर्णांकों का -एक वेक्टर 1के लिएy + 1
3. (, % +.)"0/~ 1 + i. 1 + yसे unreduced विभाजक और रेंज में अंश के साथ सभी कम अंशों का -एक मैट्रिक्स 1के लिए y + 1।
4. <`(<@|.)/. yमैट्रिक्स के तिरछे विकर्णों की एक सरणी y, एक दूसरे के विकर्ण फ़्लिप
5. ~. ; y- विकर्णों की एक सरणी हटाए गए डुप्लिकेट के साथ तत्वों के एक वेक्टर में ढह गई
6. x { yमें स्थिति xमें आइटमy
7. (u v) yके रूप में ही -इस y u v y। इस विशेष उपयोग के मामले में, uहै {और vहै3 : '~. ; <`(<@|.)/. (, % +.)"0/~ 1 + i. 1 + y'

Comments

30 बाइट्स

— FrownyFrog

Answer 2

हास्केल, 78 वर्ण

q(r,f)=[(r-b,b)|b<-f[1..r-1],r`gcd`b==1]
d=reverse:id:d
f=((zip[2..]d>>=q)!!)

नमूना रन:

> map f [0..10]
[(1,1),(2,1),(1,2),(1,3),(3,1),(4,1),(3,2),(2,3),(1,4),(1,5),(5,1)]
> f 100
(17,1)
> f 1000
(3,55)

---

• संपादित करें: (100 → 87) मुझे मूर्खतापूर्ण, बस एलसीडी का परीक्षण करना पर्याप्त है!
• संपादित करें: (87 → 85) के साथ चतुर चाल cycleऔर पंक्ति क्रम को वैकल्पिक करने के लिए
• संपादित करें: (85 → 82) cycleहाथ से निर्मित अनंत सूची के साथ बदलेंd
• संपादित करें: (82 → 78) gcdमैटिस द्वारा सुझाए गए अनुसार लागू पहचान

Comments

परिभाषा के अनुसार, gcd (r-b) b == gcd r bऔर आप चार और पात्रों को शेव कर सकते हैं।

— मटियास जियोवन्नी

Answer 3

अजगर, 144 चरस

def F(i):
 r,d,z=[1],1,[]
 while z[:i]==z:z+=[(x,y)for x,y in zip(r[::d],r[::-d])if all(x%j+y%j for j in r[1:])];d=-d;r+=[r[-1]+1]
 return z[i]

Answer 4

रूबी 1.9, 109 106

F=->n{x=y=d=1
e=0
n.times{(x+=d).gcd(y+=e)>1&&redo
x<2?d<0?d=0:(d,e=1,-1):y<2?e<0?e=0:(d,e=-1,1):0}
[x,y]}

Answer 5

OCaml + बैटरियों, 182 168 अक्षर

हास्केल में यह स्वाभाविक होगा लेकिन ओमेक्एल में केवल मुश्किल से ही संभव है:

open LazyList
let rec r(i,j)=lazy(let a,b=if(i+j)mod 2=0then i,j else j,i in
Cons((a,b),filter(fun(c,d)->a*d<>c*b)(r(if j=1 then 1,i+1else i+1,j-1))))
let f=nth(r(1,1))

संपादित करें: विकर्ण अनावश्यक है

Answer 6

पर्ल 6 , 75 बाइट्स

{(({|(1…($+=2)…1)}…*)Z/(1,{|(1…(($||=1)+=2)…1)}…*)).unique[$_]}

झसे आज़माओ

यह मूल रूप से तर्कसंगत मूल्यों के पूरे अनुक्रम को उत्पन्न करता है, केवल अनुक्रमित मान उत्पन्न होने पर रोकना।

( एक अन्य चुनौती के लिए मेरे गोल्फ पर आधारित ।)

विस्तारित:

{  # bare block lambda with implicit parameter $_

  (
      ( # sequence of numerators

        {
          |( # slip into outer sequence (flatten)

            1      # start at one
            …
            (
              $    # state variable
              += 2 # increment it by two each time this block is called
            )
            …
            1      # finish at one
          )

        }
        … * # never stop generating values
      )


    Z/   # zip using &infix:« /  » (generates Rats)


      ( # sequence of denominators

        1,  # start with an extra one

        {
          |( # slip into outer sequence (flatten)

            1
            …
            (
              ( $ ||= 1 ) # state variable that starts with 1 (rather than 0)
              += 2        # increment it by two each time this is called
            )
            …
            1
          )
        }
        … * # never stop generating values
      )


  ).unique                # get only the unique values
  .[ $_ ]                 # index into the sequence
}

---

({1…($+=2)…1}…*)संख्याओं के अनंत क्रम को उत्पन्न करता है ( |(…)इसे समतल करने के लिए ऊपर प्रयोग किया जाता है)

(1 2 1)
(1 2 3 4 3 2 1)
(1 2 3 4 5 6 5 4 3 2 1)
(1 2 3 4 5 6 7 8 7 6 5 4 3 2 1)
(1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1)
…

(1,{1…(($||=1)+=2)…1}…*) हर के अनंत क्रम को उत्पन्न करता है

1
(1 2 3 2 1)
(1 2 3 4 5 4 3 2 1)
(1 2 3 4 5 6 7 6 5 4 3 2 1)
(1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1)
(1 2 3 4 5 6 7 8 9 10 11 10 9 8 7 6 5 4 3 2 1)
…