-कार्बन अल्केन्स की संख्या

Question

एक सकारात्मक संख्या को देखते हुए , की संख्या को खोजने हाइड्रोकार्बन के साथ कार्बन परमाणुओं, अनदेखी स्टीरियोआइसोमर ; या इसके विपरीत, नोड्स के साथ बिना लेबल वाले पेड़ों की संख्या , जैसे कि प्रत्येक नोड में डिग्री ।$n$$n$$n$$\le 4$

यह OEIS अनुक्रम A000602 है ।

यह भी देखें: पैराफिन - रोसेटा कोड

उदाहरण

के लिए , जवाब है , क्योंकि हेपटैन नौ आइसोमरों :$n = 7$$9$

• हेप्टेन :$\mathrm{H_3C-CH_2-CH_2-CH_2-CH_2-CH_2-CH_3}$

• 2- :$\mathrm{H_3C-CH(CH_3)-CH_2-CH_2-CH_2-CH_3}$

• 3- :$\mathrm{H_3C-CH_2-CH(CH_3)-CH_2-CH_2-CH_3}$

• 2,2-डाइमिथाइलपूर्न :$\mathrm{H_3C-C(CH_3)_2-CH_2-CH_2-CH_3}$

• 2,3-डाइमिथाइलपार्ने :$\mathrm{H_3C-CH(CH_3)-CH(CH_3)-CH_2-CH_3}$

• 2,4- :$\mathrm{H_3C-CH(CH_3)-CH_2-CH(CH_3)-CH_3}$

• 3,3-डाइमिथाइलपूर्न : $\mathrm{H_3C-CH_2-C(CH_3)_2-CH_2-CH_3}$

• 3-एथिलपूर्न : $\mathrm{H_3C-CH_2-C(CH_2CH_3)-CH_2-CH_3}$

• 2,2,3-ट्राइमेथाइलबुटन : $\mathrm{H_3C-C(CH_3)_2-CH(CH_3)-CH_3}$

ध्यान दें कि 3-मिथाइलहेक्सेन और 2,3-डाइमिथाइलपार्ने चिरल हैं , लेकिन हम यहां स्टीरियोइसोमर्स को अनदेखा करते हैं।

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

आपको मामला हैंडल करने की आवश्यकता नहीं है ।$n = 0$

intput	output
=============
0	1
1	1
2	1
3	1
4	2
5	3
6	5
7	9
8	18
9	35
10	75
11	159
12	355
13	802
14	1858
15	4347
16	10359
17	24894
18	60523
19	148284
20	366319

Comments

अगर कोई अल्केमिस्ट के साथ समाधान लिखने का प्रबंधन करता है तो मैं प्रभावित होऊंगा !

— ბიმო

@PeterTaylor खैर यह हर बार एक अंक

— l4m2

@ बी एम ओ भी अल्केमिस्ट पूर्ण रूप से ट्यूरिंग करते दिख रहे हैं यदि बड़ी संख्या में समर्थन

— l4m2

@ l4m2: मैंने इसे पहले एक सीक्वेंस चैलेंज और कुछ नंबर चैलेंज के लिए इस्तेमाल किया था , आप अनरी आउटपुट का भी इस्तेमाल कर सकते हैं, जो सबसे ज्यादा आसान है। और हाँ, यह सबसे अधिक संभावना है टीसी ( bignums का उपयोग करता है ), मैंने औपचारिक रूप से इसे साबित नहीं किया है।

— ბიმო

@ बीएमओ यह सिर्फ CM

— l4m2

Answer 1

CJam ( 100 98 91 89 83 बाइट्स)

1a{_[XX]*\_{_0a*}:E~\{E\_{ff*W%{0@+.+}*}:C~.+2f/}:D~.+C.+3f/1\+}q~:I*DE1$D.-X\+.+I=

स्टड से इनपुट लेता है, स्टडआउट के आउटपुट। ध्यान दें कि यह लाइसेंस का शोषण करता है और इनपुट को न संभालने 0के लिए दो बाइट को बचाने के लिए Cऔर की परिभाषाओं को सम्मिलित करके D। ऑनलाइन डेमो

