महिला और पुरुष अनुक्रम

20

यह सवाल शायद उन सभी की तुलना में कठिन है, जो "संख्याओं के अनुक्रम को उत्पन्न करते हैं" कार्य करते हैं, क्योंकि इसके लिए एक साथ काम करने वाले TWO दृश्यों की आवश्यकता होती है।

वास्तव में जवाब के लिए आगे देख!

अपनी पुस्तक " गोदेल, एस्चर, बाख: एक शाश्वत गोल्डन ब्रैड " में, डगलस हॉफस्टैटर के पास संख्याओं के काफी कम अनुक्रम हैं, ये सभी किसी न किसी तरह से पिछले शब्द पर भरोसा करते हैं। सभी अनुक्रमों की जानकारी के लिए, यह विकिपीडिया पृष्ठ देखें ।

दृश्यों की एक जोड़ी जो वास्तव में दिलचस्प है, महिला और पुरुष अनुक्रम हैं, जिन्हें इस तरह परिभाषित किया गया है:

के लिए n > 0।

यहाँ स्त्री अनुक्रम और पुरुष अनुक्रम है ।

आपका कार्य है, जब एक पूर्णांक nइनपुट के रूप में दिया जाता है, तो महिला अनुक्रम और पुरुष अनुक्रम की एक सूची लौटाएं n, जिसमें आउटपुट की दो पंक्तियों के बराबर शब्द हों , पहली पंक्ति में महिला अनुक्रम और पुरुष अनुक्रम। द्वितीय।

नमूना इनपुट और आउटपुट: इनपुट: 5 आउटपुट:[1, 1, 2, 2, 3] [0, 0, 1, 2, 2]

इनपुट: 10 आउटपुट:[1, 1, 2, 2, 3, 3, 4, 5, 5, 6] [0, 0, 1, 2, 2, 3, 4, 4, 5, 6]

नोट: सूचियों के बीच पृथक्करण एक लाइन ब्रेक को दर्शाता है।

यह कोड-गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा कोड है। इसके अलावा, अपने कोड के लिए भी स्पष्टीकरण डालें।

लीडरबोर्ड

कोड स्निपेट दिखाएं

code-golf  math  sequence 
— clismique
स्रोत
5
क्या हम सूचियों को छापने के बजाय, किसी फ़ंक्शन से सूचियों की एक जोड़ी लौटा सकते हैं?
— जर्ग्ब
हॉफस्टैटर के अनुक्रमों से संबंधित अन्य चुनौतियां: क्यू अनुक्रम , आंकड़ा-आंकड़ा अनुक्रम
— मार्टिन एंडर
@Zgarb आप कर सकते हैं, जब तक कि दो सूचियाँ अलग-अलग लाइनों में हों।
— '11:
2
@DerpfacePython सूचियों की एक जोड़ी में कोई रेखाएं नहीं हैं ; एक समारोह है, तो रिटर्न सूचियों की एक जोड़ी है, तो आप उन्हें प्रिंट को मनचाहे कर सकते हैं। कहा जा रहा है, मैं उत्पादन को प्रिंट करते हुए भी लाइनों की आवश्यकता का बहुत बड़ा प्रशंसक नहीं हूं। बोझिल I / O प्रारूप चुनौतियों को लिखते समय बचने वाली चीजों में से एक हैं।
— डेनिस
4
यह कुछ दृष्टिकोणों / भाषाओं के लिए कोई बड़ी बात नहीं है, लेकिन यह दूसरों के लिए एक बड़ा बदलाव ला सकता है। सी में, पंक्तियों के बजाय स्तंभों में अनुक्रमों को मुद्रित करके बहुत सारे बाइट्स को बचाया जा सकता है। पायथन में, सबसे छोटा तरीका जो मैं सोच सकता हूं, वह मेरे पुनरावर्ती जूलिया जवाब के समान एक पुनरावर्ती लंबोदर है जो सूची की एक जोड़ी लौटाता है, लेकिन एक लाइनफीड के साथ एक स्ट्रिंग में बदलने के लिए यह बहुत लंबा बनाता है, यहां तक ​​कि पूर्ण कार्यक्रम की तुलना में भी अधिक Sp3000 द्वारा पोस्ट किया गया। अन्य दृष्टिकोण, जैसे कि एक पुनरावर्ती समाधान जो ऊपर की बजाय नीचे गिना जाता है, पूरी तरह से खारिज कर दिया जाता है क्योंकि नई लाइन को जोड़ना असंभव है।
— डेनिस

