स्ट्रेट-चेन अलक की संख्या * दी गई लंबाई के nes

28

एक सीधी-चेन एल्क * ने सिंगल (अल्केन), डबल (एल्केन), या ट्रिपल बॉन्ड (एल्केनी) से जुड़े कार्बन परमाणुओं के अनुक्रम के रूप में परिभाषित किया गया है, (निहित हाइड्रोजेन का उपयोग किया जाता है।) कार्बन परमाणु केवल 4 बॉन्ड बनाते हैं, इसलिए। किसी भी कार्बन परमाणु को चार से अधिक बंधनों के लिए बाध्य नहीं किया जा सकता है। एक सीधी-चेन एल्क * ने अपने कार्बन-कार्बन बांड की एक सूची के रूप में प्रतिनिधित्व किया जा सकता है।

ये मान्य सीधी-श्रृंखला alk * nes के कुछ उदाहरण हैं:

[]       CH4              Methane
[1]      CH3-CH3          Ethane
[2]      CH2=CH2          Ethene
[3]      CH≡CH            Ethyne
[1,1]    CH3-CH2-CH3      Propane
[1,2]    CH3-CH=CH2       Propene
[1,3]    CH3-C≡CH         Propyne
[2,1]    CH2=CH-CH3       Propene
[2,2]    CH2=C=CH2        Allene (Propadiene)
[3,1]    CH≡C-CH3         Propyne 
[1,1,1]  CH3-CH2-CH2-CH3  Butane
...

हालांकि ये नहीं हैं, क्योंकि कम से कम एक कार्बन परमाणु में 4 से अधिक बॉन्ड होंगे:

[2,3]
[3,2]
[3,3]
...

आपका कार्य एक प्रोग्राम / फ़ंक्शन बनाना है, जो एक सकारात्मक पूर्णांक दिया गया हो n, लंबाई में बिल्कुल कार्बन परमाणुओं के वैध स्ट्रेट-चेन एल्क * एनईएस की संख्या / आउटपुट देता है n। यह OEIS A077998 है ।

निर्दिष्टीकरण / स्पष्टीकरण

  • 1लौटकर आपको सही ढंग से संभालना चाहिए 1।
  • Alk * nes को पसंद करते हैं [1,2]और [2,1]इन्हें अलग माना जाता है।
  • आउटपुट है लंबाई एक दिया लंबाई के सभी संभव ALK * एनईएस की एक सूची की।
  • आपको 0 को सही तरीके से हैंडल करने की आवश्यकता नहीं है।

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

1 => 1
2 => 3
3 => 6
4 => 14

यह कोड गोल्फ है, इसलिए सबसे कम बाइट गिनती जीतती है!

code-golf  combinatorics  chemistry 
— जाकारी
स्रोत
बस स्पष्ट करने के लिए, एक श्रृंखला वैध है यदि सभी लगातार जोड़े को <=4सही, के लिए अभिव्यक्त किया जाता है ?
— माल्टीसेन
फिक्स्ड। @ माल्टीसेन: हाँ।
— जकार्इ
4
हर चीज के लिए OEIS अनुक्रम क्यों है? : पी
— हाइपरएनुट्रिनो
2
@ZacharyT, शून्य कार्बन परमाणुओं के साथ ठीक एक हाइड्रोकार्बन है, और यह एक है जिसमें शून्य हाइड्रोजन परमाणु भी हैं। यह पास्कल के त्रिकोण के लिए 0 के बजाय शीर्ष पर 1, या सचमुच सैकड़ों अन्य दहनशील अनुक्रमों के लिए सटीक तर्क है।
— पीटर टेलर
1
@ एग्निमा, ऐसा इसलिए है क्योंकि गलत अनुक्रम जुड़ा हुआ था। मैं इसे सही कर दूंगा।
— पीटर टेलर

जवाबों:

7

ओएसिस , 9 7 बाइट्स

xcd-+3V

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

व्याख्या

यह OEIS में पुनरावृत्ति संबंध का उपयोग करता है :

a (n) = 2 * a (n-1) + a (n-2) - a (3)

