Konverter biner ke desimal

Sejauh yang saya lihat, kami tidak memiliki tantangan konversi biner sederhana ke desimal.

Tulis program atau fungsi yang mengambil bilangan bulat biner positif dan mengeluarkan nilai desimalnya.

Anda tidak diperbolehkan menggunakan fungsi konversi basis bawaan apa pun. Fungsi integer-ke-desimal (mis., Fungsi yang berubah 101010menjadi [1, 0, 1, 0, 1, 0]atau "101010") dikecualikan dari aturan ini dan karenanya diizinkan.

Aturan:

• Kode harus mendukung angka biner hingga nilai numerik tertinggi yang didukung bahasa Anda (secara default)
• Anda dapat memilih untuk memiliki nol di depan dalam representasi biner
• Output desimal mungkin tidak memiliki nol di depan.
• Format input dan output adalah opsional, tetapi tidak ada pemisah antara digit. (1,0,1,0,1,0,1,0)bukan format input yang valid, tetapi keduanya 10101010dan (["10101010"])sedang.
  • Anda harus mengambil input ke arah "normal". 1110adalah 14tidak 7.

Kasus uji:

1
1

10
2

101010
42

1101111111010101100101110111001110001000110100110011100000111
2016120520371234567

Tantangan ini terkait dengan beberapa tantangan lain, misalnya ini , ini dan ini .

Jelly , 5 byte

DḤ+¥/

Cobalah online!

Penjelasan

Pemeran

• Dadalah monad (fungsi argumen tunggal): digit, berubah 1234menjadi [1, 2, 3, 4].

• Ḥ adalah monad yang menggandakan argumen tunggal.

• + adalah angka dua (fungsi dua argumen) yang menambahkan argumen kiri dan kanannya.

Dari sana, itu menjadi sedikit rumit.

Inilah yang terjadi pada waktu parse

• D,, Ḥdan +dibaca. Rantai itu terlihat seperti [D, Ḥ, +].

• Dua karakter berikutnya adalah quicks , yang bertindak seperti operator postfix parse-time pada tautan (fungsi) yang telah kita baca sejauh ini.

• Ketika ¥dibaca, dua tautan terakhir akan muncul dan diganti oleh tautan yang bertindak seperti angka dua yang dibentuk dengan menyusunnya. Jadi sekarang rantai itu seperti [D, dyad(Ḥ+)].

• Ketika /dibaca, tautan terakhir (yang seharusnya menjadi angka dua) akan muncul dan digantikan oleh monad yang melipat menggunakan angka dua ini (secara intuitif: f/mengambil daftar, mengganti koma di dalamnya dengan f, dan mengevaluasi hasilnya.)

• Rantai terakhir terlihat seperti [D, fold(dyad(Ḥ+))], dua monad.

Inilah yang terjadi pada saat run time

• Input (angka) secara implisit membaca ke dalam nilai kerja (katakanlah, 101010).

• Ddieksekusi, mengganti nilai kerja dengan digitnya ( [1,0,1,0,1,0]).

• fold(dyad(Ḥ+))dieksekusi, menggantikan nilai kerja dengan 1∗0∗1∗0∗1∗0, di mana ∗angka dua itu Ḥ+.

Jadi apa yang x∗ydievaluasi?

• Dalam definisi diadik, nilai kerja pada awalnya adalah argumen kirix ,.

• Ḥ, Yang ganda monad, ganda nilai ini. Nilai kerja sekarang 2x.

• +, ditambah angka dua, tidak memiliki argumen yang benar, jadi ini adalah sebuah kait : pola sintaksis khusus di mana argumen yang tepat dari angka dua ini akan disuntikkan ke +. Ini menghasilkan 2x + ysebagai nilai kerja akhir, yang dikembalikan.

Jadi seluruh ekspresi dievaluasi menjadi:

1∗0∗1∗0∗1∗0 = 2×(2×(2×(2×(2×1+0)+1)+0)+1)+0
            = 32×1 + 16×0 + 8×1 + 4×0 + 2×1 + 1×0
            = 42

Python 2, 49 37 31 30 Bytes

Sekarang ini akan mengambil angka biner dalam representasi desimal, karena Python dapat menangani bilangan bulat besar yang sewenang-wenang.

b=lambda n:n and n%2+2*b(n/10)

^{terima kasih kepada xnor untuk menyimpan byte :)}

