Dada uma sequência de entrada contendo apenas letras e números, escreva um programa ou função que imprima os possíveis caracteres ASCII imprimíveis (Hex 20-7E) que correspondem ao valor da sequência nas bases 8, 10 e 16 (sempre que possível). Os caracteres devem ser escritos em ordem crescente em termos das bases com as quais eles correspondem (base 8 primeiro, etc). A saída pode estar no formato de matriz (como [& . F]) ou separada por espaços ou novas linhas (uma nova linha à direita é opcional) como as amostras.

Se não for possível formar um caractere ASCII imprimível, o programa não deverá ter saída.

Amostras

31
==> 1

47
==> ' / G

69
==> E i

7A
==> z

100
==> @ d

156
==> n

189
==> <empty>

potaTO
==> <empty>

5G
==> <empty>

19
==> <empty>

Isso é código-golfe , então a resposta com o menor número de bytes vence. Aplicam-se regras padrão.

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 de desconto, graças a @David

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

Experimente online!

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

Pitão, 23 21 20 18 bytes

@rd\m.xCizd0[8T16

Saída como uma matriz. Existe um literal \x80entre a barra invertida e o C, que substituí por um •.

@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).

Experimente aqui .

Jolf, 26 bytes

Experimente aqui! Suíte de teste

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

Explicação

 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 + utilitários GNU + ascii , 36

Não tenho certeza se o uso do asciiutilitário é permitido. A entrada é tomada como um parâmetro da linha de comandos.

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

asciipode ser instalado no Ubuntu com 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` `

Teste:

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

Eu não acho que posso jogar muito mais, testei várias maneiras de fazê-lo, e aqui vem o mais curto. Mesmo usando um compilador antigo que contém a função obsoleta table.foreach(table,function)não reduz alguns bytes.

Este programa usa uma string como argumento e imprime a concatenação dos valores de uma tabela separados por espaços.

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

Ungolfed e explicações

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

Se você está pensando por que há um conjunto de variáveis, mas não é usado em um código de golfe (a variável _no loop for), eis o porquê:

Você tem duas maneiras de iterar sobre uma matriz em Lua, em um estilo for:

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

ou no estilo foreach:

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

Eu estava precisando dos valores contidos na tabela {8,10,16}, pois são as diferentes bases que eu tenho que repetir. Mas as funções com retorno múltiplo não permitirão que você escolha qual delas realmente deseja devolver, elas seguem uma ordem. Para valuedefinir a variável , também preciso capturar o valor key: é o que chamamos de manequim _.

C (função), 76

• 2 bytes salvos graças a @anatolyg.
• 5 bytes salvos graças 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;}

Ideone.

JavaScript ES6, 89 88 bytes

Guardado 1 byte graças a Neil!

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

Retorna uma matriz. Se não estiver certo, isso funciona por mais 8 bytes, exibindo as possíveis correspondências.

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

usa strtoipara converter para cada uma das bases e depois converter para caractere se estiver no intervalo apropriado. Poderia economizar mais 4 bytes removendo catse permitíssemos a impressão padrão de caracteres (encapsulados "")