J'inverse le code source, vous niez l'entrée!

36

Blatant arnaque d'une arnaque . Allez upvote ceux-ci!

Votre tâche, si vous souhaitez l'accepter, consiste à écrire un programme / une fonction qui génère / retourne son entrée / argument entier. La partie délicate est que si j'inverse votre code source, la sortie doit être le nombre entier original nié.

Exemples

Disons que votre code source est ABCet son entrée est 4. Si j'écris à la CBAplace et l'exécute, la sortie doit être -4.

Disons que votre code source est ABCet son entrée est -2. Si j'écris à la CBAplace et l'exécute, la sortie doit être 2.

Une entrée de 0peut donner 0ou -0, cependant, si vous supportez zéro signé, -0devrait donner 0.

code-golf  math  number  source-layout 
— Adam
source
5
Pourquoi avons-nous besoin d'une copie de la même question?
— Christian le
5
@Christian Celui-ci sort un nombre constant (et sa négation) alors que celui-ci doit prendre en entrée et le retourner / le nier. Un travail très différent dans beaucoup de langues.
— Adám
5
Un oui, maintenant je vois la différence. Il faut lire TRÈS attentivement
— Christian, le
Si vous utilisez un langage structuré tel que C #, ne faites-vous que renverser des lignes?
— PerpetualJ
@PerpetualJ Non, regardez la source comme une liste de caractères, dont certains sont des sauts de ligne.
— Adám

Réponses:

11

code machine x86, 3 octets

C3 D8 F7

Les octets de code ci-dessus définissent une fonction qui n'est pas une opération: elle rend simplement le contrôle à l'appelant. Cette fonction est suivie de deux octets parasites qui ne seront pas exécutés, car ils viennent après un retour - ils sont dans le "no man's land". En mnémonique assembleur:

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

Bon, alors maintenant un troll passe et inverse l'ordre des octets:

F7 D8 C3

Ces octets définissent maintenant une fonction qui prend un argument entier dans le EAXregistre, le nie et rend le contrôle à l'appelant. En mnémonique assembleur:

neg  eax     ; F7 D8
ret          ; C3

Alors… c'était simple. :-)

Notez que nous pouvons faire que l'instruction "négation" soit ce que nous voulons, puisqu'elle n'est jamais exécutée dans l'orientation "en avant" et uniquement dans l'orientation "inversée". Par conséquent, nous pouvons suivre le même schéma pour faire des choses arbitrairement plus compliquées. Par exemple, prenons ici un argument entier dans un registre différent (par exemple, EDIpour suivre la convention d'appel System V couramment utilisée sur les systèmes * nix), le nier et le retourner dans le EAXregistre conventionnel :

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
source
6

Espaces blancs , 48 octets

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

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.

Modification mineure de mon Whitespace answer car je inverse le code source, vous annulez la sortie! défi .

Essayez-le en ligne ou inversez-le en ligne (avec des espaces bruts, des onglets et des nouvelles lignes uniquement).

Explication:

Utiliser le programme de sortie intégré étant un palindrome court NNN.
Le programme régulier va:

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

Le programme inverse va:

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

Petite explication supplémentaire de pousser un nombre:

  • Premièrement S: Activer la manipulation de pile
  • Deuxième S: Pousser un nombre à la pile
  • Sou T: positif / négatif respectivement
  • Certains S/ Tsuivis d’un dernier N: nombre en binaire, où S=0etT=1

C'est à dire SSTTSTSNpousse -10. Pour le, 0nous n’avons pas besoin d’un explicite S=0, donc tout simplement SSSNou SSTNc’est suffisant.

— Kevin Cruijssen
source
5

Brain-Flak , 7 octets

#)]}{[(

Essayez-le en ligne!

Renversé:

([{}])#

Essayez-le en ligne!

Remarque: Ne fonctionne que dans les interprètes prenant en charge les commentaires (par exemple, fonctionne dans Rain-Flak, mais pas dans BrainHack)

Si nous échangeons également les crochets d’ouverture / fermeture au lieu d’inverser simplement les octets, nous pouvons le faire en 8 octets sans utiliser de commentaires:

({}[{}])

Essayez-le en ligne!
Essayez-le inversé!