Cara termudah untuk melihat bagaimana ini bekerja adalah dengan melihat rumus dasar untuk mengubah biner menjadi desimal:

= 101010 
= 1*(2^5) + 0*(2^4) + 1*(2^3) + 0*(2^2) + 1*(2^1) + 0*(2^0)
= 1*32 + 0*16 + 1*8 + 0*4 + 1*2 + 0*1
= 42

Ini adalah cara konversi yang 'standar'. Anda dapat memperluas baris ketiga seperti:

= ((((1*2 + 0)*2 + 1)*2 + 0)*2 + 1)*2 + 0

Dan pada dasarnya inilah yang dilakukan metode rekursif yang saya lakukan.

Solusi alternatif yang saya miliki:

b=lambda n:n and n%10+2*b(n/10)
b=lambda n:n%10+2*(n and b(n/10))
b=lambda n:0if n<1else n%10+2*b(n/10)
b=lambda n:0**(n/10)or n%10+2*b(n/10)
b=lambda n,o=0:o*(n<'0')or b(n[1:],2*o+int(n[0]))
lambda j:sum(int(b)*2**a for a,b in enumerate(j,1))

05AB1E , 6 byte

Kode:

$¦v·y+

Untuk penjelasannya, mari kita ambil contoh 101010 . Kita mulai dengan angka 1 (yang diwakili oleh digit pertama). Setelah itu, kami memiliki dua kasus:

• Jika digit adalah 0 , kalikan angkanya dengan 2.
• Jika digit adalah 1 , kalikan angkanya dengan 2 dan tambahkan 1.

Jadi untuk kasus 101010 , berikut ini dihitung:

• 1 01010, mulai dengan angka 1 .
• 1 0 1010, kalikan dengan dua, menghasilkan 2 .
• 10 1 010, kalikan dua dan tambahkan satu, menghasilkan 5 .
• 101 0 10, kalikan dengan dua, menghasilkan 10 .
• 1010 1 0, kalikan dengan dua dan tambahkan satu, menghasilkan 21 .
• 10101 0 , kalikan dua, menghasilkan 42 , yang merupakan hasil yang diinginkan.

Penjelasan kode:

$         # Push 1 and input
 ¦        # Remove the first character
  v       # For each character (starting with the first)
   ·      #   Multiply the carry number by two
    y+    #   Add the current character (converted automatically to a number)

Menggunakan pengkodean CP-1252 . Cobalah online!

Haskell, 16 111 + 57 = 168 byte

import Data.String
instance IsString[Int]where fromString=map((-48+).fromEnum)
f::[Int]->Int
f=foldl1((+).(2*))

+57 byte untuk flag kompilasi -XOverloadedStrings, -XOverlappingInstancesdan -XFlexibleInstances.

Tantangannya memiliki beberapa format IO yang rumit , karena sangat tergantung pada bagaimana tipe data diekspresikan dalam kode sumber. Versi pertama saya (16 byte), yaitu

foldl1((+).(2*))

mengambil daftar bilangan bulat, misalnya [1,0,1,0,1,0]dan dinyatakan tidak valid karena daftar Haskell literal terjadi di ,antara elemen-elemen. Daftar per se tidak dilarang. Dalam versi baru saya, saya menggunakan fungsi yang sama, sekarang dinamai f, tetapi saya membebani "Kutipan urutan karakter terlampir". Fungsi masih mengambil daftar bilangan bulat seperti yang Anda lihat dalam anotasi jenis [Int] -> Int, tetapi daftar dengan bilangan bulat tunggal sekarang dapat ditulis seperti "1234", misalnya

f "101010"

yang dievaluasi menjadi 42. Sial, Haskell, karena format daftar asli tidak sesuai dengan aturan tantangan. Btw, f [1,0,1,0,1,0]masih berfungsi.

Retina, 15 byte

Mengubah dari biner ke unary, lalu unary ke desimal.

1
01
+`10
011
1

Cobalah online

PHP, 44 byte

for(;""<$c=$argv[1][$i++];)$n+=$n+$c;echo$n;

Saya bersumpah bahwa saya pernah melihat pertanyaan itu sebelumnya. Tapi baiklah.

Membaca angka dari kiri ke kanan, bergeser ke kiri dan menambahkan bit saat ini.

JavaScript (ES6), 33 31 byte

s=>[...s].map(c=>r+=+c+r,r=0)|r

Sunting: Lebih pendek tapi kurang manis: 2 byte disimpan berkat @ETHproduksi.

Labirin , 17 15 byte

-+:
8 +
4_,`)/!