जवाबों:

3

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

ṙṪḢạL}ṭ
çƓḤ¤Ð¡1ṫ-Ṗ€G

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

यह काम किस प्रकार करता है

çƓḤ¤Ð¡1ṫ-Ṗ€G  Main link. No user arguments. Left argument defaults to 0.
   ¤          Combine the two links to the left into a niladic chain.
 Ɠ              Read an integer from STDIN.
  Ḥ             Unhalve/double it.
ç   С1       Call the helper link that many times. Return all results.
              In the first call, the left and right argument are 0 and 1 resp.
              After each iteration, the left argument is set to the return value
              and the right argument to the prior value of the left one.
       ṫ-     Tail -1; keep the last two items of the list of results.
         Ṗ€   Discard the last item of each list.
           G  Grid; format the pair of lists.


ṙṪḢạL}ṭ       Helper link. Arguments: x, y (lists)

ṙ             Rotate x k units to the left, for each k in y.
 Ṫ            Tail; extract the last rotation.
  Ḣ           Head; extract the last element.
              This essentially computes x[y[-1]] (Python notation), avoiding
              Jelly's 1-based indexing.
    L}        Yield the length of y.
   ạ          Take the absolute difference of the results to both sides.
      ṭ       Tack; append the difference to y and return the result.
— डेनिस
स्रोत
5
और यह वह हिस्सा है जहां मैं एक चुनौती बनाने के लिए खुद को गौरवान्वित महसूस करता हूं जो जेली को 10 से अधिक बाइट का उपयोग करता है।
— clismique
13

जूलिया, 52 48 बाइट्स

x->[n÷φ|(5n^2|4∈(2:3n).^2)for| =(+,-),n=1:x]

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

पृष्ठभूमि

में पर होफस्टैड्टर की शादी कार्यों , लेखक से पता चलता है कि

एफ / एम सूत्र

जहां φ सुनहरे अनुपात को दर्शाता है ,

डेल्टा / एप्सिलॉन सूत्र

और F n , n वें फाइबोनैचि संख्या को दर्शाता है ।

इसके अलावा, उन्नत समस्याओं और समाधानों में, एच -187: फाइबोनैचि एक वर्ग है , प्रस्तावक से पता चलता है कि

फाइबोनैचि / लुकास पहचान

जहां L n n वें लुकास संख्या को दर्शाता है , और वह - इसके विपरीत - यदि

फाइबोनैचि / लुकास की पहचान

तब n एक फाइबोनैचि संख्या है और m एक लुकास संख्या है।

इससे, हम यह घटाते हैं

डेल्टा / एप्सिलॉन प्रमेय

जब भी n> 0 ।

यह काम किस प्रकार करता है

इनपुट x को देखते हुए , हम x मैट्रिक्स द्वारा 2 का निर्माण करते हैं , जहाँ | पहले कॉलम में जोड़ और दूसरे में घटाव है, और n पंक्तियों में 1 और x के बीच पूर्णांकों पर पुनरावृत्त करता है।

F (n - 1) और M (n - 1) दोनों का पहला शब्द बस है n÷φ।

हम 5n। की गणना करके ) (n) और ε (n) की गणना करते हैं 4 और परीक्षण अगर परिणाम 2 और 3n के बीच पूर्णांकों के वर्गों के सरणी से संबंधित है । यह दोनों वर्गाकारिता के लिए और, के बाद से परीक्षण 1 , श्रेणी में नहीं है के लिए n> 1 अगर | घटाव है।

अंत में हम 5n^2|4∈(2:3n).^2पहले से गणना किए गए पूर्णांक से या उसके परिणामस्वरूप बूलियन को जोड़ते या घटाते हैं ।

— डेनिस
स्रोत
क्या इसे गैर-पुनरावर्ती / पुनरावृत्त तरीके से व्यक्त किया जा सकता है ?, इसके लिए बंद रूप क्या है?
— अब्राहम
मैंने एक स्पष्टीकरण जोड़ा है।
— डेनिस
11

पायथन 2, 79 70 बाइट्स

