Biasanya, kami menguraikan angka menjadi angka biner dengan menetapkannya dengan kekuatan 2, dengan koefisien 0atau 1untuk setiap istilah:

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

Pilihan 0dan 1... tidak terlalu biner. Kami akan melakukan ekspansi biner yang sebenarnya dengan memperluas dengan kekuatan 2, tetapi dengan koefisien 1atau -1sebaliknya:

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

Sekarang ini terlihat biner.

Dengan angka positif, sepele untuk melihat bahwa:

• Setiap angka ganjil memiliki banyak sekali ekspansi biner sejati
• Setiap angka genap tidak memiliki ekspansi biner yang benar

Oleh karena itu, agar ekspansi biner yang benar dapat didefinisikan dengan baik, kami membutuhkan ekspansi yang paling kecil , yaitu dengan panjang terpendek.

Dengan bilangan bulat positif, ganjil n, kembalikan ekspansi biner yang sebenarnya, dari digit paling signifikan ke digit paling tidak signifikan (atau dalam urutan terbalik).

Aturan:

• Karena ini adalah kode-golf , Anda harus melakukan ini dalam hitungan byte sesingkat mungkin. Dibangun secara bawaan.
• Output apa pun yang dapat mewakili dan daftar koefisien dapat diterima: array, serangkaian koefisien dengan pemisah, dll ...
• Berlaku celah golf standar.
• Program Anda harus bekerja untuk nilai-nilai dalam ukuran integer standar bahasa Anda.

Uji Kasus

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 byte

¤é r0J

Cobalah online!

Penjelasan:

¤é 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 byte

|R_1.>jQ2 1

Coba di sini!

Bagaimana?

| R_1.> JQ2 1 Program lengkap.

      jQ2 Mengonversi input ke daftar biner.
     .> 1 Putar secara siklus daftar di atas dengan 1 tempat ke kanan.
| R_1 Pengganti 0 dengan -1.
               Keluaran tersirat.

Pertama, kita perhatikan bahwa tugasnya hanyalah "mengganti 0huruf s dalam biner dengan huruf -1s dan bergeser ke kanan dengan 1 tempat." - Itulah tepatnya yang harus kita lakukan! Konversi biner memberi kita daftar 0s dan 1s. Semua harus kita lakukan di sini adalah untuk menemukan cara Golfy untuk mengkonversi 0ke -1. Operator bitwise |(bitwise OR) adalah teman kami. Peta di atas representasi biner bergeser dengan |dan -1. Jika nomor saat ini 0, itu akan dikonversi ke -1.

Perl 6

Versi string, 31 byte

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

Cobalah online!

Versi daftar, 36 byte

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

Cobalah online!

JavaScript (ES6), 35 34 byte

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

Cuplikan tes

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 byte

Pasti ada cara yang lebih baik, tetapi inilah yang saya miliki ...

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

Cobalah online!

Penjelasan : Ini adalah fungsi yang membutuhkan satu argumen ( ->$a). Kami pertama-tama mendapatkan jumlah koefisien yang dibutuhkan ( $a.base(2).chars= jumlah karakter dalam representasi basis 2), kemudian membuat produk Cartesian ( X) dari banyak pasangan itu (1,-1). ( [X]Berarti: kurangi daftar berikut dengan X.) Jadi, kami mendapatkan daftar semua kemungkinan kombinasi 1s dan -1s. Kemudian kami memfilter ( grep) hanya daftar yang menyandikan nomor yang diberikan $a. Hanya ada satu, jadi kami mendapatkan daftar satu daftar dengan koefisien.

Blok grep melakukan ini: mengambil argumennya sebagai daftar ( @^a), membalikkannya dan menutupnya dengan daftar tanpa batas 0,1,2,...menggunakan operator "shift bit kiri" +<. Zipping berhenti segera setelah daftar pendek habis (baik untuk kita!) Kami kemudian menjumlahkan semua hasil dan membandingkannya dengan nomor yang diberikan. Kami harus menggunakan .reversekarena OP menuntut agar koefisien berada dalam urutan dari yang paling signifikan hingga yang tidak signifikan.

Jelly , 5 byte

Bṙ-o-

Cobalah online!

05AB1E , 6 5 byte

bÁ0®:

Cobalah online!

J, 11 byte

1-~2*_1|.#:

Cobalah online!

Terima kasih kepada @JosiahWinslow untuk algoritmenya.

Adakah pemikiran untuk mempersingkat konversi? Pikiranku adalah menggunakan !.-fit (nvm, itu hanya mengubah toleransi konversi).

Menggunakan {-membawa lebih lama dengan 1 karakter.

_1 1{~_1|.#:

Java 8, 101 byte

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

Port dari @Oliver 's Japt answer , dengan beberapa byte lagi ..;)

Pasti bisa bermain golf dengan menggunakan pendekatan matematika, bukan pendekatan String ini.

Penjelasan:

Coba di sini.

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 byte

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

Cobalah online!

Menerapkan algoritma Oliver , tetapi mengembalikan digit dalam urutan terbalik. Karena kami dijamin ntidak pernah genap, bit yang paling tidak signifikan (pertama) selalu 1, jadi kami menghapusnya dan menambahkan 1sampai akhir untuk mensimulasikan rotasi dalam R. Terima kasih kepada Shaggy karena membuat saya memperbaiki matematika saya .

Cukup dengan menempatkan rev( )fungsi panggilan di footer harus mengembalikan nilai dalam urutan yang sama.

jawaban asli, 88 byte:

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

Fungsi anonim; mengembalikan nilai dalam urutan terbalik dengan nama kolom terlampir.

Cobalah online!

Penjelasan:

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 byte

Kode 29 byte, 1 byte untuk -pswitch.

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

Cobalah online!

CJam, 12 byte

Port jawaban Golfscript saya.

qi2b{_+(}%)\

Ruby , 44 37 33 32 byte

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

Cobalah online!

Golfscript, 14 13 14 byte

-1 byte karena saya lupa %ada. +1 byte karena saya juga lupa input adalah string.

~2base{.+(}%)\