Sua tarefa é simples. O programa lê uma linha de texto da entrada padrão e imprime o mesmo texto em um formulário invertido. Não é permitido imprimir mais nada.

Por exemplo:

entrada: "Olá!", saída: "! olleH"

O problema é que o seu programa deve ser capaz de fazer exatamente a mesma coisa se o código-fonte for invertido!

Pontuação: aplica-se a pontuação padrão de código-golfe, com a seguinte modificação para limitar a pontuação

//margorp
program//

respostas de estilo: qualquer solução que seja um palíndromo sofrerá uma penalidade de + 25% na pontuação, arredondada para cima. Essa penalidade ainda se aplica, se você, por exemplo, inserir caracteres no programa que não tenham nenhum efeito útil, apenas para quebrar o palíndromo.

APL, 5

⌽⍞⍝⍞⊖

Isso reverte ( ⌽, ao longo do último eixo) a entrada ( ⍞) e é seguida por um comentário ( ⍝marca um comentário na linha). Invertido, o programa reverte ( ⊖, ao longo do primeiro eixo) a entrada e é seguido por um comentário. Porque a entrada sempre será unidimensional, neste caso, ⌽e ⊖é funcionalmente equivalente. Talvez seja ainda mais furtivo do que a solução GolfScript, então aqui está uma solução mais limpa (sem comentários), com pontuação 9 .

⍬,⌽,⍞,⊖,⍬

Primeiro, ele pega um vetor vazio ( ⍬), nivela (monádico ,) e o inverte ( ⊖, ao longo do primeiro eixo). Isso ainda deixa um vetor vazio. Em seguida, concatena (diádica ,) à entrada ( ⍞), deixando a entrada intocada. Nivela (monádico ,) a entrada já plana e a inverte ( ⌽, ao longo do último eixo). Em seguida, concatena (diádico ,) outro vetor vazio ( ⍬) para a entrada reversa. Isso não faz nada e deixa para trás a entrada reversa. Revertida, este programa faz a mesma coisa, com base novamente no fato de que ⌽e ⊖são funcionalmente equivalentes com argumentos de um dimesional.

Você realmente não poderia dizer que estou adicionando caracteres inúteis para quebrar o palíndromo (as duas funções inversas diferentes são diferentes com entradas bidimensionais ou mais dimensionais; estou apenas aproveitando o fato de que elas agem da mesma maneira com uma) entrada dimensional)

Shell Unix - 8 + 25% = 10

rev||ver

A resposta anterior de cat|tacrealmente não funcionou, tacinverte a ordem das linhas, não a ordem dos caracteres em uma linha.

Haskell, 53

main=niam
niam=interact reverse
esrever tcaretni=main

Tecnicamente, não é um palíndromo, mas, como a ordem das declarações de funções não importa, uma vez revertido, você tem exatamente o mesmo programa.

Ruby, 37

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

Invertida:

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

Tcl, 78

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

Não é um palíndromo.

gs2, 2

(Sim, esse idioma foi criado antes do desafio. Não, não é uma piada ou brecha. O espaço ASCII ( 0x20) é inverso .)

EDIT: ah, cara, esta pergunta é super antiga? Se ao menos eu tivesse cometido antes. : <Vou deixar essa resposta só porque é bom demais para deixar passar.

Golfscript, 9 (7 * 1,25 = 8,75)

-1%#%1-

sujo, sujo, sujo, mas extremamente curto. -1%significa "selecione cada elemento (caractere), ao contrário" e #significa "comentário de linha". O resto é apenas um pouco da mágica de E / S do GolfScript.

Esta é a menor solução "limpa" (sem comentários) que eu encontrei ( 14 * 1,25 = 17,5 ):

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

significado: empurre uma string vazia, solte-a, inverta a entrada, clone-a duas vezes, divida-a sozinha (consumindo duas cópias e produzindo uma matriz vazia), remova todas as da matriz vazia, solte a matriz vazia, empurre uma string vazia e (implicitamente) imprima a pilha.

Ruby, 44

puts gets.reverse#esrever.steg stup

Apenas um comentário no final de um programa normal: P

35 caracteres, + 25% = 44

Tcl, 75,25

Desta vez, um palíndromo.

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

Python 3, 42

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

Créditos