Cobalah online!

Labyrinth adalah bahasa dua dimensi, berbasis stack. Di labirin, eksekusi kode mengikuti jalur kode seperti labirin dengan spasi yang bertindak sebagai dinding dan dimulai dengan karakter non-spasi paling kiri. Alur kode ditentukan oleh tanda bagian atas tumpukan. Karena tumpukan memiliki nol tersirat di bagian bawah, empat instruksi pertama ( -+:+) tidak berpengaruh.

Loop dimulai pada ,

• , Dorong nilai kode ascii dari karakter input berikutnya ke stop stack, atau tekan -1 jika EOF.
• _48 mendorong 48 ke atas tumpukan
• -Pop y, pop x, push x-y. Instruksi sebelumnya memiliki efek mengurangi 48 dari input yang menghasilkan 0 untuk "0" dan 1 untuk "1".
• +Pop y, pop x, push x+y.
• : Gandakan bagian atas tumpukan
• + Instruksi ini dan sebelumnya memiliki efek mengalikan nilai saat ini dengan 2

Jadi bagian melingkar dari kode, pada dasarnya, mengalikan angka saat ini dengan 2 dan menambahkan angka 1 atau 0 tergantung pada apakah karakter 1 atau 0 dimasukkan.

Ekor

Jika bagian atas tumpukan negatif (artinya EOF ditemukan), kode akan belok kiri di persimpangan (menuju tanda titik koma).

