Invierto el código fuente, ¡tú niegas la entrada!

36

Flagrante estafa de una estafa . ¡Vota esos!

Su tarea, si desea aceptarla, es escribir un programa / función que genere / devuelva su entrada / argumento entero. La parte difícil es que si invierto su código fuente, la salida debe ser el entero original negado.

Ejemplos

Digamos que su código fuente es ABCy su entrada es 4. Si escribo en su CBAlugar y lo ejecuto, la salida debe ser -4.

Digamos que su código fuente es ABCy su entrada es -2. Si escribo en su CBAlugar y lo ejecuto, la salida debe ser 2.

Una entrada de 0puede dar 0o -0, sin embargo, si admite cero con signo, -0debería dar 0.

code-golf  math  number  source-layout 
— Adán
fuente
55
¿Por qué necesitamos una copia de la misma pregunta?
— Christian
55
@Christian Ese genera un número constante (y su negación) mientras que este tiene que tomar entrada y devolver / negarlo. Un trabajo muy diferente en muchos idiomas.
— Adám
55
Un sí, ahora veo la diferencia. Uno necesita leer MUY cuidadosamente
— Christian
Si usa un lenguaje estructurado como C #, ¿simplemente está invirtiendo líneas?
— PerpetualJ
@PerpetualJ No, mira la fuente como una lista de caracteres, algunos de los cuales son saltos de línea.
— Adám

Respuestas:

11

código de máquina x86, 3 bytes

C3 D8 F7

Los bytes de código anteriores definen una función que no funciona: simplemente devuelve el control a la persona que llama. A esa función le siguen dos bytes basura que no se ejecutarán, ya que vienen después de un retorno; están en "tierra de nadie". En mnemotecnia de ensamblador:

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

Bien, ahora viene un troll e invierte el orden de los bytes:

F7 D8 C3

Estos bytes ahora definen una función que toma un argumento entero en el EAXregistro, lo niega y devuelve el control a la persona que llama. En mnemotecnia de ensamblador:

neg  eax     ; F7 D8
ret          ; C3

Entonces ... eso fue simple. :-)

Tenga en cuenta que podemos hacer que la instrucción de "negación" sea lo que queramos, ya que nunca se ejecuta en la orientación "hacia adelante" y solo se ejecuta en la orientación "invertida". Por lo tanto, podemos seguir el mismo patrón para hacer cosas arbitrariamente más complicadas. Por ejemplo, aquí tomamos un argumento entero en un registro diferente (por ejemplo, EDIpara seguir la convención de llamadas del Sistema V que se usa comúnmente en los sistemas * nix), lo negamos y lo devolvemos en el 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
fuente
6

Espacio en blanco , 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

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.

Modificación menor de mi respuesta de espacios en blanco para el reverso del código fuente, ¡usted niega la salida! reto .

Pruébelo en línea o en línea al revés (solo con espacios en bruto, pestañas y nuevas líneas).

Explicación:

Utilizando el programa de salida incorporado es un palíndromo corto NNN.
El programa regular:

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

El programa inverso:

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

Pequeña explicación adicional de presionar un número:

  • Primero S: Habilite la manipulación de la pila
  • Segundo S: empujar un número a la pila
  • So T: Positivo / negativo respectivamente
  • Algunos S/ Tseguido de un final N: número en binario, donde S=0yT=1

Es decir, SSTTSTSNempuja -10. Para el 0no necesitamos un explícito S=0, así que simplemente SSSNo SSTNes suficiente.

— Kevin Cruijssen
fuente
5

Brain-Flak , 7 bytes

#)]}{[(

Pruébalo en línea!

Invertido:

([{}])#

Pruébalo en línea!

Nota: Solo funciona en intérpretes que admiten comentarios (por ejemplo, funciona en Rain-Flak, pero no en BrainHack)

Si también intercambiamos corchetes de apertura / cierre en lugar de simplemente invertir los bytes, podemos hacer esto en 8 bytes sin usar comentarios:

({}[{}])

Pruébalo en línea!
¡Pruébalo al revés!

— Riley
fuente
¿Es este abuso de comportamiento indefinido? No creo que la especificación Brain-Flak permita ese paréntesis.
— HighRadioactive
@TwilightSparkle #Comienza un comentario, por lo que se ignora el paréntesis en la versión original.
— Riley
¡Oh sí, lo olvidé! Pero solo funciona en Rain-Flak (aunque es el intérprete oficial). ¿Probablemente necesites mencionarlo?
— Altamente radioactivo
@TwilightSparkle agregó una nota para aclaración. Gracias.
— Riley
Pequeño desafío divertido: ¿Puedes hacer esto sin comentarios si también cambias los corchetes de apertura / cierre en lugar de solo retroceder?
— DJMcMayhem
4

