Normalmente, descomponemos un número en dígitos binarios asignándolo con potencias de 2, con un coeficiente de 0o 1para cada término:

25 = 1*16 + 1*8 + 0*4 + 0*2 + 1*1

La elección de 0y 1es ... no muy binaria. Realizaremos la verdadera expansión binaria expandiéndonos con potencias de 2, pero con un coeficiente de 1o en su -1lugar:

25 = 1*16 + 1*8 + 1*4 - 1*2 - 1*1

Ahora esto parece binario.

Dado cualquier número positivo, debería ser trivial ver que:

• Cada número impar tiene infinitas expansiones binarias verdaderas
• Cada número par no tiene expansiones binarias verdaderas

Por lo tanto, para que una verdadera expansión binaria esté bien definida, requerimos que la expansión sea la menor , es decir, con la longitud más corta.

Dado cualquier número entero positivo e impar n, devuelve su verdadera expansión binaria, del dígito más significativo al dígito menos significativo (o en orden inverso).

Reglas:

• Como se trata de código de golf , debe intentar hacerlo en el menor recuento de bytes posible. Las construcciones están permitidas.
• Cualquier salida que pueda representar y enumerar los coeficientes es aceptable: una matriz, una cadena de coeficientes con separadores, etc.
• Se aplican lagunas de golf estándar.
• Su programa debería funcionar para valores dentro del tamaño entero estándar de su idioma.

Casos de prueba

25 -> [1,1,1,-1,-1]
47 -> [1,1,-1,1,1,1]
1 -> [1]
3 -> [1,1]
1234567 -> [1,1,-1,-1,1,-1,1,1,-1,1,-1,1,1,-1,1,-1,-1,-1,-1,1,1]

Japt , 6 bytes

¤é r0J

Pruébalo en línea!

Explicación:

¤é r0J  // Test input:                  25
¤       // Binary the input:            11001
 é      // Rotate 1 chars to the right: 11100
   r0J  // Replace 0s with -1:          111-1-1

Pyth ,  12  11 bytes

|R_1.>jQ2 1

Pruébalo aquí!

¿Cómo?

| R_1.> JQ2 1 Programa completo.

      jQ2 Convierta la entrada a una lista binaria.
     .> 1 Gire cíclicamente la lista anterior 1 lugar a la derecha.
| R_1 Sustituye 0 con -1.
               Salida implícita.

En primer lugar, nos damos cuenta de que la tarea es simplemente "sustituir la 0s en la escritura binaria con -1sy desplazarse a la derecha por 1 lugar". - Eso es exactamente lo que debemos hacer! La conversión binaria nos da una lista de 0sy 1s. Todo lo que hay que hacer aquí es encontrar una manera de convertir golfy 0a -1. El operador bit a bit |(bitwise OR) es nuestro amigo. El mapa sobre la representación binaria cambió con |y -1. Si el número actual es 0, se convierte a -1.

Perl 6

Versión de cadena, 31 bytes

1~(*+>1).base(2).subst(0,-1,:g)

Pruébalo en línea!

Lista de versiones, 36 bytes

{map * *2-1,1,|($_+>1).base(2).comb}

Pruébalo en línea!

JavaScript (ES6), 35 34 bytes

f=n=>n?[...f(n>>=1),!n|n%2||-1]:[]

Fragmento de prueba

let f=n=>n?[...f(n>>=1),!n|n%2||-1]:[];

[25, 47, 1, 3, 1234567].map(x => console.log(x + ":", JSON.stringify(f(x))))

Perl 6 , 72 bytes

Seguramente hay una mejor manera, pero esto es lo que tengo ...

->$a {grep {$a==[+] @^a.reverse Z+< ^∞},[X] (1,-1)xx $a.base(2).chars}

Pruébalo en línea!