• `` `Negasikan bagian atas tumpukan untuk mendapatkan 1
• ) Tambahkan bagian atas tumpukan untuk mendapatkan 2
• /Pop y, pop x, push x / y (pembagian integer). Ini memiliki efek membatalkan yang terakhir *2dari loop.
• !Keluarkan representasi integer dari bagian atas tumpukan. Pada titik ini program berbalik karena menemui jalan buntu dan kemudian keluar dengan kesalahan karena mencoba untuk membaginya dengan nol.

Terima kasih kepada @Martin Ender karena telah menyelamatkan saya 2 byte (dan mengajari saya cara berpikir yang lebih baik di Labyrinth).

Brain-Flak , 46 , 28 byte

([]){{}({}<>({}){})<>([])}<>

Cobalah online!

Banyak byte yang disimpan berkat @Riley!

Karena brain-flak tidak dapat mengambil input biner, input adalah daftar '0 dan' 1.

Penjelasan:

#Push the height of the stack
([])

#While true:
{

 #Pop the height of the stack
 {}

 #Push this top number to (the other stack * 2)
 ({}<>({}){})

 #Toggle back on to the main stack
 <>

 #Push the new height of the stack
 ([])

#endwhile
}

#Toggle back to the other stack, implicitly display.
<>

Java, 84 79 46 48 byte

• Versi 3.1

Diubah menjadi long/ 48 byte:

s->{long x=0;for(char c:s)x=c-48l+x*2;return x;}

• Versi 3.0

Melakukan beberapa golf / 46 byte:

s->{int x=0;for(char c:s)x=c-48+x*2;return x;}

• Versi 2.0

Terima kasih kepada @Geobits! / 79 byte:

s->{int i=Math.pow(2,s.length-1),j=0;for(char c:s){j+=c>48?i:0;i/=2;}return j;}

• Versi 1.0

84 byte:

s->{for(int i=-1,j=0;++i<s.length;)if(s[i]>48)j+=Math.pow(2,s.length-i+1);return j;}

Befunge-98, 12 byte

2j@.~2%\2*+

Cobalah online!

Membaca satu karakter sekaligus dari input, mengubahnya menjadi 0 atau 1 dengan mengambil nilainya modulo 2 (0 adalah karakter (48), 1 adalah karakter (49)), kemudian menggunakan algoritma biasa menggandakan nilai saat ini dan menambahkan digit baru setiap kali.

Bonus: Ini berfungsi dengan segala jenis string input, saya sudah mencoba beberapa saat sekarang untuk menemukan kombinasi input-> output yang lucu, tetapi saya tidak dapat menghasilkan apa-apa (sayangnya, "jawaban" = 46). Bisakah kamu?

Javascript (ES7) 41 40 36 byte

f=([c,...b])=>c?c*2**b.length+f(b):0

mengambil string sebagai input

Mencukur satu byte berkat produk ETH

f=([c,...b])=>c?c*2**b.length+f(b):0
document.write([
    f('101010'),
    f('11010'),
    f('10111111110'),
    f('1011110010110'),
].join("<br>"))

C # 6, 85 37 36 byte

long b(long n)=>n>0?n%2+2*b(n/10):0;

• Terima kasih kepada Kade karena telah menghemat 41 byte!
• Mengubah ke C # 6 menyimpan 7 byte lagi.

05AB1E , 7 byte

RvNoy*O

Cobalah online!

Penjelasan

R         # reverse input
 v     O  # sum of
  No      # 2^index
     *    # times
    y     # digit

C, 53

v(char*s){int v=0,c;while(c=*s++)v+=v+c-48;return v;}

Sama seperti jawaban javascript saya

Ide Tes

Perl, 25 byte

-3 byte terima kasih kepada @Dom Hastings.

24 byte kode + 1 byte untuk -pflag.

$\|=$&<<$v++while s/.$//

Untuk menjalankannya:

perl -pe '$\|=$&<<$v++while s/.$//' <<< 101010

Penjelasan:

$\|=$&<<$v++  # Note that: we use $\ to store the result
              # at first $v=0, and each time it's incremented by one
              # $& contains the current bit (matched with the regex, see bellow)
              # So this operation sets a $v-th bit of $\ to the value of the $v-th bit of the input
while         # keep doing this while...
s/.$//        #  ... there is a character at the end of the string, which we remove.
         # $\ is implicitly printed thanks to -p flag

Pushy , 10 byte

Mengambil input sebagai daftar 0/1 pada baris perintah: $ pushy binary.pshy 1,0,1,0,1,0.

L:vK2*;OS#

Algoritma benar-benar menunjukkan keindahan memiliki tumpukan kedua:

            \ Implicit: Input on stack
L:    ;     \ len(input) times do:
  v         \   Push last number to auxiliary stack
   K2*      \   Double all items
       OS#  \ Output sum of auxiliary stack

Metode ini berfungsi karena tumpukan akan digandakan stack length - nkali sebelum mencapai angka n, yang kemudian dibuang ke tumpukan kedua untuk nanti. Beginilah prosesnya untuk input 101010:

1: [1,0,1,0,1,0]
2: []

1: [2,0,2,0,2]
2: [0]

1: [4,0,4,0]
2: [2]

1: [8,0,8]
2: [2,0]

1: [16,0]
2: [2,0,8]

1: [32]
2: [2,0,8,0]

1: []
2: [2,0,8,0,32]

2 + 8 + 32 -> 42

Matlab, 30 Bytes

@(x)sum(2.^find(flip(x)-48)/2)

Kasing uji terakhir memiliki kesalahan pembulatan (karena double), jadi jika Anda membutuhkan presisi penuh:

@(x)sum(2.^uint64(find(flip(x)-48))/2,'native')

dengan 47 Bytes.

Retina , 12 byte

Hitungan byte mengasumsikan penyandian ISO 8859-1.

+%`\B
¶$`:
1

Cobalah online!

Solusi alternatif:

+1`\B
:$`:
1

Penjelasan

Ini mungkin akan lebih mudah dijelaskan berdasarkan versi saya yang lama, kurang golf, dan kemudian menunjukkan bagaimana saya mempersingkatnya. Saya dulu mengonversi biner menjadi desimal seperti ini:

^
,
+`,(.)
$`$1,
1

Satu-satunya cara yang masuk akal untuk membangun angka desimal di Retina adalah dengan menghitung banyak hal (karena Retina memiliki beberapa fitur yang memungkinkannya mencetak angka desimal yang mewakili jumlah). Jadi sebenarnya satu-satunya pendekatan yang mungkin adalah mengubah biner menjadi unary, dan kemudian menghitung jumlah digit unary. Baris terakhir menghitung, jadi yang pertama mengkonversi biner ke unary.

Bagaimana kita melakukannya? Secara umum, untuk mengkonversi dari daftar bit ke integer, kami menginisialisasi hasilnya 0dan kemudian pergi melalui bit dari yang paling signifikan, menggandakan nilai yang sudah kami miliki dan menambahkan bit saat ini. Misalnya, jika angka binernya adalah 1011, kami akan menghitung:

(((0 * 2 + 1) * 2 + 0) * 2 + 1) * 2 + 1 = 11
           ^        ^        ^        ^

Di mana saya telah menandai bit individu untuk kejelasan.

Trik untuk melakukan ini di unary adalah a) bahwa menggandakan berarti mengulangi angka dan b) karena kita menghitung 1s pada akhirnya, kita bahkan tidak perlu membedakan antara 0s dan 1s dalam proses. Ini akan menjadi lebih jelas dalam sedetik.

Apa yang dilakukan oleh program adalah bahwa ia pertama kali menambahkan koma ke awal sebagai penanda untuk berapa banyak input yang sudah kami proses:

^
,

Di sebelah kiri marker, kita akan memiliki nilai yang kita akumulasikan (yang diinisialisasi dengan benar ke representasi nol unary), dan kanan nilai akan menjadi bit berikutnya untuk diproses. Sekarang kami menerapkan substitusi berikut dalam satu lingkaran:

,(.)
$`$1,

