Flagrante rip-off de um rip-off . Voto a favor!

Sua tarefa, se você deseja aceitá-la, é escrever um programa / função que produz / retorna sua entrada / argumento inteiro. A parte complicada é que, se eu reverter seu código-fonte, a saída deve ser o número inteiro original negado.

Exemplos

Digamos que seu código fonte seja ABCe sua entrada seja 4. Se eu escrever CBAe executá-lo, a saída deve ser -4.

Digamos que seu código fonte seja ABCe sua entrada seja -2. Se eu escrever CBAe executá-lo, a saída deve ser 2.

Uma entrada de 0pode dar 0ou -0, no entanto, se você suportar zero assinado, -0deve dar 0.

PowerShell , 18 14 bytes

$args#"sgra$"-

Experimente online! ! enilno ti yrT

Primeira das respostas triviais de abuso de comentários

J , 3 bytes

-&0

Experimente online!

-&0 é "argumento menos 0"

0&- é "0 argumento negativo"

JavaScript, 11 bytes

n=>n//n->=n

Experimente Online! | Invertida

código de máquina x86, 3 bytes

C3 D8 F7

Os bytes de código acima definem uma função que não é operacional: ele simplesmente retorna o controle para o chamador. Essa função é seguida por dois bytes de lixo que não serão executados, pois vêm após um retorno - eles estão na "terra de ninguém". Em mnemônicos montadores:

ret                     ; C3    
fdiv  st(0), st(7)      ; D8 F7

Ok, agora alguns trolls passam e invertem a ordem dos bytes:

F7 D8 C3

Esses bytes agora definem uma função que recebe um argumento inteiro no EAXregistro, o nega e retorna o controle para o chamador. Em mnemônicos montadores:

neg  eax     ; F7 D8
ret          ; C3

Então ... isso foi simples. :-)

Note que podemos fazer a instrução "negação" ser qualquer coisa que queremos, uma vez que nunca é executado no "forward" orientação e apenas executado no "revertida" orientação. Portanto, podemos seguir o mesmo padrão para fazer coisas arbitrariamente mais complicadas. Por exemplo, aqui pegamos um argumento inteiro em um registro diferente (por exemplo, EDIpara seguir a convenção de chamada do System V comumente usada em sistemas * nix), negá-lo e retorná-lo no EAXregistro convencional :

C3      ret
D8 F7   fdiv  st(0), st(7)      ;  \ garbage bytes that
F8      clc                     ;  | never get executed,
89      .byte 0x89              ;  / so nobody cares

  ↓ ↓

89 F8   mov  eax, edi
F7 D8   neg  eax
C3      ret

Geléia , 2 bytes

oN

Experimente online! e seu reverso .

oN - (input) OR ((input) negated)

No - ((input) negated) OR (input)

Haskell , 8 bytes

Função de identidade anônima, transformando-se em subtração 0quando invertida.

id--)-0(

Experimente online!

Invertida:

(0-)--di

Experimente online!

Espaço em branco , 48 bytes

S S S N
S N
S T N
T   T   T   T   T   T   N
S T N
N
N
T   S N
T   N
S S T   N
T   T   S S T   T   T   T   T   N
T   S N
S N
S S S 

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.

Modificação menor da minha resposta de espaço em branco para inverter o código fonte, você nega a saída! desafio .

Experimente on-line ou on -line invertida (apenas com espaços brutos, guias e novas linhas).

Explicação:

Utilizando o Programa de Saída, é um palíndromo curto NNN.
O programa regular irá:

SSSN   # Push 0 to the stack
SNS    # Duplicate it
TNTT   # Read STDIN as integer, and store it at heap address 0
TTT    # Retrieve the input from heap address 0, and push it to the stack
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

O programa reverso irá:

SSSN   # Push 0 to the stack
SNS    # Duplicate it
TNTT   # Read STDIN as integer, and store it at heap address 0
TTT    # Retrieve the input from heap address 0, and push it to the stack
SSTTN  # Push -1 to the stack
TSSN   # Multiply the top two values on the stack together
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

Pequena explicação adicional de como pressionar um número:

• Primeiro S: Ativar manipulação de pilha
• Segundo S: Empurre um número para a pilha
• Sou T: positivo / negativo, respectivamente
• Alguns S/ Tseguidos por um final N: número em binário, onde S=0eT=1

Ou seja, SSTTSTSNempurra -10. Para o 0que não precisamos de um explícito S=0, tão simples SSSNou SSTNé suficiente.

Perl 6 / Raku, 3 bytes

*-0

Experimente online!

Cria um bloco de código Whatever. Leia normalmente seu equivalente de bloco padrão é -> \x {x - 0}, mas ao contrário ele se torna -> \x {0 - x}.

C (clang) , 23 bytes

f(*x){}//};x*-=x*{)x*(g

Experimente online!

Flak cerebral , 7 bytes

#)]}{[(

Experimente online!

Invertida:

([{}])#

Experimente online!

Nota: Funciona apenas em intérpretes que suportam comentários (por exemplo, funciona no Rain-Flak, mas não no BrainHack)

Se também trocarmos colchetes de abertura / fechamento em vez de apenas reverter os bytes, podemos fazer isso em 8 bytes sem usar comentários:

({}[{}])

Experimente online!
Experimente invertido!

Labirinto / Hexagonia , 6 bytes

Labirinto:

?!@!`?

Experimente online! e seu reverso .

Hexagonia:

?!@!~?

Experimente online! e seu reverso .

Quão?

?       - take a signed integer
(` / ~) - negate
!       - output top-of-stack / current-memory-edge
@       - exit