— Riley
source
Est-ce un abus de comportement indéfini? Je ne pense pas que la spécification Brain-Flak permette une telle parenthèse.
— Hautement radioactif le
@TwilightSparkle The #démarre un commentaire, les parenthèses de la version d'origine sont donc ignorées.
— Riley
Ah oui j'avais oublié! Mais cela ne fonctionne que dans Rain-Flak alors (c'est l'interprète officiel cependant). Vous aurez probablement besoin de le mentionner?
— Hautement radioactif le
@TwilightSparkle a ajouté une note pour clarification. Merci.
— Riley
Petit défi amusant: pouvez-vous le faire sans commentaires si vous échangez également des crochets d'ouverture / fermeture au lieu de simplement inverser?
— DJMcMayhem
4

R , 23 octets

J'ai décidé de tenter le coup sans l'astuce de commentaire.

Vers l'avant

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

Essayez-le en ligne!

Sens inverse

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

Essayez-le en ligne!

Dans la version en +aval agit un opérateur binaire, et -est un opérateur unaire.

À l'inverse, le +devient unaire et le -est binaire. Donc, la fonction scan prend les arguments: file=""ce qui signifie stdin et what=0, qui sont aussi des valeurs par défaut. Ainsi, lorsque le +paramètre est unaire, le premier argument est à droite, lorsqu'il est binaire, le premier argument est à gauche.

le 

;nacs=`+`

une partie du code ne fait rien de vraiment utile, donc dans un sens, mon code n’est pas vraiment beaucoup plus valable que le commentaire.

— Aaron Hayman
source
1
C'est très intelligent (+1). Nous redéfinissons souvent les opérateurs R en octets de golf, mais je pense que c’est la première fois que j’ai vu +redéfini pour être utilisé à la fois unaire et binaire. Il m'a fallu une minute pour comprendre comment cela avait été analysé… Aucun autre nom d'opérateur n'aurait fait le travail.
— Robin Ryder le
4

Perl 5 ( -p), 7 6 octets

-1 grâce à @primo

$_*=$#

TIO

Un commentaire ne change pas l'entrée

#1-=*_$

Nier l'entrée

$_*=-1#

TIO

— Nahuel Fouilleul
source
-1: $_*=$# TIO . Notez que le #doit être le tout dernier octet du programme, sinon il sera interprété comme la variable $#plutôt que le dernier index du tableau nommé <vide>.
— Primo le
1
Cependant, je ne comprends pas comment cela fonctionne car essayer d'imprimer $#donne une erreur (si # n'est pas le dernier caractère) ou rien
— Nahuel Fouilleul
Semble travailler uniquement avec -pou -n. Je soupçonne que quelque chose a boilerplate faire avec ...
— Primo
2
@primo Cela fonctionne car -p/-najoute un ;après le code. Ce qui signifie que $#c'est en réalité $#;: la taille du tableau @;. Si la taille des @;modifications change, le résultat n'est plus correct ( TIO ). Quoi qu'il en soit, c'est super intelligent, bravo! :)
— Dada
c'est une explication qui pourrait être vue perl -MO=Deparse -p <(echo -n '$_*=$#'), car il semble perl -MO=Deparse -pe '$_*=$#'ajouter une nouvelle ligne
— Nahuel Fouilleul
4

Gaia , 2 octets

_@

Essayez-le en ligne!

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

Renversé:

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

Revers , 6 5 octets

I@-Ov

Essayez-le en ligne! Essayez-le doublé!

Fait un peu complexe en raison de la nature du pointeur dans le revers. Je ne pense pas qu'il soit possible d'avoir un haha plus court , je me suis trompé. Cela ne duplique aucune instruction et réutilise les commandes d’entrée, de sortie et de fin entre les deux programmes. Maintenant, je pense que c'est optimal, car toutes les IO-@commandes doivent fonctionner, et dans un programme de 4 octets, vous ne pouvez exécuter que deux de ces commandes.

Explication:

Le pointeur de Backhand déplace une coche sur trois cellules et rebondit sur les limites de la cellule, ce qui signifie que la logique générale se chevauche. Cependant, vous pouvez manipuler cette vitesse avec les commandes vet ^.

Le programme d'origine exécute les instructions IO-@, qui sont entrées sous forme de nombre, sorties sous forme de nombre, soustraction, terminées. Évidemment, la soustraction est superflue. Dans le code, ce sont:

I@-Ov
^  ^    Reflect
  ^     Reflect again
 ^

Le programme inversé s'exécute v-I-vO-@. Le vréduit les pas de pointeur entre les ticks, et les -soustrait du bas de la pile, ce qui est implicitement zéro. Les -commandes supplémentaires ne font rien. Le programme s'exécute comme

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

APL (Dyalog Unicode) , 13 3 octets

-∘0

Essayez-le en ligne!