Explicación : Es una función que toma un argumento ( ->$a). Primero obtenemos el número de coeficientes necesarios ( $a.base(2).chars= número de caracteres en la representación de base 2), luego hacemos un producto cartesiano ( X) de tantos pares (1,-1). (Los [X]medios: reduzca la siguiente lista con X). Entonces obtenemos una lista de todas las combinaciones posibles de 1s y -1s. Luego filtramos ( grep) solo las listas que codifican el número dado$a . Solo hay uno, por lo que obtenemos una lista de una lista con los coeficientes.

El bloque grep hace esto: toma su argumento como una lista ( @^a), lo invierte y lo comprime con una lista infinita 0,1,2,...utilizando el operador "desplazamiento de bit izquierdo" +<. La compresión se detiene tan pronto como se agota la lista más corta (¡bueno para nosotros!) Luego sumamos todos los resultados y los comparamos con el número dado. Tuvimos que usar .reverseporque el OP exige que los coeficientes estén en el orden de más significativo a menos significativo.

Jalea , 5 bytes

Bṙ-o-

Pruébalo en línea!

05AB1E , 6 5 bytes

bÁ0®:

Pruébalo en línea!

J, 11 bytes

1-~2*_1|.#:

Pruébalo en línea!

Gracias a @JosiahWinslow por el algoritmo.

¿Alguna idea sobre hacer la conversión más corta? Mis pensamientos son usar !.-fit (nvm, solo cambia la tolerancia de la conversión).

Usar {-take es más largo por 1 personaje.

_1 1{~_1|.#:

Java 8, 101 bytes

n->{String s=n.toString(n,2);return(s.charAt(s.length()-1)+s.replaceAll(".$","")).replace("0","-1");}

Puerto de @Oliver Japt respuesta 's , con unos cuantos más bytes ..;)

Definitivamente se puede jugar al golf utilizando un enfoque matemático en lugar de este enfoque de cadena.

Explicación:

Pruébalo aquí.

n->{                             // Method with Integer parameter and String return-type
  String s=n.toString(n,2);      //  Convert the Integer to a binary String
  return(s.charAt(s.length()-1)  //  Get the last character of the binary String
    +s.replaceAll(".$","")       //   + everything except the last character
   ).replace("0","-1");          //  Then replace all zeroes with -1, and return the result
}                                // End of method

R , 90 88 46 bytes

function(n)c((n%/%2^(0:log2(n))%%2)[-1],1)*2-1

Pruébalo en línea!

Implementa el algoritmo de Oliver , pero devuelve los dígitos en orden inverso. Como estamos garantizados de que nnunca es par, el bit menos significativo (el primero) es siempre 1, por lo que lo eliminamos y agregamos una 1al final para simular la rotación en R. Gracias a Shaggy por ayudarme a arreglar mis matemáticas .

Simplemente colocando rev( )las llamadas de función en el pie de página debería devolver los valores en el mismo orden.

respuesta original, 88 bytes:

function(n,b=2^(0:log2(n)))(m=t(t(expand.grid(rep(list(c(-1,1)),sum(b|1))))))[m%*%b==n,]

Función anónima; devuelve los valores en orden inverso con los nombres de columna adjuntos.

Pruébalo en línea!

Explicación:

function(n){
 b <- 2^(0:log2(n))         # powers of 2 less than n
 m <- expand.grid(rep(list(c(-1,1)),sum(b|1))) # all combinations of -1,1 at each position in b, as data frame
 m <- t(t(m))               # convert to matrix
 idx <- m%*%b==n            # rows where the matrix product is `n`
 m[idx,]                    # return those rows
}

Perl 5 , 30 bytes

Código de 29 bytes, 1 byte para el -pinterruptor.

$_=sprintf'1%b',$_/2;s/0/-1/g

Pruébalo en línea!

CJam, 12 bytes

Un puerto de mi respuesta Golfscript.

qi2b{_+(}%)\

Ruby , 44 37 33 32 bytes

->n{("1%b"%n).chop.gsub ?0,"-1"}

Pruébalo en línea!

Golfscript, 14 13 14 bytes

-1 byte porque olvidé que %existía. +1 byte porque también olvidé que input es una cadena.

~2base{.+(}%)\