Una secuencia de enteros es una secuencia si la diferencia entre dos números consecutivos en esta secuencia es -1 o 1 y su primer elemento es 0.

Más precisamente: a1, a2, ..., an es una secuencia si:

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

Entrada

• n - número de elementos en la secuencia
• s - suma de elementos en la secuencia

Salida

• un conjunto de una secuencia / lista / matriz / etc. de longitud ncon suma de elementos s, si es posible
• un conjunto / lista / matriz / etc vacío si no es posible

Ejemplos

Para la entrada 8 4, la salida podría ser [0 1 2 1 0 -1 0 1]o [0 -1 0 1 0 1 2 1]. Puede haber otras posibilidades.

Para la entrada 3 5, la salida está vacía [], ya que no se puede hacer.

Reglas

Este es un código de golf, la respuesta más corta en bytes gana. Los envíos deben ser un programa o función. La entrada / salida se puede dar de cualquiera de las formas estándar .

CJam, 56 47 44 34 bytes

Aquí hay muchas posibilidades de mejora, pero aquí va el primer intento:

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

Créditos a Dennis por la forma eficiente de hacer la { ... }%parte.

Imprime la representación de matriz si es posible, de lo contrario ""

Pruébalo en línea aquí

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

No hay necesidad de fuerza bruta o enumeración de todas las tuplas.

Vea una secuencia de longitud n como n -1 pasos, cada paso es un incremento o decremento.
Tenga en cuenta que solo puede cambiar un incremento por una disminución, la suma varía en 2, por lo que para cualquier longitud dada la suma es siempre par o siempre impar.
Teniendo todos los incrementos, la secuencia es 0, 1, 2, 3, ..., n-1 y sabemos que la suma es (n-1) * n / 2
Cambiando el último paso, la suma cambia en 2, entonces el el último paso pesa 2.
Cambiando el penúltimo paso, la suma cambia en 4, por lo que el último paso pesa 4. Esto se debe a que el paso sucesivo se basa en la suma parcial hasta el momento.
Al cambiar el paso anterior, la suma cambia en 6, por lo que el último paso pesa 6 (no 8, no son números binarios).
...
Cambiar el primer paso 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 sin golf

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
}

Prueba en la consola Firefox / FireBug

F(8,4)

Salida

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

GolfScript ( 41 39 bytes)

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

Demostración en línea

Gracias a Dennis por 41-> 39.

Mathematica, 73 bytes

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

Solución simple de fuerza bruta.

Estoy generando todas las opciones de pasos. Luego los convierto en listas acumuladas para obtener las secuencias de una. Y luego estoy buscando el primero cuya suma es igual al segundo parámetro. Si no existe, el valor predeterminado es {}.

Haskell, 56 bytes

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

Explicación:

• Construya una lista con las permutaciones de 1,-1y longitud n-1: replicateM n-1[-1,1]
  Ejemplo: replicateM 2 [-1,1]==[[-1,-1],[-1,1],[1,-1],[1,1]]
• Construye la secuencia de una de ellas. scanltiene un bajo rendimiento, pero hace el trabajo correcto aquí.
• Filtra todas las secuencias de una posible con longitud ndonde la suma ess

Pitón, 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

Apenas más corto que mi solución de Mathematica, pero eso es principalmente mi culpa por no seguir usando CJam correctamente:

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

Es literalmente el mismo algoritmo: obtener todas las n-1tuplas de {1, -1}. Encuentre el primero cuya acumulación es la misma que s, anteponga a 0. Imprima una matriz vacía si no se encuentra ninguna.

CJam, 40

Otro enfoque en CJam.

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

Rubí (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

Comprueba cada secuencia como muchas otras respuestas. Intentará hacer una solución de O (n) más corta.

   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*⍵),⊂⍬}

Ejemplo:

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

Este, como muchos otros, simplemente fuerza bruta a través de cada combinación para encontrar uno que coincida, si no se encuentra no devuelve nada. En realidad, intenta algunas combinaciones más de una vez para acortar el código.