x    Multiply a(n-1) by 2: gives 2*a(n-1)
c    Push a(n-2)
d    Push a(n-3)
-    Subtract: gives a(n-2) - a(n-3)
+    Add: gives 2*a(n-1) + a(n-2) - a(n-3)
3    Push 3: initial value for a(n-1)
V    Push 1, 1: initial values for a(n-2), a(n-3)
— लुइस मेंडो
स्रोत
1
प्रारंभिक मूल्यों का अच्छा उपयोग! आप इस बार जीतें;)
— ईमिका
हाँ, वहाँ शायद यह हरा करने के लिए कोई रास्ता नहीं है।
— जकार्इ
4
@ZacharyT केवल अगर किसी को प्रोग्राम बनाने का तरीका पता चल सकता xkcdहै।
— hBy2Py
4
@ hBy2Py ठीक है, xkcd-+311काम करता है , क्योंकि kवर्तमान में एक नहीं सेशन है ...
— लुइस मेंडो
10

MATL , 10 बाइट्स

7K5vBiY^1)

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

व्याख्या

यह OEIS में पाए गए वर्णीकरण का उपयोग करता है

ए (एन) 3 एक्स 3 मैट्रिक्स [1, 1, 1] की एन-वें शक्ति की शीर्ष बाईं प्रविष्टि है; 1, 0, 0; 1, 0, 1]

7    % Push 7
K    % Push 4
5    % Push 5
v    % Concatenate all numbers into a column vector: [7; 4; 5]
B    % Convert to binary: gives 3×3 matrix [1, 1, 1; 1, 0, 0; 1, 0, 1]
i    % Input n
Y^   % Matrix power
1)   % Take the first element of the resulting matrix, i.e. its upper-left corner.
     % Implicitly display
— लुइस मेंडो
स्रोत
6

ओएसिस , 9 8 बाइट्स

अदनान को बाइट देकर धन्यवाद दिया

xc+d-63T

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

व्याख्या

a(0) = 0
a(1) = 1
a(2) = 3
a(3) = 6

a(n) = xc+d-

x         # calculate 2*a(n-1)
 c        # calculate a(n-2)
  +       # add: 2*a(n-1) + a(n-2)
   d      # calculate a(n-3)
    -     # subtract: 2*a(n-1) + a(n-2) - a(n-3)
— Emigna
स्रोत
1
अच्छा! इसके अलावा, :) के xलिए छोटा है 2*।
— अदनान
1
फिर हराया :-P (मैंने पहले से ही एक OASIS जवाब वहाँ नहीं देखा था)
— लुइस मेंडो
@ अदनान ओएसिस को यह बताने का एक तरीका है कि आप आउटपुट अनुक्रम सूचकांक को 1 से स्थानांतरित करना चाहते हैं? मेरा मतलब है, इनपुट तर्क के लिए 1 को घटाएं ( 0यहां एक प्रारंभिक का उपयोग करने के बजाय )
— लुइस मेंडो
1
@LuisMendo आह, कि अभी तक लागू नहीं किया गया है। लेकिन यह अगली रिलीज के लिए एक अच्छा विचार है :)।
— अदनान
भविष्य के संदर्भ के लिए, यह अब लागू किया गया है
— लुइस मेंडो
4

जेली, 10 बाइट्स

745DBæ*µḢḢ

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

लुइस मेंडो के एल्गोरिथ्म का उपयोग करता है ।

व्याख्या

745DBæ*µḢḢ    Main link. Argument: n
745D          Get the digits of 745
    B         Convert each to binary
     æ*       Matrix power
        ḢḢ    First element of first row

जेली, 15 बाइट्स

3Rṗ’µ+2\<5PµÐfL

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

पाशविक बल का उपयोग करता है।

व्याख्या

3Rṗ’µ+2\<5PµÐfL    Main link. Argument: n
3R                 Start with [1, 2, 3]
   ’               Take the (n-1)'th
  ṗ                Cartesian power
            Ðf     Filter on:
     +2\             Sums of overlapping pairs
        <5           1 for sums < 5, 0 otherwise
          P          Product: 1 if all pairs < 5
              L    Length