Python 3 , 22 bytes

lambda x:x#x-:x adbmal

Experimente online!

Um lambda que implementa a função de identidade (ou negação)

MarioLANG , 22 bytes

;:
=#
:)!
--
<(
"
[>
;

Experimente online!

Ele apenas insere e gera o número antes de cair para o EOF

invertido:

;
>[
"
(<
--
!):
#=
:;

Experimente online!

Ele faz um loop até que o valor de entrada seja 0 e o valor de saída seja -input, ele diz o número.

R , 23 bytes

Eu decidi tentar sem o truque para comentar.

frente

`+`=scan;""+-0;nacs=`+`

Experimente online!

Marcha ré

`+`=scan;0-+"";nacs=`+`

Experimente online!

Na versão direta, +está atuando como um operador binário e -é um operador unário.

No reverso, +torna - se unário e -é binário. Portanto, a função scan aceita os argumentos: o file=""que significa stdin e what=0, que também são padrões. Portanto, quando o +é unário, o primeiro argumento está à direita, quando é binário, o primeiro argumento está à esquerda.

o

;nacs=`+`

parte do código não faz nada realmente útil, portanto, em certo sentido, meu código não é realmente muito mais válido do que usar o truque de comentário.

Haskell, 12 bytes

f=id;x-0=x f

Experimente online! Marcha ré:

f x=0-x;di=f

Experimente online!

Não é tão curto quanto a resposta de Ørjan Johansen , mas sem comentários.

Perl 5 ( -p), 7 6 bytes

-1 graças a @primo

$_*=$#

TIO

Um comentário não altera a entrada

#1-=*_$

Negar a entrada

$_*=-1#

TIO

Gaia , 2 bytes

_@

Experimente online!

_	| implicit push input and negate
 @	| push next input OR push last input (when all inputs have been pushed)
	| implicit print TOS

Invertida:

@	| push input
 _	| negate
	| implicit print TOS

Backhand , 6 5 bytes

I@-Ov

Experimente online! Experimente dobrou!

Tornou um pouco complexo devido à natureza do ponteiro no Backhand. Eu não acho que é possível ficar mais curto haha, acontece que eu estava errado. Isso não duplica nenhuma instrução e reutiliza os comandos de entrada, saída e finalização entre os dois programas. Agora eu acho que é ótimo, já que você precisa de todos os IO-@comandos para funcionar, e em um programa de 4 bytes você pode executar apenas dois desses comandos.

Explicação:

O ponteiro no Backhand move-se para três células um carrapato e ricocheteia nos limites da célula, o que significa que a lógica geral está sobreposta. No entanto, você pode manipular essa velocidade com os comandos ve ^.

O programa original executa as instruções IO-@, que são inseridas como número, produzidas como número, subtraem e terminam. Obviamente, a subtração é supérflua. No código, são eles:

I@-Ov
^  ^    Reflect
  ^     Reflect again
 ^

O programa revertido é executado v-I-vO-@. A vreduz as etapas de ponteiro entre as carraças e os -substratos a partir do fundo da pilha, que é implicitamente zero. Os -comandos extras não fazem nada. O programa executa como

vO-@I
v       Reduce pointer speed to 2
  -     Subtract zero from zero
    I   Get input as number and reflect off boundary
  -     Subtract input from zero
v       Reduce pointer speed to 1
 O      Output as number
  -     Subtract zero from zero
   @    Terminate

Wolfram Language (Mathematica) , 9 bytes

1&0+#-0&1

Experimente online!

Encaminhar: ler ((1)&*0+#-0)&*1 =#&

Para trás: read ((1)&*0-#+0)&*1=-#&

R , 14 bytes

scan()#)(nacs-

Experimente online!

Um programa completo que lê um número ou lê e nega um número. A funcionalidade reversa é protegida por um comentário embutido

Python 3 , 22 14 bytes

int#__bus__. 0

Experimente online!

Usa o intconstrutor da classe e um método pseudo-privado interno.

05AB1E , 2 bytes

(I

Experimente online!

Invertida

(    negates nothing
  I  pushes input

I    pushes input
  (  negates input

Befunge-98 (FBBI) , 6 bytes

&[email protected]&

Experimente online! Experimente invertido!

APL (Dyalog Unicode) , 13 3 bytes

-∘0

Experimente online!

Resposta trivial. Retorna argou ¯arg.

Economizou 10 bytes por não ser burro (obrigado Adám).

Alterou o 3-byter resultante para uma função mais adequada.

Linguagem de Máquina de Turing , 39 bytes

O positivo

1 r - _ 0
0 l * * 0
0 - _ l 0
0 _ _ r 0

O negativo

0 r _ _ 0
0 l _ - 0
0 * * l 0
0 _ - r 1

Este foi um pouco mais complicado do que eu pensava, principalmente porque eu tinha que superar meus preconceitos de ter código que é executado com erros de 'compilação'.

> <> , 5 4 bytes

n-r0

usa a inicialização da pilha com a -vopção, coloque sua variável de entrada lá.

Experimente online!

Ou tente a reversão

Explicação

n       Prints whatever is on the stack as a number
 -      Subtract the top 2 elements on the stack.
        There aren't 2 elements, so it crashes.
  r0    Never gets executed

or reversed:

0       Push a 0 onto the stack
 r      reverse the stack (now 0, -v)
  -     Subtract top 2 elements and push result (0-v, ie negated)
   n    Print as number
        The code wraps around and executes again. 
        It crashes on the - as there is only one
        item on the stack: 0.

Stack Cats -mn , 2 bytes

-X

Experimente online!

Tente o contrário!

Explicação

Acontece que isso é realmente muito mais fácil do que o desafio anterior no Stack Cats. O programa completo (após a inscrição -m) aqui é -X-. Xé usado para trocar as pilhas esquerda e direita da cabeça da fita, ou seja, não afeta a pilha inicial, portanto podemos ignorá-la. Mas então o programa é efetivamente justo --(negue o topo da pilha duas vezes), o que não faz nada.

Para o programa inverso, a aplicação do -mgive X-X. Mais uma vez, Xnão faz nada, então o programa é efetivamente justo -, o que nega o topo da pilha.

A única outra solução de 2 bytes é -=, mas é praticamente a mesma. A única diferença é que= troca apenas as partes superiores das pilhas adjacentes, não as pilhas inteiras.

Mas, novamente, o uso -mparece um pouco como trapaça, então abaixo está uma solução que usa um programa totalmente espelhado.

Stack Cats -n , 7 bytes

:I<->I:

Experimente online!

Tente o contrário!

Explicação

As considerações da resposta anterior ainda se aplicam : qualquer solução válida precisa usar os caracteres emparelhados e I. As seis soluções possíveis (incluídas no link do TIO) são praticamente as mesmas. -e _são equivalentes neste programa e :podem ser substituídos por |ou T(que fazem o mesmo para entradas diferentes de zero e coincidentemente também funcionam para entradas zero). Eu escolhi este para explicar porque é mais fácil.

Portanto, lembre-se de que a pilha inicial mantém a entrada em cima de um -1(em cima de infinitos zeros), enquanto todas as outras pilhas ao longo da fita mantêm apenas zeros. O Stack Cats também possui a propriedade de que qualquer programa de tamanho par não faz nada (desde que seja encerrado, mas não podemos usar loops para esse desafio). O mesmo é obviamente verdadeiro para qualquer programa de tamanho ímpar, cujo caractere central não faça nada ... vamos ver:

:    Swap the input with the -1 below.
I    Move the -1 one stack to the left and turn it into +1.
<    Move another stack left (without taking the value).
-    Negate the zero on top of that stack (i.e. do nothing).

Portanto, a segunda metade do programa desfaz exatamente a primeira metade e terminamos com a entrada em cima de uma -1novamente.

O programa inverso é :I>-<I:. Vamos ver como isso muda as coisas:

:    Swap the input with the -1 below.
I    Move the -1 one stack to the left and turn it into +1.
>    Move one stack right, i.e. back onto the initial stack which still holds the input.
-    Negate the input.
<    Move back to the left where we've parked the 1.
I    Move that 1 back onto the initial stack and turn it back into a -1.
:    Swap the -1 below the negated input to act as an EOF marker.

Lote, 34 bytes

@ECHO.%1 2>MER@
@REM>2 1%=-aa/TES@

Repete ( ECHO.) a entrada ( %1). O restante da primeira linha redireciona tecnicamente STDERRpara um arquivo chamado MER@, mas isso não causa impacto.
A segunda linha está comentada ( REM...).

Invertida

@SET/aa-=%1 2>MER@
@REM>2 1%.OHCE@

Usa o modo aritmético do comando set ( SET /a) para subtrair ( -=) a entrada ( %1) de uma variável indefinida ( a) que é equivalente a 0 - input. Novamente, o restante da primeira linha redireciona tecnicamente STDERRpara um arquivo chamado MER@, mas isso não causa impacto.
A segunda linha está comentada ( REM...).

Braquilog , 2 bytes

&ṅ

O Brachylog insere implicitamente da esquerda e sai da direita.
&ignora qualquer coisa à esquerda e passa a entrada para a função à direita.
ṅrestringe cada lado a ser versões negadas uma da outra.

Experimente online

Triangular , 8 7 bytes

$%%.|.$

Experimente online!

Ungolfed:

   $           | $: Read an Integer
  % %          | %: Output it
 . | .
$

Invertida:

$.|.%%$

Experimente online!

Versão anterior (8 bytes):

$.%..|.$