Votre tâche, si vous souhaitez l'accepter, consiste à écrire un programme générant un nombre différent de zéro (entier ou flottant). La partie délicate est que si j'inverse votre code source, la sortie doit être le nombre entier original nié.

Règles

• Vous devez construire un programme complet . C'est-à-dire que votre sortie doit être imprimée sur STDOUT.

• Les deux numéros doivent être en base 10 (leur sortie dans une autre base ou avec une notation scientifique est interdite).

• La sortie des nombres avec des espaces de fin / fin est autorisée.

• C'est du code-golf, donc le code le plus court (original) dans chaque langue gagne!

• Les failles par défaut s'appliquent.

Exemple

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

05AB1E , 2 octets

(1

Essayez-le en ligne!

! enilno ti yrT

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

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

JavaScript (V8) , 19 octets

print(1)//)1-(tnirp

Essayez-le en ligne!

presque identique à ...

C # (compilateur interactif Visual C #) , 19 octets

Print(1)//)1-(tnirP

Essayez-le en ligne!

(merci à quelqu'un pour l'avoir signalé)

toujours à peu près la même chose dans

Lua , 19 octets

print(1)--)1-(tnirp

Essayez-le en ligne!

mais plus court dans ...

Python 2 , 15 octets

print 1#1-tnirp

Essayez-le en ligne!

Encore plus court en PHP, car il possède cet outil d'impression magique: <?=...

PHP , 12 octets

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

Essayez-le en ligne!

Encore plus court dans Ruby, parce que vous pouvez inspectplutôt que d'imprimer

Ruby , 8 octets

p 1#1- p

Essayez-le en ligne!

PowerShell ,  4  3 octets

1-0

Essayez-le en ligne! ou ! enilno ti yrT

Golfé un octet en utilisant l'arithmétique au lieu du format numéro-commentaire-numéro.

C'est apparemment aussi pareil que jshell (par Sam ), et jq (par manatwork - 1-0et 0-1).

/// , 4 octets

9/9-

Sorties 9.

Essayez-le en ligne!

Renversé:

-9/9

Sorties -9.

Essayez-le en ligne!

Tout ce qui précède /est imprimé, tandis que le reste est ignoré (les barres obliques sont peu utilisées, donc je ne sais pas exactement ce qui se passe, mais rien ne s'affiche).

Klein 011, 5 octets

1-
@/

Essayez-le en ligne!

Renversé

/@
-1

Essayez-le en ligne!

Celles-ci tirent parti de la topologie unique de Klein, en particulier du véritable plan projectif. (Bien qu’individuellement, chaque réponse nécessite seulement une bouteille de Klein).

Espaces blancs , 21 octets

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

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

Sorties 1/ -1.

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:

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

Le programme inversé va:

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

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.

T-SQL, 16 octets

--Forwards:
PRINT 4--4-TNIRP

--Backwards:
PRINT-4--4 TNIRP

Choisi 4 parce que 1 est trop utilisé :)

Japt , 2 octets

Tout entier à un seul chiffre >0peut être utilisé à la place du 2comme peut A-G, H, I, Jou L( 10-16, 32, 64, -1et 100, respectivement).

n2

Testez le | Renversé

La nméthode, lorsqu'elle est appliquée à un entier, soustrait cet entier de l'argument qui lui est transmis, qui est la valeur par défaut 0. Lorsqu'elle est exécutée vers l'avant, la nméthode est en cours d'exécution sur la première entrée implicite, dont la valeur par défaut est également 0.

Alternativement, la gméthode pourrait être utilisée à la place de n, ce qui donne le signe du résultat de la soustraction de son argument du nombre entier auquel il est appliqué.

Haskell sans commentaires, 41 octets

Impressions vers l'avant 1+ nouvelle ligne:

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

Essayez-le en ligne!

Impressions inversées -1sans nouvelle ligne (pouvant être ajoutées au coût de 2 octets):

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

Essayez-le en ligne!

• La première ligne de chaque programme imprime le numéro.
  • Pour les -1chaînes, la sortie est utilisée pour éviter les parenthèses.
  • L'utilisation de $!(application stricte) au lieu d'un espace permet à la ligne inversée d'être une définition valide de l'opérateur !$( $ce n'est tout simplement pas le cas, car la redéfinition briserait l'utilisation).
• La ligne médiane garantit que niamest défini pour la dernière ligne.
• La dernière ligne est une définition d'un opérateur !$, qui n'est pas utilisé mais qui doit être analysé et vérifié correctement.

PHP , 15 à 13 octets

Une version de PHP sans abus de commentaires. ohceest une constante non définie, elle sera donc égale à la valeur chaîne de son nom. En conséquence, ceci essaiera d’imprimer +1-'ohce'ou -1+'ohce'lorsqu’il sera inversé. Comme il 'ohce's'agit d'une valeur non numérique, 0 sera utilisé à la place dans les opérations arithmétiques et seul 1ou -1sera imprimé.

;echo+1-ohce;

Essayez-le en ligne!

Essayez-le en ligne!

Google , 3 octets

2-1

Essayez-le en ligne!
! enilno ti yrT

Gelée , 2 octets

NC

Essayez-le en ligne!

Négatif, résultats en 0, puis Ccomplément, résultats en 1-0= 1.

CN

Essayez-le en ligne! CComplément, résultats 1-0= 1. Négatif, résultats en -1.

K (ngn / k) , 3 octets

2-1

Essayez-le en ligne!

est-ce que je manque quelque chose? semble évident pour les langues REPL

Cubix , 7 6 5 octets

@)O(@

Essayez ici
inversé

Explication

Cubifié:

  @
) O ( @
  .

En déroulant le flux de contrôle, nous exécutons ce )O(@qui incrémente, produit, décrémente et quitte.

Renversé et cubifié:

  @
( O ) @
  .

En déroulant le flux de contrôle, nous exécutons ce (O)@qui décrémente, affiche, incrémente et quitte.

La version précédente

@O(.)O@

Essayez ici
inversé

Pas aussi court, mais esthétique.

Enchantements runiques , 4 octets

1@Z1

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

Je ne pouvais pas trouver un moyen de réutiliser la 1commande, même au détriment d'un octet ou deux.

1@ɩ fonctionne également, mais est le même nombre d'octets.

APL (Dyalog Unicode) ,  4 à  3 octets

1-0

Essayez-le en ligne!

Réponse triviale. Imprime 1quand exécuté et ¯1quand exécuté inversé.

Stack Cats -mn , 4 octets

:-:_

Essayez-le en ligne! Dans le pied de page, j'ai inclus toutes les autres solutions à 4 octets. (Stack Cats ignore tout après le premier saut de ligne.)

Essayez l'inverse!

Explication

L’ -nindicateur active la sortie numérique (et l’entrée, mais nous n’en avons aucune), et l’ -mindicateur n’est en principe qu’une commodité permettant de jouer au golf, ce qui vous permet d’éviter la partie redondante du code source. En effet, chaque programme Stack Cats doit avoir une symétrie miroir. Avec le -mdrapeau, vous ne lui donnez que la première moitié (plus le personnage central). Le programme actuel est donc le suivant:

:-:_:-:

Comme vous pouvez le constater dans le premier lien TIO, il existe une tonne de solutions à 4 octets, mais j’ai choisi celle-ci pour sa simplicité. Stack Cats est basé sur une pile et ce programme utilise uniquement la pile initiale. Comme nous n’avons aucune entrée, il contient un seul -1marqueur (un marqueur EOF) au-dessus d’un nombre infini de zéros. Les trois commandes du programme ont la signification suivante:

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

Voici donc comment le programme modifie la pile (les états et les commandes sont décalés pour indiquer comment chaque commande modifie la pile d’un état à l’autre):

   :   -   :   _   :   -   :

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

Il s’avère que la seule commande qui fait vraiment quelque chose ici est celle _qui transforme notre marqueur EOF en a 1. La sortie à la fin du programme est implicite, et le marqueur EOF est facultatif, donc cela affiche simplement le1 obtenu.

Maintenant, si nous inversons le code source, en raison de la mise en miroir implicite, le programme actuel devient:

_:-:-:_

Cela fait quelque chose de très différent:

   _   :   -   :   -   :   _

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

Cette fois le bas de la pile est encore un-1 donc il fait office de marqueur EOF et seul -1le dessus est imprimé.

...

Cela dit, étant donné que Stack Cats a une relation unique avec le code inversé, j’estime que l’utilisation -mest un peu de la triche. Normalement, il s'agit uniquement d'économiser des octets en omettant la partie redondante du code source, mais ici, le défi est beaucoup plus simple et le programme complet plus court. En effet, inverser un programme complet ne changera le programme que s’il en contient <>[], ce qui signifie également que le programme finit par utiliser plusieurs piles (Stack Cats possède en fait une bande de piles où toutes, sauf la première, ne sont remplies). avec des zéros pour commencer). De plus, l'inverser puis simplement échanger les paires <>et [], ce qui rend l'exécution toujours symétrique. Le seul moyen de briser cette symétrie est d’utiliser Ice qui fait -]ou-[ou rien selon le signe du haut de la pile. Alors...

Stack Cats -n , 11 octets

*|]I*:*I[|*

Essayez-le en ligne! Le pied de page inclut à nouveau toutes les autres alternatives au même nombre d'octets. Certaines de ces sorties 1 / -1 et d'autres 2 / -2 comme indiqué après chaque programme. J'ai choisi celui-ci pour expliquer un peu au hasard en tant que l'un de ceux qui produisent 2.

Essayez l'inverse!

Explication

Comme je l'ai dit, celui-ci est un peu plus long. Même si nous utilisions la -mnotation pour cela, cela pèserait 6 octets au lieu de 4 ci-dessus.

Les commandes utilisées cette fois-ci:

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

Le premier programme utilise seulement deux piles. C'est un peu brouillon à faire en ASCII, mais je vais faire de mon mieux. Les crochets indiquent la pile sur laquelle se trouve la tête de lecture et je vais placer les commandes entre chaque paire d'états de pile.

  [-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
    …   …

Maintenant, le -1fait office de marqueur EOF et le2 est imprimé.

L’autre programme est le même jusqu’à ce que le [. C'est pratiquement le même jusqu'à la seconde I. Techniquement, nous serons sur une pile différente, mais sans valeurs, elles sont toutes indiscernables. Mais alors la différence entre I[et I]finit par compter:

    *|[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
    …   …   …

Et cette fois, nous n’avons pas de marqueur EOF, mais le programme affiche toujours le fichier -2.

Zsh , 12 octets

<<<2 # 2-<<<

Essayez-le en ligne!

Avance de base, commentaire, méthode inverse.

Si les E / S sont moins restrictives, une solution plus intéressante à 11 octets est possible grâce à Zsh prenant en charge les codes de retour négatifs:

return -127

Renversé, 721- nruterquitte avec du code 127(commande introuvable). exit -127ne peut pas être utilisé, il serait jeté à u8. Essayez-le en ligne!

CJam , 3 octets

W;1

Essayez-le en ligne!

• Ordinaire
• Renversé

Comment ils travaillent

Version normale:

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

Version inversée: vous avez l'idée.

MATL , 3 octets

Nqv

Essayez-le en ligne!

• Ordinaire
• Renversé

Comment ils travaillent

Ordinaire:

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

Renversé:

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 octets

Print@1;tnirP//1-0

Essayez-le en ligne!

-3 grâce à Martin Ender

Hexagonie , 5 octets

1!@!(

Essayez-le en ligne!

Tout programme valide doit:

• Avoir une commande de résiliation ( @ou :). Le dernier n'est différent pour le premier que lorsqu'il existe une commande de déplacement du pointeur de la mémoire. De plus, cette commande ne doit pas être au premier ou au dernier octet.
• Avoir une commande de sortie. ( !,; est également possible mais prendrait probablement plus d'octets)
• Avoir une commande de manipulation de mémoire.

Par conséquent, un programme de 2 octets est évidemment impossible. Un programme de 3 octets est impossible car le deuxième octet doit être la commande de terminaison et que le premier octet ne doit pas être une commande de manipulation miroir / IP. Par conséquent, un seul octet peut être exécuté.

Je pense qu'un programme de 4 octets n'est pas possible. Un tel programme doit avoir la forme a@bcavec grille hexagonale

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

Par conséquent, adoit être une commande de redirection IP. Cependant, il est impossible de générer des nombres positifs et négatifs avec une seule commande de manipulation de mémoire.

Haskell , 28 octets

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

Essayez-le en ligne!

Essayez-le enilno!

Triangulaire , 4 octets

i%%d

Essayez-le en ligne!

Sorties 1.

Ungolfed:

   i
  % %
 d

Renversé:

d%%i

Essayez-le en ligne!

Sorties -1.

Java 5 ou 6, 127 67 octets

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

Sorties 9/ -9.

Pas de compilateur en ligne, car Java 5 ou 6 n'est disponible nulle part.

Vous pouvez toutefois essayer cet équivalent de 127 octets Java 8:
Essayez-le en ligne ou essayez-le en ligne inversé .

Explication:

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

Java 5 et 6 présentaient un bogue qui vous permettait de créer un bloc de code dans une énumération afin de faire quelque chose, même s'il manquait la méthode principale obligatoire d'un programme. Cela entraînera une erreur:

java.lang.NoSuchMethodError: main
Exception dans le thread "main"

Mais restera toujours ce que nous voudrions commencer par STDOUT, afin que nous puissions l'ignorer .

Golang , 109 octets

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

Et son revers:

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

Essayez-le en ligne!

Perl 5 (-p), 12 octets

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

Essayez-le en ligne!

! enilno ti yrT

Le }{pseudo-opérateur est vraiment utile.

Perl 5 (-M5.010), 9 octets

Fourni par Nahuel Fouilleul dans un commentaire

say+1-yas

Essayez-le en ligne!

! enilno ti yrT

Retina , 6 octets

-`<
-

Impressions 1 .

Essayez-le en ligne!

-
<`-

Impressions -1 .

Essayez-le en ligne!

Explication: 1

-`<
-

Ceci ... ne fait rien. En raison de `, il s'agit d'une substitution de <à -(avec la configuration -, qui ne fait rien), mais l'entrée est vide, donc la sortie est également vide.

Et cette deuxième étape met en correspondance la regex vide avec l'entrée vide et compte le nombre de correspondances, qui est exactement 1. La sortie est implicite.

Explication: -1

-

Cette fois, nous remplaçons la regex vide par -. Cela transforme en effet l'entrée vide en un seul -.

<`-

Ici, la configuration fait réellement quelque chose: <imprime les entrées de la scène avant de les exécuter, nous imprimons donc la- . Puis -compte les traits d'union dans l'entrée de la scène qui est encore 1. En raison de la sortie implicite, ceci affiche un 1après le -, nous donnant -1au besoin.

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

1%1-

brainfuck , 156 octets

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

Essayez-le en ligne! / Vérificateur avant / arrière dans Bash

Imprime en -1avant et en \n1arrière.

En dépit d'être presque trivial, je crois que c'est la solution optimale pour cette sortie fixe particulière.

Preuve:

• Le programme ne peut pas avoir [ou ].

  Par conséquent, le programme doit avoir la forme <A> . <B> . <C>.

• Chacun ,peut être remplacé par un nombre suffisant de <sans augmenter le nombre de +ou -.

• Chacun +n’est utile que dans le programme en amont ou en aval, jamais les deux.

  Preuve: +dans la partie A, ce n’est évidemment utile que dans le programme en aval, et +dans la partie C, dans le programme en arrière.

  Indiquer shift(P)= nombre de <dans P - nombre de >dans P. Envisager programme <B> = <D> + <E>, +le milieu est utile dans le programme suivant$\iff$ shift(E) = 0de même, il est utile dans le programme en arrière $\iff$ shift(D) = 0. Toutefois, si shift(D) = shift(E) = 0le programme Bexécuté en avant ou en arrière ajoute une valeur fixe à la cellule en cours avant la deuxième impression, ce qui ne peut pas être le cas car ord('1') - ord('\n') != ord('1') - ord('-').

Par conséquent, le programme nécessite au moins ord('-')+ord('1')+ord('\n')+ord('1') = 153 +s, 2 .s et au moins un < >ou ,parce que shift(B) != 0.