Зазвичай ми розкладаємо число на двійкові цифри, присвоюючи їм потужність 2, з коефіцієнтом 0або 1для кожного члена:

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

Вибір 0і 1є ... не дуже бінарний. Ми будемо виконувати справжнє бінарне розширення шляхом розширення з потужностями 2, але з коефіцієнтом 1або -1замість:

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

Тепер це виглядає бінарним.

З огляду на будь-яке додатне число, слід бачити, що:

• Кожне непарне число має нескінченно багато справжніх бінарних розширень
• Кожне парне число не має справжніх двійкових розширень

Отже, щоб справжнє бінарне розширення було чітко визначене, нам потрібно розширення як мінімум , тобто з найменшою довжиною.

Враховуючи будь-яке додатне ціле ціле число n, поверніть його справжнє бінарне розширення, від найбільш значущої цифри до найменш значущої цифри (або у зворотному порядку).

Правила:

• Як це є код-гольф, ви повинні поставити за мету зробити це в найкоротшій кількості можливих байт. Вбудовані дозволені.
• Будь-який вихід, який може представляти та перераховувати коефіцієнти, є прийнятним: масив, рядок коефіцієнтів з роздільниками тощо ...
• Застосовуються стандартні лазівки для гольфу.
• Ваша програма повинна працювати на значення в межах стандартного цілого розміру вашої мови.

Випробування

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 байт

¤é r0J

Спробуйте в Інтернеті!

Пояснення:

¤é 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 байт

|R_1.>jQ2 1

Спробуйте тут!

Як?

| R_1.> JQ2 1 Повна програма.

      jQ2 Перетворити вхід у бінарний список.
     .> 1 Циклічно поверніть список вище на 1 місце праворуч.
| R_1 Замініть 0 на -1.
               Неналежне виведення.

По-перше, ми помічаємо, що завдання полягає в тому, щоб "просто замінити 0s у двійковому записі на -1s і перемістити вправо на 1 місце". - Це саме те, що ми повинні робити! Бінарне перетворення дає нам список 0s і 1s. Все , що ми повинні зробити тут , щоб знайти golfy спосіб перетворити 0в -1. Побітовий оператор |(побітовий АБО) - наш друг. Карта над бінарним поданням зміщується на |та -1. Якщо поточне число є 0, воно перетворюється в -1.

Перл 6

Версія для рядків, 31 байт

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

Спробуйте в Інтернеті!

Версія списку, 36 байт

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

Спробуйте в Інтернеті!

JavaScript (ES6), 35 34 байт

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

Фрагмент тесту

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

Перл 6 , 72 байти

Звичайно, є кращий спосіб, але це те, що я маю ...

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

Спробуйте в Інтернеті!

Пояснення : Це функція, яка бере один аргумент ( ->$a). Ми спочатку отримуємо кількість необхідних коефіцієнтів ( $a.base(2).chars= кількість символів у представленні бази 2), потім робимо декартовий добуток ( X) з цих багатьох пар (1,-1). ( [X]Засоби: зменшіть наступний список за допомогою X.) Отже, ми отримаємо список усіх можливих комбінацій 1s та -1s. Тоді ми фільтруємо ( grep) лише списки, які кодують задане число$a . Є лише один, тому ми отримуємо список одного списку з коефіцієнтами.

Блок grep робить це так: приймає його аргумент як list ( @^a), перевертає його і додає до нескінченного списку, 0,1,2,...використовуючи оператор "зсув лівого біта" +<. Зіпсування припиняється, як тільки коротший список вичерпується (добре для нас!) Потім ми підсумовуємо всі результати та порівнюємо їх із заданим числом. Нам довелося використовувати, .reverseтому що ОП вимагає, щоб коефіцієнти були в порядку від найбільш значущих до найменш значущих.

Желе , 5 байт

Bṙ-o-

Спробуйте в Інтернеті!

05AB1E , 6 5 байт

bÁ0®:

Спробуйте в Інтернеті!

J, 11 байт

1-~2*_1|.#:

Спробуйте в Інтернеті!

Завдяки @JosiahWinslow за алгоритм.

Будь-які думки щодо скорочення конверсії? Мої думки - до використання!. -fit (nvm, це просто змінює толерантність перетворення).

Використання {-take довше на 1 символ.

_1 1{~_1|.#:

Java 8, 101 байт

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

Порт відповіді Japt @Oliver , ще з кількома байтами ..;)

Однозначно можна пограти в гольф, використовуючи математичний підхід замість цього струнного підходу.

Пояснення:

Спробуйте тут.

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 байт

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

Спробуйте в Інтернеті!

Реалізує алгоритм Олівера , але повертає цифри у зворотному порядку. Оскільки ми гарантуємо, що nце ніколи не є рівним, найменше значущий біт (перший) - це завжди 1, тому ми видаляємо його і додаємо a 1до кінця, щоб імітувати обертання в Р. Завдяки Shaggy за те, що я змусив мене виправити математику .

Просте розміщення rev( )викликів функції у нижньому колонтитулі має повертати значення в тому ж порядку.

оригінальна відповідь, 88 байт:

function(n,b=2^(0:log2(n)))(m=t(t(expand.grid(rep(list(c(-1,1)),sum(b|1))))))[m%*%b==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 байт

29 байт коду, 1 байт для -pкомутатора.

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

Спробуйте в Інтернеті!

CJam, 12 байт

Порт моєї відповіді Golfscript.

qi2b{_+(}%)\

Рубі , 44 37 33 32 байт

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

Спробуйте в Інтернеті!

Гольфскрипт, 14 13 14 байт

-1 байт, бо я забув, що %існував. +1 байт, тому що я також забув, вхід - це рядок.

~2base{.+(}%)\