Palindrom to ciąg znaków, który jest taki sam w przód iw tył, takie jak „wyścigowy”.

Napisz program w jakimś języku L, który pobiera dowolny program P1 w języku L jako dane wejściowe i generuje program palindromiczny P2 w języku L, który robi to samo co P1.

Nie musisz się martwić obsługą programów wejściowych z błędami składniowymi.

To jest kod golfowy , więc wygrywa rozwiązanie z najmniejszą liczbą bajtów.

Perl, 55 54 bajtów

undef$/;$a=<>."\n__END__\n";print$a,scalar reverse$a;

Odczytuje źródło programu ze standardowego wejścia i zapisuje na standardowe wyjście.

Wynik działania na sobie:

undef$/;$a=<>."\n__END__\n";print$a,scalar reverse$a;

__END__

__DNE__

;a$esrever ralacs,a$tnirp;"n\__DNE__n\".><=a$;/$fednu

Java, 225 bajtów

class c{public static void main(String[]a){String s="";java.util.Scanner r=new java.util.Scanner(System.in);while(r.hasNext())s+=r.nextLine()+"\n";s=s.replace("\n","//\n");System.out.print(s+new StringBuilder(s).reverse());}}

Wyjście samo w sobie (po uprzednim upiększeniu):

class c {//
    public static void main(String[] a) {//
        String s = "";//
        java.util.Scanner r = new java.util.Scanner(System.in);//
        while (r.hasNext()) s += r.nextLine() + "\n";//
        s = s.replace("\n", "//\n");//
        System.out.print(s + new StringBuilder(s).reverse());//
    }//
}//

//}
//}
//;))(esrever.)s(redliuBgnirtS wen + s(tnirp.tuo.metsyS        
//;)"n\//" ,"n\"(ecalper.s = s        
//;"n\" + )(eniLtxen.r =+ s ))(txeNsah.r( elihw        
//;)ni.metsyS(rennacS.litu.avaj wen = r rennacS.litu.avaj        
//;"" = s gnirtS        
//{ )a ][gnirtS(niam diov citats cilbup    
//{ c ssalc

Python 2, 68 bajtów

import sys
x=''.join(l[:-1]+'#\n'for l in sys.stdin)
print x+x[::-1]

Nie działa, jeśli jest uruchamiany z IDLE, ponieważ musisz wygenerować znak EOF, aby program nie czekał na dane wejściowe.

Dane wyjściowe po uruchomieniu na sobie:

import sys#
x=''.join(l[:-1]+'#\n'for l in sys.stdin)#
print(x+x[::-1])#

#)]1-::[x+x(tnirp
#)nidts.sys ni l rof'n\#'+]1-:[l(nioj.''=x
#sys tropmi

Podziękowania dla Grega Hewgilla za pomoc w rozwiązywaniu problemów i grze w golfa.

GolfScript, 10 9 bajtów

"
}"+.-1%

Zupełnie podobne do rozwiązania minitech , ale działa dobrze z nowymi liniami . Polega na śmiesznym (i nieudokumentowanym) zachowaniu GolfScript, aby zignorować niedopasowane (i nieskomentowane) }, a także wszystko, co następuje po nim.

Nie powiedzie się, jeśli dane wejściowe zawierają niedopasowane dane {, ale technicznie stanowi to błąd składniowy.

Jak to działa

"
}"   # Push the string "\n}".
+    # Concatenate it with the input string.
.    # Duplicate the modified string.
-1%  # Reverse the copy.

Przykład

