Eu inverto o código fonte, você nega a entrada!

36

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.

code-golf  math  number  source-layout 
— Adão
fonte
5
Por que precisamos de uma cópia da mesma pergunta?
— Christian
5
@ Christian Esse gera um número constante (e sua negação), ao passo que este deve receber entradas e retornar / negá-las. Um trabalho muito diferente em muitos idiomas.
— Adám 18/09
5
Um sim, agora vejo a diferença. É preciso ler com muito cuidado
— Christian
Se estiver usando uma linguagem estruturada como C #, você está apenas invertendo as linhas?
— PerpetualJ
@PerpetualJ Não, veja a fonte como uma lista de caracteres, alguns dos quais são quebras de linha.
— Adám 19/09

Respostas:

11

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
— Cody Gray
fonte
6

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.

— Kevin Cruijssen
fonte
5

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!

— Riley
fonte
Esse comportamento é indefinido? Não acho que a especificação Brain-Flak permita esse parêntese.
— HighlyRadioactive
@TwilightSparkle O #comentário inicia, então os parênteses na versão original são ignorados.
— Riley
Ah sim, eu esqueci! Mas ele só funciona no Rain-Flak (é o intérprete oficial). Você provavelmente precisará mencionar isso?
— HighlyRadioactive
@TwilightSparkle adicionou uma nota para esclarecimento. Obrigado.
— Riley
Pequeno e divertido desafio: você pode fazer isso sem comentários se também trocar os colchetes de abertura / fechamento em vez de apenas reverter?
— DJMcMayhem
4

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.

— Dorian
fonte
4

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.

— Aaron Hayman
fonte
1
Isso é muito inteligente (+1). Costumamos redefinir os operadores R para bytes de golfe, mas acho que é a primeira vez que vejo +redefinidos para serem usados ​​como unários e binários. Levei um minuto para entender como isso foi analisado ... Nenhum outro nome de operador teria feito o trabalho.
— Robin Ryder
4

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

— Nahuel Fouilleul
fonte
-1: $_*=$# TIO . Observe que #deve ser o último byte do programa, caso contrário, será interpretado como a variável $#, e não o último índice da matriz com o nome <vazio>.
— primo
1
No entanto eu não entender como ele funciona, porque a tentar imprimir $#dá tanto um erro (se # não é o último caractere) ou nada
— Nahuel FOUILLEUL
Parece funcionar apenas com -pou -n. Eu suspeito que o clichê tenha algo a ver com isso ...
— primo
2
@primo Funciona porque -p/-nadiciona um ;após o código. O que significa que $#é realmente $#;: o tamanho da matriz @;. Se o tamanho das @;alterações for alterado, o resultado não está mais correto ( TIO ). Enfim, isso é super inteligente, muito bem! :)
— Dada
essa é a explicação que pode ser vista perl -MO=Deparse -p <(echo -n '$_*=$#'), porque parece perl -MO=Deparse -pe '$_*=$#'acrescentar uma nova linha
— Nahuel Fouilleul
4

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
— Giuseppe
fonte
4

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
— Brincadeira
fonte
2

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.

— J. Sallé
fonte
Uau, isso pode ser feito trivialmente em três bytes!
— Adám 17/09
Curiosamente, você já tem uma resposta de 3 bytes incorporada como uma substring disso.
— Adám 18/09
@ Adám sim, eu sabia que havia uma resposta simples em algum lugar. Obrigado.
— J. Sallé 18/09
2

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'.

— ouflak
fonte
2

> <> , 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.
— steenbergh
fonte
2

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.
— Martin Ender
fonte
2

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...).

— Furioso
fonte
Isso parece interessante. Gostaria de explicar?
— Adám 25/09
@ Adám Adicionou uma explicação e também percebi que eu tinha os programas ao contrário.
— Οurous 25/09
2

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

— IFcoltransG
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.