a=0,;b=1,
exec"a,b=b,a+(len(a)-b[a[-1]],);"*~-input()*2
print b,'\n',a

पुनरावर्ती के बजाय Iterative, क्योंकि क्यों नहीं। पहली पंक्ति में एक अनुगामी स्थान है - यदि यह ठीक नहीं है तो इसे अतिरिक्त बाइट के लिए तय किया जा सकता है। -9 बाइट्स @ डेनिस को धन्यवाद।

यहां कुछ संयुक्त लंबोदर हैं जो वास्तव में मदद नहीं करते थे:

f=lambda n,k:n and n-f(f(n-1,k),k^1)or k
f=lambda n,k:[k][n:]or f(n-1,k)+[n-f(f(n-1,k)[-1],k^1)[-1]]

पुरुष / महिला को निर्दिष्ट करते हुए, दोनों या 0 या 1 nपैरामीटर लेते हैं k। पहला लैम्ब्डा nth तत्व देता है, और दूसरा लैम्ब्डा पहला n एलिमेंट्स (एक्सपोनेंशियल रनटाइम के साथ) लौटाता है।

— Sp3000
स्रोत
9

MATL , 23 बाइट्स

1Oiq:"@XJth"yy0)Q)_J+hw

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

व्याख्या

यह चलने का काम करता है। प्रत्येक अनुक्रम को एक सरणी में रखा जाता है। प्रत्येक अनुक्रमणिका n के लिए प्रत्येक अनुक्रम का नया शब्द संगणित होता है और संबंधित सरणी से जुड़ा होता है। N terms1 शब्दों के forसाथ एक लूप का उपयोग किया जाता है, जहां N इनपुट संख्या है।

अनुक्रम M के लिए अद्यतन पहले किया जाना चाहिए। इसका कारण यह है कि अनुक्रम F हमेशा समान अनुक्रमित के लिए अनुक्रम M से अधिक या बराबर होता है, इसलिए यदि हमने F को अपडेट करने का प्रयास किया है तो हमें M के एक शब्द की आवश्यकता होगी जो अभी तक गणना नहीं की गई है।

दो अपडेट समीकरण समान इंटरचेंजिंग एफ और एम हैं। इस प्रकार अपडेट के लिए कोड forदो पुनरावृत्तियों के साथ एक लूप लगाने और स्टैक में अनुक्रमों को स्वैप करके पुन: उपयोग किया जाता है ।

1        % Push 1: seed for F sequence
O        % Push 0: seed for M sequence
iq:      % Input N. Generate range [1 2 ... N-1]
"        % For each (i.e. iterate N-1 times)
  @      %   Push current index, n (starting at 1 and ending at N-1)
  XJ     %   Copy to clipboard J
  th     %   Duplicate and concatenate. This generates a length-2 array
  "      %   For each (i.e. iterate twice)
    yy   %   Duplicate top two elements, i.e. F and M sequences
    0)   %     In the *first* iteration: get last entry of M, i.e M(n-1)
    Q)   %     Add 1 and index into F. This is F(M(n-1))
    _J+  %     Negate and add n. This is n-F(M(n-1)), that is, M(n)
    h    %     Concatenate to update M
    w    %     Swap top two elements, to bring F to top.
         %     In the *second* iteration the procedure is repeated to update F,
         %     and then the top two elements are swapped to bring M to top again,
         %     ready for the next iteration of the outer loop
         %   End for implicitly
         % End for implicitly
         % Display implicitly from bottom to top: first line is F, second is M
— लुइस मेंडो
स्रोत
6

जे, 47 बाइट्स

f=:1:`(-m@f@<:)@.*
m=:0:`(-f@m@<:)@.*
(f,:m)@i.

पुनरावर्ती परिभाषा का उपयोग करता है। पहली दो पंक्तियाँ क्रियाओं को परिभाषित करती हैं fऔर mजो क्रमशः महिला और पुरुष कार्यों को दर्शाती हैं। अंतिम पंक्ति एक क्रिया है जो एक एकल तर्क लेती है nऔर nमहिला और पुरुष अनुक्रमों की पहली शर्तों को आउटपुट करती है ।

प्रयोग

   (f,:m)@i. 5
1 1 2 2 3
0 0 1 2 2
   (f,:m)@i. 10
