Étant donné une chaîne d'entrée contenant uniquement des lettres et des chiffres, écrivez un programme ou une fonction qui imprime les caractères ASCII imprimables possibles (Hex 20-7E) qui correspondent à la valeur de la chaîne dans les bases 8, 10 et 16 (si possible). Les caractères doivent être écrits en ordre croissant en fonction des bases avec lesquelles ils correspondent (base 8 d'abord, etc.). La sortie peut être au format tableau (comme [& . F]) ou séparée par des espaces ou des retours à la ligne (un retour à la ligne est facultatif) comme les échantillons.

Si aucun caractère ASCII imprimable possible ne peut être formé, le programme ne doit pas avoir de sortie.

Échantillons

31
==> 1

47
==> ' / G

69
==> E i

7A
==> z

100
==> @ d

156
==> n

189
==> <empty>

potaTO
==> <empty>

5G
==> <empty>

19
==> <empty>

Il s'agit de code-golf , donc la réponse avec le moins d'octets l'emporte. Des règles standard s'appliquent.

JavaScript (SpiderMonkey 30+), 74 octets

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

MATL , 23 24 28 octets

1 octet de moins grâce à @David

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

Essayez-le en ligne!

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 octets

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 octets

@rd\m.xCizd0[8T16

Sortie sous forme de tableau. Il y a un littéral \x80entre la barre oblique inverse et le C, que j'ai remplacé par un •.

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

Essayez-le ici .

Jolf, 26 octets

Essayez-le ici! Suite de tests

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

Explication

 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 + utilitaires GNU + ascii , 36

Je ne sais pas si l'utilisation de l' asciiutilitaire est autorisée. L'entrée est considérée comme un paramètre de ligne de commande.

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

asciipeut être installé sur Ubuntu avec sudo apt-get install ascii.

Javascript ES6, 89 caractères

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

Tester:

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 octets

Je ne pense pas que je puisse jouer au golf beaucoup plus bas, j'ai testé de nombreuses façons de le faire et voici le plus court. Même en utilisant un ancien compilateur qui contient la fonction obsolètetable.foreach(table,function) ne supprime pas certains octets.

Ce programme prend une chaîne en argument et affiche la concaténation des valeurs d'une table séparées par des espaces.

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

Non golfé et explications

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 vous vous demandez pourquoi il y a un ensemble de variables mais non utilisé dans un code golfé (la variable _dans la boucle for), voici pourquoi:

Vous avez 2 façons d'itérer sur un tableau dans Lua, soit dans un style for:

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

ou dans un style foreach:

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

J'avais besoin des valeurs contenues dans le tableau {8,10,16}car ce sont les différentes bases sur lesquelles je dois répéter. Mais les fonctions à retours multiples ne vous permettront pas de choisir celle que vous souhaitez réellement retourner, elles suivent un ordre. Pour que la variable soit valuedéfinie, je dois également saisir la valeur de key: c'est ce que nous appelons un mannequin _.

C (fonction), 76

• 2 octets enregistrés grâce à @anatolyg.
• 5 octets enregistrés grâce à @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 octets

1 octet enregistré grâce à Neil!

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

Renvoie un tableau. Si ce n'est pas correct, cela fonctionne pour 8 octets supplémentaires, affichant les correspondances possibles.

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 octets

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

utilise strtoipour convertir à chacune des bases, puis convertir en caractère si dans la plage appropriée. Pourrait économiser 4 octets supplémentaires en supprimant catsi nous autorisions l'impression par défaut des caractères (enveloppé "")