14

सकारात्मक परिमेय संख्याओं को निम्नलिखित प्रक्रिया के साथ संख्यात्मक रूप से दिखाया जा सकता है:

शून्य में क्रमांक 0 है
एक ग्रिड में अन्य संख्याओं को व्यवस्थित करें ताकि पंक्ति a, कॉलम b में a / b शामिल हो
एक विकर्ण ज़िग-ज़ैग शीर्ष दाएं से नीचे बाईं ओर प्लॉट करें
ज़िग-ज़ैग के साथ सामना किए गए अनूठे नंबरों की एक चलने वाली टैली रखें

यहाँ ज़िग-ज़ैग की एक तस्वीर है:

तो, क्रम में अंकित संख्याएँ हैं

1/1, 2/1, 1/2, 1/3, 2/2, 3/1, 4/1, 3/2, 2/3, 1/4, 1/5, 2/4, 3/3, 4/2, 5/1, 6/1, 5/2, 4/3, 3/4, 2/5, 1/6, 1/7, 2/6, 3/5, 4/4, 5/3 ...

और सरलीकृत, अद्वितीय संख्याएँ हैं

1, 2, 1/2, 1/3, 3, 4, 3/2, 2/3, 1/4, 1/5, 5, 6, 5/2, 4/3, 3/4, 2/5, 1/6, 1/7, 3/5, 5/3, ...

चुनौती:

दो से अधिक-शून्य पूर्णांक p और q को देखते हुए , p / q के क्रमिक संख्या को आउटपुट करता है
पी और क्यू आवश्यक रूप से सह-प्रधान नहीं हैं
सबसे छोटा कोड जीतता है
मानक कमियां निषिद्ध हैं

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

यहां पहले 24 परिमेय संख्याओं का सामना किया गया है, और प्रत्येक के लिए वांछित आउटपुट:

1/1: 1
2/1: 2
1/2: 3
1/3: 4
2/2: 1
3/1: 5
4/1: 6
3/2: 7
2/3: 8
1/4: 9
1/5: 10
2/4: 3
3/3: 1
4/2: 2
5/1: 11
6/1: 12
5/2: 13
4/3: 14
3/4: 15
2/5: 16
1/6: 17
1/7: 18
2/6: 4
3/5: 19

और, आगे के परीक्षण मामलों के लिए, यहां 200 पहले सकारात्मक परिमेय संख्याएं हैं:

1, 2, 1/2, 1/3, 3, 4, 3/2, 2/3, 1/4, 1/5, 
5, 6, 5/2, 4/3, 3/4, 2/5, 1/6, 1/7, 3/5, 5/3, 
7, 8, 7/2, 5/4, 4/5, 2/7, 1/8, 1/9, 3/7, 7/3, 
9, 10, 9/2, 8/3, 7/4, 6/5, 5/6, 4/7, 3/8, 2/9, 
1/10, 1/11, 5/7, 7/5, 11, 12, 11/2, 10/3, 9/4, 8/5, 
7/6, 6/7, 5/8, 4/9, 3/10, 2/11, 1/12, 1/13, 3/11, 5/9, 
9/5, 11/3, 13, 14, 13/2, 11/4, 8/7, 7/8, 4/11, 2/13, 
1/14, 1/15, 3/13, 5/11, 7/9, 9/7, 11/5, 13/3, 15, 16, 
15/2, 14/3, 13/4, 12/5, 11/6, 10/7, 9/8, 8/9, 7/10, 6/11, 
5/12, 4/13, 3/14, 2/15, 1/16, 1/17, 5/13, 7/11, 11/7, 13/5, 
17, 18, 17/2, 16/3, 15/4, 14/5, 13/6, 12/7, 11/8, 10/9, 
9/10, 8/11, 7/12, 6/13, 5/14, 4/15, 3/16, 2/17, 1/18, 1/19, 
3/17, 7/13, 9/11, 11/9, 13/7, 17/3, 19, 20, 19/2, 17/4, 
16/5, 13/8, 11/10, 10/11, 8/13, 5/16, 4/17, 2/19, 1/20, 1/21, 
3/19, 5/17, 7/15, 9/13, 13/9, 15/7, 17/5, 19/3, 21, 22, 
21/2, 20/3, 19/4, 18/5, 17/6, 16/7, 15/8, 14/9, 13/10, 12/11, 
11/12, 10/13, 9/14, 8/15, 7/16, 6/17, 5/18, 4/19, 3/20, 2/21, 
1/22, 1/23, 5/19, 7/17, 11/13, 13/11, 17/7, 19/5, 23, 24, 
23/2, 22/3, 21/4, 19/6, 18/7, 17/8, 16/9, 14/11, 13/12, 12/13, 
11/14, 9/16, 8/17, 7/18, 6/19, 4/21, 3/22, 2/23, 1/24, 1/25

