Objetivo

O objetivo desse desafio é produzir uma função nque calcule o número de maneiras de particionar a n X 1grade em triângulos, onde todos os vértices dos triângulos estão em pontos da grade.

Exemplo

Por exemplo, existem 14 maneiras de particionar a grade 2 x 1, portanto, f(2) = 14através das partições a seguir, nas quais as partições possuem 2, 2, 2, 2, 4 e 2 orientações distintas, respectivamente.

Pontuação

Isso é código-golfe , então o código mais curto vence.

05AB1E , 13 bytes

·LÉœÙεÅγo;P}O

Porto da resposta Jelly do @Bubbler .

Muito lento devido às permutações embutidas.

Experimente online ou verifique as quatro primeiras entradas .

Explicação:

·                # Double the (implicit) input
 L               # Create a list in the range [1, doubled_input]
  É              # Check for each if they're odd (1 if truthy, 0 is falsey)
                 # We now have a list of n 0s and n 1s (n being the input)
   œ             # Get all permutations of that list
    Ù            # Only leave the unique permutations
     ε     }     # Map each permutation to:
      Åγ         #  Run-length encode the current value (short for `γ€g`)
        o        #  Take 2 to the power for each
         ;       #  Halve each
          P      #  Take the product of the mapped permutation
            O    # Sum all mapped values together (and output implicitly)

Haskell , 60 55 54 52 bytes

Depois de desenhar e programar muitos exemplos, ocorreu-me que isso é o mesmo que o problema das gralhas:

Em um tabuleiro de xadrez $(n+1) \times (n+1)$ , de quantas maneiras há uma torre para ir de $(0,0)$ a $(n,n)$ movendo-se apenas para a direita $+(1,0)$ ou para cima $+(0,1)$ ?

Basicamente, você tem a linha superior e inferior da grade $1 \times n$ . Agora você deve preencher a linha não horizontal. Cada triângulo deve ter duas linhas não horizontais. Se um dos lados faz parte do topo ou da linha de fundo corresponde à direção e ao comprimento que você seguiria no problema das gralhas. Este é o OEIS A051708 . Como ilustração dessa correspondência, considere os seguintes exemplos. Aqui, a linha superior corresponde aos movimentos para cima, enquanto a linha inferior corresponde aos movimentos para a direita.

Obrigado @PeterTaylor por -6 bytes e @PostLeftGarfHunter por -2 bytes!

b 0=1
b 1=2
b n=div((10*n-6)*b(n-1)-9*(n-2)*b(n-2))n

Experimente online!

Haskell , 42 bytes

0?0=1
a?b=sum[a?i+i?a|i<-[0..b-1]]
f n=n?n

Experimente online!

Uma implementação bastante direta que se repete mais de 2 variáveis.

Veja como podemos obter esta solução. Comece com o código implementando uma fórmula recursiva direta:

54 bytes

0%0=1
a%b=sum$map(a%)[0..b-1]++map(b%)[0..a-1]
f n=n%n

Experimente online!

Usando a interpretação de movimento da torre de flawr , a%bé o número de caminhos que levam a torre de (a,b)para (0,0), usando apenas os movimentos para diminuir uma coordenada. O primeiro movimento diminui aou diminui b, mantendo o outro igual, daí a fórmula recursiva.

49 bytes

a?b=sum$map(a%)[0..b-1]
0%0=1
a%b=a?b+b?a
f n=n%n

Experimente online!

Podemos evitar a repetição map(a%)[0..b-1]++map(b%)[0..a-1]observando que as duas metades são iguais ae btrocadas. A chamada auxiliar a?bconta os caminhos em que o primeiro movimento diminui ae, portanto, b?aconta aqueles em que o primeiro movimento diminui b. Em geral, são diferentes e adicionam a a%b.

O somatório em a?btambém pode ser escrito como uma compreensão da lista a?b=sum[a%i|i<-[0..b-1]].

42 bytes

0?0=1
a?b=sum[a?i+i?a|i<-[0..b-1]]
f n=n?n

Experimente online!

Finalmente, nos livramos %e escrevemos a recursão em termos de ?substituindo a%ipor a?i+i?ana chamada recursiva.

O novo caso base faz com que isso ?dê a saídas o dobro do da ?versão de 49 bytes, já que com 0?0=1nós teríamos 0%0=0?0+0?0=2. Isso permite definir f n=n?nsem a metade que precisaríamos fazer.

CJam (24 bytes)

