Tome una cadena de caracteres binarios separados por un espacio y conviértalo en una cadena ASCII.

Por ejemplo...

1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100

Se convertiría a ...

Hello World

La cadena binaria se almacenará en una variable llamada s.

Este es un desafío de código de golf, por lo que gana la solución más corta.

Rubí, 36 32

s.split.map{|x|x.to_i(2).chr}*""

O 31

s.gsub(/\w+ ?/){$&.to_i(2).chr}

Optimizaciones gracias a Chron

JavaScript (ES6) 49 55 56 64

s.replace(/\d+./g,x=>String.fromCharCode('0b'+x))

Editar Aceptando @bebe sugerencia - gracias
Edit2 No sabía acerca del literal numérico binario - gracias @kapep
Edit3 Wow 6 no 4 bytes guardados thx @ETHproductions

Explicación según lo solicitado en los comentarios

String.replace puede tomar 2 argumentos:

• expresión regular /\d+./g: uno o más dígitos seguidos de un carácter diferente: el indicador g especifica que busque el patrón más de una vez
• una función, aquí especificada en formato de flecha, donde el argumento (x) será la cadena encontrada (la secuencia de dígitos finalmente seguida por un espacio) y el valor de la función es lo que se reemplaza (en este caso, el carácter único de el código).

Vale la pena señalar que al final de la cadena la expresión regular coincide con la secuencia de dígitos sin un espacio final, en este caso el punto coincide con el último dígito. Prueba '123'.match (/ (\ d +) ./) para verificar.

(Aún así) una de las piezas más detalladas de javascript jamás ...
(La asignación a la cadena s no cuenta)

var s='1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100'
var x=
s.replace(/\d+./g,x=>String.fromCharCode('0b'+x))

console.log(x)

Bash + utilidades comunes de Linux, 25 bytes

dc<<<2i$s[Pz0\<m]dsmx|rev

explicación dc

• empuje 2 a la pila; pop y usar como entrada radix
• empuje la cadena de entrada para apilar (todos los valores a la vez)
• Definir macro recursiva mpara:
  • pop, luego imprima el valor como ASCII
  • empujar la profundidad de la pila a la pila
  • presione 0 para apilar
  • pop top 2 valores de pila; comparar y llamar mmacro si la pila no está vacía
• duplicar la parte superior de la pila (definición de macro)
• pop y guardar macro para mregistrarse
• pop y ejecutar macro

Debido a que primero empujamos toda la cadena binaria a la pila, cuando sacamos cada valor, terminamos con la cadena invertida. Entonces usamos la revutilidad para corregir eso.

Ejemplo de uso:

$ s="1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100"
$ dc<<<2i$s[Pz0\<m]dsmx|rev
Hello World
$ 

PowerShell, 49

-join(-split$s|%{[char][convert]::toint32($_,2)})

EDITAR: No vi la otra respuesta de PowerShell. Pero esencialmente solo hay una forma de resolver esto.

C - 57 43 38/31

Versión de 38 bytes:

for(int*x=s;putchar(strtol(x,&x,2)););

O solo 31 bytes si s es un puntero:

while(putchar(strtol(s,&s,2)));

No creo que esto sea exactamente cómo se supone que se debe usar el ciclo while y while ... pero funciona.

Pyth , 12

smCv+"0b"dPZ

Tenga en cuenta que s no es una variable legal en Pyth, por lo que usé Z en su lugar.

Explicación:

        print(
s             sum(
m                 map(lambda d:
C                     chr(
v                         eval(
+"0b"d                         "0b"+d)),
P                     split(
Z                           Z))))

Ejemplo:

=Z"<the binary string from above>"smCv+"0b"dPZ
Hello World

Código de máquina x86 en DOS: 22 bytes

00000000  30 d2 b4 08 cd 21 2c 30  72 06 d0 e2 08 c2 eb f2  |0....!,0r.......|
00000010  b4 02 cd 21 eb ea                                 |...!..|

Como no hay variables de cadena reales en el código de máquina (y en particular, no hay variables llamadas " s"), me decidí por stdin como entrada.

Entrada NASM:

    org 100h

section .text

start:
    xor dl,dl
loop:
    mov ah,8
    int 21h
    sub al,'0'
    jb print
    shl dl,1
    or dl,al
    jmp loop
print:
    mov ah,2
    int 21h
    jmp start

Powershell ( 52 49)

-join(-split$s|%{[char][convert]::ToInt16($_,2)})

Bucle simple sobre cadena binaria en $ s. Sin embargo, tener que incluir el [convertir] mata mi puntaje.