— PurkkaKoodari
स्रोत
4

MATL , 14 बाइट्स

q3:Z^TTZ+!5<As

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

व्याख्या

यह [1 2 3]एटम माइनस 1 की संख्या के लिए "उठाया" की कार्टेशियन शक्ति उत्पन्न करता है, और फिर यह जांचने के लिए कि प्रत्येक कार्टेशियन ट्यूपल राशि में कोई दो सन्निहित संख्या से अधिक का उपयोग नहीं करता है 4।

q    % Take number of atoms n implicitly
3:   % Push [1 2 3]
Z^   % Cartesian power. Gives a matrix with each (n-1)-tuple on a row
TT   % Push [1 1]
Z+   % 2D convolution. For each tuple this gives the sum of contiguous numbers
5<   % For each entry, gives true if less than 5
!    % Transpose
A    % True if all elements of each column are true. Gives a row vector
s    % Sum of true results. Implicitly display
— लुइस मेंडो
स्रोत
3

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

MatrixPower[{{1,1,1},{1,0,0},{1,0,1}},#][[1,1]]&

जैसा कि लुइस मेंडो ने बताया , यह OEIS में A006356 है। यहाँ मेरे मूल प्रयास हैं:

Count[Length@Split[#,+##<5&]&/@Tuples[{1,2,3},#-1],0|1]&

एक इनपुट के लिए n, कार्बन परमाणुओं के लिए सिंगल, डबल या ट्रिपल बॉन्ड के सभी संभावित अनुक्रमों का प्रतिनिधित्व करने वाले तत्वों Tuples[{1,2,3},n-1]के सभी- (n-1)टुपल्स की सूची है । एक शुद्ध कार्य है, जो यह बताता है कि क्या इसके तर्कों का योग इससे कम है , इसलिए एक सूची में उन तत्वों को विभाजित करता है जिनमें निरंतर तत्व होते हैं, जिनके युग्मक सम से कम होते हैं । मान्य alk * ne का वर्णन करना इस सूची के बराबर है जिसकी लंबाई (मामले में जहां ) है या , इसलिए मैं सिर्फ -tuples की संख्या जहां उस सूची की लंबाई मेल खाती है ।{1,2,3}n+##<5&5Split[#,+##<5&]&50n=11Count(n-1)0|1

Count[Fold[If[+##>4,4,#2]&]/@Tuples[{1,2,3},#-1],Except@4]&

If[+##>4,4,#2]&रिटर्न 4अगर इसके तर्कों का योग से अधिक है 4और अन्यथा दूसरा तर्क देता है। इस कार्य के साथ अपने इनपुट के Fold[If[+##>4,4,#2]&]बाईं ओर करता है Fold। तो यहाँ मैं -tuples Countकी संख्या (n-1)है जो इस ऑपरेटर को लागू करने के लिए नहीं देता है 4। जिस मामले n=1को तब से कवर किया गया Foldहै, जब इसका दूसरा तर्क खाली सूची है, तब तक यह निर्धारित नहीं है {}।

— ngenisis
स्रोत
1
क्या यह काम करेगा? (समायोजन के साथ OEIS से सही तरह से फट गया) LinearRecurrence[{2,1,-1},{1,3,6},#][[#]]&?
— जकार्इ
क्यों मैं इस साइट से प्यार करता हूँ का एक हिस्सा Mathematica की पेशकश करने के लिए सभी सुविधाओं को सीख रहा है :)
— ngenisis
द्वारा this site, क्या आपको OEIS या PPCG से मतलब है?
— जकर्याह
PPCG। मैंने लोगों के सुझावों से मैथमेटिका को लिया है।
— ngenisis
3

पायथन, 51 बाइट्स

f=lambda n:n<4and(n*n+n)/2or 2*f(n-1)+f(n-2)-f(n-3)

यह पुनरावृत्ति संबंध का एक सीधा कार्यान्वयन है। 3 बाइट्स के लिए टिम पेडरिक को धन्यवाद। आउटपुट Python 3 में एक फ्लोट और Python 2 में पूर्णांक है।

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

— मै जाऊं
स्रोत
(n*n+n)/2से छोटा है [1,3,6][n-1]। और अगर आप पायथन 3 का उपयोग कर रहे हैं और फ्लोटिंग-पॉइंट आउटपुट के साथ समाप्त होना पसंद नहीं करते हैं, तब (n*n+n)//2भी कम है।
— टिम पैडरिक
2

पायथ - 16 बाइट्स

पाशविक बल का उपयोग करता है।

lf.AgL4+VTtT^S3t

टेस्ट सूट ।

— Maltysen
स्रोत
1
यह हममें से उन लोगों के लिए एक विवरण प्रदान करना अच्छा होगा जो अजगर को "ग्रॉक" नहीं करते हैं।
— 1
2

रूबी, 62 बाइट्स

->n{c=0
(10**n/10).times{|i|"#{i}#{i*11}"=~/[3-9]/||c+=1}
c}

बुरी तरह से अक्षम आधार 10 जानवर बल दृष्टिकोण। अतिरिक्त बाइट्स के लिए आधार 5 में सुधार किया जा सकता है।

संख्याएँ उत्पन्न होती हैं जहाँ प्रत्येक अंक एक बॉन्ड (n-1 अंक) का 0प्रतिनिधित्व करता है । 1 के बॉन्ड ऑर्डर का 2प्रतिनिधित्व करता है , 3. बॉन्ड ऑर्डर का प्रतिनिधित्व करता है। 2 से अधिक अंक अमान्य हैं।

हम निकटवर्ती जोड़ी के अंकों के योग को 11 से गुणा करते हैं। 3 से अधिक अंक फिर से अमान्य हैं।

हम दो नंबरों को एक स्ट्रिंग में जोड़ते हैं और अमान्य अंकों की खोज करने के लिए एक regex करते हैं। यदि कोई नहीं पाया जाता है, तो हम काउंटर को बढ़ाते हैं।

परीक्षण कार्यक्रम में

f=->n{c=0
(10**n/10).times{|i|"#{i}#{i*11}"=~/[3-9]/||c+=1}
c}

p f[gets.to_i]
— स्तर नदी सेंट
स्रोत
2

रूबी, 51 बाइट्स

->n{a=[1,1,3]
n.times{a<<2*a[-1]+a[-2]-a[-3]}
a[n]}

OEIS A006356 प्रति पुनरावृत्ति संबंध के आधार पर।

अनुक्रम 0,1 और 2 के तत्वों के लिए एक सरणी के साथ शुरू होता है जो 1 हैं (जैसा कि मेरे द्वारा गणना की जाती है, इसे काम करने के लिए), 1 और 3 क्रमशः।

Iteratively nअनुक्रम में अधिक तत्व जोड़ता है , फिर तत्व देता है n। यह हमेशा 2 तत्वों की गणना करता है जो वास्तव में इसकी आवश्यकता है, लेकिन यह अभी भी रैखिक समय है, जो मेरे पिछले उत्तर की तुलना में अधिक कुशल है।

परीक्षण कार्यक्रम में

f=->n{a=[1,1,3]
n.times{a<<2*a[-1]+a[-2]-a[-3]}
a[n]}

p f[gets.to_i]
— स्तर नदी सेंट
स्रोत
2

गणितज्ञ, 42 40 बाइट्स

बाइट काउंट CP-1252 (विंडोज इंस्टॉलेशन पर डिफ़ॉल्ट) जैसे एक संगत सिंगल-बाइट एन्कोडिंग को मानता है।

±0=±1=1;±2=3;±n_:=±(n-1)2+±(n-2)-±(n-3);

यह केवल OEIS पर दी गई पुनरावृत्ति को एक एकीकृत ऑपरेटर के रूप में लागू करता है।

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

CJam (19 बाइट्स)

{2,{__-2=+1b+}@*W=}

ऑनलाइन टेस्ट सूट । यह एक अनाम ब्लॉक (फ़ंक्शन) है जो स्टैक पर एक आइटम लेता है और स्टैक पर एक छोड़ देता है। ध्यान दें कि परीक्षण सूट शामिल है a(0) = 1।

उपयोग की गई पुनरावृत्ति संबंधित OEIS अनुक्रम A006356 के अवलोकन पर आधारित है :

(N) = a (n-1) + 2 * a (n-2) + a (n-3) + के समतुल्य (1, 2, 1, 1, 1, ...) के INVERT परिवर्तन के बराबर है a (n-4) + ... + 1. a (6) = 70 = (31 + 2 * 14 + 6 + 3 + 1 + 1)। - गैरी डब्ल्यू एडम्सन, 27 अप्रैल 2009

लेकिन उपयुक्त ऑफसेट के साथ, जो फाइनल की आवश्यकता को हटा देता है + 1जैसा कि अब कवर किया गया है a(0)।

विच्छेदन

{         e# Define a block
  2,      e#   Take starting sequence [0 1] (beginning at index -1 for golfiness)
  {       e#   Loop...
    _     e#     Copy sequence so far
    _-2=+ e#     Append an extra copy of a(n-2)
    1b    e#     Sum
    +     e#     Append
  }@*     e#   ...n times
  W=      e#   Take the final value from the sequence
}
— पीटर टेलर
स्रोत
2

ब्रेन-फ्लैक, 56 बाइट्स

OEIS पृष्ठ पर पहली टिप्पणी में विस्तृत एल्गोरिथ्म का उपयोग करता है।

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

({}[()]<(((())))>){({}[()]<{({}<>({}))<>}<>>)}{}({}<>{})

व्याख्या

अनुक्रम को इस प्रकार परिभाषित किया जा सकता है:

For u(k), v(k), and w(k) such that
u(1) = v(1) = w(1) = 1
u(k+1) = u(k) + v(k) + w(k)
v(k+1) = u(k) + v(k)
w(k+1) = u(k)
u(k) is the number of straight-chain alk*nes with length k

कार्यक्रम शुरू होता है 1और बार-बार गणना करने के लिए इस पुनरावृत्ति को लागू करता हैu(k)

एनोटेट कोड (आने वाला वास्तविक एनोटेशन)

# Setup: decrement the input by one and push three 1's to the stack under it
({}[()]<(((())))>)

# Calculation:
{                          }           # While the input is not zero (main loop)
 ({}[()]                  )            # Pop the counter decrement it by one and push it
        <                >             # Before the counter gets pushed back to the stack...
         {            }                # Loop while the top of the stack is not zero (subloop)
          (        )                   # Push...
           {}                          # The top of the stack (popped)...
             <>                        # to the other stack...
               ({})                    # plus the top of the other stack (peeked)
                    <>                 # Switch back to the first stack.
                       <>              # Switch to the other stack
                            {}         # Pop the input (now zero)
                              (      ) # Push...
                               {}      # The top of the stack (u(k))...
                                 <>    # to the other stack...
                                   {}  # plus the top of the other stack (zero).

ढेर का दृश्य

मुख्य लूप की एक पुनरावृत्ति में यही होता है (ध्यान दें कि शून्य मौजूद हो सकता है या नहीं लेकिन यह या तो बात नहीं करता है):

Start of main loop iteration/subloop first iteration:
A    B

u
v
w
0    0
^

After first subloop iteration:
A    B

v
w    u
0    0
^

After second subloop iteration:
A    B

    u+v
w    u
0    0
^

After third subloop iteration (top of stack is zero so subloop terminates):

A    B

   u+v+w
    u+v
     u
0    0
^

End of main loop iteration:
A    B

   u+v+w
    u+v
     u
0    0
     ^

ढेर के राज्य अब एक ही रूप में यह छोड़कर वर्तमान ढेर अब के लिए अगले मानों पाश के शुरू में किया गया है u, vऔर wउस पर।

— 0 '
स्रोत
2

पर्ल 6, 48

{my @a=1,0,0;@a=reverse [\+] @a for 1..$_;@a[0]}

मौलिक रूप से

sub f {$_>2??2*f($_-1)+f($_-2)-f($_-3)!!(1,1,3)[$_]}

लेकिन मैं भूल गया कि मुझे इसकी आवश्यकता है sub fताकि पुनरावृत्त समाधान बाहर जीत जाए।

— bb94
स्रोत
2

दिल्लोग एपीएल, 30 बाइट्स

{⍵<3:⍵⌷1 3⋄+/∧/¨4≥2+/¨,⍳1↓⍵/3}

पाशविक बल का उपयोग करता है। स्पष्टीकरण (कम से कम मेरा सबसे अच्छा प्रयास):

⍵<3:⍵⌷1 3 - if ⍵ (function arg) is 1 (case 1) or 2 (case 2), return 1 (case 1) or 3 (case 2)
⋄ - separate statements
⍵/3 - otherwise, 3 repeated ⍵ times
1↓ - without the first element
⍳ - the matrix of possible indices of a matrix of that size
,  - ravel, return a list of all the elements of the matrix
2+/¨ - sum of each contiguous pair on each element
4≥ - tests whether each element is less than or equal to 4
∧/¨ - all elements are true, applied to each item.
+/ - Sum.
— जाकारी
स्रोत
1

दिल्लोग एपीएल, 29 बाइट्स

{⍵<4:⍵⌷1 3 6⋄+/2 1 ¯1×∇¨⍵-⍳3}

पूर्णांक अनुक्रम OEIS A006356 की पुनरावर्ती परिभाषा का उपयोग करके काम करता है।

— जाकारी
स्रोत
1

62 वें बाइट के साथ नाथन के साथ पायथन

मुझे इसकी कोशिश करनी थी, लेकिन ऐसा लगता है कि शुद्ध पायथन और पुनरावृत्ति सुस्वाद और OEIS पृष्ठ पर स्पष्ट, मैट्रिक्स-आधारित गणना से छोटी है।

from numpy import*
lambda n:(mat('1 1 1;1 0 0;1 0 1')**n)[0,0]
— टिम पेडरिक
स्रोत
1

आर, 61 58 55 55 50 बाइट्स

स्टडिन से इनपुट लेता है, सटीक परिणाम निर्धारित करने के लिए मैट्रिक्स एक्सप्रेशन का उपयोग करता है।

el(expm::`%^%`(matrix(!-3:5%in%2^(0:2),3),scan()))

यदि आप एक पुनरावर्ती समाधान पसंद करते हैं, तो यहां 55 बाइट्स के लिए OEIS में सूचीबद्ध पुनरावृत्ति संबंध का सीधा कार्यान्वयन है ।

f=function(n)`if`(n<4,(n*n+n)/2,2*f(n-1)+f(n-2)-f(n-3))
— rturnbull
स्रोत
1

एक्सेल, 123 बाइट्स

OEIS से सूत्र लागू करता है:

=4*(SIN(4*PI()/7)^2*(1+2*COS(2*PI()/7))^A1+SIN(8*PI()/7)^2*(1+2*COS(4*PI()/7))^A1+SIN(2*PI()/7)^2*(1+2*COS(8*PI()/7))^A1)/7

हमेशा की तरह, इनपुट इन A1, फॉर्मूला किसी अन्य सेल में।

मदद करने के लिए पुरानी ट्रिग पहचान को खोदा जा सकता है। अब मेरा सर दुखता है।

— Wernisch
स्रोत
0

लिथप , 79 बाइट्स

#N:(((if(< N 4)((/(+ N(* N N))2))((-(+(* 2(f(- N 1)))(f(- N 2)))(f(- N 3)))))))

कार्यान्वयन पुनरावर्ती पूर्णांक अनुक्रम OEIS में सूचीबद्ध हैं।

पठनीय कार्यान्वयन और परीक्षण सूट।

% alkaline.lithp
% run with: ./run.js alkaline.lithp
(
    (def f #N : ((
        (if (< N 4) (
            (/ (+ N (* N N)) 2)
        ) (else (
            (- (+ (* 2 (f (- N 1))) (f (- N 2))) (f (- N 3)))
        )))
    )))

    % Test cases 1 to 4
    (import lists)
    (each (seq 1 4) #I :: ((print (f I))))
)
— Andrakis
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.