Fast jede Funktion kann als Polynom mit unendlichen Termen ausgedrückt werden.

Beispielsweise, e^x = 1 + x + x^2/2! + x^3/3! + x^4/4! + ...

Beispielsweise, sin(x) = x - x^3/3! + x^5/5! - x^7/7! + ...

Die Koeffizienten der n-ten Terme bilden eine Folge, und die entsprechende Funktion wird als Erzeugungsfunktion der Folge bezeichnet.

Die Koeffizienten der n-ten Terme bilden eine Folge.

Oft hätte der n-te Term einen Nenner von n!. Daher multiplizieren wir den Koeffizienten mit n!, um eine andere Sequenz zu erhalten, deren Exponentialerzeugungsfunktion die ursprüngliche Funktion wäre.

Zum Beispiel kann die Sequenz , deren Funktion Exponential Generierung ist e^xwäre 1,1,1,1,....

Zum Beispiel kann die Sequenz , deren Funktion Exponential Generierung ist sin(x)wäre 0,1,0,-1,0,1,0,-1,....

Aufgabe

Ihre Aufgabe ist es, den n-ten Term der Sequenz zu finden, deren Exponential Generating Function ist tan(x).

Testfälle

n result
0 0
1 1
2 0
3 2
4 0
5 16
6 0
7 272
8 0
9 7936
10 0
11 353792
12 0
13 22368256
14 0
15 1903757312
16 0
17 209865342976
18 0
19 29088885112832
20 0
21 4951498053124096
22 0
23 1015423886506852352
24 0
25 246921480190207983616
26 0

(Von hier kopiert .) (Warnung: der 0-te Begriff ist anders)

Beispielimplementierung

# copied from https://github.com/Mego/Seriously/blob/v2.0/SeriouslyCommands.py#L16
def memoized(f):
    memo = {}
    def m_fun(*args):
        if args in memo:
            return memo[args]
        else:
            res = f(*args)
            memo[args] = res
            return res
    return m_fun

# copied from https://github.com/Mego/Seriously/blob/v2.0/SeriouslyCommands.py#L169
@memoized
def binomial(n,r):
    if r > n:
        return 0
    elif r==n:
        return 1
    res = 1
    i = 1
    while i<=r:
        res *= (n+1-i)
        res /= i
        i+=1
    return int(res)

# 2*u(n+1) = Sum_{k=0..n} binomial(n, k)*u(k)*u(n-k)
# from A000111
@memoized
def u(n):
    if n<0: return 0
    if n==0: return 1
    if n==1: return 1
    return sum([binomial(n-1,k)*u(k)*u(n-1-k) for k in range(n)])//2     

def t(n):
    if n%2 == 0: return 0
    return u(n)

print('\n'.join([str(x) + ' ' + str(t(x)) for x in range(26)]))

Ideone es!

Verweise

• Generierungsfunktion auf Wikipedia
• Exponentielle Erzeugungsfunktion bei Wikipedia
• Beispiel für eine exponentielle Generierungsfunktion in Wikipedia
• Generierungsfunktion in MathWorld
• Exponentielle Generierungsfunktion in MathWorld
• Taylor-Reihe auf Wikipedia
• Ableitung der ersten 9 Terme der erforderlichen Reihenfolge
• Obligatorisch OEIS A009006 (Beachten Sie, dass der 0-te Begriff unterschiedlich ist)
• Algorithmus
• OEIS A000111: Aufwärts- / Abwärtsnummern

CJam ( 33 32 27 26 23 20 Byte)

2,{ee::*_(@+.+}ri*0=

Online-Demo

Präparation

Dies implementiert im Wesentlichen die von xnor beschriebene Wiederholung .

2,        e# [0 1] represents the base case f(0,j) = j==1
{         e# Loop...
  ee::*   e#   Multiply each array element by its index
  _(@+.+  e#   Sum the array shifted left and the array shifted right
}ri*      e# ... n times
0=        e# Evaluate at j=0

Oder mit einem etwas anderen Ansatz für 23 Bytes:

ri_1&a{{1$+}*]W%0+}@*0=

Online-Demo . Danke an Dennis für 3 Bytes.

Präparation

1a         e# Push [1]
{          e# Repeat...
  {1$+}*]  e#   Compute array of partial sums
  W%0+     e#   Reverse and append 0
}qi:A*     e# ... A times, where A is the input value
0=A1&*     e# Result is first element if A odd, and 0 otherwise