उलटा सवाल करने के लिए चिल्लाओ , जहां पहला कदम नीचे है, इसलिए आप अतिरिक्त परीक्षण मामलों को उत्पन्न करने के लिए उत्तर का उपयोग नहीं कर सकते।

code-golf rational-numbers

— जो रूधिर
स्रोत

मुझे आश्चर्य है कि क्या वैकल्पिक नंबरिंग योजनाएं हैं जो छोटे कोड के लिए बनाती हैं।

— qwr

1

अंशों के संख्यात्मक : oeis.org/A157807 भाजक: oeis.org/A157813 क्रमिक अनुक्रम के लिए कोई मेल नहीं: oeis.org/…

— qwr

समझा। आपको अंश को कम करना होगा और फिर गिनना होगा। केवल जिग-जैग ही नहीं

— उज्ज्वल

संबंधित: Zigzagify एक मैट्रिक्स और एक zigzagified मैट्रिक्स पुनर्निर्माण ।

— केविन क्रूज़सेन

4

जेली , 21 20 बाइट्स

^{शायद कुछ चतुर गणित का उपयोग करके कई बाइट्स से हरा ...}

:g/
ÇµSRRUĖ€UÐeẎÇ€Qi

एक मौद्रिक लिंक [p,q]जिसमें से सौंपी गई प्राकृतिक संख्या लौटाती है, उसकी एक सूची को स्वीकार करता है p/q।

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

कैसे?

पहले ध्यान दें कि एन ^वें विकर्ण का सामना ग्रिड के सभी परिमेय संख्याओं से होता है, जिसके लिए अंश और हर का योग N + 1 के बराबर होता है , इसलिए एक फ़ंक्शन दिया जाता है जो एक [p,q]जोड़ी को सरलतम रूप में घटाता है ( [p/gcd(p,q),q/gcd(p,q)]) जहां तक हम द्विपद का निर्माण कर सकते हैं जरूरत है *, सभी प्रविष्टियों को कम करें, डी-डुप्लिकेट करें और सरलीकृत इनपुट के सूचकांक को ढूंढें।

* एक बाइट को बचाने के लिए वास्तव में यहाँ एक और

:g/ - Link 1, simplify a pair: list of integers, [a, b]
  / - reduce using:
 g  - Greatest Common Divisor -> gcd(a, b)
:   - integer division (vectorises) -> [a/gcd(a,b), b/gcd(a,b)]

ÇµSRRUĖ€UÐeẎÇ€Qi - Main Link: list of integers, [p, q]
Ç                - call last Link as a monad (simplify)
 µ               - start a new monadic chain (call that V)
  S              - sum -> the diagonal V will be in plus one
   R             - range -> [1,2,3,...,diag(V)+1]
    R            - range (vectorises) -> [[1],[1,2],[1,2,3],...,[1,2,3,...,diag(V)+1]]
     U           - reverse each       -> [[1],[2,1],[3,2,1],[diag(V)+1,...,3,2,1]]
      Ė€         - enumerate €ach     -> [[[1,1]],[[1,2],[2,1]],[[1,3],[2,2],[3,1]],[[1,diag(V)+1],...,[diag(V)-1,3],[diag(V),2],[diag(V)+1,1]]]
         Ðe      - apply only to the even indexed items:
        U        -   reverse each     -> [[[1,1]],[[2,1],[1,2]],[[1,3],[2,2],[3,1]],[[4,1],[3,2],[2,3],[1,4]],...]
           Ẏ     - tighten            -> [[1,1],[2,1],[1,2],[1,3],[2,2],[3,1],[4,1],[3,2],[2,3],[1,4],...]
            Ç€   - for €ach: call last Link as a monad (simplify each)
                 -                    -> [[1,1],[2,1],[1,2],[1,3],[1,1],[3,1],[4,1],[3,2],[2,3],[1,4],...]
              Q  - de-duplicate       -> [[1,1],[2,1],[1,2],[1,3],[3,1],[4,1],[3,2],[2,3],[1,4],...]
               i - index of V in that list

