Il tuo compito è semplice. Il programma legge una riga di testo dall'input standard e stampa lo stesso testo in una forma capovolta. Non è consentito stampare nient'altro.

Per esempio:

input: "Hello!", output: "! olleH"

Il problema è che il tuo programma deve essere in grado di fare esattamente la stessa cosa se il codice sorgente stesso è invertito di caratteri!

Punteggio: si applica il punteggio standard del golf di codice, con la seguente modifica per limitare il noioso

//margorp
program//

risposte di stile: qualsiasi soluzione che sia un palindromo comporterà una penalità del + 25% al ​​punteggio, arrotondato per eccesso. Questa penalità si applica ancora, se, ad esempio, si inseriscono nel programma personaggi che non hanno effetti utili, solo per rompere il palindromo.

APL, 5

⌽⍞⍝⍞⊖

Questo inverte ( ⌽, lungo l'ultimo asse) l'input ( ⍞), ed è seguito da un commento ( ⍝segna un commento di riga). Invertito, il programma inverte ( ⊖lungo il primo asse) l'input ed è seguito da un commento. Perché l'input sarà sempre monodimensionale, in questo caso ⌽e ⊖funzionalmente equivalenti. Forse è anche più subdolo della soluzione GolfScript, quindi ecco una soluzione più pulita (nessun commento), che segna 9 .

⍬,⌽,⍞,⊖,⍬

Questo prima afferra un vettore vuoto ( ⍬), lo appiattisce (monadico ,) e lo inverte ( ⊖, lungo il primo asse). Questo lascia ancora un vettore vuoto. Quindi si concatena (diadico ,) all'input ( ⍞), lasciando l'input intatto. Quindi appiattisce (monadicamente ,) l'ingresso già piatto e lo inverte ( ⌽, lungo l'ultimo asse). Quindi concatena (diadico ,) un altro vettore vuoto ( ⍬) all'ingresso invertito. Questo non fa nulla e lascia indietro l'input invertito. Invertito, questo programma fa la stessa cosa, basandosi di nuovo sul fatto che ⌽e ⊖sono funzionalmente equivalenti a argomenti unidimensionali.

Non potevi davvero dire che sto aggiungendo caratteri inutili per spezzare il palindromo (le due diverse funzioni inverse sono diverse con un input bidimensionale o più; sto solo approfittando del fatto che si comportano allo stesso modo con uno- input dimensionale)

Shell Unix - 8 + 25% = 10

rev||ver

La precedente risposta di cat|tacnon ha effettivamente funzionato, tacinverte l'ordine delle righe, non l'ordine dei caratteri in una riga.

Haskell, 53

main=niam
niam=interact reverse
esrever tcaretni=main

Tecnicamente non è un palindromo, ma, poiché l'ordine di dichiarazione delle funzioni non ha importanza, una volta invertito si ha esattamente lo stesso programma.

Ruby, 37

eval <<1.reverse#
esrever.steg stup
1

invertito:

1
puts gets.reverse
#esrever.1<< lave

Tcl, 78

puts [string rev [gets stdin]];#\
]]nidts steg[ ver gnirts[ stup;# tixe emaner

Non un palindromo.

gs2, 2

(Sì, questo linguaggio è stato creato prima della sfida. No, non è uno scherzo o una scappatoia. Lo spazio ASCII ( 0x20) è al contrario .)

EDIT: aw, amico, questa domanda è super vecchia? Se solo avessi commesso prima. : <Lascerò questa risposta solo perché è troppo bello per lasciar perdere, però.

Golfscript, 9 (7 * 1.25 = 8.75)

-1%#%1-

sporco, sporco, sporco, ma estremamente corto. -1%significa "seleziona ogni elemento (carattere), all'indietro" e #significa "commento riga". Il resto è solo un po 'della magia I / O di GolfScript.

Questa è la soluzione "pulita" più breve (senza commenti) che ho trovato ( 14 * 1.25 = 17.5 ):

'';-1%..%1-;''

significato: spingere una stringa vuota, rilasciarla, invertire l'input, clonarla due volte, dividerla da sola (consumando due copie e producendo una matrice vuota), rimuovere tutte quelle dalla matrice vuota, rilasciare la matrice emtpy, premere una stringa vuota e (implicitamente) stampa la pila.

Ruby, 44

puts gets.reverse#esrever.steg stup

Solo un commento alla fine di un normale programma: P

35 caratteri, + 25% = 44

Tcl, 75,25

Questa volta un palindromo.

puts [string rev [gets stdin]]]]nidts steg[ ver gnirts[ stup

Python 3, 42

print(input()[::-1]);#)]1-::[)(tupni(tnirp

Titoli di coda

• Versione iniziale con punteggio del 49 + 25% = 61,25 creato da me
• Grazie ad Arshajii per migliorare il punteggio da 61,25 a 51,25
• Nuova versione con punteggio di 42 ( :-)) creata da me

Rebmu : 9 (con penalità) o 13 (senza)

La noiosa soluzione Rebmu è 9 e sopporta la penalità palindromica. Lo mostrerò comunque "solo perché":

rnRVaVRnr

Usando il trucco poco pratico di notare lettere maiuscole di lettere sono parole separate, e la mancanza di una corsa maiuscola principale significa che non stiamo creando una parola fissa , produciamo cinque parole ordinarie:

rn rv a vr nr

Che è una scorciatoia per il codice equivalente (anche Rebmu legale):

return reverse a vr nr

Il fatto che vr e nr siano privi di significato non importa, perché nonostante non siano assegnati a nulla sono parole valide. Quindi il valutatore esegue solo il return reverse a... funziona in entrambi i modi. Ma questo è analogo in un certo senso al noioso trucco: il codice non è commentato, ma è morto e non eseguito su un percorso.

Per qualcosa di più eccitante che non comporta penalità, che ne dici di questa soluzione a 13 personaggi:

a VR :rv AvrA

Diamo un'occhiata a come viene elaborato sui percorsi avanti e indietro, quando espanso. Inoltrare:

a               ; evaluate a, as it is a string it has no side effects
vr: :reverse    ; "set" vr to mean what a "get" of reverse means now
a: vr a         ; assign a to calling "vr" on a, effectively reversing
                ;   ^-- result of assign is last expression, the answer!

Indietro come ArvA vr: RV a:

a: reverse a    ; assign A to its reversal
vr: rv: a       ; make the abbreviation vr equal to assignment of a to rv
                ;   ^-- result of assign is last expression, the answer!

Sul lato negativo, la variante all'indietro sta sovrascrivendo l'abbreviazione per il contrario. Ma hey, non è un palindromo, ed è solo 13 personaggi. :-)