Oder mit einem ganz anderen Ansatz für 29 Bytes:

qie!Ma-{W\+W+3ew{_$.=1=},!},,

Online-Demo

Für die Eingabe ist leider ein Sonderfall erforderlich 0.

Präparation

qi            e# Take an integer n from stdin
e!            e#   Compute all permutations of [0 ... n-1]
Ma-           e#   Special-case n=0
{             e#   Filter...
  W\+W+       e#     Prepend and postpend -1
  3ew         e#     Take slices of 3 consecutive elements
  {           e#     Filter...
    _$.=1=    e#       Test whether the middle element is the second largest
  },!         e#     ... and require no matches
},,           e#   ... and count

Sie denken vielleicht "WTF ?! Er beantwortet die falsche Frage." Wenn ja, ist das verständlich, aber beide Ansätze liefern in der Tat die richtigen Ergebnisse .

Julia, 40 38 32 Bytes

!n=2(2*4^n-2^n-0^n)abs(zeta(-n))

Ein- und Ausgabe erfolgt in Form von BigFloats. Probieren Sie es online!

Hintergrund

Die Maclaurin-Reihe der Tangensfunktion erfüllt die Identität

wenn x in seinem Konvergenzradius liegt, wobei B _n eine Bernoulli-Zahl ist.

Da B _{2 (n + 1)} und (-1) ⁿ dasselbe Vorzeichen haben, B _{2n + 1} = 0, wenn n> 0 und B ₁ = 1/2 , können wir das Obige wie folgt umschreiben.

Außerdem haben wir immer dann, wenn n eine nicht negative ganze Zahl ist

wobei ζ die Riemannsche Zetafunktion bezeichnet .

Daraus folgt mit der Konvention 0 ⁰ = 1 , dass

Welches ist die Formel, die die Implementierung verwendet.

Python, 57 Bytes

f=lambda i,j=0:~-j*f(i-1,j-1)-~j*f(i-1,j+1)if i else j==1

Weniger golfen:

f=lambda i,j=0:j==1 if i==0 else (j-1)*f(i-1,j-1)+(j+1)*f(i-1,j+1)

Wir können den iKoeffizienten der exponentiellen Erzeugungsfunktion berechnen, indem wir die Tangensfunktionszeiten differenzieren iund bei auswerten 0. Jede Ableitung ist ein Polynom in tan(x)und ihr Wert bei 0 ist ihr konstanter Term.

Wir drücken den Koeffizienten von rekursiv tan(x)**jin der iAbleitung von tanmit der Funktion aus f(i,j). Der rekursive Ausdruck stammt aus der Relation tan(x)' = 1 + tan(x)**2.

So ist die Ableitung von tan(x)**jIS

j*tan(x)**(j-1)*(tan(x)**2+1), or equivalently
j*tan(x)**(j+1) + j*tan(x)**(j-1)

Die Mitwirkenden tan(x)**jin der ith-Ableitung sind also tan(x)**(j-1)und tan(x)**(j+1)in der (i-1)st-Ableitung, wobei jeder Koeffizient seiner Potenz entspricht. Dies ergibt den rekursiven Ausdruck

f(i,j) = (j-1)*f(i-1,j-1) + (j+1)*f(i-1,j+1)

Beachten Sie, dass wir negative Exponenten nicht ausschließen müssen, jda sie ohnehin mit Null bewertet werden und keinen Beitrag leisten, da die Kreuzung j=0einen Multiplikator von ergibt 0.