Réponse triviale. Retours argou ¯arg.

Sauvé 10 octets en n'étant pas stupide (merci Adám).

Modifié le 3-octet résultant en une fonction plus adaptée.

— J. Sallé
source
Whoa, cela peut être fait trivialement en trois octets!
— Adám
Fait intéressant, vous avez déjà une réponse de 3 octets incorporée en tant que sous-chaîne de celle-ci.
— Adám
@ Adám ouais, je savais qu'il y avait une réponse simple quelque part. Merci.
— J. Sallé le
2

Langage machine de Turing , 39 octets

Le positif

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

Le négatif

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

Celui-ci était un peu plus compliqué que je ne le pensais, principalement parce que je devais dépasser mes préjugés d'avoir un code qui fonctionne avec des erreurs de 'compilation'.

— ouflak
source
2

> <> , 5 4 octets

n-r0

utilise l’initialisation de pile avec l’ -voption, placez-y votre variable d’entrée.

Essayez-le en ligne!

Ou essayez l'inversion

Explication

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

Stack Cats -mn , 2 octets

-X

Essayez-le en ligne!

Essayez l'inverse!

Explication

Il s'avère que c'est en réalité beaucoup plus facile que le défi précédent dans Stack Cats. Le programme complet (après application -m) est ici -X-. Xest utilisé pour échanger les piles gauche et droite de la tête de bande, c’est-à-dire que cela n’affecte en rien la pile initiale, nous pouvons donc l’ignorer. Mais alors, le programme est effectivement juste --(annule le haut de la pile deux fois), ce qui ne fait rien.

Pour le programme inverse, appliquer -mdonne donne X-X. Encore une fois, Xne fait rien, donc le programme est effectivement juste -, ce qui annule le sommet de la pile.

La seule autre solution à 2 octets est -=, mais c'est pratiquement la même chose. La seule différence est que =seuls les sommets des piles adjacentes sont échangés, et non les piles entières.

Mais encore une fois, utiliser -mest un peu comme tricher, voici donc une solution qui utilise un programme totalement en miroir.

Stack Cats -n , 7 octets

:I<->I:

Essayez-le en ligne!

Essayez l'inverse!

Explication

Les considérations de la réponse précédente sont toujours valables : toute solution valable doit utiliser les caractères et les paires I. Les six solutions possibles (incluses dans le lien TIO) sont pratiquement les mêmes. -et _sont équivalents dans ce programme, et :peuvent être remplacés par |ou T(qui font la même chose pour des entrées non nulles et qui fonctionnent également pour des entrées nulles). Je viens de choisir celui-ci pour expliquer parce que c'est le plus facile.

Donc, rappelez-vous que la pile initiale contient l’entrée au-dessus d’un -1nombre infini de zéros, alors que toutes les autres piles de la bande ne contiennent que des zéros. Stack Cats a également pour caractéristique que tout programme de longueur égale ne fait rien (à condition qu'il se termine, mais nous ne pouvons pas utiliser de boucles pour ce défi de toute façon). La même chose est alors évidemment vraie pour tout programme de longueur impaire dont le personnage central ne fait rien ... voyons:

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

Par conséquent, la seconde moitié du programme annule exactement la première moitié et nous nous retrouvons à nouveau avec l'entrée -1.

Le programme inverse est :I>-<I:. Voyons comment cela change les choses:

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

Lot, 34 octets

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

Écho ( ECHO.) l'entrée ( %1). Le reste de la première ligne est techniquement redirigé STDERRvers un fichier appelé MER@, mais cela n’a aucun impact.
La deuxième ligne est commentée ( REM...).

Renversé

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

Utilise le mode arithmétique de la commande set ( SET /a) pour soustraire ( -=) l'entrée ( %1) d'une variable non définie ( a) équivalente à 0 - input. Encore une fois, le reste de la première ligne est techniquement redirigé STDERRvers un fichier appelé MER@, mais cela n’a aucun impact.
La deuxième ligne est commentée ( REM...).

— Οurous
source
Cela semble intéressant. Soin d'expliquer?
— Adám
@ Adám Ajout d'une explication et aussi réalisé que j'avais les programmes en arrière.
— Sepurous
2

Brachylog , 2 octets

&ṅ

Brachylog entre implicitement à gauche et en sortie à droite.
&ignore tout ce qui se trouve à gauche et passe l’entrée à la fonction à droite.
ṅcontraint chaque côté de celui-ci à être nié versions de l'autre.

Essayez-le en ligne

— IFcoltransG
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.