Sua tarefa, se você deseja aceitá-la, é escrever um programa que produza um número diferente de zero (pode ser inteiro ou flutuante). A parte complicada é que, se eu reverter seu código-fonte, a saída deve ser o número inteiro original negado.

Regras

• Você deve criar um programa completo . Ou seja, sua saída deve ser impressa em STDOUT.

• Ambos os números devem estar na base 10 (é proibido produzi-los em qualquer outra base ou com notação científica).

• É permitida a saída de números com espaços à direita / à direita.

• Isso é código-golfe, então o código mais curto (original) em cada idioma vence!

• Aplicam-se lacunas padrão.

Exemplo

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

05AB1E , 2 bytes

(1

Experimente online!

! enilno ti yrT

(       # negate nothing
 1      # push 1 (and implictly output it)

1       # push 1
 (      # negate it (and implictly output it)

JavaScript (V8) , 19 bytes

print(1)//)1-(tnirp

Experimente online!

quase idêntico a ...

C # (compilador interativo do Visual C #) , 19 bytes

Print(1)//)1-(tnirP

Experimente online!

(obrigado a @someone por apontar)

ainda praticamente o mesmo em ...

Lua , 19 bytes

print(1)--)1-(tnirp

Experimente online!

mas mais curto em ...

Python 2 , 15 bytes

print 1#1-tnirp

Experimente online!

Ainda mais curto no PHP, porque possui esta ferramenta de impressão mágica: <?=...

PHP , 12 bytes

<?=1;#;1-=?<

Experimente online!

Ainda menor no Ruby, porque você pode, em inspectvez de imprimir

Ruby , 8 bytes

p 1#1- p

Experimente online!

PowerShell ,  4  3 bytes

1-0

Experimente online! ou ! enilno ti yrT

Golpeou um byte usando aritmética em vez do formato número-comentário-número.

Aparentemente, isso também é o mesmo que jshell (por Sam ) e jq (por manatwork - 1-0e 0-1).

/// , 4 bytes

9/9-

Saídas 9.

Experimente online!

Invertida:

-9/9

Saídas -9.

Experimente online!

Tudo antes da /impressão é impresso, enquanto o resto é ignorado (as barras realmente não são muito usadas, então não sei exatamente o que acontece, mas não produz nada).

Klein 011, 5 bytes

1-
@/

Experimente online!

Invertida

/@
-1

Experimente online!

Eles aproveitam a topologia exclusiva de Klein, especificamente o plano projetivo real. (Embora individualmente cada resposta precise apenas de uma garrafa de Klein).

Espaço em branco , 21 bytes

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

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

Saídas 1/ -1.

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

Explicação:

Utilizando o programa Exit, é um palíndromo curto NNN.
O programa regular irá:

SSSTN  # Push 1 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á:

SSTTN  # Push -1 to the stack
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.

T-SQL, 16 bytes

--Forwards:
PRINT 4--4-TNIRP

--Backwards:
PRINT-4--4 TNIRP

Escolheu 4 porque 1 é usado em excesso :)

Japt , 2 bytes

Qualquer inteiro único dígito >0pode ser usado em lugar do 2como lata A-G, H, I, Jou L( 10-16, 32, 64, -1& 100, respectivamente).

n2

Teste |Invertida

O nmétodo, quando aplicado a um número inteiro, subtrai esse número inteiro do argumento passado a ele, cujo padrão é0 . Quando executado adiante, o nmétodo está sendo executado na primeira entrada implícita, que também é padrão 0.

Como alternativa, o gmétodo poderia ser usado em vez de n, o que indica o resultado da subtração do argumento do número inteiro ao qual é aplicado.

Haskell sem comentários, 41 bytes

Encaminha impressões 1+ nova linha:

main=print$!1
niam=main
"1-"!$rtStup=niam

Experimente online!

Impressões invertidas -1sem nova linha (que podem ser adicionadas ao custo de 2 bytes):

main=putStr$!"-1"
niam=main
1!$tnirp=niam

Experimente online!

• A primeira linha de cada programa imprime o número.
  • Para -1 string, a saída é usada para evitar parênteses.
  • Usar $!(aplicação estrita) em vez de um espaço permite que a linha invertida seja uma definição válida do operador !$(simplesmente $não faria, pois a redefinição interromperia o uso).
• A linha do meio garante que niam seja definida para a última linha.
• A última linha é uma definição de operador !$, que não é usada, mas precisa analisar e digitar corretamente.

PHP , 15 13 bytes

Uma versão PHP sem abuso de comentários. ohceé uma constante indefinida; portanto, será igual ao valor da string do seu nome. Como resultado, isso tentará imprimir +1-'ohce'ou -1+'ohce'quando invertido. Como 'ohce'é um valor não numérico, 0 será usado nas operações aritméticas e somente 1ou -1será impresso.

;echo+1-ohce;

Experimente online!

Experimente online!

Google , 3 bytes

2-1

Experimente online!
! enilno ti yrT

Geléia , 2 bytes

NC

Experimente online!

Negativo, resulta em e 0, em seguida C, complementa, resulta em 1-0= 1.

CN

Experimente online! Complementar, resulta em 1-0= 1. Nnegativo, resulta em -1.

K (ngn / k) , 3 bytes

2-1

Experimente online!

estou esquecendo de algo? parece óbvio para idiomas REPL

Cubix , 7 6 5 bytes

@)O(@

Experimente aqui
Invertido

Explicação

Cubificado:

  @
) O ( @
  .

Desenrolando o fluxo de controle, executamos )O(@, que incrementa, produz, diminui e sai.

Invertida e cubificada:

  @
( O ) @
  .

Desenrolando o fluxo de controle, executamos (O)@ , que diminui, produz, incrementa e sai.

Versão anterior

@O(.)O@

Experimente aqui
Invertido

Não é tão curto, mas esteticamente agradável.

Encantos Rúnicos , 4 bytes

1@Z1

Experimente online! Experimente invertido!

Não consegui encontrar uma maneira de reutilizar o 1comando, mesmo à custa de um byte ou dois.

1@ɩ também funciona, mas é o mesmo número de bytes.

APL (Dyalog Unicode) ,  4  3 bytes

1-0

Experimente online!

Resposta trivial. Imprime 1quando executado e ¯1quando invertido.

Stack Cats -mn , 4 bytes

:-:_

Experimente online! No rodapé, incluí todas as outras soluções de 4 bytes. (Stack Cats ignora tudo após o primeiro avanço de linha.)

Tente o contrário!

Explicação

O -nsinalizador ativa a saída numérica (e a entrada, mas não temos nenhum), e -mnormalmente é apenas uma conveniência de golfe que permite evitar a parte redundante do código-fonte. Isso ocorre porque todo programa Stack Cats precisa ter simetria espelhada. Com a -mbandeira, você só dá a primeira metade (mais o caractere central). Portanto, o programa atual aqui é:

:-:_:-:

Como você pode ver no primeiro link do TIO, há várias soluções de 4 bytes, mas eu escolhi essa por sua simplicidade. Stack Cats é baseado em pilha, e este programa usa apenas a pilha inicial. Como não temos nenhuma entrada, ela contém uma única -1(um marcador EOF) em cima de um poço infinito de zeros. Os três comandos no programa têm o seguinte significado:

:   Swap the top two stack elements.
-   Negate the top stack element (i.e. multiply by -1).
_   Pop a. Peek b. Push b-a.

Então, aqui está como o programa modifica a pilha (estados e comandos são escalonados para indicar como cada comando altera a pilha de um estado para o próximo):

   :   -   :   _   :   -   :

-1   0   0  -1   1   0   0   1
 0  -1  -1   0   0   1   1   0
 0   0   0   0   0   0   0   0
 …   …   …   …   …   …   …   …

Como se vê, o único comando que realmente faz alguma coisa aqui é _que transforma nosso marcador EOF em um 1. A saída no final do programa está implícita, e o marcador EOF é opcional, portanto, apenas imprime o 1que obtemos.

Agora, se revertermos o código fonte, devido ao espelhamento implícito, o programa atual se tornará:

_:-:-:_

Isso faz algo muito diferente:

   _   :   -   :   -   :   _

-1   1   0   0   1  -1   0  -1
 0   0   1   1   0   0  -1  -1
 0   0   0   0   0   0   0   0
 …   …   …   …   …   …   …   …

Desta vez, a parte inferior da pilha ainda é uma -1e, portanto, atua como marcador EOF e apenas o-1 parte superior é impressa.

...

Agora, com tudo isso dito, como o Stack Cats tem uma relação única com a reversão de código, sinto que usar -mé um pouco trapaceiro. Normalmente, ele serve apenas para salvar bytes, omitindo a parte redundante do código-fonte, mas aqui isso torna o desafio muito mais fácil e até o programa completo, mais curto. Isso ocorre porque a reversão de um programa completo só mudará o programa se ele contiver algum <>[], o que também significa que o programa acaba fazendo uso de várias pilhas (a Stack Cats na verdade possui uma fita de pilhas, onde todas, exceto a inicial, são preenchidas apenas com zeros para começar). Além disso, revertê-lo apenas troca os pares <>e [], o que ainda torna a execução simétrica. A única maneira de quebrar essa simetria é usarI que faz-] ou-[ou nada, dependendo do sinal do topo da pilha. Tão...

Stack Cats -n , 11 bytes

*|]I*:*I[|*

Experimente online! O rodapé novamente inclui todas as outras alternativas na mesma contagem de bytes. Alguns deles emitem 1 / -1 e outros 2 / -2, conforme indicado após cada programa. Eu escolhi este para explicar de forma aleatória como um dos que produzem 2.

Tente o contrário!

Explicação

Como eu disse, este é um pouco mais. Mesmo se usássemos o-m notação para isso, ela pesaria 6 bytes em vez dos 4 acima.

Os comandos em uso desta vez:

*   Toggle the least significant bit of the top of the stack.
|   Reverse the longest non-zero of prefix on this stack.
[]  Move one stack to the left/right and take the top of the current stack with you.
I   If the top of the stack is positive, -], if it's negative, -[, otherwise do nothing.
:   Swap the top two stack elements.

O primeiro programa usa apenas duas pilhas. Isso é um pouco bagunçado na arte ASCII, mas vou tentar o meu melhor. Os colchetes indicam em qual pilha a cabeça da fita está e eu colocarei os comandos entre cada par de estados da pilha.

  [-1]
…   0   0   …
    0   0
    …   …

      *

  [-2]
…   0   0   …
    0   0
    …   …

      | (does nothing)
      ]

      [-2]
