Biorąc pod uwagę ciąg wejściowy zawierający tylko litery i cyfry, napisz program lub funkcję, która wypisze możliwe do wydrukowania znaki ASCII (Heks 20-7E), które odpowiadają wartości ciągu w podstawach 8, 10 i 16 (tam, gdzie to możliwe). Znaki muszą być pisane w kolejności rosnącej, zgodnie z podstawami, z którymi się korespondują (najpierw podstawa 8 itp.). Dane wyjściowe mogą być w formacie tablicowym (jak [& . F]) lub być oddzielone spacjami lub znakami nowej linii (końcowy znak nowej linii jest opcjonalny), podobnie jak próbki.

Jeśli nie można utworzyć możliwego do wydrukowania znaku ASCII, program nie może mieć żadnych danych wyjściowych.

Próbki

31
==> 1

47
==> ' / G

69
==> E i

7A
==> z

100
==> @ d

156
==> n

189
==> <empty>

potaTO
==> <empty>

5G
==> <empty>

19
==> <empty>

To jest golf golfowy , więc wygrywa odpowiedź z najmniejszą liczbą bajtów. Obowiązują standardowe zasady.

JavaScript (SpiderMonkey 30+), 74 bajty

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

MATL , 23 24 28 bajtów

1 bajt off dzięki @David

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

Wypróbuj 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 bajtów

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 bajtów

@rd\m.xCizd0[8T16

Dane wyjściowe jako tablica. \x80Między odwrotnym ukośnikiem a literą C jest literał , który zastąpiłem literą •.

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

Wypróbuj tutaj .

Jolf, 26 bajtów

Wypróbuj tutaj! Zestaw testowy

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

Wyjaśnienie

 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 + narzędzia GNU + ascii , 36

Nie jestem pewien, czy korzystanie z asciinarzędzia jest dozwolone. Dane wejściowe są traktowane jako parametr wiersza polecenia.

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

asciimoże być zainstalowany na Ubuntu z sudo apt-get install ascii.

JavaScript ES6, 89 znaków

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

Test:

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 bajtów

Nie sądzę, żebym mógł grać w golfa o wiele bardziej, przetestowałem wiele sposobów, aby to zrobić, a tutaj jest najkrótszy. Nawet użycie starego kompilatora, który zawiera przestarzałą funkcję table.foreach(table,function), nie goli niektórych bajtów.

Ten program przyjmuje ciąg jako argument i wypisuje konkatenację wartości tabeli oddzielonych spacjami.

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

Bez golfa i wyjaśnienia

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

Jeśli zastanawiasz się, dlaczego istnieje zestaw zmiennych, ale nie jest używany w kodzie golfowym (zmienna _w pętli for), oto dlaczego:

Masz 2 sposoby na iterację po tablicy w Lua, albo w stylu for:

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

lub w stylu foreach:

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

Potrzebowałem wartości zawartych w tabeli, {8,10,16}ponieważ są to różne podstawy, nad którymi muszę iterować. Ale funkcje z wielokrotnym zwrotem nie pozwalają wybrać, który z nich rzeczywiście chcesz zwrócić, wykonują polecenie. Aby valueustawić zmienną , muszę również złapać wartość key: to nazywamy manekinem _.

C (funkcja), 76

• 2 bajty zapisane dzięki @anatolyg.
• 5 bajtów zapisanych dzięki @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 bajtów

Zaoszczędzono 1 bajt dzięki Neilowi!

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

Zwraca tablicę. Jeśli nie jest to w porządku, działa to na dodatkowe 8 bajtów, wyświetlając możliwe dopasowania.

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 bajtów

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

służy strtoido konwersji do każdej z baz, a następnie do postaci, jeśli znajduje się w odpowiednim zakresie. Można zaoszczędzić 4 bajty, usuwając, catjeśli zezwolimy na domyślny druk znaków (zawinięty w "")