Scrivi un programma che codifica il testo dato nel proprio testo, fornito come input, senza interrompere la sua logica. Il programma deve anche funzionare come decodificatore, ripristinando il messaggio originale dal suo testo. Deve conservare le sue funzioni di codifica / decodifica dopo la trasformazione.

Più formalmente parlando, il programma richiesto P deve eseguire le seguenti trasformazioni con il testo del messaggio dato M:
P (M, P) -> P *
P * (P *) -> M

Qui P * è il programma trasformato, che deve anche soddisfare le regole di cui sopra, ovvero:
P * (M2, P *) -> P **
P ** (P **) -> M2
e così via ... Ciascuno la codifica successiva non cancella il testo precedentemente codificato, quindi P ** porta due messaggi: M e M2.

Il modo più semplice per il programma di distinguere tra le modalità di codifica / decodifica è la presenza dell'argomento aggiuntivo M, ma la decisione finale dipende da te, a condizione che sia chiaramente indicato. Il programma potrebbe leggere il proprio testo dal file. Se la lingua scelta non ha mezzi per questo, il testo sorgente può essere passato al programma in qualsiasi altro modo.

Ci sono soluzioni banali, ovviamente, quindi questa è piuttosto una gara di popolarità. Tuttavia, impongo una limitazione che vieta i commenti nel testo del programma.

Perl

Questo è un one-liner in Perl solo perché è possibile.

if($ARGV[0]){open(F,__FILE__);while(<F>){print;print"$ARGV[0]\n"if/^_/;}}else{print<DATA>;}
__DATA__

I messaggi vengono scritti dopo __DATA__, prima i più recenti.

Pitone

Sai cosa? Perché non renderlo una singola espressione?

P = (lambda M,P=None:(lambda t:P[:74]+repr(M)[1:-1]+"'))"if P else M[74:-3])(''))
Pc = "(lambda M,P=None:(lambda t:P[:74]+repr(M)[1:-1]+\"'))\"if P else M[74:-3])(''))"
P2c = P('Hi there, mate!', Pc)
print "Encode tests:"
print " P2 = P('Hi there, mate!', Pc) =", P2c
exec 'P2 = ' + P2c
print " P2(\"Test 2's the best.\", P2c) =", P2("Test 2's the best.", P2c)

print "Decode tests:"
print "P2(P2) =", P2(P2c)
print "P(P2)  =", P(P2c)
print "P2(P)  =", P2(Pc)
print "P(P)   =", P(Pc)

Vecchio messaggio; La funzione P accetta gli argomenti come specificato e genera il codice / testo decodificato risultante.

def P(data,func=None):
    text = ""
    if func:
        return func[:35]+data+'"\n'+'\n'.join(func.split('\n')[2:])
    return data[35:].split('\n')[0][:-1]

# The source code.
Pc = """def P(data,func=None):
    text = ""
    if func:
        return func[:35]+data+'"\\n'+'\\n'.join(func.split('\\n')[2:])
    return data[35:].split('\\n')[0][:-1]"""

P2c = P('Hi there, mate!', Pc)
print "Encode test:"
print "P('Hi there, mate!', P) ->"
print P2c

# This is outputted by P('Hi there, mate!', code-of-P)
def P2(data,func=None):
    text = "Hi there, mate!"
    if func:
        return func[:35]+data+'"\n'+'\n'.join(func.split('\n')[2:])
    return data[35:].split('\n')[0][:-1]

print "P2('Text 2', P2) -<"
print P2('Text 2', P2c)

print "Decode test:"
print "P2(P2) =", P2(P2c)
print "P(P2)  =", P(P2c)
print "P2(P)  =", P2(Pc)
print "P(P)   =", P(Pc)

JavaScript