…   0   0   …
    0   0
    …   …

      I

   [2]
…   0   0   …
    0   0
    …   …

      *

   [3]
…   0   0   …
    0   0
    …   …

      :

   [0]
…   3   0   …
    0   0
    …   …

      *

   [1]
…   3   0   …
    0   0
    …   …

      I

      [-1]
…   3   0   …
    0   0
    …   …

      [

  [-1]
…   3   0   …
    0   0
    …   …

      |

  [ 3]
…  -1   0   …
    0   0
    …   …

      *

  [ 2]
…  -1   0   …
    0   0
    …   …

Agora, -1atua como um marcador EOF e o2 é impresso.

O outro programa é o mesmo até o [. Ainda é praticamente o mesmo até o segundo I. Tecnicamente, estaremos em uma pilha diferente, mas sem valores neles, eles são todos indistinguíveis. Mas então a diferença entre I[e I]acaba importando:

    *|[I*:*I

      [-1]
…   3   0   0   …
    0   0   0
    …   …   …

        ]

          [-1]
…   3   0   0   …
    0   0   0
    …   …   …

        | (does nothing)
        *

          [-2]
…   3   0   0   …
    0   0   0
    …   …   …

E desta vez, não temos um marcador EOF, mas o programa ainda gera o -2.

Zsh , 12 bytes

<<<2 # 2-<<<

Experimente online!

Encaminhamento básico, comentário, método reverso.

Se a E / S for menos restritiva, é possível uma solução mais interessante de 11 bytes , graças ao Zsh que suporta códigos de retorno negativos:

return -127

Invertido, 721- nrutersai com o código 127(comando não encontrado). exit -127não pode ser usado, seria convertido em a u8. Experimente online!

CJam , 3 bytes

W;1

Experimente online!

• Normal
• Invertida

Como eles trabalham

Versão normal:

W    e# Push -1
;    e# Delete
1    e# Push 1
     e# Implicit display

Versão reversa: você entendeu a idéia.

MATL , 3 bytes

Nqv

Experimente online!

• Normal
• Invertida

Como eles trabalham

Normal:

N   % Push number of elements in the stack: 0
q   % Subtract 1: gives -1
v   % Concatenate stack contents vertically: leaves -1 as is
    % Implicit display stack contents

Invertida:

v   % Concatenate stack contents vertically: gives the empty array, []
q   % Subtract 1: leaves [] as is
N   % Push number of elements in the stack: 1
    % Implicit display. [] is not displayed

Wolfram Language (Mathematica) , 21 18 bytes

Print@1;tnirP//1-0

Experimente online!

-3 graças a Martin Ender

Hexagonia , 5 bytes

1!@!(

Experimente online!

Qualquer programa válido deve:

• Tenha um comando de término ( @ou: ). O último só é diferente para o primeiro quando há um comando de movimento do ponteiro de memória. Além disso, este comando não deve estar no primeiro ou no último byte.
• Tenha um comando de saída. ( !,; também é possível, mas provavelmente levaria mais bytes)
• Tenha um comando de manipulação de memória.

Portanto, um programa de 2 bytes é obviamente impossível. Um programa de 3 bytes é impossível porque o segundo byte deve ser o comando de finalização e o primeiro byte não deve ser um comando de manipulação de espelho / IP, portanto, apenas 1 byte pode ser executado.

Eu acho que um programa de 4 bytes não é possível. Esse programa deve ter a forma a@bccom grade hexagonal

 Forward:       | Backward:
                | 
  c b           |   a @
 @ a .          |  b c .
  . .           |   . .

Portanto, adeve ser um comando de redirecionamento de IP. No entanto, é impossível gerar números positivos e negativos com apenas um comando de manipulação de memória.

Haskell , 28 bytes

main=print 1--)1-(tnirp=niam

Experimente online!

Experimente enilno!

Triangular , 4 bytes

i%%d

Experimente online!

Saídas 1.

Ungolfed:

   i
  % %
 d

Invertida:

d%%i

Experimente online!

Saídas -1.

Java 5 ou 6, 127 67 bytes

enum A{A;{System.out.print(9);}}//}};)9-(tnirp.tuo.metsyS{;A{A mune

Saídas 9/-9.

Nenhum compilador online, porque o Java 5 ou 6 não está disponível em nenhum lugar.

No entanto, você pode tentar este equivalente a Java 8 de 127 bytes :
Experimente online ou online invertido .

Explicação:

enum A{                              // Create an enum
 A;                                  //  With a mandatory value
 {                                   //  And in a separate instance code-block:
  System.out.print(9);}}             //   Print 9 to STDOUT
//}};)9-(tnirp.tuo.metsyS{;A{A mune  // Comment and thus a no-op

O Java 5 e 6 tiveram um bug, permitindo criar um bloco de código dentro de uma enumeração para fazer alguma coisa, apesar da falta do método principal obrigatório de um programa. Isso resultará em um erro:

java.lang.NoSuchMethodError: main
Exceção no encadeamento "main"

Mas ainda produzirá o que gostaríamos de exibir primeiro, para que possamos ignorar isso .

Golang , 109 bytes

package main;import "fmt";func main(){fmt.Println(1)}//})1(nltnirP.tmf{)(niam cnuf;"tmf" tropmi;niam egakcap

E o contrário:

package main;import "fmt";func main(){fmt.Println(-1)}//})1(nltnirP.tmf{)(niam cnuf;"tmf" tropmi;niam egakcap

Experimente online!

Perl 5 (-p), 12 bytes

\$--{}}{++$\

Experimente online!

! enilno ti yrT

O }{pseudo-operador é realmente útil.

Perl 5 (-M5.010), 9 bytes

Fornecido por Nahuel Fouilleul em um comentário

say+1-yas

Experimente online!

! enilno ti yrT

Retina , 6 bytes

-`<
-

Imprime 1.

Experimente online!

-
<`-

Imprime -1.

Experimente online!

Explicação: 1

-`<
-

Isso ... não faz nada. Devido a `, essa é uma substituição de <para -(com configuração -, que não faz nada), mas a entrada está vazia, portanto a saída também está vazia.

E esse segundo estágio corresponde ao regex vazio com a entrada vazia e conta o número de correspondências, que é exatamente 1. A saída está implícita.

Explicação: -1

-

Desta vez, substituímos o regex vazio por -. Isso de fato transforma a entrada vazia em uma única -.

<`-

Aqui, a configuração realmente faz algo: <imprime a entrada do palco antes de executá-lo, então imprimimos o -. Em seguida, -conta os hífens na entrada do palco, que é novamente 1. Devido à saída implícita, isso imprime um 1após o -, fornecendo-nos -1conforme necessário.

$\Large{\mathbf{\TeX} \left(\text{MathJax}\right)},~4\,\text{bytes}$

1%1-

brainfuck , 156 bytes

+++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++<+++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++

Experimente online! / Verificador para a frente / para trás no Bash

Imprime -1para frente e \n1para trás.

Apesar de quase trivial, acredito que esta é a solução ideal para essa saída fixa específica.

Prova:

• O programa não pode ter [ou ].

  Portanto, o programa deve ter o formulário <A> . <B> . <C>.

• Cada um ,pode ser substituído por um número suficiente de <sem aumentar o número de +ou -.

• Cada + é útil apenas no programa de avanço ou retrocesso, nunca em ambos.

  Prova: +na parte A, obviamente, só é útil no programa forward e+ na parte C, obviamente, é útil apenas no programa reverso.

  Denote shift(P)= número de <em P - número de >em P. Considere o programa <B> = <D> + <E>, +o meio é útil no programa avançado$\iff$ shift(E) = 0, da mesma forma, é útil no programa anterior $\iff$ shift(D) = 0. No entanto, se shift(D) = shift(E) = 0o programa Bexecutado para frente ou para trás adicionasse um valor fixo à célula atual antes de imprimir pela segunda vez, o que não pode ser o caso ord('1') - ord('\n') != ord('1') - ord('-').

Portanto, o programa precisa de pelo menos ord('-')+ord('1')+ord('\n')+ord('1') = 153 +s, 2 se .pelo menos um < >ou ,porque shift(B) != 0.