Écrivez un programme qui prend en entrée une chaîne composée de caractères imprimables (ASCII 20-7E) et un entier nen [2,16] et effectue la modification suivante de la chaîne.

• Chaque caractère de la chaîne est converti en son code ASCII (les exemples donnés sont en hexadécimal, bien que la base 10 soit également acceptable).
• Les codes ASCII sont convertis en base net concaténés ensemble.
• La nouvelle chaîne est divisée tous les autres caractères. S'il y a un nombre impair de caractères, le dernier caractère est entièrement supprimé.
• Les codes ASCII d'impression (en base 16) sont reconvertis en leurs caractères, tandis que les codes ASCII non imprimables sont supprimés.
• La chaîne résultante est imprimée.

Cas de test

Contribution

Hello, World!
6

Pas

Hello, World!
48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21
2002453003003031125222330331030024453
20 02 45 30 03 00 30 31 12 52 22 33 03 31 03 00 24 45

La sortie de ce programme est E001R"31$E.

C'est du golf de code, donc les règles standard s'appliquent. Le code le plus court en octets gagne.

Pyth - 22 octets

J'espère jouer au golf beaucoup plus, assez simple.

sfq3l`TmCid16csjRQCMz2

Essayez-le en ligne ici .

CJam, 33 octets

q~:i\fb:~0+2/W<Gfb:c' ,-'ÿ),127>-

Prend la saisie dans le formulaire 6 "Hello, World!". Testez-le ici.

Voir la réponse de Dennis pour une solution similaire mais meilleure avec une belle explication.

Bash + Common Linux Utils, 118

printf %s "$1"|xxd -p|sed -r "s/../\U& /g;y/ /n/;s/^/dc -e$2o16i/e;s/../& /g;s/ .$//;"|xxd -rp|sed 's/[^[:print:]]//g'

CJam, 24 octets

l:irifbe_2/{Gbc',32>&}/

Notez qu'il y a un caractère DEL (0x7F) entre 'et ,. Essayez-le en ligne dans l' interpréteur CJam .

Comment ça marche

l:i                     Read a line from STDIN and cast each char to integer. 
   ri                   Read another integer (base) from STDIN.
     fb                 Convert each integer from line 1 to that base.
       e_2/             Flatten and split into chunks of length 2.
                        If the last chunk has only one element, it will get
                        converted into a control character, which will be
                        removed later.
          {         }/  For each digit pair:
           Gb             Convert the pair from base 16 to integer.
             c            Cast to character.
              ',          Push the string of ASCII characters up to '~'.
                32>       Remove the first 32 (control characters).
                   &      Intersect.

JavaScript (ES6), 137 147

Utilisation des fonctions les plus verbeuses disponibles en JavaScript

f=(s,b)=>alert(s.replace(/./g,x=>x.charCodeAt().toString(b)).match(/../g).map(x=>(x=String.fromCharCode('0x'+x))<='~'&x>' '?x:'').join``)

// Just for test purpose, redefine alert()
alert=x=>document.write('<pre>'+x+'</pre>')

f('Hello, World!',6)
f('PORK',3)

Julia, 118 octets

f(s,n)=join(map(i->(c=string(Char(parse(Int,i,16))))^isprint(c),matchall(r"..",join(map(i->base(n,Int(i)),[s...])))))

Non golfé:

function f(s::AbstractString, n::Integer)
    # Construct an array of ASCII codes in base n
    v = map(i -> base(n, Int(i)), [s...])

    # Join into a string and get all pairs, truncating
    # to an even length
    m = matchall(r"..", join(v))

    # Parse each pair as an integer in base 16, get the
    # character associated with that code point, convert
    # to a string, and include if it's printable
    x = map(i -> (c = string(Char(parse(Int, i, 16)))^isprint(c), m)

    # Join as a string and return
    return join(x)
end

Mathematica, 134 octets

Print@FromCharacterCode@Select[#~FromDigits~16&/@StringPartition[""<>ToCharacterCode@InputString[]~IntegerString~Input[],2],31<#<127&]

Si une fonction est autorisée:

Mathematica, 112 octets

FromCharacterCode@Select[#~FromDigits~16&/@StringPartition[""<>ToCharacterCode@#~IntegerString~#2,2],31<#<127&]&

TeaScript, 23 octets

TeaScript est JavaScript pour le golf

£lc¡T(y©K(2)ßC(P(l,16±µ

Relativement simple mais délicieusement court. Je peux probablement jouer au golf avec quelques autres opérateurs avec plus d'opérateurs. Quelques autres nouvelles fonctionnalités pourraient également être utilisées pour réduire certains octets.

Ungolfed && Explication

x.l(#
    l.c().T(y)
).K(2)
.m(#
    C(
      P(l,16)
    )
).j``

Rubis 92

->s,n{o=''
s.chars.map{|x|x.ord.to_s n}.join.scan(/../).map{|x|x>?2&&x<?8&&o<<x.to_i(16)}
o}

Test en ligne ici .

Python 2, 174 octets

def J(a,b,i=0):
 h=r=''
 B=lambda n,b:n*'x'and B(n/b,b)+chr(48+n%b+7*(n%b>9))
 for c in a:h+=B(ord(c),b)
 while i<len(h):v=int(h[i:i+2],16);r+=chr(v)*(31<v<127);i+=2
 print r

Essayez-le ici

Pas vraiment le meilleur outil pour le travail. Puisque Python n'a pas de fonction de conversion en base arbitraire, j'ai dû implémenter la mienne. C'était amusant, au moins - en particulier trouver une expression [légèrement] plus courte pour les chiffres que "0123456789ABCDEF"[n%b]. Pour itérer sur deux caractères à la fois, j'ai trouvé qu'une whileboucle était légèrement plus courte qu'une approche fonctionnelle.

181 octets en tant que programme complet:

B=lambda n,b:n*'x'and B(n/b,b)+chr(48+n%b+7*(n%b>9))
a=raw_input()
b=input()
h=r=''
for c in a:h+=B(ord(c),b)
i=0
while i<len(h):v=int(h[i:i+2],16);r+=chr(v)*(31<v<127);i+=2
print r

MATLAB, 103 octets

function k(s,n),b=dec2base(s,n)';b(~cumsum(b-'0',1))='';c=base2dec(textscan(b,'%2c'),16)';char(c(c>31))

J'ai écrit une fonction k qui prend une chaîne s et un entier n en entrée. par exemple:

k('Hello, World!',6)

donne

 E001R"31$E

La chose la plus ennuyeuse que j'ai dû contourner est que les zéros apparaissent lors de la conversion en base n . Les retirer du tableau qui devait être divisé après chaque 2ème caractère coûtait beaucoup d'octets. Je ne sais pas s'il est possible d'enregistrer d'autres octets en utilisant cette approche.

PHP - 286 octets

Mettez la chaîne $set l'entier $b.

<?php $s=$_GET["s"];$b;$m="array_map";echo implode($m(function($v){return ctype_print($v)?$v:"";},$m("chr",$m("hexdec",str_split(strlen(implode($a=$m(function($v){global$b;return base_convert($v,16,$b);},$m("dechex",$m("ord",str_split($s))))))%2==1?substr(implode($a),0,-1):$a,2)))));?>

Passez la valeur à GET["s"].