EDITAR: Realmente solo hay una forma de lograr esto en Powershell, wowie. ¡Joey y yo obtuvimos casi la misma respuesta trabajando independientemente!

Entrada:

1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100

Salida:

Hello World

Mathematica, 52 bytes

Ah, los bonitos nombres de funciones de Mathematica

f=FromCharacterCode[#~FromDigits~2&/@StringSplit@#]&

Perl 33 32

Editar: Solución actualizada, 32.

say$s=~s/\d+ ?/chr oct"0b$&"/rge

Solución anterior (33):

$_=$s;say map{chr oct"0b$_"}split

o

say map{chr oct"0b$_"}split/ /,$s

Prueba:

perl -E '$s="1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100";$_=$s;say map{chr oct"0b$_"}split'

J (23)

u:;(#.@:("."0))&.>cut s

Prueba:

   s=:'1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100'
   u:;(#.@:("."0))&.>cut s
Hello World

Explicación:

                  cut s    NB. split S on spaces
   (          )&.>         NB. for each element
        ("."0)             NB. evaluate each character
      @:                   NB. and
    #.                     NB. convert bitstring to number
  ;                        NB. unbox each number
u:                         NB. convert to ASCII

Golfscript - 21

' '/{1/{~}%2base}%''+

Puedes probarlo aquí .

Python shell  44  40 caracteres

''.join(chr(int(x,2))for x in s.split())

Gracias por la ayuda Griffin .

APL (15)

⎕UCS{2⊥⍎¨⍕⍵}¨⍎s

Prueba:

      s←'1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100'
      ⎕UCS{2⊥⍎¨⍕⍵}¨⍎s
Hello World

Explicación:

• ⍎s: evaluar s, convirtiéndolo en una matriz de enteros. Las matrices se escriben como números separados por espacios, por lo que esto se divide s.
• {... }¨: para cada elemento:
  • ⍕⍵: convierte el número de nuevo en una cadena
  • ⍎¨: evalúa cada dígito individual, dando una cadena de bits
  • 2⊥: decodificación base-2, dando los números
• ⎕UCS: obtener el carácter para cada número

PHP (61)

<?=join(array_map('chr',array_map('bindec',explode(' ',$s))))

Baco , 25 bytes

S,' 'j:A=(Ö,2,10b:c),A¨

Explicación:

S,' 'j divide la Cadena S por el espacio vacío y la convierte en un bloque (algún tipo de matriz).

:A= obtener el bloque anterior y asignarlo a una variable.

(),A¨ para cada elemento en A

Ö,2,10bLee el elemento actual (representado por Ö) en la base 2 y transfórmalo en la base 10.

:c obtener el valor anterior e imprimir como char

GolfScript 23

' '/{[{49=}/]2base}%''+

Prueba en línea aquí .

C - 63

ya que C no tiene un convertidor de base 2 en la biblioteca estándar: prueba
editar aquí : hay, soy demasiado estúpido para saberlo

r;f(char*s){for(;*s;(*s|32)-32||(putchar(r),r=0))r=2*r|*s++&1;}

Longitud de ejecución codificada Brainfuck, 49 bytes

Como no hay variables en Brainfuck, solo utilicé la entrada y salida estándar.

El 32+intérprete debe interpretar el código como 32 +s. Simplemente reemplácelos manualmente si su intérprete no admite RLE.

>,[32->+<[16-<[>++<-]>[<+>-]>-<]>[<<.[-]>>-]<,]<.

Versión ampliada (no RLE): (91 bytes)

>,[-------------------------------->+<[----------------<[>++<-]>[<+>-]>-<]>[<<.[-]>>-]<,]<.

El código supone que EOF está codificado como 0.

Explicación

Se utiliza el siguiente diseño:

+---+---+------+
| x | a | flag |
+---+---+------+

Dónde xse imprimirá el byte ASCII, aes el carácter de la entrada estándar y flages 1 si afuera un espacio.

>,            Read a character a into the second cell
[             While not EOF: 
  32-           Decrease a by 32 (a -= ' ')
  >+<           Set the flag to 1 
  [             If a was not a space:
    16-           Decrease by 16 more ('0' == 32+16)
    <[>++<-]      a += 2*x
    >[<+>-]       Move it back (x = a)
    >-<           Reset the flag, it was not a space.
  ]>
  [             If a was a space (flag == 1):
    <<.[-]        Print and reset x
    >>-           Reset the flag
  ]
  <,            Read the next caracter a
]
<.            Print the last character x

Java 8: 60 bytes

Usando lambdas en Java 8 (75 bytes):

Arrays.stream(s.split(" ")).reduce("",(a,b)->a+(char)Byte.parseByte(b,2));

Y si permite las importaciones estáticas (que algunos usan aquí) es (61 bytes):

stream(s.split(" ")).reduce("",(a,b)->a+(char)parseInt(b,2))

Una versión un poco más corta que usa for loop (60 bytes):

for(String n:s.split(" ")){out.print((char)parseInt(n,2));}

Clojure 63 (o 57)

El todo-Clojure implica:

(apply str(map #(char(read-string(str"2r"%)))(re-seq #"\d+"s)))

Con interoperabilidad Java:

(apply str(map #(char(Long/parseLong % 2))(.split s" ")))

Sesión REPL:

golf> (def s "1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100")
#'golf/s
golf> (apply str(map #(char(read-string(str"2r"%)))(re-seq #"\d+"s)))
"Hello World"
golf> (apply str(map #(char(Long/parseLong % 2))(.split s" ")))
"Hello World"

QBasic, 103

s$=s$+" ":FOR i=1 TO LEN(s$):c$=MID$(s$,i,1):IF c$=" "THEN n=0:r$=r$+CHR$(n)ELSE n=n*2+VAL(c$)
NEXT:?r$

¿Qué? No tenemos funciones elegantes de binario a decimal aquí. ¡Hazlo tu mismo!

Estoy contando la nueva línea (que creo que es necesaria para obtener el if-then-else sin un END IF) como un byte, según esta meta publicación . No sé si QB64 en Windows aceptaría un archivo de código de esa manera o no. Probablemente no importa mucho.

NodoJS - 62

Buffer(s.split(' ').map(function(a){return parseInt(a,2)}))+''

PHP - 75

array_reduce(explode(' ', $b),function($a,$b){return $a.chr(bindec($b));});

JavaScript 111

Esto hace la conversión de número sin parseInt o eval. Al leer la cadena hacia atrás y contar los bits, establece el bit x si es uno. Cuando se encuentra un espacio, el número se convierte en un carácter y se inicia un nuevo número 0 para establecer bits.

x=n=0,w='',s=' '+s
for(i=s.length;i--;){m=s[i]
if(m==1)n|=1<<x
x++
if(m==' ')w=String.fromCharCode(n)+w,n=x=0
}

Maravilloso 64

{it.split(" ").collect{Integer.parseInt(it,2) as char}.join("")}

CJam, 11 bytes

NS/{:~2bc}/

s no es un nombre de variable legal en CJam, así que elegí N en su lugar.

Pruébalo en línea.

Ejecución de ejemplo

$ cjam <(echo '
> "1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100"
> :N;
> NS/{:~2bc}/
> '); echo
Hello World

Cómo funciona

NS/            " Split N at spaces.                            ";
   {     }/    " For each chunk:                               ";
    :~         "   Evaluate each character ('0' ↦ 0, '1' ↦ 1). ";
      2b       "   Convert from base 2 array to integer.       ";
        c      "   Cast to character.                          ";

Haskell - 48 (+13 importaciones (?))

Aquí está mi primer intento de golf en Haskell.

map(chr.foldl1((+).(*2)).map digitToInt)$words s

Necesitas importar datos.

uso (en ghci):

Prelude> :m +Data.Char
Prelude Data.Char> let s = "1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100"
Prelude Data.Char> map(chr.foldl1((+).(*2)).map digitToInt)$words s
"Hello World"

Explicación:

map(chr.foldl1((+).(*2)).map digitToInt)$words s
                                        $words s -- split s on spaces into a list
                         map digitToInt          -- convert each digit in input string to int
              ((+).(*2))                         -- a function that multiplies its first 
-- argument by 2, then adds the second argument
        foldl1((+).(*2)).map digitToInt          -- fold the above over the list of ints: 
-- in other words this is a function that reads strings as binary and gives the value as int
   (chr.foldl1((+).(*2)).map digitToInt)         -- cast to character
map(chr.foldl1((+).(*2)).map digitToInt)$words s -- map our function over the list of words

GNU Sed, 19 bytes

Inspirado por una excelente respuesta @Digital Trauma.

Golfed

s/\w*/dc -e2i&P;/eg

Prueba

echo 1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100|\
sed 's/\w*/dc -e2i&P;/eg'

Hello World

Pyth, 7 bytes (no competitivos)

smCid2c

Toma la entrada como cadena.

¡Intentalo!

05AB1E , 4 bytes (no competitivos)

Guardado 3 bytes gracias a @Emigna

#CçJ

Pruébalo en línea!