Dada una cadena de entrada que contiene solo letras y números, escriba un programa o función que imprima los posibles caracteres ASCII imprimibles (Hex 20-7E) que se corresponden con el valor de la cadena en las bases 8, 10 y 16 (donde sea posible). Los caracteres deben escribirse en orden creciente en términos de las bases con las que se corresponden (base 8 primero, etc.). La salida puede estar en formato de matriz (como [& . F]) o separada por espacios o nuevas líneas (una nueva línea final es opcional) como las muestras.

Si no se puede formar un posible carácter ASCII imprimible, el programa no debe tener ningún resultado.

Muestras

31
==> 1

47
==> ' / G

69
==> E i

7A
==> z

100
==> @ d

156
==> n

189
==> <empty>

potaTO
==> <empty>

5G
==> <empty>

19
==> <empty>

Este es el código de golf , por lo que gana la respuesta con la menor cantidad de bytes. Aplican reglas estándar.

JavaScript (SpiderMonkey 30+), 74 bytes

s=>[for(b of'o0x')if((c=+(0+b+s))>31&c<127)String.fromCharCode(c)].join` `

MATL , 23 24 28 bytes

1 byte apagado gracias a @David

8H6hhYs"G@ZA32:126m?6Mc

Pruébalo en línea!

8H6hhYs         % array [8,10,16]
"               % for each base
  G             %   push input. Do nothing the first time
  @             %   push base (8, 10 or 16)
  ZA            %   convert from base to decimal. Takes implicit input the first time
  32:126m       %   is result in acceptable range?
  ?             %   if so
    6M          %     push result of base conversion again
    c           %     convert to char
                %   implicitly end if
                % implicitly end for each
                % implicitly display stack contents

Python 3, 84 82 bytes

def a(s):
 for n in 8,10,16:
  try:b=int(s,n);31<b<127and print(chr(b))
  except:0

Pyth, 23 21 20 18 bytes

@rd\m.xCizd0[8T16

Salida como una matriz. Hay un literal \x80entre la barra diagonal inversa y la C, que he reemplazado con a •.

@rd\•m.xCizd0[8T16    Implicit: z=input
     m     d [8T16    Map the following lambda d over [8, 10, 16]:
      .x                try:
         izd              convert z from that base
        C                                          and convert to char
            0           except: return the number 0
@                     Filter that on presence in
 rd\•                   strings from space to \x80 (the printable ASCII characters).

Pruébalo aquí .

Jolf, 26 bytes

Pruébalo aquí! Banco de pruebas

 fΜ‘Ci8iΗi’dpAHdh sH"[ -~]

Explicación

 fΜ‘Ci8iΗi’dpAHdh sH"[ -~]
   ‘      ’                array containing
    Ci8                     input as base 8
       i                    input as base 10
        Ηi                  input as base 16
  Μ        d               mapped
            pAH             with from char code
_f             d           filtered
                _sH"[ -~]   with strings matching that.

Bash + utilidades GNU + ascii , 36

No estoy seguro si el uso de la asciiutilidad está permitido. La entrada se toma como un parámetro de línea de comandos.

ascii $1|tac|grep -Po '(?<=s as `).'

asciise puede instalar en Ubuntu con sudo apt-get install ascii.

Javascript ES6, 89 caracteres

s=>'0o,,0x'.split`,`.map(x=>(x+=s)>31&x<128&&String.fromCharCode(x)).filter(x=>x).join` `

Prueba:

f=s=>'0o,,0x'.split`,`.map(x=>(x+=s)>31&x<128&&String.fromCharCode(x)).filter(x=>x).join` `
"31,47,69,7A,100,156,189,potaTo,5G,19".split`,`.map(f) == "1,' / G,E i,z,@ d,n,,,,"

Lua, 147 bytes

No creo que pueda jugar mucho más, he probado muchas formas de hacerlo, y aquí viene la más corta. Incluso el uso de un compilador antiguo que contiene la función obsoleta table.foreach(table,function)no elimina algunos bytes.

Este programa toma una cadena como argumento e imprime la concatenación de los valores de una tabla separados por espacios.

t={}for _,i in pairs({8,10,16})do x=tonumber(arg[1],i)x=x and x or 0 t[#t+1]=127>x and 19<x and string.char(x)or nil end print(table.concat(t," "))

Sin golfos y explicaciones

t={}                        -- Initalise the array containing the chars to print
for _,i in pairs({8,10,16}) -- Iterate over the array {8,10,16}
do
  x=tonumber(arg[1],i)      -- convert the input in base i to a number in base 10
  x=x and x or 0            -- if the input wasn't a number, x is nil
                            -- use a ternary operator to set x in this case
  t[#t+1]=127>x and 19<x    -- if x is the bytecode of a printable character
    and string.char(x)or nil-- insert this character into t
end
print(table.concat(t," "))  -- concatenate the values in t with " " as separator
                            -- and print it

Si está deambulando por qué hay un conjunto de variables pero no se usa en un código golfizado (la variable _en el bucle for), este es el motivo:

Tiene 2 formas de iterar sobre una matriz en Lua, ya sea en un estilo for:

for i=1,#table do --[[code here, use table[i] ]] end

o en un estilo foreach:

for key,value do pairs(table) do --[[code here]] end

Necesitaba los valores contenidos en la tabla, {8,10,16}ya que son las diferentes bases sobre las que tengo que repetir. Pero las funciones con retorno múltiple no le permitirán elegir cuál desea que se devuelva, siguen un pedido. Para tener la variable valueestablecida, también necesito capturar el valor de key: eso es lo que llamamos un maniquí _.

C (función), 76

• 2 bytes guardados gracias a @anatolyg.
• 5 bytes guardados gracias a @luserdroog.

j,c;f(char*s){for(j=8;c=strtol(s,0,j);j=j*j/6)isprint(c)?printf("%c ",c):0;}

Ideona

JavaScript ES6, 89 88 bytes

¡Guardado 1 byte gracias a Neil!

n=>[..."0x+"].map(t=>String.fromCharCode(eval(`0${t+n}`))).filter(k=>~k.search(/[ -~]/))

Devuelve una matriz. Si no está bien, esto funciona para 8 bytes adicionales, mostrando las posibles coincidencias.

n=>[..."0x+"].map(t=>String.fromCharCode(eval(`0${t+n}`))).filter(k=>~k.search(/[ -~]/)).join` `

F=n=>[..."0x+"].map(t=>String.fromCharCode(eval(`0${t+n}`))).filter(k=>~k.search(/[ -~]/)).join` `
//`
U=x=>o.innerHTML=F(+i.value);
i.onchange=i.onkeydown=i.onkeyup=i.onkeypress=U;U();

*{font-family:Consolas,monospace;}

<input id=i type="number" value=31><div id=o></div>

R, 84 bytes

function(x){s=sapply;y=s(c(8,10,16),strtoi,x=x);cat(s(y[y%in%c(32:126)],intToUtf8))}

utiliza strtoipara convertir a cada una de las bases y luego convertir a personaje si está en el rango apropiado. Podría ahorrar 4 bytes más al eliminar catsi permitimos la impresión predeterminada de caracteres (envuelta "")