Hanya dengan melihat ,(.)dan $1,, ini menggerakkan marker sedikit ke kanan setiap kali. Tapi kami juga menyisipkan $`, yang merupakan segalanya di depan marker, yaitu nilai saat ini, yang kami gandakan. Berikut adalah langkah-langkah individual saat memproses input 1011, di mana saya telah menandai hasil dari menyisipkan di $`atas setiap baris (kosong untuk langkah pertama):

,1011

1,011
 _
110,11
   ___
1101101,1
       _______
110110111011011,

Anda akan melihat bahwa kami telah mempertahankan dan menggandakan nol bersama dengan yang lainnya, tetapi karena kami mengabaikannya pada akhirnya, tidak masalah seberapa sering kami menggandakannya, selama jumlah 1s adalah benar. Jika Anda menghitungnya, ada beberapa 11, hanya yang kita butuhkan.

Sehingga menyisakan pertanyaan bagaimana cara memainkan golf ini hingga 12 byte. Bagian termahal dari versi 18-byte adalah harus menggunakan marker. Tujuannya adalah untuk menyingkirkan itu. Kami benar-benar ingin menggandakan awalan setiap bit, jadi ide pertama mungkin ini:

.
$`$&

Masalahnya adalah bahwa pergantian ini terjadi secara bersamaan, jadi bit pertama tidak menjadi dua kali lipat untuk setiap bit, tetapi hanya akan disalin sekali setiap kali. Untuk input yang 1011akan kami dapatkan (menandai yang dimasukkan $`):

 _ __ ___
1101011011

Kita masih perlu memproses input secara rekursif sehingga awalan pertama yang digandakan digandakan lagi oleh yang kedua dan seterusnya. Satu ide adalah menyisipkan spidol di mana-mana dan berulang kali menggantinya dengan awalan:

\B
,
+%`,
¶$`

