Convertitore binario a decimale

Per quanto posso vedere, non abbiamo una semplice sfida di conversione da binaria a decimale.

Scrivi un programma o una funzione che accetta un numero intero binario positivo e genera il suo valore decimale.

Non è consentito utilizzare alcuna funzione di conversione di base integrata. Le funzioni da intero a decimale (ad es. Una funzione che si trasforma 101010in [1, 0, 1, 0, 1, 0]o "101010") sono esenti da questa regola e quindi consentite.

Regole:

• Il codice deve supportare i numeri binari fino al valore numerico più alto supportato dalla tua lingua (per impostazione predefinita)
• Puoi scegliere di avere zeri iniziali nella rappresentazione binaria
• L'output decimale potrebbe non avere zeri iniziali.
• I formati di input e output sono opzionali, ma non possono esserci separatori tra le cifre. (1,0,1,0,1,0,1,0)non è un formato di input valido, ma entrambi 10101010e lo (["10101010"])sono.
  • Devi prendere l'input nella direzione "normale". non lo 1110è .147

Casi test:

1
1

10
2

101010
42

1101111111010101100101110111001110001000110100110011100000111
2016120520371234567

Questa sfida è collegata ad alcune altre sfide, ad esempio questo , questo e questo .

Gelatina , 5 byte

DḤ+¥/

Provalo online!

Spiegazione

Il cast

• Dè una monade (funzione argomento singolo): cifre, che si trasformano 1234in [1, 2, 3, 4].

• Ḥ è una monade che raddoppia il suo unico argomento.

• + è una diade (funzione a due argomenti) che aggiunge i suoi argomenti sinistro e destro.

Da lì, diventa un po 'complicato.

Ecco cosa succede al momento dell'analisi

• D, Ḥe +vengono letti. La catena sembra [D, Ḥ, +].

• I prossimi due caratteri sono rapidi , che agiscono come operatori postfix di parse-time sui collegamenti (funzioni) che abbiamo letto finora.

• Quando ¥viene letto, gli ultimi due collegamenti vengono visualizzati e sostituiti da un collegamento che agisce come la diade formata componendoli. Quindi ora la catena sembra [D, dyad(Ḥ+)].

• Quando /viene letto, l'ultimo collegamento (che dovrebbe essere una diade) viene visualizzato e sostituito da una monade che si piega usando questa diade (intuitivamente: f/prende un elenco, sostituisce le virgole in esso con fe valuta il risultato).

• Sembra la catena finale [D, fold(dyad(Ḥ+))], due monadi.

Ecco cosa succede in fase di esecuzione

• L'input (un numero) viene letto implicitamente nel valore di lavoro (diciamo, 101010).

• Dviene eseguito, sostituendo il valore di lavoro con le sue cifre ( [1,0,1,0,1,0]).

• fold(dyad(Ḥ+))viene eseguito, sostituendo il valore di lavoro con 1∗0∗1∗0∗1∗0, dove si ∗trova la diade Ḥ+.

Quindi cosa x∗yvaluta?

• In una definizione diadica, il valore di lavoro è inizialmente a sinistra argomento x.

• Ḥ, il doppio monade, raddoppia questo valore. Il valore di lavoro è ora 2x.

• +, Il più diade, manca un argomento di destra, quindi questo è un gancio : un modello speciale sintattica dove il diritto argomento di questa diade viene iniettato+ . Questo produce 2x + yil valore operativo finale, che viene restituito.

Quindi l'intera espressione valuta:

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 byte

Ora questo richiederà un numero binario in una rappresentazione decimale, poiché Python può gestire numeri interi arbitrariamente grandi.

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

^{grazie a xnor per aver salvato un byte :)}

Il modo più semplice per vedere come funziona è vedere una formula di base per convertire i binari in decimali:

= 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

Questo è un modo "standard" di conversione. Puoi espandere la terza riga in questo modo:

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

E questo è essenzialmente ciò che sta facendo il metodo ricorsivo che ho fatto.

Soluzioni alternative che ho avuto:

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

Codice:

$¦v·y+

Per la spiegazione, prendiamo l'esempio 101010 . Iniziamo con il numero 1 (che è rappresentato dalla prima cifra). Successivamente, abbiamo due casi:

• Se la cifra è 0 , moltiplicare il numero per 2.
• Se la cifra è a 1 , moltiplica il numero per 2 e aggiungi 1.

Quindi per il caso 101010 , viene calcolato quanto segue:

• 1 01010, inizia con il numero 1 .
• 1 0 1010, moltiplicare per due, risultando in 2 .
• 10 1 010, moltiplicalo per due e aggiungi uno, risultando in 5 .
• 101 0 10, moltiplicare per due, risultando in 10 .
• 1010 1 0, moltiplicalo per due e aggiungi uno, risultando in 21 .
• 10101 0 , moltiplicare per due, risultando in 42 , che è il risultato desiderato.

Spiegazione del codice:

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

Utilizza la codifica CP-1252 . Provalo 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 per la flag di compilazione -XOverloadedStrings, -XOverlappingInstancese-XFlexibleInstances .

La sfida ha un formato I / O ingombrante , poiché dipende fortemente dal modo in cui i tipi di dati sono espressi nel codice sorgente. La mia prima versione (16 byte), vale a dire

foldl1((+).(2*))

accetta un elenco di numeri interi, ad esempio, [1,0,1,0,1,0]ed è stato dichiarato non valido perché ,tra gli elementi sono presenti elenchi letterali di Haskell . Gli elenchi di per sé non sono vietati. Nella mia nuova versione utilizzo la stessa funzione, ora denominataf , ma sovraccarico "Cita sequenze di caratteri racchiuse". La funzione prende ancora un elenco di numeri interi come puoi vedere nell'annotazione del tipo [Int] -> Int, ma gli elenchi con numeri interi a una cifra ora possono essere scritti come "1234", ad es.

f "101010"

che valuta 42. Sfortunato Haskell, perché il formato dell'elenco nativo non si adatta alle regole della sfida. A proposito, f [1,0,1,0,1,0]funziona ancora.

Retina, 15 byte

Converte da binario a unario, quindi da unario a decimale.