नायब यह बहुत धीमा और स्मृति-अक्षम है। सरणियों को ट्रिम करने से बहुत तेज़ संस्करण प्राप्त होता है (3 बाइट्स अधिक)। ऑनलाइन डेमो ।

विच्छेदन

$$\begin{eqnarray} A000598(x) &=& 1 + x Z(S_3; A000598(x)) \\ A000678(x) &=& x Z(S_4; A000598(x)) \\ A000599(x) &=& Z(S_2; A000598(x) - 1) \\ A000602(x) &=& A000678(x) - A000599(x) + A000598(x^2) \\ \end{eqnarray}$$ $Z(S_n; f(x))$$S_n$$f(x)$

मैंने इसे थोड़ा गोल्फ खिलाड़ी अपघटन में हेरफेर किया, और फिर मध्यवर्ती दृश्यों को देखा और पता चला कि वे OEJ में भी हैं:

$$\begin{eqnarray} A000642(x) &=& Z(S_2, A000598(x)) \\ A000631(x) &=& Z(S_2, A000642(x)) \\ A000602(x) &=& A000642(x) + x A000642(x^2) - x A000631(x) \end{eqnarray}$$

पहले के संस्करणों Cने इस उत्तर से ब्लॉक (दो बहुपद को हल करें ) का पुन: उपयोग किया । मुझे एक बहुत छोटा मिला है, लेकिन मैं उस जवाब को अपडेट नहीं कर सकता क्योंकि यह एक चेनिंग प्रश्न से है।

1a            e# Starting from [1]...
{             e# Loop I times (see below) to build A000598 by f -> 1 + Z(S_3; f)
  _[XX]*      e#   Copy and double-inflate to f(x^3)
  \_          e#   Flip and copy: stack is f(x^3) f(x) f(x)
  {_0a*}:E~   e#   Assign copy-and-inflate to E and execute
              e#   Stack: f(x^3) f(x) f(x) f(x^2)
  \           e#   Flip
  {           e#   Define and execute block D, which applies f -> Z(S_2;f)
              e#     Stack: ... f
    E\_       e#     Stack: ... f(x^2) f(x) f(x)
    {         e#     Define and execute block C, which convolves two sequences
      ff*     e#       Multiply copies of the second sequence by each term of the first
      W%      e#       Reverse
      {       e#       Fold
        0@+.+ e#         Prepend a 0 to the first and pointwise sum
      }*
    }:C~      e#     Stack: ... f(x^2) f(x)^2
    .+2f/     e#     Pointwise average
  }:D~        e#   Stack: f(x^3) f(x) f(x^2) Z(S_2;f(x))
  .+C         e#   Stack: f(x^3) f(x)*(f(x^2) + Z(S_2;f(x)))
  .+3f/       e#   Add and divide by 3 to finish computing Z(S_3; f)
  1\+         e#   Prepend a 1
}
q~:I          e# Read input to I
*             e# Loop that many times
              e# Stack: I+1 terms of A000598 followed by junk
D             e# Stack: I+1 terms of A000642 followed by junk
E1$D          e# Stack: A000642 A000642(x^2) A000631
.-X\+.+       e# Stack: A000602
I=            e# Extract term I

Answer 2

Node.js 11.6.0 ,  229 223 221  218 बाइट्स

रोसेट्टा कोड पर सुझाए गए जावा कार्यान्वयन से व्युत्पन्न ।

f=(N,L=1,u=[...r=[c=[],1,...Buffer(N)]],k=u[(g=(n,B,S,i,b=B,m,d=0)=>{for(;++b<5;)for(x=c[B]=(d+r[m=n])*(d++?c[B]/d:i),u[S+=n]+=L*2<S&&x,r[S]+=b<4&&x;--m;)g(m,b,S,c[B])})(L,0,1,1),L]-=~(x=r[L++/2])*x>>1)=>L>N?k:f(N,L,u)

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

Answer 3

अल्केमिस्ट (1547 बाइट्स)

