Uma sequência de números inteiros é uma sequência se a diferença entre dois números consecutivos nessa sequência for -1 ou 1 e seu primeiro elemento for 0.

Mais precisamente: a1, a2, ..., an é uma sequência se:

For any k (1 ≤  k < n): |a[k] - a[k+1]|=1, 
a[1]=0

Entrada

• n - número de elementos na sequência
• s - soma dos elementos na sequência

Resultado

• um conjunto / lista / matriz / etc de uma sequência de comprimento ncom a soma dos elementos s, se possível
• um conjunto / lista / matriz / etc vazio, se não for possível

Exemplos

Para entrada 8 4, a saída pode ser [0 1 2 1 0 -1 0 1]ou [0 -1 0 1 0 1 2 1]. Pode haver outras possibilidades.

Para entrada 3 5, a saída está vazia [], pois não pode ser feita.

Regras

Este é um código de golfe, a resposta mais curta em bytes ganha. As submissões devem ser um programa ou função. A entrada / saída pode ser fornecida de qualquer uma das maneiras padrão .

CJam, 56 47 44 34 bytes

Muitas possibilidades de aprimoramento aqui, mas aqui está a primeira tentativa:

L0aa{{[~_(]_)2++}%}l~:N;(*{:+N=}=p

Créditos a Dennis pela maneira eficiente de fazer a { ... }%peça.

Imprime a representação do array, se possível, caso contrário ""

Experimente online aqui

JavaScript (E6) 79 82

F=(n,t,
  d=n+n*~-n/4-t/2,
  l=1,
  q=[for(x of Array(n))d<n--?++l:(d+=~n,--l)]
)=>d?[]:q

Não há necessidade de força bruta ou enumeração de todas as tuplas.

Veja uma sequência de comprimento n como n -1 etapas, cada etapa sendo incrementada ou decrescente.
Observe que você só pode trocar um incremento por um decremento, a soma varia de 2; portanto, para qualquer comprimento determinado, a soma é sempre par ou sempre ímpar.
Tendo todos os incrementos, a sequência é 0, 1, 2, 3, ..., n-1 e sabemos que a soma é (n-1) * n / 2
Alterando o último passo, a soma muda em 2, então a o último passo pesa 2.
Alterando o próximo para o último passo, a soma muda em 4, então o último passo pesa 4. Isso ocorre porque o passo sucessivo se baseia na soma parcial até agora.
Alterando a etapa anterior, a soma muda em 6, então a última etapa pesa 6 (não 8, não são números binários).
...
Alterar o primeiro passo pesa (n-1) * 2

Algoritmo

Find the max sum (all increments)  
Find the difference with the target sum (if it's not even, no solution)  
Seq[0] is 0  
For each step  
  Compare current difference with the step weight
  if is less 
     we have an increment here, seq[i] = seq[i-1]+1 
  else 
     we have a decrement here, seq[i] = seq[i-1]-1.  
     Subtract we current weight from the current diff.
If remaining diff == 0, solution is Seq[]. Else no solution

Código ungolfed

F=(len,target)=>{
  max=(len-1)*len/2
  delta = max-target
  seq = [last=0]
  sum = 0
  weight=(len-1)*2
  while (--len > 0)
  {
    if (delta >= weight)
    {
      --last
      delta -= weight;
    }
    else
    {
      ++last
    }  
    sum += last
    seq.push(last);
    weight -= 2;
  }  
  if (delta) return [];
  console.log(sum) // to verify

  return seq
}

Teste no console Firefox / FireBug

F(8,4)

Resultado

[0, -1, 0, -1, 0, 1, 2, 3]

GolfScript ( 41 39 bytes)

[][1,]@~:^;({{.-1=(+.)))+}%}*{{+}*^=}?`

Demonstração online

Agradecimentos a Dennis por 41-> 39.

Mathematica, 73 bytes

f=FirstCase[{0}~Join~Accumulate@#&/@Tuples[{-1,1},#-1],l_/;Tr@l==#2,{}]&;

Solução simples de força bruta.

Estou gerando todas as opções de etapas. Então eu as transformo em listas acumuladas para obter as seqüências únicas. E então eu estou procurando o primeiro cuja soma é igual ao segundo parâmetro. Se não houver, o valor padrão é {}.

Haskell, 56 bytes

n%s=[x|x<-scanl(+)0`map`mapM(\_->[1,-1])[2..n],s==sum x]

Explicação:

• Crie uma lista com as permutações 1,-1e comprimento n-1: replicateM n-1[-1,1]
  Exemplo: replicateM 2 [-1,1]==[[-1,-1],[-1,1],[1,-1],[1,1]]
• Crie a sequência única a partir dela. scanltem um desempenho ruim, mas faz o trabalho certo aqui.
• Filtre todas as sequências únicas possíveis com o comprimento em nque a soma és

Python, 138

from itertools import*
def f(n,s):
 for i in[list(accumulate(x))for x in product([-1,1],repeat=n-1)]:
  if sum(i)==s:return[0]+i
 return[]

CJam, 65 58 54 bytes

Pouco mais curto que minha solução Mathematica, mas a culpa é minha por ainda não usar o CJam corretamente:

0]]l~:S;({{_1+\W+}%}*{0\{+_}%);}%_{:+S=}#_@\i=\0>\[]?p

É literalmente o mesmo algoritmo: obter todos os n-1-tuplos de {1, -1}. Encontre o primeiro cuja acumulação é igual a s, acrescente a 0. Imprima uma matriz vazia se nenhuma for encontrada.

CJam, 40

Outra abordagem no CJam.

ri,W%)\_:+ri-\{2*:T1$>1{T-W}?2$+\}/])!*p

Rubi (136)

def one_sequences(n)
  n.to_s.chars.map(&:to_i).each_cons(2).to_a.select{|x|x[0] == 0 && (x[1] == 1 || x[1]
  == -1)}.count
end

J, 47 caracteres

Verifica cada sequência como muitas outras respostas. Tentará fazer uma solução O (n) mais curta.

   f=.4 :'(<:@#}.])(|:#~y=+/)+/\0,|:<:2*#:i.2^<:x'

   8 f 4
0 1 2 1 0 1 0 _1

   3 f 5
[nothing]

APL 38

{⊃(↓a⌿⍨⍺=+/a←+\0,⍉1↓¯1*(⍵⍴2)⊤⍳2*⍵),⊂⍬}

Exemplo:

     4 {⊃(↓a⌿⍨⍺=+/a←+\0,⍉1↓¯1*(⍵⍴2)⊤⍳2*⍵),⊂⍬}8
0 1 2 1 0 1 0 ¯1

Este, como muitos outros, apenas força bruta em todas as combinações para encontrar uma que combine, se não for encontrada, não retorna nada. Na verdade, ele tenta algumas combinações mais de uma vez para diminuir o código.