1
01
+`10
011
1

Provalo online

PHP, 44 byte

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

Avrei potuto giurare di aver già visto quella domanda prima. Ma bene.

Legge il numero da sinistra a destra, sposta a sinistra e aggiunge il bit corrente.

JavaScript (ES6), 33 31 byte

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

Modifica: più breve ma meno dolce: 2 byte salvati grazie a @ETHproductions.

Labirinto , 17 15 byte

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

Provalo online!

Labyrinth è un linguaggio bidimensionale basato su stack. Nel labirinto, l'esecuzione del codice segue il percorso del codice come un labirinto con spazi che agiscono come muri e iniziano dal carattere non spaziale più in alto a sinistra. Il flusso di codice è determinato dal segno della parte superiore dello stack. Poiché lo stack ha zeri impliciti in fondo, le prime quattro istruzioni ( -+:+) non hanno alcun effetto.

Loop che inizia al ,

• , Spingere il valore del codice ASCII del carattere di input successivo fino all'arresto dello stack o premere -1 se EOF.
• _48 spinge 48 in cima alla pila
• - Pop y, pop x, push x-y . Le precedenti istruzioni hanno l'effetto di sottrarre 48 dall'input restituendo 0 per "0" e 1 per "1".
• +Pop y, pop x, push x+y.
• : Duplica la parte superiore della pila
• + Questa e l'istruzione precedente hanno l'effetto di moltiplicare il valore corrente per 2

Quindi la parte circolare del codice, in effetti, moltiplica il numero corrente per 2 e aggiunge 1 o 0 a seconda che sia stato inserito il carattere 1 o 0.

Coda

Se la parte superiore dello stack è negativa (significa che è stato trovato EOF), il codice girerà a sinistra al bivio (andando verso il punto e virgola).

• `` Annulla la parte superiore dello stack per ottenere 1
• ) Icrementa la cima dello stack per ottenere 2
• /Pop y, pop x, push x / y (divisione intera). Ciò ha l'effetto di annullare l'ultimo *2dal ciclo.
• !Emette la rappresentazione intera della parte superiore dello stack. A questo punto il programma si gira perché ha raggiunto un vicolo cieco e quindi esce con un errore perché tenta di dividere per zero.

Grazie a @Martin Ender per avermi salvato 2 byte (e insegnandomi come pensare meglio in Labyrinth).

Brain-Flak , 46 , 28 byte

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

Provalo online!

Molti byte salvati grazie a @Riley!

Poiché il brain-flak non può accettare input binari, input è un elenco di "0" e "1".

Spiegazione:

#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 bytes

• Version 3.1

Changed to long/48 bytes:

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

• Version 3.0

Did some golfing/46 bytes:

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

• Version 2.0

Thanks to @Geobits!/79 bytes:

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

• Version 1.0

84 bytes:

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 bytes

2j@.~2%\2*+

Try it online!

Reads one char at a time from input, converts it to 0 or 1 by taking its value modulo 2 (0 is char(48), 1 is char(49)), then uses the usual algorithm of doubling the current value and adding the new digit each time.

Bonus: This works with any kind of input string, I've been trying for a while now to find any funny input->output combination, but I wasn't able to produce anything (sadly, "answer"=46). Can you?

Javascript (ES7) 41 40 36 bytes

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

takes a string as input

Shaved a byte thanks to ETHproductions

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 bytes

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

• Thanks to Kade for saving 41 bytes!
• Changing to C# 6 saved another 7 bytes.

05AB1E, 7 bytes

RvNoy*O

Try it online!

Explanation

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;}

Same as my javascript answer

Test Ideone

Perl, 25 bytes

-3 bytes thanks to @Dom Hastings.

24 bytes of code + 1 byte for -p flag.

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

To run it:

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

Explanations:

$\|=$&<<$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 bytes

Takes input as a list of 0/1 on the command line: $ pushy binary.pshy 1,0,1,0,1,0.

L:vK2*;OS#

The algorithm really shows the beauty of having a second stack:

            \ 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

This method works because the stack will be doubled stack length - n times before reaching number n, which is then dumped into the second stack for later. Here's what the process looks like for 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)

The last test case has rounding errors (because of double), so if you need full precision:

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

with 47 Bytes.

Retina, 12 bytes

Byte count assumes ISO 8859-1 encoding.

+%`\B
¶$`:
1

Try it online!

Alternative solution:

+1`\B
:$`:
1

Explanation

This will probably be easier to explain based on my old, less golfed, version and then showing how I shortened it. I used to convert binary to decimal like this:

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

The only sensible way to construct a decimal number in Retina is by counting things (because Retina has a couple of features that let it print a decimal number representing an amount). So really the only possible approach is to convert the binary to unary, and then to count the number of unary digits. The last line does the counting, so the first four convert binary to unary.

How do we do that? In general, to convert from a list of bits to an integer, we initialise the result to 0 and then go through the bits from most to least significant, double the value we already have and add the current bit. E.g. if the binary number is 1011, we'd really compute:

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

Where I've marked the individual bits for clarity.

The trick to doing this in unary is a) that doubling simply means repeating the number and b) since we're counting the 1s at the end, we don't even need to distinguish between 0s and 1s in the process. This will become clearer in a second.

What the program does is that it first adds a comma to the beginning as marker for how much of the input we've already processed:

^
,

Left of the marker, we'll have the value we're accumulating (which is correctly initialised to the unary representation of zero), and right of the value will be the next bit to process. Now we apply the following substitution in a loop:

,(.)
$`$1,

Just looking at ,(.) and $1,, this moves the marker one bit to the right each time. But we also insert $`, which is everything in front of the marker, i.e. the current value, which we're doubling. Here are the individual steps when processing input 1011, where I've marked the result of inserting $` above each line (it's empty for the first step):

,1011

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

You'll see that we've retained and doubled the zero along with everything else, but since we're disregarding them at the end, it doesn't matter how often we've doubled them, as long as the number of 1s is correct. If you count them, there are 11 of them, just what we need.

So that leaves the question of how to golf this down to 12 bytes. The most expensive part of the 18-byte version is having to use the marker. The goal is to get rid of that. We really want to double the prefix of every bit, so a first idea might be this:

.
$`$&

The problem is that these substitutions happen simultaneously, so first bit doesn't get doubled for each bit, but it just gets copied once each time. For input 1011 we'd get (marking the inserted $`):

 _ __ ___
1101011011

We do still need to process the input recursively so that the doubled first prefix is doubled again by the second and so on. One idea is to insert markers everywhere and repeatedly replace them with the prefix:

\B
,
+%`,
¶$`

After replacing each marker with the prefix for the first time, we need to remember where the beginning of the input was, so we insert linefeeds as well and use the % option to make sure that the next $` only picks up things up the closest linefeed.

This does work, but it's still too long (16 bytes when counting 1s at the end). How about we turn things around? The places where we want to insert markers are identified by \B (a position between two digits). Why don't we simply insert prefixes into those positions? This almost works, but the difference is that in the previous solution, we actually removed one marker in each substitution, and that's important to make the process terminate. However, the \B aren't character but just positions, so nothing gets removed. We can however stop the \B from matching by instead inserting a non-digit character into this place. That turns the non-word boundary into a word boundary, which is the equivalent of removing the marker character earlier. And that's what the 12-byte solution does:

+%`\B
¶$`:

Just for completeness, here are the individual steps of processing 1011, with an empty line after each step:

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

Again, you'll find that the last result contains exactly 11 1s.

As an exercise for the reader, can you see how this generalises quite easily to other bases (for a few additional bytes per increment in the base)?

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 bytes

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

We reverse our binary number, split it into its component digits, and sum them based on position.

Bash + GNU utilities, 29 bytes

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

I/O via stdin/stdout.

The sed expression splits the binary up into each digit and builds a RPN expression for dc to evaluate.

PowerShell v2+, 55 bytes

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

Feels too long ... Can't seem to golf it down any -- tips appreciated.

Explanation

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 bytes

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

Recursion saves the day again! Though the parameterization seems a little long...

Mathematica, 27 13 11 bytes

Fold[#+##&]

Accepts a List of bits as input (e.g. {1, 0, 1, 1, 0} -- Mathematica's binary representation of the number 22)

Clojure, 114 105 63 41 bytes

V4: 41 bytes

-22 bytes thanks to @cliffroot. Since digit is a character, it can be converted to it's code via int, then have 48 subtracted from it to get the actual number. The map was also factored out. I don't know why it seemed necessary.

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

V3: 63 bytes

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

-42 bytes (!) by peeking at other answers. My "zipping" was evidently very naïve. Instead of raising 2 to the current place's power, then multiplying it by the current digit and adding the result to the accumulator, it just multiplies the accumulator by 2, adds on the current digit, then adds it to the accumulator. Also converted the reducing function to a macro to shave off a bit.

Thanks to @nimi, and @Adnan!

Ungolfed:

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

V2: 105 bytes

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

-9 bytes by reversing the string so I don't need to create an awkward descending range.

V1: 114 bytes

Well, I'm certainly not winning! In my defense, this is the first program I've ever written that converts between bases, so I had to learn how to do it. It also doesn't help that Math/pow returns a double that requires converting from, and Integer/parseInt doesn't accept a character, so the digit needs to be wrapped prior to passing.

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

Zips the string with a descending index representing the place number. Reduces over the resulting list.

Ungolfed:

(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 bytes

-4 bytes thanks to @Dada

Run with -F -p (including the extra space after the F). Pipe values to the function using echo -n

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

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

I feel this is sufficiently different from @Dada's answer that it merits its own entry.

Explanation:

-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 $\

This uses my personal algorithm of choice for binary-to-decimal conversion. Given a binary number, start your accumulator at 0, and go through its bits one by one. Double the accumulator each bit, then add the bit itself to your accumulator, and you end up with the decimal value. It works because each bit ends up being doubled the appropriate number of times for its position based on how many more bits are left in the original binary number.

R (32-bit), 64 Bytes

Input for the function should be given as character. The base functions of R support 32-bit integers.

Input:

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

Output:

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

R (64-bit), 74 Bytes

Input for the function should be given as character. The package bit64 has to be used for 64-bit integers.

Input:

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

Output:

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

Dyalog APL, 12 bytes

(++⊢)/⌽⍎¨⍞

⍞ get string input

⍎¨ convert each character to number

⌽ reverse

(...)/ insert the following function between the numbers

 ++⊢ the sum of the arguments plus the right argument

ngn shaved 2 bytes.

k, 8 bytes

Same method as the Haskell answer above.

{y+2*x}/

Example:

{y+2*x}/1101111111010101100101110111001110001000110100110011100000111b
2016120520371234567