1 1 2 2 3 3 4 5 5 6
0 0 1 2 2 3 4 4 5 6
— मील की दूरी पर
स्रोत
6

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

g=n=>--n?([f,m]=g(n),m=[...m,n-f[m[n-1]]],[[...f,n-m[f[n-1]]],m]):[[1],[[0]]

अगर मैं पुरुष अनुक्रम को पहले वापस करने की अनुमति देता तो मैं 2 बाइट्स बचा सकता था:

g=n=>--n?([f,m]=g(n),[m=[...m,n-f[m[n-1]]],[...f,n-m[f[n-1]]]]):[[1],[[0]]
— नील
स्रोत
6

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

l#s=scanl(\a b->b-l!!a)s[1..]
v=w#1
w=v#0
(<$>[v,w]).take

उपयोग उदाहरण: (<$>[v,w]).take $ 5->[[1,1,2,2,3],[0,0,1,2,2]]

सहायक फ़ंक्शन #प्रारंभिक मान के साथ एक अनंत सूची बनाता है sऔर lआगे के सभी तत्वों को देखने के लिए एक सूची बनाता है (पिछले मूल्य के सूचकांक पर)। v = w#1महिला और w = v#0पुरुष अनुक्रम है। मुख्य फ़ंक्शन में हम nदोनों के पहले तत्वों को लेते हैं vऔर w।

— nimi
स्रोत
4

पायथन 2, 107 बाइट्स

F=lambda n:n and n-M(F(n-1))or 1
M=lambda n:n and n-F(M(n-1))
n=range(input())
print map(F,n),'\n',map(M,n)

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

बड़ा इनपुट मान एक RuntimeError (बहुत अधिक पुनरावर्तन) का कारण बनता है। यदि यह एक समस्या है, तो मैं एक संस्करण लिख सकता हूं जहां त्रुटि नहीं होती है।

— मै जाऊं
स्रोत
3

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

reduceबाइट-काउंट को कम करने के लिए उपयोग करना शायद असंभव है ।

सीधा कार्यान्वयन।

L&b-b'ytbL?b-by'tb1'MQyM

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

यह काम किस प्रकार करता है

L&b-b'ytb  defines a function y, which is actually the male sequence.

L          def male(b):
 &b            if not b: return b
   -b          else: return b-
     'ytb            female(male(b-1))


L?b-by'tb1 defines a function ', which is actually the female sequence.

L          def female(b):
 ?b            if b:
   -by'tb          return b-male(female(b-1))
         1     else: return 1


'MQ        print(female(i) for i from 0 to input)
yMQ        print(male(i) for i from 0 to input)
— लीक नन
स्रोत
क्या मैं लीडरबोर्ड में एनाग्रेटेड नाम या आपका मूल नाम शामिल करता हूं? इसके अलावा, यह कोड भयानक रूप से एक पायथ कार्यक्रम के लिए लंबा है।
— मौलवी
आप यहाँ कितने समय से हैं ... आप कैसे जानते हैं कि मैंने अपना नाम बदल लिया है? मेरा नया नाम वहाँ रखो।
— लीक नन
1
मैं यह जानने के लिए यहां काफी समय से हूं कि आपने अपना नाम बदल लिया है।
— मौलवी
@DerpfacePython यह देखकर कि अन्य उत्तर लगभग 4 गुना लंबे हैं ... मैं कहूंगा कि मेरा समाधान बहुत लंबा नहीं है।
— लीक नन
यह बहुत सच है, लेकिन यह अन्य सवालों के लिए अन्य पायथ कार्यक्रमों की तुलना में अभी भी लंबा है।
— मौलवी
3

ब्रेकीलॉग , 65 बाइट्स

:{:1-:0re.}fL:2aw,@Nw,L:3aw
0,1.|:1-:2&:3&:?--.
0.|:1-:3&:2&:?--.

नर और मादा दोनों के लिए एक साथ संयोजन करने के मेरे प्रयास ने वास्तव में कोड को लंबा कर दिया।

आप निम्नलिखित एक लाइनर का उपयोग कर सकते हैं जिसमें बाइट्स की संख्या समान हो:

:{:1-:0re.}fL:{0,1.|:1-:2&:3&:?--.}aw,@Nw,L:{0.|:1-:3&:2&:?--.}aw

नोट : यह प्रोलॉग ट्रांसपिलर के साथ काम करता है, पुराने जावा एक से नहीं।

व्याख्या

मुख्य विधेय:

:{:1-:0re.}fL                Build a list L of integers from 0 to Input - 1
             :2aw            Apply predicate 2 to each element of L, write the resulting list
                 ,@Nw        Write a line break
                     ,L:3aw  Apply predicate 3 to each element of L, write the resulting list

2 (महिला) को समर्पित करें:

0,1.                         If Input = 0, unify Output with 1
    |                        Else
     :1-                     Subtract 1 from Input
        :2&                  Call predicate 2 with Input - 1 as argument
           :3&               Call predicate 3 with the Output of the previous predicate 2
              :?-            Subtract Input from the Output of the previous predicate 3
                 -.          Unify the Output with the opposite of the subtraction

प्रेडिकेट 3 (पुरुष):

0.                           If Input = 0, unify Output with 0
  |                          Else
   :1-                       Subtract 1 from Input
      :3&                    Call predicate 3 with Input - 1 as argument
         :2&                 Call predicate 2 with the Output of the previous predicate 3
            :?-              Subtract Input from the Output of the previous predicate 3
               -.            Unify the Output with the opposite of the subtraction
— Fatalize
स्रोत
रुको ... कौन सा 3 का विधेय है?
— क्लिस्मिक्स
@DerpfacePython वूप्स, फिक्स्ड। यह भी ध्यान दें कि एक को समर्पित {:1-:0re.}किया जाता है , जिसका उपयोग सीमा सूची बनाने के लिए किया जाता है।
— घातक
3

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

(fn [n](loop[N 1 M[0]F[1]](if(< N n)(let[M(conj M(- N(F(peek M))))F(conj F(- N(M(peek F))))](recur(inc N)M F))(do(prn F)(prn M)))))

बस शून्य से n तक क्रमिक रूप से क्रम बनाता है।

अनप्लग्ड संस्करण

(fn [n]
  (loop [N 1 M [0] F [1]]
    (if (< N n)
      (let [M (conj M (- N (F (peek M))))
            F (conj F (- N (M (peek F))))]
        (recur (inc N) M F))
      (do
        (prn F)
        (prn M)))))
— निशान
स्रोत
अच्छा जवाब, साइट पर आपका स्वागत है! क्या एक अनुगामी स्थान या न्यूलाइन आवश्यक है? मैं 131 + एक अनुगामी व्हाट्सएप गिन रहा हूं।
— DJMcMayhem
नहीं, अनुगामी व्हॉट्सएप की कोई आवश्यकता नहीं है। चुपके से विम ने गिनने के लिए wc के लिए एक नई रेखा जोड़ी।
— मार्क
3

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

jCuaG-LHtPs@LGeGr1Q],1Z

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

jCuaG-LHtPs@LGeGr1Q],1Z

  u                ],1Z    start with G = [[1, 0]]
                           (this will be the list of F-M pairs)
  u             r1Q        for each H in [1, 2, ..., Q-1]:
              eG              take the last pair of G [F(H-1), M(H-1)]
           @LG                lookup the pairs of these values:
                              [[F(F(H-1)), M(F(H-1))], [F(M(H-1)), M(M(H-1))]]
          s                   join them:
                              [F(F(H-1)), M(F(H-1)), F(M(H-1)), M(M(H-1))]
        tP                    get rid of the first and last element:
                              [M(F(H-1)), F(M(H-1))]
     -LH                      subtract these values from H
                              [H - M(F(H-1)), H - F(M(H-1))]
   aG                         and append this new pair to G