Der Grundfall von i==0entspricht sich tan(x)selbst j==1und sonst Nullkoeffizienten. Die endgültige Auswertung erfolgt zum konstanten Term j=0, der als Standardwert eingegeben wird.

Mathematica, 20 Bytes

Tan@x~D~{x,#}/.x->0&

Unkomplizierter Ansatz. Berechnen Sie die n- ^te Ableitung von tan (x) und bewerten Sie sie bei x = 0 .

Verwendung

Haskell, 48 Bytes

0%1=1
0%_=0
i%j=sum[k*(i-1)%k|k<-[j+1,j-1]]
(%0)

Wir können den iKoeffizienten der exponentiellen Erzeugungsfunktion berechnen, indem wir die iZeiten der Tangensfunktion differenzieren und bei auswerten 0. Jede Ableitung ist ein Polynom in tan(x)und der Wert bei 0 ist sein konstanter Term.

Wir drücken den Koeffizienten von rekursiv tan(x)^jin der iAbleitung von tanmit der Funktion aus i%j. Der rekursive Ausdruck stammt aus der Relation tan(x)' = 1 + tan(x)^2.

So ist die Ableitung von tan(x)^jIS

j*tan(x)^(j-1)*(tan(x)^2+1), or equivalently
j*tan(x)^(j+1) + j*tan(x)^(j-1)

Die Mitwirkenden tan(x)^jin der ith-Ableitung sind also tan(x)^(j-1)und tan(x)^(j+1)in der (i-1)st-Ableitung, wobei jeder Koeffizient gleich seiner Potenz ist.

Jelly , 12 11 Bytes

Ṛ+\;S
ḂÇ⁸¡Ḣ

Wie Peter Taylor CJam antworten , berechnet dies die n - ten Laufzeit von Eulers up / down - Sequenz , wenn n ungerade und Sonderfälle sind auch n als 0 .

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

ḂÇ⁸¡Ḣ  Main link. Argument: n

Ḃ       Bit; yield n's parity.
 Ç⁸¡    Apply the helper link (Ç) n (⁸) times.
    Ḣ   Head; retrieve the first element of the resulting list.


Ṛ+\;S   Helper link. Argument: A (list or 1/0)

Ṛ       Cast A to list (if necessary) and reverse the result.
 +\     Take the cumulative sum.
   ;S   Append the sum of A.

Salbei, 26 Bytes

lambda n:tan(x).diff(n)(0)

Wie die anderen Lösungen in mathematisch orientierten Sprachen berechnet diese Funktion die nth-Ableitung von tan(x)und wertet sie bei aus x = 0.

Probieren Sie es online aus

J, 15 bis 13 Bytes

Es gibt auch das Builtin, t:das den n- ^ten Koeffizienten der exponentiellen Erzeugungsfunktion von tan (x) berechnet .

(1&o.%2&o.)t:

Vielen Dank an @ Leaky Nun , der mich an die Adverbien der Taylor-Reihe in J erinnert hat, die 2 Bytes gespart haben.

Alternative für 15 Bytes .

3 :'(3&o.d.y)0'

Ein anderer Ansatz besteht darin, die n- ^te Ableitung von tan (x) zu berechnen und bei x = 0 zu bewerten .

Anmerkung: In J nimmt die von der Ableitungsfunktion verwendete Speichermenge d.schnell zu, wenn n 10 überschreitet.

Verwendung

   f =: (1&o.%2&o.)t:
   f 7
272
   (,.f"0) i. 11  NB. Additional commands are just for formatting the output
 0    0
 1    1
 2    0
 3    2
 4    0
 5   16
 6    0
 7  272
 8    0
 9 7936
10    0

Erläuterung

(1&o.%2&o.)t:  Input: n
(         )    Define a monad (one argument function), call the input y
 1&o.          Get the trig function sin(x) and call it on y
      2&o.     Get the trig function cos(x) and call it on y
     %         Divide sin(y) by cos(y) to get tan(y)
           t:  Get the nth coefficient of the exponential generating series
               for that function and return

3 :'(3&o.d.y)0'  Input: n
3 :'          '  Define a monad (one argument function) with input y
     3&o.        Get the trig function tan(x)
           y     The input n
         d.      Get the nth derivative of tan(x)
             0   Evaluate the nth derivative at x = 0 and return

Julia, 39 37 Bytes

!n=(spdiagm((0:n,1:n+1),(1,-1))^n)[2]

2 Bytes gespart dank Dennis.

Nicht die kürzeste Julia-Lösung (siehe Dennis 'Lösung), aber diese wird ausschließlich mit der abgeleiteten Logik durchgeführt ... in Form von Matrizen.

Grundsätzlich wird die Tatsache ausgenutzt, dass die Ableitung von tan (x) 1 + tan (x) ^ 2 ist. Da also die Ableitung einer Potenz von tan (x), sagen wir tan (x) ^ k, k tan (x) ^ (k-1) tan (x) '= k tan (x) ^ (k-1) + k tan (x) ^ (k + 1) können wir eine einfache Matrixleistung auf einer Matrix mit den entsprechenden Werten verwenden, um die Expansion zu erzeugen, wobei die zweite Zeile oder Spalte (je nach Konstruktion) die Ableitungen von tan (x) enthält ) selbst.

Wir müssen also nur die Konstante im resultierenden Ausdruck finden, und das ist der erste Wert in der entsprechenden Zeile oder Spalte.

JavaScript (ES6), 127 - 45 Byte

f=(n,m=0)=>n?++m*f(--n,m--)+--m*f(n,m):m-1?0:1

Port von @ xnors Lösungen.

Haskell, 95 93 Bytes

p=product
f n=sum[(-1)^(n`div`2+j+1)*j^n*p[k-j+1..n+1]`div`p[1..n+1-k+j]|k<-[1..n],j<-[0..k]]

Es handelt sich im Grunde genommen um eine Implementierung der allgemeinen Formel mit einigen geringfügigen Optimierungen.

MATLAB mit Symbolic Toolbox, 84 Byte

n=input('');syms x;c=coeffs(taylor(tan(x),'Order',n+1))*factorial(n);c(end)*mod(n,2)

Beispiel läuft:

>> n=input('');syms x;c=coeffs(taylor(tan(x),'Order',n+1))*factorial(n);c(end)*mod(n,2)
7
ans =
272

>> n=input('');syms x;c=coeffs(taylor(tan(x),'Order',n+1))*factorial(n);c(end)*mod(n,2)
8
ans =
0

>> n=input('');syms x;c=coeffs(taylor(tan(x),'Order',n+1))*factorial(n);c(end)*mod(n,2)
9
ans =
7936

Haskell (zu viele Bytes)

Verwenden Sie nur Operationen für Listen und Raymond Manzonis Ergebnis :

c n = last $ map numerator $ zipWith (*) (scanl (*) (1) [2,3..]) (intersperse 0 $ foldr (.) id (replicate n (\xs->(xs ++ [(1%(1+2*length xs)) * (sum (zipWith (*) xs (reverse xs)))]))) [1])

Leider läuft dies bei bescheidenen Werten über n, da es IntWerte verwendet. Ich werde versuchen, das Problem mit IntegerWerten zu beheben . Bis dahin sind Vorschläge willkommen.

Axiom, 46 Bytes

f(n:NNI):NNI==(n=0=>0;eval(D(tan(x),x,n),x=0))

Code für Test und Ergebnisse

(32) -> [[i, f(i)] for i in 0..26]
   (32)
   [[0,0], [1,1], [2,0], [3,2], [4,0], [5,16], [6,0], [7,272], [8,0], [9,7936],
    [10,0], [11,353792], [12,0], [13,22368256], [14,0], [15,1903757312],
    [16,0], [17,209865342976], [18,0], [19,29088885112832], [20,0],
    [21,4951498053124096], [22,0], [23,1015423886506852352], [24,0],
    [25,246921480190207983616], [26,0]]
                                       Type: List List NonNegativeInteger