R , 23 bytes

Decidí intentarlo sin el truco de comentarios.

Adelante

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

Pruébalo en línea!

Marcha atrás

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

Pruébalo en línea!

En la versión forward +está actuando un operador binario, y -es un operador unario.

En el reverso la +convierte en unario y -es binario. Así función de exploración toma los argumentos: file=""lo que significa la entrada estándar y what=0, que también son valores predeterminados. Así que cuando el +es unario el primer argumento es a la derecha, cuando es binario es el primer argumento de la izquierda.

los 

;nacs=`+`

parte del código no hace nada realmente útil, por lo que en cierto sentido mi código no es realmente mucho más válido que el uso de la observación truco.

— Aaron Hayman
fuente
1
Esto es muy inteligente (+1). A menudo redefinimos los operadores R en bytes de golf, pero creo que esta es la primera vez que he visto +redefinido para ser utilizado como unario y binario. Me tomó un minuto entender cómo se analizó esto ... Ningún otro nombre de operador habría hecho el trabajo.
— Robin Ryder
4

Perl 5 ( -p), 7 6 bytes

-1 gracias a @primo

$_*=$#

TIO

Un comentario no cambia la entrada

#1-=*_$

Negar la entrada

$_*=-1#

TIO

— Nahuel Fouilleul
fuente
-1: $_*=$# TIO . Tenga en cuenta que #debe ser el último byte del programa; de lo contrario, se interpretará como la variable $#, en lugar del último índice de la matriz con el nombre <vacío>.
— primo
1
Sin embargo, no entiendo cómo funciona porque intentar imprimir $#da un error (si # no es el último carácter) o nada
— Nahuel Fouilleul
Parece que solo funciona con -po -n. Sospecho que el texto modelo tiene algo que ver con esto ...
— Primo
2
@primo Funciona porque -p/-nagrega un ;después del código. Lo que significa que en $#realidad es $#;: el tamaño de la matriz @;. Si el tamaño de los @;cambios, el resultado ya no es correcto ( TIO ). De todos modos, esto es súper inteligente, ¡bien hecho! :)
— Dada
esa es la explicación que se puede ver perl -MO=Deparse -p <(echo -n '$_*=$#'), porque parece que perl -MO=Deparse -pe '$_*=$#'agrega una nueva línea
— Nahuel Fouilleul,
4

Gaia , 2 bytes

_@

Pruébalo en línea!

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

Invertido:

@	| push input
 _	| negate
	| implicit print TOS
— Giuseppe
fuente
4

Revés , 6 5 bytes

I@-Ov

Pruébalo en línea! ¡Pruébalo doblado!

Hecho un poco complejo debido a la naturaleza del puntero en Backhand. No creo que sea posible acortarla jaja, resulta que me equivoqué. Esto no duplica ninguna instrucción y reutiliza los comandos de entrada, salida y terminación entre los dos programas. Ahora creo que es óptimo, ya que necesita todos los IO-@comandos para trabajar, y en un programa de 4 bytes solo puede ejecutar dos de esos comandos.

Explicación:

El puntero en Backhand se mueve en tres celdas una marca y rebota en los límites de la celda, lo que significa que la lógica general se superpone. Sin embargo, puede manipular esta velocidad con los comandos vy ^.

El programa original ejecuta las instrucciones IO-@, que se ingresan como número, salen como número, restan, terminan. Obviamente el sustrato es superfluo. En el código estos son:

I@-Ov
^  ^    Reflect
  ^     Reflect again
 ^

El programa invertido se ejecuta v-I-vO-@. Esto vreduce los pasos del puntero entre ticks y los -resta del fondo de la pila, que es implícitamente cero. Los -comandos adicionales no hacen nada. El programa se ejecuta 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
— Jo King
fuente
3

Python 3 , 22 14 bytes

int#__bus__. 0

Pruébalo en línea!

Utiliza el intconstructor de la clase y un método pseudo-privado incorporado.

— mypetlion
fuente
Huh ¿Por qué es obligatorio el espacio antes del atributo?
— Jo King
2
@JoKing 0.sería interpretado como un número, que es seguido por un símbolo
— attinat
2

APL (Dyalog Unicode) , 13 3 bytes

-∘0

Pruébalo en línea!