jC                         at the end: zip G and print each list on a line

वैकल्पिक समाधान जो कम करने के बजाय एक फ़ंक्शन का उपयोग करता है (23 बाइट्स भी):

L?>b1-LbtPsyMytb,1ZjCyM
— Jakube
स्रोत
अच्छा लगा। वाकई बहूत बढिया।
— लीक नून
3

रूबी, 104 92 97 82 बाइट्स

f=->n,i{n>0?n-f[f[n-1,i],-i]:i>0?1:0}
->n{[1,-1].map{|k|p (0...n).map{|i|f[i,k]}}}

संपादित करें: f और mअब होपफुल हेल्पफुल के लिए एक फ़ंक्शन धन्यवाद है । मैंने fतब प्रिंट करने के लिए दूसरा फ़ंक्शन बदला m। इसके बाद व्हाट्सएप pमहत्वपूर्ण है, क्योंकि (0...n)परिणाम के बजाय फ़ंक्शन प्रिंट करता है map।

तीसरे फ़ंक्शन में पहले n शब्दों की fएक सरणी होती है, जिसके बाद पहले n शब्दों की एक सरणी होती हैm

इन कार्यों को इस तरह कहा जाता है:

> f=->n,i{n>0?n-f[f[n-1,i],-i]:i>0?1:0}
> s=->n{[1,-1].map{|k|p (0...n).map{|i|f[i,k]}}}
> s[10]
[1, 1, 2, 2, 3, 3, 4, 5, 5, 6]
[0, 0, 1, 2, 2, 3, 4, 4, 5, 6]
— Sherlock9
स्रोत
आप पी और parens ड्रॉप कर सकते हैं। आउटपुट को प्रिंट करने की आवश्यकता नहीं है। इसके अलावा, आप रेंज के चारों ओर पैरेंस को घेर सकते हैं।
— नहीं कि चार्ल्स
आप 2 फ़ंक्शन को 1 से बदल सकते हैं, जिसमें 2 तर्क हैं nऔरi n>0?n-f(f(n-1,i),-i):i>0?1:0
— उम्मीद है कि
@HopefullyHelpful एक गुच्छा धन्यवाद: D
— शर्लक
@NhathatCharles क्या आउटपुट को प्रिंट करने की आवश्यकता नहीं है? रूबी में, अगर मैं चाहता हूं कि वह लाइन बीच में टूट जाए fऔर m, मुझे इसे प्रिंट करने की आवश्यकता है। अन्यथा, मुझे सिर्फ एक सरणी मिलती है जैसे[[1, 1, 2, 2, 3, 3, 4, 5, 5, 6], [0, 0, 1, 2, 2, 3, 4, 4, 5, 6]]
— शर्लक
ओह, यह "लाइन ब्रेक" कहता है। बहुत बुरा।
— नहीं कि चार्ल्स
3

