직쇄 알킬 *은 단일 (알칸), 이중 (알켄) 또는 삼중 결합 (알킨)에 의해 연결된 일련의 탄소 원자로 정의되며, 암시 적 수소가 사용됩니다. 탄소 원자는 4 개의 결합 만 형성 할 수 있습니다. 어떠한 탄소 원자도 4 개 이상의 결합을 갖도록 강요 될 수 없다. 직쇄 알킨은 탄소-탄소 결합의 목록으로 표현 될 수있다.

다음은 유효한 직쇄 알킨의 예입니다.

[]       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출력 / 반환 하는 프로그램 / 함수를 만드는 것 입니다. 이다 OEIS A077998 .n

사양 / 설명

• 1을 반환하여 올바르게 처리해야합니다 1.
• 알 크네 는 좋아 [1,2]하고 [2,1]구별되는 것으로 간주됩니다.
• 출력 인 길이가 소정 길이의 모든 가능한 ALK의 *의 NES의리스트.
• 당신은 할 수 없습니다 제대로 공을 처리해야합니다.

테스트 사례 :

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

이것은 코드 골프이므로 가장 낮은 바이트 수로 승리합니다!

오아시스 , 9 7 바이트

xcd-+3V

온라인으로 사용해보십시오!

설명

이것은 OEIS 의 재발 관계를 사용합니다 .

a (n) = 2 * a (n-1) + a (n-2)-a (n-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)

MATL , 10 바이트

7K5vBiY^1)

온라인으로 사용해보십시오!

설명

이것은 OEIS에 있는 특성을 사용합니다

a (n)은 3 X 3 행렬의 n 번째 거듭 제곱의 왼쪽 상단 항목입니다 [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

오아시스 , 9 8 바이트

Adnan 덕분에 바이트 절약

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)

젤리, 10 바이트

745DBæ*µḢḢ

온라인으로 사용해보십시오!

Luis Mendo의 알고리즘을 사용 합니다 .

설명

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

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

매스 매 티카, 48 바이트

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

로 루이스 Mendo 지적 이는 A006356 OEIS한다. 내 원래 시도는 다음과 같습니다.

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

입력의 경우 n, Tuples[{1,2,3},n-1]전체의 목록 (n-1)의 요소 -tuples {1,2,3}위한 하나의 이중 또는 삼중 결합의 모든 가능한 시퀀스를 나타내는 n탄소 원자. +##<5&인수의 합이보다 작은 지 여부를 리턴하는 순수한 함수 5이므로 Split[#,+##<5&]&,리스트를 쌍별 합이보다 작은 연속 요소로 구성된 서브리스트로 분할합니다 5. 유효한 alk * ne을 설명하는 것은 길이가 0(이 경우 n=1) 또는 이 목록 의 수와 1같으므로Count(n-1) -tuples 곳에서 일치의 길이 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을 수행합니다. 그래서 여기 에이 연산자를 적용하지 않는 튜플 Count수가 있습니다. 두 번째 인수가 빈 목록 인 경우 적용 되는 경우 평가되지 않은 상태로 유지됩니다 .(n-1)4n=1Fold{}

파이썬, 51 바이트

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

이것은 되풀이 관계의 간단한 구현입니다. 3 바이트의 Tim Pederick에게 감사합니다. 출력은 Python 3의 부동 소수점과 Python 2의 정수입니다.

온라인으로 사용해보십시오!

Pyth-16 바이트

무차별 대입.

lf.AgL4+VTtT^S3t

테스트 스위트 .

루비, 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을 초과하는 숫자는 유효하지 않습니다.

두 숫자를 문자열로 결합하고 정규식을 수행하여 유효하지 않은 숫자를 검색합니다. 아무것도 발견되지 않으면 카운터를 증가시킵니다.

테스트 프로그램에서

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

p f[gets.to_i]

루비, 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 인 배열로 시작합니다.

n시퀀스에 더 많은 요소를 반복적으로 추가 한 다음 element를 반환합니다 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]

Mathematica, 42 40 바이트

바이트 수는 CP-1252 (Windows 설치의 기본값)와 같은 호환 가능한 단일 바이트 인코딩을 가정합니다.

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

이것은 단항 연산자로서 OEIS에 주어진 반복을 단순히 구현합니다.

CJam (19 바이트)

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

온라인 테스트 스위트 . 이것은 익명의 블록 (함수)으로 스택에서 한 항목을 가져 와서 스택에 남겨 둡니다. 테스트 스위트에는가 포함되어 있습니다 a(0) = 1.

사용 된 재발은 관련 OEIS 시퀀스에 대한 관찰을 기반으로합니다. A006356 .

a (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). -Gary W. Adamson, 2009 년 4 월 27 일

그러나 적절한 오프셋으로 최종의 필요성을 제거 + 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
}

Brain-Flak, 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).

스택의 시각화

메인 루프의 한 번의 반복에서 이것이 발생합니다 (0은 존재할 수도 있고 존재하지 않을 수도 있지만 어느 쪽이든 중요하지 않습니다).

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합니다.

펄 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반복 솔루션이 승리하도록 필요한 것을 잊었습니다 .

Dyalog APL, 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.

Dyalog APL, 29 바이트

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

정수 시퀀스 OEIS A006356의 재귀 적 정의를 사용하여 작동합니다.

Numpy가 포함 된 Python, 62 바이트

나는 그것을 시도해야했지만 순수한 파이썬과 재귀 는 numpy 및 OEIS 페이지의 명시 적 매트릭스 기반 계산보다 짧습니다.

from numpy import*
lambda n:(mat('1 1 1;1 0 0;1 0 1')**n)[0,0]

R, 61 58 55 51 50 바이트

stdin에서 입력을 가져오고 행렬 지수를 사용하여 정확한 결과를 결정합니다.

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

재귀 솔루션을 선호하는 경우 OEIS에 나열된 반복 관계를 55 바이트 로 간단하게 구현 합니다 .

f=function(n)`if`(n<4,(n*n+n)/2,2*f(n-1)+f(n-2)-f(n-3))

Excel, 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다른 셀에 수식을 입력하십시오 .

오래된 Trig ID를 파고 도움이 될 수 있는지 확인하십시오. 이제 내 머리가 아프다.

Lithp , 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))))
)