给定正数 $n$ ，则忽略立体异构体；找到具有碳原子的烷烃数；或等效，未标记的树的与该数节点，使得每个节点具有度 $n$ $n$ $\le 4$ 。

这是OEIS序列A000602。

另请参阅：石蜡-罗塞塔代码

例

对于 $n = 7$ ，答案是 $9$ ，因为庚烷有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

— Alephalpha
source

3

如果有人设法与Alchemist编写解决方案，我会印象深刻！

— ბიმო

@PeterTaylor Well它可以每次输出一个数字

— l4m2

@BMO 另外，如果有大量支持，炼金术士看起来也

— 平方米

@ l4m2：我以前用它来进行序列挑战和一些数字挑战，您还可以使用一元输出，这很可能会更容易。是的，这很可能是TC（使用bignums），不过我还没有正式证明它。

— ბიმო

@BMO它看起来只能够模拟CM

— l4m2

11

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=

从stdin输入，输出到stdout。请注意，这0通过内联的定义利用许可证不处理输入以节省两个字节C和D。在线演示

注意，这是非常慢并且内存效率低下。通过修剪数组，可以获得更快的版本（多出3个字节）。在线演示。

解剖

OEIS给（模索引错误）生成函数分解

\begin{array}{rcl} 一种 000598 （ X ） & = & 1个 + X ž （ {小号}_{3}; 一种 000598 （ X ） ） \\ 一种 000678 （ X ） & = & X ž （ {小号}_{4}; 一种 000598 （ X ） ） \\ 一种 000599 （ X ） & = & ž （ {小号}_{2}; 一种 000598 （ X ） - 1个 ） \\ 一种 000602 （ X ） & = & 一种 000678 （ X ） - 一种 000599 （ X ） + 一种 000598 （ X^{2} ） \end{array}

$\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))

$Z(S_n; f(x))$

S_{n}

$S_n$

f (x)

$f(x)$ 。

我将其处理成稍微有点高尔夫球的分解，然后查看了中间序列，发现它们也在OEIS中：

\begin{array}{rcl} 一种 000642 （ X ） & = & ž （ {小号}_{2} ， 一种 000598 （ X ） ） \\ 一种 000631 （ X ） & = & ž （ {小号}_{2} ， 一种 000642 （ X ） ） \\ 一种 000602 （ X ） & = & 一种 000642 （ X ） + X 一种 000642 （ X^{2} ） - X 一种 000631 （ X ） \end{array}

$\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从此答案中重用了block （包含两个多项式）。我找到了一个短得多的答案，但是我无法更新该答案，因为它来自于链接问题。

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

— 彼得·泰勒
source

5

Node.js 11.6.0， 229个223 221 218字节

源自Rosetta Code上建议的Java实现。

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)

在线尝试！

— Arnauld
source

5

炼金术士（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答案相同的方法。

炼金术士的计算模型本质上是Minsky注册机。但是，炼金术士很好地揭示了代码和数据的等效性，并且通过有效地在生产规则的左侧允许许多标记，使状态不受限于由一个原子表示：我们可以使用一个原子元组，并且这允许（非递归）子例程。这对于高尔夫非常有用。它真正缺少的只是宏和可调试性。

对于阵列，我使用的是配对功能，可以在RM中轻松实现。空数组表示为 $0$ ，以及前置结果 $x$ 排列 $A$ 是 $(2A+1)2^x$ 。有一个子例程可以配对：该子例程被调用P，并且将eto 的值放在前缀b。有两个子程序解除配对：nunpairs b到e和b; 和tunpairs d以e和d。这使我可以在变量之间保存大量转换数据，这很重要：单个“移动”操作

a, b = b, 0

扩展到至少17个字节：

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

S当前状态T是哪里，下一个状态是哪里。非破坏性的“复制”，更是昂贵，因为它有许多工作要做作为一个从“移动” a到b和辅助tmp，随后从“招” tmp回a。

混淆

在使程序打高尔夫球的过程中，我相互混用了各种变量并消除了大约60个状态，而且其中许多都没有特别有意义的名称，但是为了充分打高尔夫球，我写了一个最小的代码，因此这些名称现在可以完全理解。好运逆向工程吧！这是最小化程序（在CJam中），它对代码进行了一些假设，但可以进行调整以最小化其他Alchemist程序：

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

— 彼得·泰勒
source

等等...那个翻译工作吗？AFAICT ...您选择一个随机规则，然后找出可以应用的次数。那还能正常工作吗？

— ASCII码，仅ASCII，

嗯您将如何提高可调试性

— 仅

仅@ASCII，这可以工作，但实际上并非如此。它首先选择一个适用的规则，然后算出可以应用多少次。可调试性很棘手。当时，我对学位论文项目的想法之一是使用带有反向调试器的GUI RM编辑器。

— 彼得·泰勒，

但是...规则执行顺序会影响程序顺序，但不会

— ASCII码，仅ASCII

仅@ASCII，是的。这就是为什么变量太多的原因。其中只有约16个是数据：其余均为状态。通过有效地并行执行独立的“移动”操作，我使用了非确定性技术。

— 彼得·泰勒

1

巴黎/ GP，118字节

直接翻译过来的彼得·泰勒的CJam答案。

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

在线尝试！

— Alephalpha
source