Scrivi un programma che accetta come input una stringa composta da caratteri stampabili (ASCII 20-7E) e un numero intero nin [2,16] ed esegue la seguente modifica alla stringa.

• Ogni carattere nella stringa viene convertito nel suo codice ASCII (gli esempi forniti sono in esadecimali, sebbene anche la base 10 sia accettabile).
• I codici ASCII vengono convertiti in base ne vengono concatenati insieme.
• La nuova stringa è divisa ogni altro carattere. Se è presente un numero dispari di caratteri, l'ultimo carattere viene rimosso completamente.
• I codici ASCII di stampa (nella base 16) vengono riconvertiti nei loro caratteri, mentre i codici ASCII non stampabili vengono rimossi.
• La stringa risultante viene stampata.

Caso di prova

Ingresso

Hello, World!
6

passi

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

L'output di questo programma è E001R"31$E.

Questo è il golf del codice, quindi si applicano le regole standard. Vince il codice più breve in byte.

Pyth - 22 byte

Spero di giocare a golf molto di più, piuttosto semplice.

sfq3l`TmCid16csjRQCMz2

Provalo online qui .

CJam, 33 byte

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

Accetta input nel modulo 6 "Hello, World!". Provalo qui.

Vedi la risposta di Dennis per una soluzione simile ma migliore con una bella spiegazione.

Bash + utility Linux comuni, 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 byte

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

Si noti che esiste un carattere DEL (0x7F) tra 'e ,. Provalo online nell'interprete CJam .

Come funziona

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

Utilizzo delle funzioni più dettagliate disponibili in 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 byte

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 byte

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

Se una funzione è consentita:

Mathematica, 112 byte

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

TeaScript, 23 byte

TeaScript è JavaScript per il golf

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

Relativamente semplice ma deliziosamente breve. Posso probabilmente giocare a golf con qualche altro personaggio con altri operatori. Alcune altre nuove funzionalità potrebbero anche essere utilizzate per ridurre alcuni byte.

Ungolfed && Explanation

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}

Test online qui .

Python 2, 174 byte

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

Provalo qui

Non è davvero lo strumento migliore per il lavoro. Dato che Python non ha alcuna funzione di conversione in base arbitraria, ho dovuto implementare la mia. È stato divertente, almeno - in particolare trovare un'espressione [marginalmente] più corta per le cifre rispetto a "0123456789ABCDEF"[n%b]. Per aver ripetuto più di due personaggi alla volta, ho scoperto che un whileciclo era leggermente più breve di un approccio funzionale.

181 byte come programma 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 byte

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

Ho scritto una funzione k che prende una stringa s ed un numero intero n come input. per esempio:

k('Hello, World!',6)

dà

 E001R"31$E

La cosa più fastidiosa su cui ho dovuto lavorare è la visualizzazione degli zeri durante la conversione in base n . Ottenere questi dall'array che doveva essere diviso dopo ogni 2 ° carattere costava parecchi byte. Non sono sicuro se è possibile salvare altri byte usando questo approccio.

PHP - 286 byte

Inserire la stringa $se l'intero $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)))));?>

Passa il valore a GET["s"].