Temos 40 varas da mesma largura, mas com alturas diferentes. Quantos arranjos são possíveis para colocá-los um ao lado do outro, de modo que, quando olhamos da direita, vemos 10 paus e quando olhamos da esquerda, vemos novamente exatamente 10 paus?

Por exemplo, esse pedido é:

Paus pretos estão escondidos, paus vermelhos são os que você pode ver quando olha da esquerda, os paus azuis são os que você vê quando olha da direita e da roxa (ou seja, a mais longa) é a que pode ser vista. de ambos os lados.

Como casos de teste:

• Se tivéssemos 3 varas, o número de pedidos para ver 2 da esquerda e 2 da direita é 2
• Se tivéssemos 5 varas, o número de pedidos para ver 3 da esquerda e 3 da direita é 6
• Se tivéssemos 10 varas, o número de pedidos para ver 4 da esquerda e 4 da direita é 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)))

O número de paus visíveis também é chamado de Números de arranha-céu , depois do jogo de lápis / grade. Este código é baseado (apenas ligeiramente alterado) na fórmula do OEIS A218531 . Não conheço muito PARI, mas acho que não há muito para jogar aqui.

Os casos de teste são todos mostrados em ideone.com . O resultado para f(40,10)é:

192999500979320621703647808413866514749680

Python 3, 259 bytes

Não estou muito feliz com isso.

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)

Exemplo de entrada e saída:

10 4
90720

Ele gera todas as combinações possíveis do intervalo fornecido e os percorre, verificando cada número neles para ver se é igual ao máximo dos números anteriores. Em seguida, ele faz o mesmo ao contrário, e se a contagem para a frente (t) = a contagem para trás (d) = o número de exibição fornecido (k), é válido. Adiciona isso a um contador (c) e imprime isso no final.

R, 104

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

De-golfe um pouco:

    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)))
    }

Pitão - 38 36 bytes

Basicamente, uma porta da resposta R. Muito lento, nem pode ser concluído 10, 4online.

AGHQLlfqhS<bhT@bTUGlf!-,yTy_TH.pr1hG

As únicas coisas que Pyth não possui são cummax e os ==vetores over, mas esses precisaram de apenas alguns bytes para serem implementados.

Explicação e mais golfe em breve.

Experimente aqui online .