_->In_NN+2b+al+g
al+g+0NN->ak
al+g+NN->ah
ah+b->ah+m+d+z+a
ah+0b->C+Z+Q
Z+j+z->Z+j+d
Z+j+0z->M+s
M+g+b->M+g+r
M+g+h->M+g+d
M+g+0b+0h+q->J+U
J+o+h->J+o+m
J+o+a->J+o+d
J+o+0h+0a->2C+an+Q
an+j+h->an+j+d
an+j+0h->aC+s
aC+g->e+am+P
am+l+b->am+l+d
am+l+0b->al+s
ak+b->ak+m+d
ak+0b->C+aj+Q
aj+j+h->aj+j+b
aj+j+0h->I+n
I+f+e->I+f+a
I+f+b->I+f+m+d+z
I+f+0e+0b->C+ai+Q
ai+j+h->ai+j+b
ai+j+0h->aB+n
aB+f->H
H+z->H+d
H+a+e->H
H+0z+0e->G+i
G+i+0b->ag
G+i+b->az+b+n
az+f+0b->Out_a
az+f+b->G+b+n
G+f->G+t
ag+e->ag
ag+0e->af+t
af+i+e->af+i+a
af+i+0e->Out_a
Q->F+s
F+g+b->F+g+y
F+g+A->F+g
F+g+0b+0A->av+o
av+o+0m->w
av+o+m->m+ae+A
ae+m->ae+b
ae+0m->u+n
u+f+b->u+f+m
u+f+e->u+f+E
u+f+A->u+f+k+c
u+f+0b+0e+0A->ad
ad+c->ad+A
ad+0c->ac
ac+y->ac+d+c
ac+0y->ab
ab+c->ab+y
ab+0c->V+l
V+l+0k->x
V+l+k->aa+t
aa+i+0e->W
aa+i+e->Y
Y+E->Y+D+c
Y+0E->X
X+c->X+E
X+0c->aa+i
W+D->W+e
W+0D->V+P
x+E->x
x+d->x
x+b->x+k
x+0E+0d+0b->aw
aw+h->aw+d
aw+0h->aE+s
aE+g->p
p+b->p+2r
p+k->p+d
p+B->p
p+q->p
p+0b+0k+0B+0q->r+q+av+U
w+h->w+d
w+y->w+r
w+C->w+B+q
w+0h+0y+0C->aD+U
aD+o->j
U->au+s
au+g+b->au+g+d
au+g+0b->v
v+d->d+aA+t
aA+i+k->R
aA+i+0k->at
at+B->at+k+c
at+0B->L
L+c->L+B
L+r->L+b
L+0c+0r->as+n
as+f+b->as+f+r
as+f+0b->R
R+0e->K
R+e+q->ar+D+c
ar+e+q->ar+c
ar+0q->aq
aq+c->aq+q
aq+0c->R
K+D->K+e
K+h->K+b
K+0D+0h->ap+P
ap+l+b->ap+l+h
ap+l+0b->v
v+0d+k->v
v+0d+r->v
v+0d+0k+0r->o
s+0d->g
s+d->d+ao+t
ao+i->ao+P
ao+l->s
P->O+c
O+b->2c+O
O+0b->N
N+c->b+N
N+0c+e->O
N+0c+0e->l
n+b->n+c
n+0b->T
T+c->ay
T+0c->e+n
ay+c->b+T
ay+0c->f
t+d->t+c
t+0d->S
S+c->ax
S+0c->e+t
ax+c->d+S
ax+0c->i

ऑनलाइन डेमो ।

नोट: यह काफी धीमा है। यदि एक दुभाषिया के साथ परीक्षण करना जो एक बार में एक नियम को लागू करने का समर्थन करता है (जैसे मेरा एक - हालांकि सुनिश्चित करें कि आपके पास नवीनतम संस्करण है जो पार्सर में बग को ठीक करता है) तो आप दो नियमों को जोड़कर एक महत्वपूर्ण गति प्राप्त कर सकते हैं:

T+2c->b+T
S+2c->d+S

जो मौजूदा नियमों के माध्यम से एक मार्ग इनलाइन करता है

T+c->ay
ay+c->b+T
S+c->ax
ax+c->d+S

आंशिक विच्छेदन

उच्च स्तर पर, यह मेरे CJam उत्तर के समान दृष्टिकोण का उपयोग करता है।