Respuesta trivial Devoluciones argo ¯arg.

Ahorró 10 bytes al no ser tonto (gracias Adám).

Alterado el 3-byter resultante a una función más adecuada.

— J. Sallé
fuente
¡Vaya, esto se puede hacer trivialmente en tres bytes!
— Adám
Curiosamente, ya tiene una respuesta de 3 bytes incrustada como una subcadena de esto.
— Adám
@ Adám, sí, sabía que había una respuesta simple en alguna parte. Gracias.
— J. Sallé
2

Lenguaje de máquina de Turing , 39 bytes

Lo positivo

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

Lo negativo

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

Este fue un poco más complicado de lo que pensaba, principalmente porque tuve que superar mis prejuicios de tener código que se ejecuta con errores de 'compilación'.

— ouflak
fuente
2

> <> , 5 4 bytes

n-r0

usa la inicialización de la pila con la -vopción, pon tu variable de entrada allí.

Pruébalo en línea!

O prueba la inversión

Explicación

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
fuente
2

Pila de gatos -mn , 2 bytes

-X

Pruébalo en línea!

¡Intenta lo contrario!

Explicación

Resulta que esto es en realidad mucho más fácil que el desafío anterior en Stack Cats. El programa completo (después de aplicar -m) aquí es -X-. Xse usa para intercambiar las pilas hacia la izquierda y hacia la derecha del cabezal de la cinta, es decir, no afecta la pila inicial en absoluto, por lo que podemos ignorarlo. Pero entonces el programa es efectivamente solo-- (niega la parte superior de la pila dos veces), lo que no hace nada.

Para el programa inverso, la aplicación -mda X-X. Nuevamente, Xno hace nada, por lo que el programa es efectivamente justo -, lo que niega la parte superior de la pila.

La única otra solución de 2 bytes es -=, pero es prácticamente la misma. La única diferencia es que =intercambia solo la parte superior de las pilas adyacentes, no las pilas completas.

Pero, de nuevo, usar se -msiente un poco como hacer trampa, por lo que a continuación se muestra una solución que utiliza un programa totalmente duplicado.

Pila de gatos -n , 7 bytes

:I<->I:

Pruébalo en línea!

¡Intenta lo contrario!

Explicación

Las consideraciones de la respuesta anterior aún se aplican : cualquier solución válida debe usar los caracteres emparejados y I. Las seis soluciones posibles (incluidas en el enlace TIO) son prácticamente todas iguales. -y _son equivalentes en este programa, y :pueden reemplazarse por |o T(que hacen lo mismo para las entradas que no son cero y coincidentemente también funcionan para las entradas cero). Acabo de elegir este para explicar porque es más fácil.

Así que recuerde que la pila inicial mantiene la entrada en la parte superior de a -1(en la parte superior de infinitos ceros) mientras que todas las otras pilas a lo largo de la cinta solo contienen ceros. Stack Cats también tiene la propiedad de que cualquier programa de longitud uniforme no hace nada (siempre que finalice, pero de todos modos no podemos usar bucles para este desafío). Lo mismo es obviamente cierto para cualquier programa de longitud impar cuyo carácter central no hace nada ... veamos:

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

Por lo tanto, la segunda mitad del programa deshace exactamente la primera mitad y terminamos con la entrada en la parte superior de una -1vez más.

El programa inverso es :I>-<I:. Veamos cómo eso cambia las cosas:

:    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
fuente
2

Lote, 34 bytes

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

Ecos ( ECHO.) la entrada ( %1). El resto de la primera línea técnicamente redirige STDERRa un archivo llamado MER@, pero esto no es impactante.
La segunda línea está comentada ( REM...).

Invertido

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

Utiliza el modo aritmético del comando set ( SET /a) para restar ( -=) la entrada ( %1) de una variable indefinida ( a) que es equivalente a 0 - input. Nuevamente, el resto de la primera línea técnicamente redirige STDERRa un archivo llamado MER@, pero esto no es impactante.
La segunda línea está comentada ( REM...).

— Οurous
fuente
Esto se ve interesante. ¿Le importaria explicar?
— Adám
@ Adám Agregó una explicación y también me di cuenta de que tenía los programas al revés.
— Οurous
2

Brachylog , 2 bytes

&ṅ

Brachylog entra implícitamente desde la izquierda y sale desde la derecha.
&ignora cualquier cosa a la izquierda y pasa la entrada a la función hacia la derecha.
ṅobliga a cada lado a ser versiones negadas el uno del otro.

Pruébalo en línea

— IFcoltransG
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.