• Versão inicial com pontuação de 49 + 25% = 61.25 criada por mim
• Agradecimentos a arshajii por melhorar a pontuação de 61,25 para 51,25
• Nova versão com pontuação de 42 ( :-)) criada por mim

Rebmu : 9 (com multa) ou 13 (sem)

A solução Rebmu chata é 9 e tem a penalidade palindrômica. Vou mostrar de qualquer maneira "apenas porque":

rnRVaVRnr

Usando o truque silencioso de perceber letras maiúsculas em maiúsculas são palavras separadas, e a falta de uma maiúscula em maiúsculas significa que não estamos criando uma palavra-chave, produzimos cinco palavras comuns:

rn rv a vr nr

Qual é uma abreviação para o código equivalente (também legal Rebmu):

return reverse a vr nr

O fato de vr e nr não terem sentido não importa, porque apesar de não serem atribuídos a nada, são palavras válidas. Portanto, o avaliador apenas executa o return reverse a... funciona nos dois sentidos. Mas isso é análogo em um sentido à fraude chata: o código não é comentado, mas está morto e não é executado em um caminho.

Para algo mais emocionante que não incorre na penalidade, que tal esta solução de 13 caracteres:

a VR :rv AvrA

Vamos ver como isso é processado nos caminhos para frente e para trás, quando expandido. Frente:

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!

Para trás como 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!

No lado negativo, a variante reversa substitui a abreviação para reversão. Mas ei, não é um palíndromo e são meros 13 caracteres. :-)

(Nota: Isso pressupõe que você esteja executando o Rebmu no modo / args, em que a é o argumento padrão do programa passado ao intérprete na linha de comando e você aceita o resultado. Se a leitura da entrada padrão é realmente um requisito, as coisas aumente, por exemplo, de 9 a 11 caracteres para a solução simples : rnRVrArVRnr. E se você precisar imprimir na saída padrão do programa em vez de aceitar a saída de expressão do intérprete que também adicionaria alguns caracteres.)

JavaScript, 62 * 1,25 = 78

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

Não é muito criativo, mas o melhor que eu poderia ter. (assume que a entrada está armazenada na variável i)

Eu recebi isso:

63 caracteres, sem palíndromo

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

mas parecia muita trapaça. : O PI poderia fazer muito mais alterações triviais (como usar em i['split']vez de i.split), mas todos ainda têm vontade de trapacear: P

Pyke, 2 (+ 25%), não concorrente

_

Pyke recebe entrada implicitamente e gera saída implicitamente.

_ é a função reversa.

Tcl, 99

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

Se um comando que não existe for chamado, será chamado um unknowncomando especial que poderá carregar o comando. Ou faça outras coisas engraçadas.

T-SQL, 86 * 1,25 = 108

Aqui está uma entrada palíndrica chata para o SQL Server 2008 (e mais recente) apenas para mostrar que é possível.

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

@ mantém o texto de entrada, a sequência de exemplo sendo "Hi". A contagem de caracteres desta entrada é para uma sequência de entrada de dois caracteres.

Barril , teto (1 + 0,25) = 2 bytes

?

Isso leva a entrada e a reversão, e a saída implícita a produz literalmente. TIO

Befunge-98 (PyFunge) , 17 bytes

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

Experimente online!

Experimente online! (Invertido)

QBIC , 14 + 25% = 18 bytes

;?_fA|#|Af_?;

Emprega um código-fonte palíndrico. O uso de duas maneiras distintas de fazer isso leva um pouco mais de tempo (34 bytes):

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

Explicação:

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 bytes (5 + 25%)

@"i"@

Experimente online!

Isso incorre na penalidade de 25%, pois é um palíndromo, mas é o melhor que eu poderia fazer. Não importa o caminho em que o programa é executado, ele executa estes 3 comandos:

@     \ Reverse the input
 "    \ Print
  i   \ Exit

Substituir ipor c(limpar pilha) ou \(comentário) tem o mesmo efeito.

05AB1E , 1 + 25% = 2 bytes

R

Experimente online!

R , 65 bytes

EDIT: Abandonei a penalidade de 25% graças a uma alteração trivial, mas invisível para mim, feita por Grimy.

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

Experimente online!

Diga Olá para a capacidade abismal de R lidar com cordas, mesmo quando você usa pacotes concebidos para cordas como stringi... barf