Setelah mengganti setiap penanda dengan awalan untuk pertama kalinya, kita perlu mengingat di mana awal input itu, jadi kami juga memasukkan umpan baris dan menggunakan %opsi untuk memastikan bahwa berikutnya $`hanya mengambil hal-hal yang sesuai dengan umpan baris terdekat.

Ini berfungsi, tetapi masih terlalu lama (16 byte saat menghitung 1s di akhir). Bagaimana kalau kita membalikkan keadaan? Tempat-tempat di mana kita ingin menyisipkan marker diidentifikasi oleh \B(posisi di antara dua digit). Mengapa kita tidak memasukkan saja awalan ke posisi itu? Ini hampir berhasil, tetapi perbedaannya adalah bahwa dalam solusi sebelumnya, kami benar-benar menghapus satu penanda di setiap substitusi, dan itu penting untuk membuat proses berakhir. Namun, \Bbukan karakter tetapi hanya posisi, jadi tidak ada yang dihapus. Namun kita dapat menghentikannya\Bdari mencocokkan dengan memasukkan karakter non-digit ke tempat ini. Itu mengubah batas non-kata menjadi batas kata, yang setara dengan menghapus karakter penanda sebelumnya. Dan itulah yang dilakukan solusi 12-byte:

+%`\B
¶$`:

Hanya untuk kelengkapan, berikut adalah langkah-langkah pemrosesan 1011, dengan baris kosong setelah setiap langkah:

1
1:0
10:1
101:1

1
1:0
1
1:0:1
1
1:0
10:1:1

1
1:0
1
1:0:1
1
1:0
1
1:0:1:1

Sekali lagi, Anda akan menemukan bahwa hasil terakhir mengandung tepat 11 1detik.

Sebagai latihan untuk pembaca, dapatkah Anda melihat bagaimana ini secara umum dengan mudah ke pangkalan lain (untuk beberapa byte tambahan per kenaikan di pangkalan)?

T-SQL, 202 Bytes

DECLARE @b varchar(max)='1',@ int=1 declare @l int=LEN(@b)declare @o bigint=CAST(SUBSTRING(@b,@l,1)AS bigint)WHILE @<@l BEGIN SET @o=@o+POWER(CAST(SUBSTRING(@b,@l-@,1)*2AS bigint),@)SET @=@+1 END PRINT @o

PHP, 64 byte

foreach(str_split(strrev($argv[1]))as$k=>$v)$t+=$v*2**$k;echo$t;

Kami membalikkan angka biner kami, membaginya menjadi digit komponennya, dan menjumlahkannya berdasarkan posisi.

Utilitas Bash + GNU, 29 byte

sed 's/./2*&+/g;s/.*/K&p/'|dc

I / O via stdin / stdout.

The sedekspresi membagi up biner ke setiap digit dan membangun ekspresi RPN untuk dcmengevaluasi.

PowerShell v2 +, 55 byte

param($n)$j=1;$n[$n.length..0]|%{$i+=+"$_"*$j;$j*=2};$i

Terasa terlalu lama ... Sepertinya tidak bisa mengurangi golf - tips dihargai.

Penjelasan

param($n)$j=1;$n[$n.length..0]|%{$i+=+"$_"*$j;$j*=2};$i
param($n)$j=1;                                          # Take input $n as string, set $j=1
              $n[$n.length..0]                          # Reverses, also converts to char-array
                              |%{                  };   # Loop over that array
                                 $i+=+"$_"*$j;          # Increment by current value of $j times current digit
                                              $j*=2     # Increase $j for next loop iteration
                                                     $i # Leave $i on pipeline
                                                        # Implicit output

JavaScript (ES6), 32 byte

f=([...n])=>n+n&&+n.pop()+2*f(n)

Rekursi menghemat hari lagi! Meskipun parameterisasi tampaknya agak panjang ...

Mathematica, 27 13 11 byte

Fold[#+##&]

Menerima Listbit sebagai input (mis. {1, 0, 1, 1, 0}- Representasi biner dari angka dari Mathematica22 )

Clojure, 114 105 63 41 byte

V4: 41 byte

-22 byte berkat @cliffroot. Karena digitkarakter, dapat dikonversikan ke kode melalui int, kemudian memiliki 48 dikurangi dari itu untuk mendapatkan angka aktual. Peta juga diperhitungkan. Saya tidak tahu mengapa itu perlu.

#(reduce(fn[a d](+(* a 2)(-(int d)48)))%)

V3: 63 byte

(fn[s](reduce #(+(* %1 2)%2)(map #(Integer/parseInt(str %))s)))

-42 byte (!) Dengan mengintip jawaban lain. "Ritsleting" saya ternyata sangat naif. Alih-alih menaikkan 2 ke kekuatan tempat saat ini, lalu mengalikannya dengan digit saat ini dan menambahkan hasilnya ke akumulator, itu hanya mengalikan akumulator dengan 2, menambahkan pada digit saat ini, kemudian menambahkannya ke akumulator. Juga mengonversi fungsi pengurang menjadi makro untuk mengurangi sedikit.

Terima kasih kepada @nimi, dan @Adnan!

Tidak Disatukan:

(defn to-dec [binary-str]
  (reduce (fn [acc digit]
            (+ (* acc 2) digit))
          (map #(Integer/parseInt (str %)) binary-str)))

V2: 105 byte

#(reduce(fn[a[p d]](+ a(*(Integer/parseInt(str d))(long(Math/pow 2 p)))))0(map vector(range)(reverse %)))

-9 byte dengan membalikkan string jadi saya tidak perlu membuat rentang turun yang canggung.

V1: 114 byte

Yah, aku tentu saja tidak menang! Dalam pembelaan saya, ini adalah program pertama yang pernah saya tulis yang mengkonversi antara pangkalan, jadi saya harus belajar bagaimana melakukannya. Itu juga tidak membantu yang Math/powmengembalikan dua kali lipat yang memerlukan konversi dari, dan Integer/parseInttidak menerima karakter, sehingga digit harus dibungkus sebelum lewat.

#(reduce(fn[a[p d]](+ a(*(Integer/parseInt(str d))(long(Math/pow 2 p)))))0(map vector(range(dec(count %))-1 -1)%))

Ritsleting string dengan indeks turun yang mewakili nomor tempat. Mengurangi daftar yang dihasilkan.

Tidak Disatukan:

(defn to-dec [binary-str]
  (reduce (fn [acc [place digit]]
            (let [parsed-digit (Integer/parseInt (str digit))
                  place-value (long (Math/pow 2 place))]
              (+ acc (* parsed-digit place-value))))
          0
          (map vector (range (dec (count binary-str)) -1 -1) binary-str)))

Perl, 21 19 16 + 4 = 20 byte

-4 byte terima kasih kepada @Dada

Jalankan dengan -F -p(termasuk ruang ekstra setelah F). Nilai pipa ke fungsi menggunakanecho -n

$\+=$_+$\for@F}{

Jalankan sebagai echo -n "101010" | perl -F -pE '$\+=$_+$\for@F}{'

Saya merasa ini cukup berbeda dari jawaban @ Dada yang pantas masuknya sendiri.

Penjelasan:

-F                              #Splits the input character by character into the @F array
-p                              #Wraps the entire program in while(<>){ ... print} turning it into
while(<>){$\+=$_+$\for@F}{print}
                   for@F        #Loops through the @F array in order ($_ as alias), and...
          $\+=$_+$\             #...doubles $\, and then adds $_ to it (0 or 1)...
while(<>){              }       #...as long as there is input.
                         {print}#Prints the contents of $_ (empty outside of its scope), followed by the output record separator $\

Ini menggunakan algoritme pilihan pribadi saya untuk konversi biner ke desimal. Diberi nomor biner, mulai akumulator Anda pada 0, dan lalui bitnya satu per satu. Gandakan akumulator setiap bit, lalu tambahkan bit itu sendiri ke akumulator Anda, dan Anda berakhir dengan nilai desimal. Ini bekerja karena setiap bit akhirnya menjadi dua kali lipat jumlah yang tepat untuk posisinya berdasarkan berapa banyak bit yang tersisa di angka biner asli.

R (32-bit), 64 Bytes

Input untuk fungsi harus diberikan sebagai karakter. Fungsi dasar R mendukung bilangan bulat 32-bit.

Memasukkan:

# 32-bit version (base)
f=function(x)sum(as.double(el(strsplit(x,"")))*2^(nchar(x):1-1))
f("1")
f("10")
f("101010")
f("1101111111010101100101110111001110001000110100110011100000111")

Keluaran:

> f("1")
[1] 1
> f("10")
[1] 2
> f("101010")
[1] 42
> f("1101111111010101100101110111001110001000110100110011100000111")
[1] 2.016121e+18

R (64-bit), 74 Bytes

Input untuk fungsi harus diberikan sebagai karakter. Paket bit64harus digunakan untuk integer 64-bit.

Memasukkan:

# 64-bit version (bit64)
g=function(x)sum(bit64::as.integer64(el(strsplit(x,"")))*2^(nchar(x):1-1))
g("1")
g("10")
g("101010")
g("1101111111010101100101110111001110001000110100110011100000111")

Keluaran:

> g("1")
integer64
[1] 1
> g("10")
integer64
[1] 2
> g("101010")
integer64
[1] 42
> g("1101111111010101100101110111001110001000110100110011100000111")
integer64
[1] 2016120520371234567

Dyalog APL , 12 byte

(++⊢)/⌽⍎¨⍞

⍞ dapatkan input string

⍎¨ konversi setiap karakter ke angka

⌽ membalikkan

(... )/masukkan fungsi berikut di antara angka-angka

 ++⊢ jumlah argumen ditambah argumen yang benar

ngn mencukur 2 byte.

k, 8 byte

Metode yang sama dengan jawaban Haskell di atas.

{y+2*x}/

Contoh:

{y+2*x}/1101111111010101100101110111001110001000110100110011100000111b
2016120520371234567