Wir haben 40 Stöcke gleicher Breite, aber unterschiedlicher Höhe. Wie viele Anordnungen gibt es, um sie nebeneinander zu stellen, sodass wir von rechts gesehen 10 Stöcke sehen und von links gesehen genau 10 Stöcke?

Zum Beispiel ist eine solche Bestellung:

Schwarze Stöcke sind versteckt, rote Stöcke sind diejenigen, die Sie sehen können, wenn Sie von links schauen, die blauen Stöcke sind diejenigen, die Sie sehen können, wenn Sie von rechts schauen, und lila (dh der längste) ist derjenige, der gesehen werden kann von beiden Seiten.

Als Testfälle:

• Wenn wir 3 Stöcke hatten, ist die Anzahl der Bestellungen 2 von links und 2 von rechts ist 2
• Wenn wir 5 Sticks hatten, sehen wir 3 von links und 3 von rechts ist 6
• Wenn wir 10 Sticks hatten, ist die Anzahl der Bestellungen, um 4 von links und 4 von rechts zu sehen, 90720

PARI / GP, 80

f(n,v)=abs(sum(k=1,n-1,binomial(n-1,k)*stirling(k,v-1,1)*stirling(n-k-1,v-1,1)))

Die Anzahl der sichtbaren Sticks wird nach dem Bleistift- / Rasterspiel auch als Skyscraper Numbers bezeichnet . Dieser Code basiert auf (nur geringfügig geänderten) Formeln aus OEIS A218531 . Ich weiß nicht viel über PARI, aber ich glaube wirklich nicht, dass es hier draußen viel zu golfen gibt.

Testfälle werden alle auf ideone.com gezeigt . Das Ergebnis für f(40,10)ist:

192999500979320621703647808413866514749680

Python 3, 259 Bytes

Nicht sehr glücklich damit.

import itertools as i
x=input().split()
y,k=x
y=int(y)
c=0
x=list(i.permutations(list(range(1,y+1))))
for s in x:
 t=d=0;l=s[::-1]
 for i in range(y):
  if max(s[:i+1])==s[i]:t+=1
 for i in range(y):
  if max(l[:i+1])==l[i]:d+=1
 if t==d==int(k):c+=1
print(c)

Beispiel für Ein- und Ausgabe:

10 4
90720

Es generiert alle möglichen Kombinationen des angegebenen Bereichs und durchläuft sie dann in einer Schleife, wobei jede Zahl in ihnen überprüft wird, um festzustellen, ob sie dem Maximum der vorherigen Zahlen entspricht. Es macht dann dasselbe rückwärts und wenn die Zählung vorwärts (t) = die Zählung rückwärts (d) = die gegebene Ansichtsnummer (k) ist, ist es eine gültige. Dies wird zu einem Zähler (c) hinzugefügt und am Ende ausgedruckt.

R 104

function(N,K)sum(sapply(combinat::permn(N),function(x)(z=function(i)sum(cummax(i)==i)==K)(x)&z(rev(x))))

Ein wenig entgolfen:

    function(N,K) {
      all_perm <- combinat::permn(N)
      can_see_K_from_left <- function(i)sum(cummax(i) == i) == K
      can_see_K_from_both <- function(x)can_see_K_from_left(x) &
                                        can_see_K_from_left(rev(x))
      return(sum(sapply(all_perm, can_see_K_from_both)))
    }

Pyth - 38 36 Bytes

Grundsätzlich ein Port der R-Antwort. Ziemlich langsam, kann nicht einmal 10, 4online abschließen .

AGHQLlfqhS<bhT@bTUGlf!-,yTy_TH.pr1hG

Die einzigen Dinge, die Pyth nicht hat, sind Cummax und das == Over-Vektoren, aber die Implementierung dauerte nur ein paar Bytes.

Erklärung und weiteres Golfen folgen in Kürze.

Probieren Sie es hier online .