एपीएल (डायलॉग यूनिकोड) , 45 25 बाइट्स

अनाम मौन कार्य। आवश्यकता है ⎕IO←0, जो कई एपीएल सिस्टम पर मानक है।

1 0∘.{×⍵:⍵-(~⍺)∇⍺∇⍵-1⋄⍺}⍳

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

यह एफ और एम को एक एकल डायडिक फ़ंक्शन में बूलियन बाएं तर्क के साथ जोड़कर काम करता है जो आवेदन करने के लिए फ़ंक्शन का चयन करता है। हम F के लिए 1 और 0 का उपयोग M के लिए करते हैं ताकि हम इस चयनकर्ता का उपयोग F  (0) और M  (0) के रिटर्न मान के रूप में कर सकें । फिर हम देखते हैं कि दोनों कार्यों को पहले खुद को (तर्क शून्य से एक पर) और फिर दूसरे परिणाम पर कॉल करने की आवश्यकता है, इसलिए पहले हम दिए गए चयनकर्ता के साथ पुनरावृत्ति करते हैं और फिर तार्किक रूप से नकारात्मक चयनकर्ता के साथ।

⍳ ices ndices; शून्य से एक तर्क शून्य के माध्यम से

1 0∘.{... } बाहरी (कार्टेशियन) "उत्पाद" (लेकिन गुणन के बजाय नीचे के फ़ंक्शन के साथ) [1,0]बाएं तर्कों ( ⍺) और सूचकांकों को सही तर्क ( ⍵) के रूप में उपयोग करते हैं:

 ×⍵ यदि सही तर्क सख्ती से सकारात्मक है (सही तर्क का संकेत दिया जाता है):

  ⍵-1 एक को सही तर्क से घटाएं

  ⍺∇ उस तर्क के साथ स्वयं को सही तर्क और बाएं तर्क को बाएं तर्क के रूप में कहें

  (~⍺)∇ उस के साथ स्वयं को सही arg और बाएं arg के रूप में बाएं arg के तार्किक निषेध को कॉल करें

  ⍵- सही तर्क से घटाएँ और परिणाम लौटाएँ

 ⋄ अन्य:

  ⍺ बाएं तर्क को लौटाएं