(Nota: questo presuppone che tu stia eseguendo Rebmu in modalità / args, dove a è l'argomento predefinito al programma passato all'interprete sulla riga di comando e tu accetti il ​​risultato. Se la lettura dall'input standard è effettivamente un requisito, cose crescere ad esempio da 9 a 11 caratteri per la soluzione semplice: rnRVrArVRnrE se si deve stampare sullo standard output dall'interno del programma invece di accettare l'espressione output dell'interprete che aggiungerebbe anche un paio di caratteri.)

JavaScript, 62 * 1.25 = 78

i.split('').reverse().join('')//)''(nioj.)(esrever.)''(tilps.i

Non troppo creativo, ma il meglio che ho potuto inventare. (presuppone che l'input sia archiviato in variabile i)

Ho ricevuto questo:

63 caratteri, nessun palindromo

i.split('').reverse().join('')//)a(nioj.)(esrever.)''=a(tilps.i

ma sembrava troppo barare. : PI potrebbe fare molti altri cambiamenti banali (come usare i['split']invece di i.split), ma tutti quelli hanno ancora voglia di barare: P

Pyke, 2 (+ 25%), non concorrenziale

_

Pyke prende l'input in modo implicito e l'output in modo implicito.

_ è la funzione inversa.

Tcl, 99

proc unknown args {puts "Hello World!"}
}"!dlroW olleH" stup{ sgra nwonknu corp

Se viene chiamato un comando che non esiste, viene chiamato un unknowncomando speciale che può caricare il comando. O fai altre cose divertenti.

T-SQL, 86 * 1,25 = 108

Ecco una voce noiosa palindromica per SQL Server 2008 (e versioni successive) solo per dimostrare che è possibile.

DECLARE @ VARCHAR(MAX)='Hi'PRINT REVERSE(@)--)@(ESREVER TNIRP''=)XAM(RAHCRAV @ ERALCED

@ contiene il testo di input, la stringa di esempio è "Ciao". Il conteggio dei caratteri di questa voce è per una stringa di input a due caratteri.

Keg , ceil (1 + 0,25) = 2 byte

?

Questo richiede input e reverse, e l'output implicito lo emette letteralmente. TIO

Befunge-98 (PyFunge) , 17 byte

#[~   #<
 [:!k@,v

Provalo online!

Provalo online! (Invertito)

QBIC , 14 + 25% = 18 byte

;?_fA|#|Af_?;

Impiega un codice sorgente palindromico. L'utilizzo di due modi distinti per farlo richiede un po 'più di tempo (34 byte):

;[_lA|,1,-1|Z=Z+mid$(A,a,1)#|Af_?;

Spiegazione:

Read the input string from the command line as A$
;

FOR len(A$); a >= 1; a--
[        Starts a FOR loop
_l...|   returns the length the argument(here, A$); sets the starting point of the loop
,1       set the end point of the loop
,-1      FOR loop incrementer (or decrementer in this case)
|        Ends the argument list for the FOR loop

On each FOR iteration, add the right-most character of the input to Z$
Z=Z+mid$(A,a,1)

The cheat:
# starts a string literal, hiding the flipped source.
    The literal is closed implicitly at the end-of-file.
    The FOR loop is closed implicitly at the end-of-file.
    Z$ gets printed implicitly at the end of the program if it's non-empty

The flipped source is the same as my palindrome-code:
;       reads in A$ from the cmd line   
 ?      PRINT
  _fA|  The reversed version of A$
      # And hide the rest of our source in a literal  

Pushy , 7 byte (5 + 25%)

@"i"@

Provalo online!

Ciò comporta una penalità del 25% in quanto è un palindromo, ma è il massimo che potrei fare. Indipendentemente dal modo in cui viene eseguito il programma, esegue questi 3 comandi:

@     \ Reverse the input
 "    \ Print
  i   \ Exit

La sostituzione idi c(clear stack) o \(comment) ha lo stesso effetto.

05AB1E , 1 + 25% = 2 byte

R

Provalo online!

R , 65 byte

EDIT: abbandonato il rigore del 25% grazie a un cambio banale, ma non visto per me, da Grimy.

stringi::stri_reverse(scan(,""))#))'',(nacs(esrever_irts::ignirts

Provalo online!

Saluta l'abilità abissale di R di gestire le stringhe, anche quando usi pacchetti progettati per stringhe come stringi... barf