— जोनाथन एलन
स्रोत

3

पर्ल 6 , 94 90 बाइट्स

->\p,\q{(({|(1…($+=2)…1)}…*)Z/(1,{|(1…(($||=1)+=2)…1)}…*)).unique.first(p/q,:k)+1}

झसे आज़माओ

{(({|(1…($+=2)…1)}…*)Z/(1,{|(1…(($||=1)+=2)…1)}…*)).unique.first($^p/$^q):k+1}

झसे आज़माओ

यह मूल रूप से मूल्यों के पूरे अनुक्रम को उत्पन्न करता है, और जब यह एक मैच पाता है तो रुक जाता है।

विस्तारित:

{  # bare block lambda with placeholder parameters $p,$q

  (
      ( # 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
  .first( $^p / $^q ) # find the first one that matches the input
  :k                  # get the index instead (0 based)
  + 1                 # add one               (1 based)
}

({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)
…

— ब्रैड गिल्बर्ट b2gills
स्रोत

3

अजगर 2 , 157 144 137 134 126 125 बाइट्स

def f(p,q):a=[((j-i)/(i+1.))**(j%-2|1)for j in range(p-~q)for i in range(j)];return-~sorted(set(a),key=a.index).index(p*1./q)

इसे ऑनलाइन आज़माएं!

मिस्टर एक्सकोडर के कारण 4 बाइट्स बचाए गए ; जोनाथन फ्रीच से 1 बाइट ।

जैसा कि श्री Xcoder द्वारा उल्लेख किया गया है, हम पायथन 3 में थोड़ा बेहतर कर सकते हैं, अन्य बातों के अलावा, पूर्णांक विभाजन परिणाम फ्लोट करने के लिए डिफॉल्ट करता है, और हम आसानी से अनपैक कर सकते हैं list:

पायथन 3 , 117 बाइट्स

def f(p,q):a=[((j-i)/-~i)**(j%-2|1)for j in range(p-~q)for i in range(j)];return-~sorted({*a},key=a.index).index(p/q)

इसे ऑनलाइन आज़माएं!

— चास ब्राउन
स्रोत

128 बाइट्स (-6) को स्वैप करके **(j%-2|1)और प्रयोग करके और p-~q।

— श्री एक्सकोडर

@श्री। Xcoder: आप सभी नकारात्मक modulo के बारे में आज कर रहे हैं! :) मुझे लगता है कि मुझे अभी भी +1अंत की आवश्यकता है , क्योंकि 1,1'देना' चाहिए 1, नहीं 0।

— चास ब्राउन

125 बाइट्स ।

— जोनाथन फ्रीच

124 बाइट्स :) हाँ नकारात्मक मोडुलो वास्तव में मददगार साबित होता है!

— श्री एक्सकोडर

वास्तव में पायथन 3 में 117 बाइट्स

— श्री एक्सकोडर

3

पायथन 3 ,157, 146, 140, 133 बाइट्स

def f(p,q):a=[(i+i-abs(j-i-i))/(abs(j-i-i+.5)+.5)for i in range(p+q)for j in range(4*i)];return sorted(set(a),key=a.index).index(p/q)

इसे ऑनलाइन आज़माएं!

जोनाथन फ्रेच की बदौलत 11 बाइट जीते

6 और बाइट्स जीते और फिर चास ब्राउन को 7 धन्यवाद

— bobrobbob
स्रोत

1

146 बाइट्स ।

— जोनाथन फ्रीच

140 बाइट्स ।

— चास ब्राउन

@bobrobbob: PPCG में आपका स्वागत है! मुझे यकीन नहीं है कि आपका एल्गोरिथ्म कैसे काम करता है (हालांकि यह स्पष्ट रूप से करता है); लेकिन प्रयोगात्मक, यह आप की जगह कुछ और बाइट्स बचा सकता है लगता है range(max(p,q)+1)के साथ range(p+q)।

— चास ब्राउन

1

के {*a}बजाय का उपयोग करके आप कुछ और बाइट्स बचा सकते हैं set(a)।

— श्री एक्सकोडर

2

जे, 41 , 35 , 30 बाइट्स

-11 बाइट्स FrownyFrog के लिए धन्यवाद

%i.~0~.@,@,[:]`|./.[:%/~1+i.@*

इसे ऑनलाइन आज़माएं!

मूल 41 बाइट्स स्पष्टीकरण के साथ पोस्ट करते हैं

%>:@i.~[:([:~.@;[:<@|.`</.%"1 0)~(1+i.@*)

ungolfed

% >:@i.~ [: ([: ~.@; [: <@|.`</. %"1 0)~ 1 + i.@*

व्याख्या

                  +
                  | Everything to the right of this
                  | calculates the list
p (left arg)      |                                      create the
divided by q      |                                      diagonals.  yes,
      (right)     |                                     +this is a         +create this list
   |              |        ++ finally rmv ^alternately  |primitive ADVERB  |1..(p*q), and pass
   |   + the index          | the boxes,  |box, or      |in J              |it as both the left
   |   | of that  |         | and remove  |reverse and  |                  |and right arg to the
   |   | in the   |         | any dups    |box, each    |                  |middle verb, where each
   |   | list on  |         |             |diagonal     |                  |element will divide the
   |   | the right|         |             |             |       +----------+entire list, producing
   |   | plus 1   |         |             |             |       |          |the undiagonalized grid
   |   |          |         |             |             |       |          |
   |   |          |         |             |             |       |          |
   |   |          +         |             |             |       |          |
  ┌+┬──|──────────┬─────────|─────────────|─────────────|───────|──────────|─────────────┐
  │%│┌─+───────┬─┐│┌──┬─────|─────────────|─────────────|───────|────────┬─|────────────┐│
  │ ││┌──┬─┬──┐│~│││[:│┌────|─────────────|─────────────|───────|─────┬─┐│┌+┬─┬────────┐││
  │ │││>:│@│i.││ │││  ││┌──┬|───────┬─────|─────────────|───────|────┐│~│││1│+│┌──┬─┬─┐│││
  │ ││└──┴─┴──┘│ │││  │││[:│+──┬─┬─┐│┌──┬─|─────────────|─┬─────|───┐││ │││ │ ││i.│@│*││││
  │ │└─────────┴─┘││  │││  ││~.│@│;│││[:│┌|───────────┬─+┐│┌─┬─┬+──┐│││ │││ │ │└──┴─┴─┘│││
  │ │             ││  │││  │└──┴─┴─┘││  ││+────────┬─┐│/.│││%│"│1 0││││ ││└─┴─┴────────┘││
  │ │             ││  │││  │        ││  │││┌─┬─┬──┐│<││  ││└─┴─┴───┘│││ ││              ││
  │ │             ││  │││  │        ││  ││││<│@│|.││ ││  ││         │││ ││              ││
  │ │             ││  │││  │        ││  │││└─┴─┴──┘│ ││  ││         │││ ││              ││
  │ │             ││  │││  │        ││  ││└────────┴─┘│  ││         │││ ││              ││
  │ │             ││  │││  │        ││  │└────────────┴──┘│         │││ ││              ││
  │ │             ││  │││  │        │└──┴─────────────────┴─────────┘││ ││              ││
  │ │             ││  ││└──┴────────┴────────────────────────────────┘│ ││              ││
  │ │             ││  │└──────────────────────────────────────────────┴─┘│              ││
  │ │             │└──┴──────────────────────────────────────────────────┴──────────────┘│
  └─┴─────────────┴──────────────────────────────────────────────────────────────────────┘

इसे ऑनलाइन आज़माएं!

— जोनाह
स्रोत

35:1+~.@;@([:<@|.`</.%~/~)@(1+i.@*)i.%

— FrownyFrog

धन्यवाद बहुत अच्छा है! मैं इसे बाद में पूरी तरह से अपडेट करूंगा क्योंकि इसके स्पष्टीकरण की आवश्यकता होगी ...

— जोनाह

और 30:%i.~0~.@,@,[:]`|./.[:%/~1+i.@*

— FrownyFrog

यह चतुर है, 0 और ~ का उपयोग करें। मुक्केबाजी और वेतन वृद्धि से बचने के लिए, मुझे यह पसंद है

— योना

2

पायथन 3, 121 बाइट्स

import math
def o(x,y):
 p=q=n=1
 while x*q!=p*y:a=p+q&1;p+=1+a*~-~-(p<2);q+=1-~-a*~-~-(q<2);n+=math.gcd(p,q)<2
 return n

— orlp
स्रोत

2

जंग, 244 बाइट्स

मैंने त्रिकोणीय संख्या सूत्रों का उपयोग करते हुए, पहेली की बाधाओं के बिना, "सादे" ज़िगज़ैग के "सादे" क्रम को खोजने के लिए एक सरल सूत्र बनाया: https://www.mathsisfun.com/algebra/triangular-numbers.html । यह पहेली में प्रत्येक विकर्ण पंक्ति को दिशा देने वाले ज़िग-ज़ैग के लिए मोडुलो 2 के साथ संशोधित किया गया था। यह फ़ंक्शन h () है

फिर इस पहेली की मुख्य चाल के लिए: जिग-जैग ट्रेल में 3/3 बनाम 1/1, 4/2 बनाम 2/1 जैसे कुछ दोहराए गए मूल्यों को 'कैसे' नहीं गिनना है। मैंने 1-200 उदाहरणों को चलाया, और एक सादे ज़िग-ज़ैग त्रिकोणीय काउंटर के बीच अंतर पर ध्यान दिया, और एक पहेली जिसके लिए इच्छा है, एक पैटर्न है। "लापता" संख्याओं का पैटर्न 5, 12, 13, 14, 23 आदि है, जिसके परिणामस्वरूप OEIS में एक हिट हुई। यह रॉबर्ट ए स्टंप द्वारा वर्णित है, https://oeis.org/A076537 पर , 3/3, 4/2, और 1/1 जैसे "डिडुप्लिकेट" संख्याओं के लिए, आप जांच सकते हैं कि क्या GCD> 1 के लिए x, सभी "पिछले" अध्यादेशों के युग्मनज में यह 'फॉर' लूप्स और जी () है जो कि जीसीडी है।

मुझे लगता है कि कुछ अंतर्निहित gcd के साथ यह छोटा होता, लेकिन मैं एक को बहुत आसानी से नहीं पा सकता था (Rust और Integer में नए तरह का मुझे भ्रमित किया), और मुझे यह तथ्य पसंद है कि यह सीधे पूर्णांक अंकगणित का उपयोग करता है, और किसी भी प्रकार का कोई निर्माण या पुस्तकालय नहीं।

fn f(x:i64,y:i64)->i64 {
        fn h(x:i64,y:i64)->i64 {let s=x+y;(s*s-3*s+4)/2-1+(s+1)%2*x+s%2*y}
        fn g(x:i64,y:i64)->i64 {if x==0 {y} else {g(y%x,x)}}
        let mut a=h(x,y);
        for i in 1..x+y {for j in 1..y+x {if h(i,j)<h(x,y) && g(i,j)>1 {a-=1;}}}
        a
}

— चमकाओ
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 86 बाइट्स

करी सिंटैक्स में इनपुट लेता है (p)(q)।

p=>q=>(g=x=>x*y?x*q-y*p?g(x+d,g[x/=y]=g[x]||++n,y-=d):n:g(x+!~d,y+=!~(d=-d)))(d=n=y=1)

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत

0

जावास्क्रिप्ट, 79 बाइट्स

a=(p,q)=>p*q==1?1:1+((p+q)%2?q==1?a(p-1,q):a(p+1,q-1):p==1?a(p,q-1):a(p-1,q+1))

(मैं कोड गोल्फिंग में नया हूं, इसलिए इसे आसानी से सुधारा जा सकता है)

व्याख्या

let a = (p, q) => p * q == 1 // If they are both 1
    ? 1
    // Do a recursive call and increment the result by 1
    : 1 + (
        (p + q) % 2 // If on an even-numbered diagonal
        ? q == 1 // If at the beginning of the diagonal
            ? a(p - 1, q) // Go to previous diagonal
            : a(p + 1, q - 1) // Go one back
        : p == 1 // rougly the same
            ? a(p, q - 1)
            : a(p - 1, q + 1)
    )

— Bary12
स्रोत

4

(3,5)में परिणाम चाहिए 19(नहीं 24) के बाद से (1,1)==(2,2)==(3,3), (2,4)==(1,2), (4,2)==(2,1)और (2,6)==(1,3)। (यानी (2,2)परिणाम 1नहीं होना चाहिए 5, आदि ...)

— योनातन एलन