{2,*e!{e`0f=:(1b2\#}%1b}

Demonstração online

Isso usa a abordagem de Bubbler de somar sobre permutações de n0s e n1s.

Dissecação

{         e# Define a block
  2,*     e#   Given input n, create an array of n 0s and n 1s
  e!      e#   Generate all permutations of that array
  {       e#   Map:
    e`    e#     Run-length encode
    0f=:( e#     Extract just the lengths and decrement them
    1b    e#     Sum
    2\#   e#     Raise 2 to the power of that sum
  }%
  1b      e#  Sum the mapped values
}

Abordagem alternativa (28 bytes)

{_1aa{_2$,f{j}@@,f{j}+1b}2j}

Demonstração online

Dissecação

Todos os triângulos têm uma aresta horizontal e duas arestas que vinculam as linhas horizontais. Rotule as arestas não horizontais por uma tupla de suas duas cordas x e classifique lexicograficamente. Então a primeira aresta é (0,0), a última aresta é (n,n)e duas arestas consecutivas diferem precisamente em uma das duas posições. Isso cria uma recursão simples, que eu implementei usando o operador de recursão memorizado j:

{            e# Define a block
  _          e#   Duplicate the argument to get n n
  1aa        e#   Base case for recursion: 0 0 => 1
  {          e#   Recursive body taking args a b
    _2$,f{j} e#     Recurse on 0 b up to a-1 b
    @@,f{j}  e#     Recurse on a 0 up to a b-1
    +1b      e#     Combine and sum
  }2j        e#   Memoised recursion with 2 args
}

Nota

Esta não é a primeira vez que desejo fjreceber suporte no CJam. Aqui, a pontuação também seria reduzida para 24 bytes. Talvez eu devesse tentar escrever um patch ...

Geléia , ₁₅ 14 bytes

Ø.xŒ!QŒɠ€’§2*S

Experimente online!

-1 byte com base no comentário de Peter Taylor.

Usa a ilustração de flawr diretamente, em vez da fórmula resultante.

Como funciona

Ø.xŒ!QŒɠ€’§2*S    Main link (monad). Input: positive integer N.
Ø.x               Make an array containing N zeros and ones
   Œ!Q            All unique permutations
      Œɠ€         Run-length encode on each permutation
         ’§       Decrement and sum each
           2*S    Raise to power of 2 and sum

Pegue todas as rotas possíveis em uma grade quadrada. O número de maneiras de mover L unidades em uma direção como uma torre é 2**(L-1). Aplique isso a todas as rotas e some o número de maneiras de percorrer cada rota.

Carvão , 44 31 bytes

riscado 44 ainda é regular 44

Ｆ⊕θ«≔⟦⟧ηＦ⊕θ⊞ηΣ∨⁺ηＥυ§λκ¹⊞υη»Ｉ⊟⊟υ

Experimente online! Explicação: Funciona calculando o número de maneiras de particionar um trapézio de comprimentos laterais opostos m,nem triângulos, todos eles com desvios inteiros. Este é simplesmente um caso geral do retângulo de tamanho nna pergunta. O número de partições é dado recursivamente como a soma dos números de partições para todos os lados m,0..n-1e n,0..m-1. Isso é equivalente ao problema generalizado das torres, OEIS A035002 . O código simplesmente calcula o número de partições trabalhando 0,0até n,nusar os valores calculados anteriormente.

Ｆ⊕θ«

Faça um loop sobre as linhas 0..n.

≔⟦⟧η

Comece com uma linha vazia.

Ｆ⊕θ

Faça um loop sobre as colunas na linha 0..n.

⊞ηΣ∨⁺ηＥυ§λκ¹

Leve a linha até o momento e os valores nas linhas anteriores na coluna atual e adicione a soma total à linha atual. No entanto, se não houver valores, substitua 1no lugar da soma.

⊞υη»

Adicione a linha finalizada à lista de linhas até agora.

Ｉ⊟⊟υ

Emita o valor final calculado.

JavaScript (ES6),  45 44  42 bytes

Usa a fórmula recursiva encontrada por Peter Taylor e flawr .

f=n=>n<2?n+1:(10-6/n)*f(--n)+9/~n*f(--n)*n

Experimente online!

Pari / GP , 43 bytes

De acordo com o OEIS , a função geradora dessa sequência é

n->Vec(sqrt((1-x)/(1-9*x)+O(x^n++))+1)[n]/2

Experimente online!

Python 3 , 51 bytes

lambda n:-~n*(n<2)or(10-6/n)*f(n-1)-(9-18/n)*f(n-2)

Experimente online!

Resposta do porto de flawr