Schreiben Sie bei einer Eingabezeichenfolge, die nur Buchstaben und Zahlen enthält, ein Programm oder eine Funktion, die die möglichen druckbaren ASCII-Zeichen (Hex 20-7E) druckt, die dem Wert der Zeichenfolge in den Basen 8, 10 und 16 entsprechen (sofern möglich). Die Zeichen müssen in aufsteigender Reihenfolge in Bezug auf die Basen geschrieben werden, mit denen sie korrespondieren (Basis 8 zuerst usw.). Die Ausgabe kann im Array-Format (wie [& . F]) oder durch Leerzeichen oder Zeilenumbrüche (eine nachfolgende Zeilenumbruch ist optional) wie die Beispiele getrennt sein.

Wenn es kein mögliches druckbares ASCII-Zeichen gibt, das gebildet werden kann, darf das Programm keine Ausgabe haben.

Proben

31
==> 1

47
==> ' / G

69
==> E i

7A
==> z

100
==> @ d

156
==> n

189
==> <empty>

potaTO
==> <empty>

5G
==> <empty>

19
==> <empty>

Dies ist Code-Golf , also gewinnt die Antwort mit den wenigsten Bytes. Es gelten Standardregeln.

JavaScript (SpiderMonkey 30+), 74 Byte

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

MATL , 23 24 28 Bytes

1 Byte weniger dank @David

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

Probieren Sie es online aus!

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

Ausgabe als Array. Es gibt ein Literal \x80zwischen dem Backslash und dem C, das ich durch ein ersetzt habe •.

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

Probieren Sie es hier aus .

Jolf, 26 Bytes

Probieren Sie es hier aus! Testsuite

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

Erläuterung

 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 + GNU-Dienstprogramme + ASCII , 36

Nicht sicher, ob die Verwendung des asciiDienstprogramms zulässig ist. Die Eingabe wird als Befehlszeilenparameter verwendet.

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

asciikann unter Ubuntu mit installiert werden sudo apt-get install ascii.

Javascript ES6, 89 Zeichen

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

Prüfung:

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

Ich glaube nicht, dass ich viel mehr Golf spielen kann, ich habe viele Möglichkeiten getestet, und hier kommt die kürzeste. Selbst die Verwendung eines alten Compilers, der die veraltete Funktion enthält, table.foreach(table,function)spart einige Bytes nicht.

Dieses Programm verwendet eine Zeichenfolge als Argument und druckt die Verkettung von Tabellenwerten, die durch Leerzeichen getrennt sind.

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 und Erklärungen

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

Wenn Sie sich überlegen, warum es einen Variablensatz gibt, der jedoch nicht in einem Golfcode verwendet wird (die Variable _in der for-Schleife), finden Sie hier folgende Gründe :

Sie haben zwei Möglichkeiten, ein Array in Lua zu durchlaufen, entweder in einem for-Stil:

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

oder in einem foreach-Stil:

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

Ich brauchte die in der Tabelle enthaltenen Werte, {8,10,16}da es sich um die verschiedenen Basen handelt, über die ich iterieren muss. Bei Funktionen mit Mehrfachrückgabe können Sie jedoch nicht auswählen, welche Sie tatsächlich zurückgeben möchten. Sie folgen einer Reihenfolge. Um die Variable valuegesetzt zu haben, muss ich auch den Wert von fangen key: das nennen wir einen Dummy _.

C (Funktion), 76

• 2 Bytes dank @anatolyg gespeichert.
• 5 Bytes dank @luserdroog gespeichert.

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 Byte

1 Byte dank Neil gespeichert!

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

Gibt ein Array zurück. Wenn das nicht in Ordnung ist, funktioniert dies für zusätzliche 8 Bytes und zeigt die möglichen Übereinstimmungen an.

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

wird verwendet strtoi, um in jede der Basen zu konvertieren und dann in Zeichen zu konvertieren, wenn sie sich im entsprechenden Bereich befinden. Könnte 4 weitere Bytes durch Entfernen sparen, catwenn wir das Standarddrucken von Zeichen zulassen (eingewickelt "")