— एडम
स्रोत
यह अच्छी तरह से काम करता है, लेकिन यह मानते हुए इनपुट एक चर में संग्रहीत है डिफ़ॉल्ट रूप से अस्वीकृत है।
— डेनिस
@ डेनिस यह वास्तव में नहीं है। यह एक tfn शरीर है। जब मैं यहां नया था, तो ngn ने मुझे बताया कि मुझे tfn हैडर (जो दो बाइट, एक सिंगल-चार नाम + एक न्यूलाइन होगा, की गिनती नहीं करनी है, ठीक उसी तरह जैसे स्रोत फ़ाइल नाम की गिनती नहीं की जाती है, और अनाम fns की अनुमति है तो यहाँ भी, जहाँ हेडर एक 1-चार नाम + स्थान + एक 1-चार तर्क नाम ( n) + प्लस एक नई
— पंक्ति है
वास्तव में एक tfn क्या है?
— डेनिस
@ डेनिस टफन्स पारंपरिक एपीएल कार्यों का प्रतिनिधित्व करते हैं। Dfns के प्रतिबंधों में से कोई भी नहीं के साथ कोड की लाइनों से मिलकर । उदाहरण के लिए, आपके पास उचित नियंत्रण संरचनाएं हो सकती हैं, और बिना परिणाम के भाव। लाइन "0" एक हेडर है जो fn के सिंटैक्स को इंगित करता है ।
— एडम
2

ईएस 6, 89 85 83 बाइट्स

2 बाइट्स @ Bálint की बदौलत बच गए

x=>{F=[n=1],M=[0];while(n<x){M.push(n-F[M[n-1]]);F.push(n-M[F[n++-1]])}return[F,M]}

लागू नहीं।

स्पष्टीकरण:

x => {
    F = [n = 1], //female and term number
    M = [0]; //male
    while (n < x) {
        M.push(n - F[M[n - 1]]); //naïve
        F.push(n - M[F[n++ - 1]]); //post-decrement means n++ acts as n in the calculation
    }
    return [F, M];
}
— ASCII-केवल
स्रोत
मुझे लगता है कि आप इसे एक Anonymus समारोह कर सकते हैं और && की जगह - साथ एस एंड
— Bálint
आप &&शॉर्ट-सर्किट नहीं कर सकते , जो चाहता है, लेकिन मैंने इसे वैसे भी हटा दिया क्योंकि ब्रेस सिंटैक्स वैसे भी उतना ही छोटा है
— ASCII-only
तो फिर तुम कर सकते थे do`F = [n = 1]
— Bálint
2

गणितज्ञ, 69 62 बाइट्स

कार्यात्मक रूप सुझाने के लिए Sp3000 का धन्यवाद जिसने 14 बाइट्स बचाए।

k_~f~0=1-k
k_~f~n_:=n-f[1-k,f[k,n-1]]
Print/@Array[f,{2,#},0]&

यह एक नामित सहायक फ़ंक्शन को परिभाषित करता है fऔर फिर एक अनाम फ़ंक्शन का मूल्यांकन करता है जो दोनों अनुक्रमों को मुद्रित करने के वास्तविक कार्य को हल करता है।

— मार्टिन एंडर
स्रोत
2

पर्ल 5.10, 85 80 बाइट्स

अगर मैं इसे नीचे गोल्फ के लिए और अधिक विचार है मेह, दूनो ...

@a=1;@b=0;for(1..<>-1){push@a,$_-$b[$a[$_-1]];push@b,$_-$a[$b[$_-1]]}say"@a\n@b"

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

मुझे फ़ंक्शन use 5.10.0को स्वीकार करने के लिए Ideone पर जोड़ना पड़ा say, लेकिन यह बाइट गिनती की ओर नहीं है।

यह @a"महिला" सूची और @b"पुरुष" सूची होने के नाते एल्गोरिथ्म का एक भोली कार्यान्वयन है ।

क्रॉस-आउट 85 अभी भी 85 है?

— पॉल पिकार्ड
स्रोत
स्पष्टीकरण, कृपया?
— मौलवी
काफी मेरी जे एस जवाब के रूप में एक ही
— ASCII-केवल
@DerpfacePython यह वास्तव में एक भोली कार्यान्वयन है। :)
— पॉल पिकार्ड
मैंने परीक्षण नहीं किया है, लेकिन मुझे नहीं लगता कि आपको प्रत्येक pushएड टर्म के चारों ओर कोष्ठक की आवश्यकता होनी चाहिए , और न ही अंतिम अर्धविराम को क्लोज-ब्रेस से पहले।
— msh210
@ msh210 वास्तव में, इस बारे में भूल गया। कुल 5 बाइट्स बचाता है, धन्यवाद!
— पॉल पिकार्ड
2

जावा, 169 बाइट्स कुल

int f(int n,int i){return n>0?n-f(f(n-1,i),-i):i>0?1:0;}void p(int n,int i){if(n>0)p(n-1,i);System.out.print(i==0?"\n":f(n,i)+" ");}void p(int n){p(n,1);p(0,0);p(n,-1);}

एफ (), एम () 56 बाइट्स

int f(int n,int i){
    return n>0?n-f(f(n-1,i),-i):i>0?1:0;
}

पुनरावर्ती-के लिए लूप और मुद्रण 77 बाइट्स

void p(int n,int i) {
    if(n>0) {
        p(n-1,i);
    }
    System.out.print(i==0?"\n":f(n,i)+" ");
}

दो अलग-अलग लाइनों में सूचियों का उत्पादन 37 बाइट्स

void p(int n) {
    p(n,1);
    p(0,0);
    p(n,-1);
}

इनपुट: p ( 10)
आउटपुट:

1 1 2 2 3 3 4 5 5 6 6 7 8 8 9 9 
0 0 1 2 2 3 4 4 5 6 6 7 7 8 9 9
— HopefullyHelpful
स्रोत
1

सी, 166 बाइट्स

#define P printf
#define L for(i=0;i<a;i++)
f(x);m(x);i;c(a){L P("%d ",f(i));P("\n");L P("%d ",m(i));}f(x){return x==0?1:x-m(f(x-1));}m(x){return x==0?0:x-f(m(x-1));}

उपयोग:

main()
{
    c(10);
}

आउटपुट:

1 1 2 2 3 3 4 5 5 6
0 0 1 2 2 3 4 4 5 6

अनगोल्डेड (331 बाइट्स)

#include <stdio.h>

int female(int x);
int male(int x);
int i;
int count(a){
    for(i=0;i<a;i++){
        printf("%d ",female(i));
    }
    printf("\n");
    for(i=0;i<a;i++){
        printf("%d ",male(i));
    }
}
int female (int x){
    return x==0?1:x-male(female(x-1));
}
int male(x){
    return x==0?0:x-female(male(x-1));
}
int main()
{
    count(10);
}
— जियाकोमो गारबेलो
स्रोत
0

8 , 195 बाइट्स

कोड

defer: M
: F dup not if 1 nip else dup n:1- recurse M n:- then ;
( dup not if 0 nip else dup n:1- recurse F n:- then ) is M
: FM n:1- dup ( F . space ) 0 rot loop cr ( M . space ) 0 rot loop cr ;

प्रयोग

ok> 5 FM
1 1 2 2 3 
0 0 1 2 2 

ok> 10 FM
1 1 2 2 3 3 4 5 5 6 
0 0 1 2 2 3 4 4 5 6

व्याख्या

यह कोड पुनरावृत्ति और आस्थगित शब्द का उपयोग करता है

defer: M- इस शब्द Mको बाद में परिभाषित किया गया है। यह एक आस्थगित शब्द है

: F dup not if 1 nip else dup n:1- recurse M n:- then ;- परिभाषा के अनुसार महिला संख्या उत्पन्न करने के लिए F पुनरावर्ती रूप से परिभाषित करें । कृपया ध्यान दें कि Mअभी तक परिभाषित नहीं किया गया है

( dup not if 0 nip else dup n:1- recurse F n:- then ) is M- परिभाषा के अनुसार पुरुष संख्या उत्पन्न करने के लिए M पुनरावर्ती रूप से परिभाषित करें

: FM n:1- dup ( F . space ) 0 rot loop cr ( M . space ) 0 rot loop cr ; - वर्ड में महिला और पुरुष संख्या के क्रम प्रिंट होते थे

— अराजकता मनोर
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.