अल्केमिस्ट का संगणना मॉडल अनिवार्य रूप से मिनस्की रजिस्टर मशीन है । हालांकि, अल्केमिस्ट बहुत अच्छी तरह से कोड और डेटा की समानता को उजागर करता है, और एक उत्पादन नियम के बाईं ओर कई टोकन की अनुमति देकर प्रभावी रूप से राज्य को एक परमाणु द्वारा प्रतिनिधित्व करने के लिए विवश नहीं किया जाता है: हम परमाणुओं के एक टपल का उपयोग कर सकते हैं, और यह (गैर-पुनरावर्ती) सबरूटिन की अनुमति देता है। यह गोल्फ के लिए बहुत उपयोगी है। केवल उन चीजों की कमी है जो मैक्रो और डिबगैबिलिटी हैं।

$0$$x$$A$$(2A+1)2^x$Pebnbebtded

a, b = b, 0

कम से कम 17 बाइट का विस्तार:

S+a->S+b
S+0a->T

Sवर्तमान राज्य कहाँ है और Tअगला राज्य है। एक गैर विनाशकारी "कॉपी" और भी अधिक महंगा है, क्योंकि यह से एक "चाल" के रूप में किया जा सकता है aकरने के लिए bऔर एक सहायक tmp, से एक "चाल" के बाद tmpवापस करने के लिए a।

कहानियो

मैंने एक-दूसरे को विभिन्न चर दिए और कार्यक्रम को आगे बढ़ाने की प्रक्रिया में लगभग 60 राज्यों को समाप्त कर दिया, और उनमें से कई के पास वैसे भी विशेष रूप से सार्थक नाम नहीं थे, लेकिन पूरी तरह से गोल्फ के लिए मैंने एक न्यूनतम लिख दिया था इसलिए नाम अब पूरी तरह से अशोभनीय हैं। गुड लक रिवर्स इंजीनियरिंग यह! यहाँ न्यूनतम (CJam में) है, जो कोड के बारे में कुछ धारणाएँ बनाता है, लेकिन अन्य अल्केम कार्यक्रमों को कम करने के लिए अनुकूलित किया जा सकता है:

e# Obfuscate / minimise Alchemist program

e# Tokenise
qN%[SNS]e_*S%

e# Get token frequencies for substitution purposes, special-casing the I/O ones
_["+" "0" "2" "->" "_" N "In_n" "n" "Out_tmp2" "tmp2"]-
$e`$W%1f=

e# Empirically we want a two-char input for n and a one-char one for tmp2
["In_n" "Out_tmp2" "n" "tmp2"]\+
["In_NN" "Out_a" "NN"] "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"1/:A+ A2m*:e_"NN"a-+
1$,<

er
_s,p

Comments

रुको ... कि दुभाषिया काम करता है? AFAICT ... आप एक यादृच्छिक नियम चुनते हैं, फिर यह पता लगाते हैं कि कितनी बार लागू किया जा सकता है। क्या वह भी सही ढंग से काम करता है?

— केवल

हम्म। आप डिबगिबिलिटी कैसे सुधारेंगे

— केवल

@ ASCII- केवल, यह काम करेगा लेकिन यह वास्तव में ऐसा नहीं करता है। यह पहले एक नियम चुनता है जो लागू होता है और फिर यह लागू होता है कि इसे कितनी बार लागू किया जा सकता है। डिबगैबिलिटी मुश्किल है। दिन में एक शोध प्रबंध परियोजना के लिए मेरे विचारों में से एक जीयूआई आरएम संपादक था जिसमें पीछे की ओर डिबगर था।

— पीटर टेलर

लेकिन ... नियम निष्पादन आदेश कार्यक्रम के क्रम को प्रभावित करता है, ऐसा नहीं करता

— केवल

@ ASCII- केवल, हाँ। यही कारण है कि बहुत सारे चर हैं। उनमें से केवल 16 डेटा हैं: बाकी राज्य हैं। मैंने स्वतंत्र रूप से स्वतंत्र "चाल" संचालन को गोल्फ द्वारा गैर-नियतात्मकता का उपयोग किया है।

— पीटर टेलर

Answer 4

परी / जीपी , 118 बाइट्स

पीटर टेलर के सीजेएम उत्तर का सीधा अनुवाद ।

n->(s(k)=subst(a,x,x^k));(z()=(a^2+s(2))/2);a=O(1);for(i=0,n,a=1+x*(a*z()+(s(3)-a^3)/3));a=z();Pol(a+x*(s(2)-z()))\x^n

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