var transform = function (p, m) {
    var _M_ = '';
    var source = arguments.callee.toString();
    var msgre = /(_M_ = ').*(';)/;
    var regex = new RegExp(source.replace(/[.*+?^$\[\]{}()\\|]/g, "\\$&").replace(msgre, "$1(.*)$2"));

    var a = p.toString().match(regex);

    if (!a) {
        throw "first argument must be a transform function"
    } else {
        a = a[1];
    }

    if (typeof m == "undefined") {
        return eval("[" + a.split("|")[0] + "]").map(x=>String.fromCharCode(x)).join("");
    } else {
        a = m.toString().split("").map(x => x.charCodeAt(0)) + (a.length ? "|" + a: a);
        return eval("(" + source.replace(msgre, "$1" + a + "$2") + ")");
    }
}

Non sono sicuro di aver compreso correttamente l'istruzione del problema: il mio decodificatore decodificherà qualsiasi programma e restituirà l'ultimo messaggio codificato nel programma specificato.

Codice di prova:

P1 = transform(transform, "first message");
P2 = P1(P1, "second message");

console.log(P1(P1));
console.log(P2(P2));

console.log(P2(P1));
console.log(P1(P2));

// Unspecified behavior
console.log(transform(transform))

Lotto

@echo off

setLocal enableDelayedExpansion
for /f %%a in (%0) do set a=%%a

if "%~1"=="e" (
    set /a a+=1
    echo !a! %~2 >> %0
    echo message encoded as !a!
) else if "%~1"=="d" for /f "skip=12 tokens=1*" %%a in (%0) do if "%%a"=="%~2" echo %%b

goto :EOF

Nota che ci deve essere un ritorno a capo dopo "l'ultima riga" di goto :EOF .

Questo richiede due input da stdin. Il primo è quello che vuoi fare; eo d(codifica e decodifica). Il secondo input dipende dal primo - se il primo input è e, allora il secondo input sarà il messaggio che si desidera codificare - se lo è d, allora il secondo input sarà il numero del messaggio che si desidera decodificare ( essere fornito dopo aver codificato un messaggio).

H:\uprof>ed.bat e "Just a message"
message encoded as 1

H:\uprof>ed.bat d 1
Just a message

Cobra

use System.Diagnostics
class Program
    var message as int[]? = nil
    def decode(program as String)
        temp = List<of String>(program.split('\n'))
        temp.insert(4, '\t\tEnvironment.exit(0)')
        temp.add('\t\tmessage = \'\'')
        temp.add('\t\tfor i in .message, message += Convert.toString(i to char)')
        temp.add('\t\tFile.writeAllText(\'message.txt\', message)')
        program = temp.join('\n')
        File.writeAllText('decode.cobra', program)
        process = Process()
        process.startInfo.fileName = 'cmd.exe'
        process.startInfo.arguments = '/C cobra decode.cobra'
        process.start
    def encode(message as String, program as String)
        temp = List<of String>()
        for i in message.toCharArray, temp.add(Convert.toString(i to int))
        message = '@' + Convert.toString(c'[')
        for n in temp.count-1, message += temp[n] + ','
        message += temp.pop + ']'
        temp = List<of String>(program.split('\n'))
        temp.insert(26,'\t\t.message = .message ? [message]')
        program = temp.join('\n')
        File.writeAllText('encode.cobra', program)
    def main
        #call methods here
        #.encode(message, program)
        #.decode(program)

Mentre l' idea è banale, l' esecuzione di tale idea è meno.

Codifica

La codifica di un messaggio nel programma aggiungerà la riga .message = .message ? ximmediatamente dopo def main. Questa riga controlla se .messageè nulla e, in tal caso, imposta.message su un array intero contenente i valori del codice carattere di ciascun carattere nel messaggio; il controllo zero e il posizionamento evitano di sovrascrivere il nuovo messaggio con uno più vecchio. Il nuovo programma viene salvato inencode.cobra

decodifica

La decodifica del programma aggiungerà tre righe alla fine del metodo principale che induce il programma a convertire i codici char in .messageuna stringa, che viene quindi salvata message.txtquando viene eseguito il nuovo programma. Il nuovo programma viene quindi salvato decode.cobrae il compilatore viene richiamato su di esso.

decode.cobra viene utilizzato come un file temporaneo e non può essere utilizzato per codificare o decodificare un altro messaggio, utilizzare l'originale o encode.cobra