Escreva um programa que tenha como entrada uma sequência composta por caracteres imprimíveis (ASCII 20-7E) e um número inteiro nem [2,16] e execute a seguinte modificação na sequência.

• Cada caractere na string é convertido em seu código ASCII (os exemplos dados são em hexadecimal, embora a base 10 também seja aceitável).
• Os códigos ASCII são convertidos em base ne são concatenados juntos.
• A nova string é dividida em todos os outros caracteres. Se houver um número ímpar de caracteres, o último caractere será removido completamente.
• Os códigos ASCII de impressão (na base 16) são convertidos novamente em seus caracteres, enquanto os códigos ASCII que não são de impressão são removidos.
• A sequência resultante é impressa.

Caso de teste

Entrada

Hello, World!
6

Passos

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

A saída deste programa é E001R"31$E.

Isso é código de golfe, então as regras padrão se aplicam. O menor código em bytes vence.

Pitão - 22 bytes

Espero jogar muito mais, bem direto.

sfq3l`TmCid16csjRQCMz2

Experimente online aqui .

CJam, 33 bytes

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

Recebe entrada no formulário 6 "Hello, World!". Teste aqui.

Veja a resposta de Dennis para uma solução semelhante, mas melhor, com uma boa explicação.

Bash + utilitários linux comuns, 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 bytes

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

Observe que há um caractere DEL (0x7F) entre 'e ,. Experimente online no intérprete CJam .

Como funciona

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

Usando as funções mais detalhadas disponíveis em 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 bytes

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

Ungolfed:

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 bytes

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

Se uma função é permitida:

Mathematica, 112 bytes

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

TeaScript, 23 bytes

TeaScript é JavaScript para jogar golfe

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

Relativamente simples, mas deliciosamente curto. Provavelmente posso jogar mais alguns personagens com mais operadores. Alguns outros novos recursos também podem ser usados ​​para reduzir alguns bytes.

Ungolfed && Explicação

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

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

Teste online aqui .

Python 2, 174 bytes

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

Experimente aqui

Não é realmente a melhor ferramenta para o trabalho. Como o Python não tem função de conversão em base arbitrária, eu tive que implementar a minha própria. Isso foi divertido, pelo menos - particularmente encontrar uma expressão [marginalmente mais curta] para os dígitos do que "0123456789ABCDEF"[n%b]. Para iterar mais de dois caracteres por vez, descobri que um whileloop era um pouco menor que uma abordagem funcional.

181 bytes como um programa completo:

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 bytes

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

Eu escrevi uma função k que leva uma string s e um inteiro n como entrada. por exemplo:

k('Hello, World!',6)

dá

 E001R"31$E

A coisa mais irritante que eu tive para contornar é o aparecimento de zeros na conversão para a base n . Tirar esses dados da matriz que seria dividida após cada segundo caractere custa muitos bytes. Não tenho certeza se é possível salvar mais bytes usando essa abordagem.

PHP - 286 bytes

Coloque a string $se o número inteiro em $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)))));?>

Passe o valor para GET["s"].