$ echo -n '1{"race{car"}
> {"foo\"bar"}
> if#' | golfscript make-palindrome.gs
1{"race{car"}
{"foo\"bar"}
if#
}}
#fi
}"rab"\oof"{
}"rac{ecar"{1
$ echo '1{"race{car"}
> {"foo\"bar"}
> if#
> }}
> #fi
> }"rab"\oof"{
> }"rac{ecar"{1' | golfscript
race{car

Kod maszynowy x86 w systemie DOS ( .complik) - 70 bajtów

Radzenie sobie z plikami .COM, tworzenie palyndromu jest łatwe - ponieważ „moduł ładujący” COM po prostu umieszcza zawartość pliku pod adresem 100h i przeskakuje tam, program musi już jakoś zakodować swój koniec i zignorować wszystko po nim, abyśmy mogli po prostu dołączyć odwrotność pierwszych bajtów N-1 (tylko zastrzeżenie: jeśli program w jakiś sposób próbuje wykonać sztuczki z długością pliku, wszystko się psuje).

Oto zrzut hex mojej .COM-palyndromizing .COM:

00000000  31 db 8a 1e 80 00 c6 87  81 00 00 ba 82 00 b8 00  |1...............|
00000010  3d cd 21 72 30 89 c6 bf  ff ff b9 01 00 ba fe 00  |=.!r0...........|
00000020  89 f3 b4 3f cd 21 3c 01  75 18 b4 40 bb 01 00 cd  |...?.!<.u..@....|
00000030  21 85 ff 75 e5 89 f3 f7  d9 88 ee b8 01 42 cd 21  |!..u.........B.!|
00000040  eb d8 47 74 f0 c3                                 |..Gt..|

Pobiera plik wejściowy z wiersza poleceń i zapisuje dane wyjściowe na stdout; oczekiwane użycie jest podobnecompalyn source.com > out.com .

Skomentowany montaż:

    org 100h

section .text

start:
    ; NUL-terminate the command line
    xor bx,bx
    mov bl, byte[80h]
    mov byte[81h+bx],0
    ; open the input file
    mov dx,82h
    mov ax,3d00h
    int 21h
    ; in case of error (missing file, etc.) quit
    jc end
    ; si: source file handle
    mov si,ax
    ; di: iteration flag
    ; -1 => straight pass, 0 reverse pass
    mov di,-1
loop:
    ; we read one byte at time at a bizarre memory
    ; location (so that dl is already at -2 later - we shave one byte)
    mov cx,1
    mov dx,0feh
    mov bx,si
    mov ah,3fh
    int 21h
    ; if we didn't read 1 byte it means we either got to EOF
    ; or sought before the start of file
    cmp al,1
    jne out
    ; write the byte on stdout
    mov ah,40h
    mov bx,1
    int 21h
    ; if we are at the first pass we go on normally
    test di,di
    jnz loop
back:
    ; otherwise, we have to seek back
    mov bx,si
    ; one byte shorter than mov cx,-1
    neg cx
    ; dl is already at -2, fix dh so cx:dx = -2
    mov dh,ch
    mov ax,4201h
    int 21h
    jmp loop
out:
    ; next iteration
    inc di
    ; if it's not zero we already did the reverse pass
    jz back
end:
    ret

Testowane na sobie i rozwiązania poprzedniego pytania wydają się działać dobrze w DosBox, nastąpi kilka bardziej szczegółowych testów „kanonicznych” plików wykonywalnych DOS.

GolfScript, 8

.-1%'#'\

Nie obsługuje nowych linii, ale nikt nie używa ich w GolfScript.

Bash + coreutils, 39 bajtów

f="`cat`
exit"
echo "$f"
tac<<<"$f"|rev

Odczytuje ze STDIN i wysyła do STDOUT:

$ cat hello.sh 
#!/bin/bash

echo 'Hello, World!'

$ ./palin.sh < hello.sh 
#!/bin/bash

echo 'Hello, World!'
exit
tixe
'!dlroW ,olleH' ohce

hsab/nib/!#
$ 

Javascript ( ES6 ) Multi-line - 71

Rodzaju ukradł metodę komentarza Quincunx tutaj:

alert((x=prompt().replace(/\n/g,'//\n')+'/')+[...x].reverse().join(''))

Pojedyncza linia - 49

alert((x=prompt()+'/')+[...x].reverse().join(''))

C ++, 214 209 bajtów

#include<cstdio>
#include<stack>
int main(){std::stack<char>s;int c;while((c=getc(stdin))>EOF){if(c=='\n')for(int i=2;i;i--)s.push(putchar('/'));s.push(putchar(c));}while(s.size()){putchar(s.top());s.pop();}}

Wynik działania na sobie:

#include<cstdio>//
#include<stack>//
int main(){std::stack<char>s;int c;while((c=getc(stdin))>EOF){if(c=='\n')for(int i=2;i;i--)s.push(putchar('/'));s.push(putchar(c));}while(s.size()){putchar(s.top());s.pop();}}//

//}};)(pop.s;))(pot.s(rahctup{))(ezis.s(elihw};))c(rahctup(hsup.s;))'/'(rahctup(hsup.s)--i;i;2=i tni(rof)'n\'==c(fi{)FOE>))nidts(cteg=c((elihw;c tni;s>rahc<kcats::dts{)(niam tni
//>kcats<edulcni#
//>oidtsc<edulcni#

Brainfuck, 749 bez białych znaków (bez gry w golfa)

Powoduje to pieprzenie mózgów, które odzwierciedlają palindromy, tzn. Są lustrzanymi odbiciami samych siebie.

++++++++++
[->++++>+++++++++<<]>+++.>+..<.>++.
>>>>+[>,]<-[+<-]
>[
  [-<+<<+>>>]
  +<-------------------------------------------[-<+>>[-]<]>[-<<<.>>>]
  +<<-[->+>[-]<<]>>[-<<<.>>>]
  +<-[-<+>>[-]<]>[-<<<.>>>]
  +<<-[->+>[-]<<]>>[-<<<.>>>]
  +<--------------[-<+>>[-]<]>[-<<<.>>>]
  +<<--[->+>[-]<<]>>[-<<<.>>>]
  +<-----------------------------[-<+>>[-]<]>[-<<<.>>>]
  +<<--[->+>[-]<<]>>[-<<<.>>>]
  <[-]>>
]
<<<<[<]
<--.<.>++..--..<.>++.
>>[>]
<[
  [->+>>+<<<]
  +>-------------------------------------------[->+<<[-]>]<[->>>.<<<]
  +>>-[-<+<[-]>>]<<[->>>.<<<]
  +>-[->+<<[-]>]<[->>>.<<<]
  +>>-[-<+<[-]>>]<<[->>>.<<<]
  +>--------------[->+<<[-]>]<[->>>++.--<<<]
  +>>--[-<+<[-]>>]<<[->>>--.++<<<]
  +>-----------------------------[->+<<[-]>]<[->>>++.--<<<]
  +>>--[-<+<[-]>>]<<[->>>--.++<<<]
  >[-]<<
]
<--.<.>++..<.

Podany program wydaje

+[[+]PROGRAM[+]][[+]MIRROR[+]]+

z programem PROGRAMi MIRRORzastąpiony przez program (bez znaków niemówiących mózgów) i jego odbicie lustrzane.

C 168 175

Prawidłowo obsługuje znaki nowej linii w kodzie źródłowym

Edytuj 1 naprawiony błąd, gdy brakuje ostatniej linii Nowa
edytuj 2 naprawiony błąd, gdy wiersz wewnątrz komentarza kończy się *: dodaj znak tabulacji przed //komentarzem
(i grał w golfa więcej)

b[999999];main(c,z){char*p,for(p=b;(*p=c=getchar())>=0;z=c,p++)c-10||(z-92?*p++=9,*p++=47,*p++=47,*p=c:(p-=2));*p=47;for(p=b;*p;)putchar(*p++);for(;p>b;)putchar(*--p);}

C99 Standardowy, poprawny kod, wiele ostrzeżeń

Nie golfił

b[999999]; // working buffer ~ 4M on 32 bit machine, max source size
// c is current char, z is previous char,
main(c,z) // z  start as argv pointer, will be out of char range
{
  char *p;
  for(p = b; 
      (*p=c=getchar()) >= 0; // while testing EOF copy char to buffer set c variable
      z=c, p++) // at end loop increment p and set previous = current
  {
      c-'\n' || // if newline 
       (z - '\\' // check if escaped
          ? *p++='\t',*p++='/',*p++='/', *p=c // if not escaped, add tab,/,/ and newline
          : (p-=2) // if escaped, drop both escape and newline
       ); 
  }
  *p='/'; // if last newline missing, will add a comment anyway
  for(p=b;*p;) putchar(*p++); // ouput buffer 
  for(;--p>=b;) putchar(*p); // outbut buffer reversed
}

C # - 174

using System;using System.Linq;class c{public static void Main(){var a="";var b="";while((a=Console.ReadLine())!="")b+=a+"//\n";Console.Write(b+string.Concat(b.Reverse()));}}

Wejście testowe:

using System; 
using System.Linq; 
class c 
{ 
    public static void Main() 
    { 
        var a = ""; 
        var b = ""; 
        while ((a = Console.ReadLine()) != "") 
            b += a + "//\n"; 
        Console.Write(b+string.Concat(b.Reverse())); 
    } 
} 

Wyjście testowe:

using System; 
using System.Linq; 
class c 
{ 
    public static void Main() 
    { 
        var a = ""; 
        var b = ""; 
        while ((a = Console.ReadLine()) != "") 
            b += a + "//\n"; 
        Console.Write(b+string.Concat(b.Reverse())); 
    } 
} 

// }
// }
// ;)))(esreveR.b(tacnoC.gnirts+b(etirW.elosnoC
// ;"n\//" + a =+ b
// )"" =! ))(eniLdaeR.elosnoC = a(( elihw
// ;"" = b rav
// ;"" = a rav
// {
// )(niaM diov citats cilbup
// {
// c ssalc
// ;qniL.metsyS gnisu
// ;metsyS gnisu

PHP, 96 bajtów

function a($b){
    echo $c = "a('$b')" . strrev("a)'" . $b . "'(");
    $d = substr($c, 0, strlen($b) + 5);
    eval("$d;");
}

Przykładowe użycie:

a('apple'); // echoes a('apple')('elppa')a until your bytes get exhausted

To nie jest mądre. To tylko prosty kod, który spełnia swoje zadanie ... Miałem ochotę grać. Wiem, że ten kod jest pełen złych praktyk programistycznych!

Na koniec chętnie zaakceptuję wszelkie uwagi i poprawki do tego kodu!

Kobra - 134

class P
    def main
        i=List<of String?>(Console.readLine.split('\n'))
        print '/#\n[i.reversed.join("\n")]\n#/#\n[i.join("\n")]\n#/'

Rakieta 133

(require srfi/13)(let((r read-line)(w display))(let l((i(r)))(when
(not(eq? eof i))(w i)(w";\n")(l(r))(w"\n;")(w(string-reverse i)))))

Niegolfowany (ale nadal bardzo imperatywny):

(require srfi/13)
(let recurse ((instr (read-line)))
  (when (not (eof-object? instr))
    (display instr)
    (display ";\n")
    (recurse (read-line))
    (display "\n;")
    (display (string-reverse instr))))

Dane wyjściowe, gdy dane wejściowe otrzymają wersję bez golfisty

(require srfi/13);
(let recurse ((instr (read-line)));
  (when (not(eof-object? instr));
    (display instr);
    (display ";\n");
    (recurse (read-line));
    (display "\n;");
    (display (string-reverse instr))));

;))))rtsni esrever-gnirts( yalpsid(    
;)";n\" yalpsid(    
;))enil-daer( esrucer(    
;)"n\;" yalpsid(    
;)rtsni yalpsid(    
;))rtsni ?tcejbo-foe(ton( nehw(  
;)))enil-daer( rtsni(( esrucer tel(
;)31/ifrs eriuqer(