Soit un nombre N, affiche le signe de N:

• Si N est positif, sortie 1
• Si N est négatif, sortie -1
• Si N est 0, sortie 0

N sera un entier compris dans la plage d'entiers pouvant être représentée dans la langue de votre choix.

Retina , 9 octets

[1-9].*
1

Essayez-le en ligne!

Remplace un chiffre différent de zéro et tout ce qui suit après 1. Cela laisse -intact un potentiel et change tous les nombres sauf 0lui-même en valeur absolue 1.

C (GCC), 24 23 22 18 octets

Merci à @aross et @Steadybox pour la sauvegarde d’un octet!

f(n){n=!!n|n>>31;}

Pas garanti de fonctionner sur tous les systèmes ou compilateurs, fonctionne sur TIO .

Mathematica, 4 octets

Clip

Pourquoi ne pas utiliser les Signoctets intégrés et toujours en cours de notation? ;)

Clipavec un seul argument coupe (ou serre) la valeur d'entrée entre -1et 1. Comme les entrées ne seront que des entiers, cela revient à utiliser Sign.

VACHE, 225 213 201 octets

oomMOOmoOmoOmoOmoOMoOMoOmOomOomOoMoOMMMmoOMMMMOOMOomOo
mOoMOomoOmoOmoomOomOoMMMmoOmoOmoOMMMMOOOOOmoOMOoMOomOo
mOomOoMoOMMMmoOMMMMOOMOomOomOoMoOmoOmoOmoomoOmoomOomOo
mOomoomoOMOOmoOmoOmoOMOoMMMOOOmooMMMOOM

Essayez-le en ligne!

La façon dont ce code fonctionne consiste à déterminer le signe en alternant l'addition et la soustraction de nombres plus grands, et à voir lequel était le dernier qui a fonctionné. Sous tout entier non nul, soustrayez d'abord 1, puis ajoutez 2, puis soustrayez 3, etc. et vous atteindrez éventuellement 0. Gardez une trace de votre état en alternant l'addition et la soustraction de 2 à une valeur commençant à 0. Pour exemple:

-5  - 1  = -6  (current state: 0 + 2 = 2)
-6  + 2  = -4  (current state: 2 - 2 = 0)
-4  - 3  = -7  (current state: 0 + 2 = 2)
-7  + 4  = -3  (current state: 2 - 2 = 0)
-3  - 5  = -8  (current state: 0 + 2 = 2)
-8  + 6  = -2  (current state: 2 - 2 = 0)
-2  - 7  = -9  (current state: 0 + 2 = 2)
-9  + 8  = -1  (current state: 2 - 2 = 0)
-1  - 9  = -10 (current state: 0 + 2 = 2)
-10 + 10 =  0  (current state: 2 - 2 = 0)
value is now at 0.  state - 1 = 0 - 1 = -1
sign of original number is -1

Lorsque vous avez terminé, soustrayez 1 de votre état et vous obtenez le signe, positif ou négatif. Si le numéro d'origine est 0, alors ne vous embêtez pas et écrivez simplement 0.

Explication détaillée:

oom                                        ;Read an integer into [0]
MOO                                        ;Loop while [0] is non-empty
    moOmoOmoOmoOMoOMoOmOomOomOo            ;    Decrement [4] twice
    MoOMMMmoOMMM                           ;    Increment [1], then copy [1] to [2]
    MOO                                    ;    Loop while [2] is non-empty
        MOomOomOoMOomoOmoO                 ;        Decrement [0] and [2]
    moo                                    ;    End loop now that [2] is empty
    mOomOoMMMmoOmoOmoOMMM                  ;    Navigate to [0], and copy to [3]
    MOO                                    ;    Perform the next steps only if [3] is non-zero
        OOOmoOMOoMOomOomOomOoMoOMMMmoOMMM  ;        Clear [3], increment [4] twice, increment [1], and copy it to [2]
        MOO                                ;        Loop while [2] is non-empty
            MOomOomOoMoOmoOmoO             ;            Decrement [2] and increment [0]
        moo                                ;        End loop now that [2] is empty
    moO                                    ;        Navigate back to [3]
    moo                                    ;    End the condition
    mOomOomOo                              ;    Navigate back to [0]
moo                                        ;End loop once [0] is empty.
moO                                        ;Navigate to [1]. If [1] is 0, then input was 0.  Otherwise, [4] contains (sign of [0] + 1)
MOO                                        ;Perform the next steps only if [1] is non-zero
    moOmoOmoOMOoMMMOOO                     ;    Navigate to [4], copy it to the register, and clear [4].
moo                                        ;End condition
MMMOOM                                     ;If the register contains something (which is true iff the condition ran), paste it and print it.  Otherwise, no-op and print 0.

J'essaie toujours de jouer au golf (vous serez surpris de découvrir que jouer au golf dans COW est assez difficile), donc cela risque de perdre quelques octets de plus dans le futur.

Cubix , 10 octets

(W0^I?>O2@

Testez-le en ligne!

Ce code est encapsulé dans le cube suivant:

    ( W
    0 ^
I ? > O 2 @ . .
. . . . . . . .
    . .
    . .

Le code est ensuite exécuté avec l’IP (pointeur d’instruction) en commençant par le Icôté est. Ientre un entier signé de STDIN, en le poussant sur la pile.

La commande suivante est ?, qui change la direction de l’IP en fonction du signe de l’élément supérieur. Si l'entrée est 0, elle continue à avancer dans la même direction, en passant par le code suivant:

• >- Pointez l'IP à l'est. (Non-op puisque nous allons déjà à l'est.)
• O - Affiche l’élément supérieur en tant qu’entier.
• 2- Poussez 2 à la pile. C'est pratiquement un no-op, parce que ...
• @ - Termine le programme.

Si l'entrée est négative, l'IP tourne à gauche au ?; comme il s’agit d’un cube, l’adresse IP se déplace vers 0la deuxième ligne, en direction est. 0pousse un 0 littéral, alors ce code est exécuté:

• ^ - Pointez le nord de l'IP.
• W - "Sur le pas" l'adresse IP d'un point à gauche.
• ( - Décrémentez le premier élément.

Le TOS est maintenant -1, et la propriété intellectuelle entoure le cube à travers un tas de non-opérations .jusqu'à ce qu'il frappe le >. Ceci exécute le même code de sortie mentionné ci-dessus, en sortie -1.

Si l'entrée est positive, la même chose se produit avec les entrées négatives, à une exception près: l'IP tourne à droite au lieu de gauche à la gauche ?et tourne autour du cube jusqu'à la 2, ce qui pousse un littéral 2. Ceci est ensuite décrémenté à 1 et envoyé à la sortie.

JavaScript (ES6), 9 octets

Math.sign

Simple.

Le plus court non intégré est de 13 octets:

n=>n>0|-(n<0)

Grâce à @Neil, cela peut être joué avec un octet, mais au prix de travailler uniquement sur des entiers 32 bits:

n=>n>0|n>>31

Ou tu pourrais faire

n=>n>0?1:!n-1

qui semble plus golfable, mais je ne sais pas comment.

APL (Dyalog APL) , 1 octet

Fonctionne aussi pour les nombres complexes, en retournant 1∠ θ :

×

TryAPL en ligne!

Sans cette fonction intégrée, pour les nombres entiers (selon l'OP):

¯1⌈1⌊⊢

¯1⌈ le plus grand des négatifs et

1⌊ le plus petit de l'un et

⊢ l'argument

TryAPL en ligne!

... et un général:

>∘0-<∘0

>∘0 plus que zéro

- moins

<∘0 moins que zéro

TryAPL en ligne!

> <> , 9 à 8 octets

Merci à Sp3000 pour la sauvegarde d’un octet.

'i$-%n/

Il y a un non imprimable 0x01avant le /.

Essayez-le en ligne!

Explication

Ceci est un port de ma réponse Labyrinth basée sur le code du personnage .

'     Push the entire program (except ' itself) onto the stack, which ends 
      with [... 1 47].
i     Read the first character of the input.
$-    Subtract the 47.
%     Take the 1 modulo this value.
n     Output the result as an integer.
0x01  Unknown command, terminates the program.

Vim, 22 octets

xVp:s/-/-1^M:s/[1-9]/1^M

Un octet enregistré grâce à @DJMcMayhem !

Voici ^Mune nouvelle ligne littérale.

Comme @ nmjcman101 l'a souligné dans les commentaires, une seule expression rationnelle peut être utilisée ( :s/\v(-)=[^0].*/\11^M, 20 octets), mais comme c'est fondamentalement la même chose qu'une réponse de Retina, je m'en tiens à ma propre méthode.

Explication:

xVp                        Delete everything except the first character. If the number is negative, this leaves a -, a positive leaves any number between 1 and 9, and 0 leaves 0.
   :s/-/-1^M               Replace a - with a -1
            :s/[1-9]/1^M   Replace any number between 1 and 9 with 1.

Voici un gif de celui-ci en cours d'exécution avec un nombre négatif (ancienne version):

La voici avec 0:

Courir avec le positif:

///, 52 36 octets

/a/\/1\/\///2a3a4a5a6a7a8a9a10a11/1/

Ungolfed, explication:

/2/1/
/3/1/
/4/1/
/5/1/
/6/1/
/7/1/
/8/1/
/9/1/
/10/1/
/11/1/

Il s’agit en gros d’une implémentation MapReduce, c’est-à-dire en deux phases:

• Remplacer toutes les occurrences de chiffres 2- 9par 1, par exemple 1230405->1110101
• Réduisez les paires de 11ou 10à 1plusieurs fois, par exemple 1110101->1

S'il y avait un -devant au début, il restera et la sortie sera -1. Un seul 0n'est jamais remplacé, ce qui donne lieu à lui-même.

Mise à jour: économisez 16 octets supplémentaires en créant //1/un alias avec a, grâce à Martin Ender.

Essayez-le en ligne, avec des cas de test

Python 2 , 17 octets

lambda n:cmp(n,0)

Essayez-le en ligne!

Labyrinthe , 10 octets

?:+:)%:(%!

Essayez-le en ligne!

Explication

La sémantique des flux de contrôle de Labyrinth vous donne en fait un moyen "libre" de déterminer le signe d'un nombre, car le chemin choisi à une fourchette à trois voies dépend du fait que le signe soit négatif, nul ou positif. Cependant, je n'ai pas encore réussi à adapter un programme avec des jonctions à moins de 12 octets (bien que cela puisse être possible).

Au lieu de cela, voici une solution de forme fermée, qui ne nécessite aucune branche:

Code    Comment             Example -5      Example 0       Example 5
?       Read input.         [-5]            [0]             [5]
:+      Double.             [-10]           [0]             [10]
:)      Copy, increment.    [-10 -9]        [0 1]           [10 11]
%       Modulo.             [-1]            [0]             [10]
:(      Copy, decrement.    [-1 -2]         [0 -1]          [10 9]
%       Modulo.             [-1]            [0]             [1]
!       Print.              []              []              []

Le pointeur d'instruction frappe ensuite une impasse, se retourne et se termine lorsque %tente maintenant une division par zéro.

Il est nécessaire de doubler les entrées pour que cela fonctionne avec des entrées 1et -1, sinon, une des deux opérations modulo tenterait déjà une division par zéro.

PHP, 16 octets

Utilise le nouvel opérateur de vaisseau spatial.

<?=$argv[1]<=>0;

Brain-Flak 74 42 40 Octets

Économisé 2 octets grâce à 1000000000

{([({}<([()])>)]<>(())){({}())<>}}{}({})

Essayez-le en ligne!

Explication:

{                                }       # if 0 do nothing
   (          )                          # push:                           
    {}<     >                            # the input, after 
       (    )                            # pushing:
        [  ]                             # negative:
         ()                              # 1

 (                    )                  # Then push:
  [            ]                         # the negative of the input
                <>                       # on the other stack with:
                   ()                    # a 1 
                  (  )                   # pushed under it

                       {        }        # while 1: 
                        ({}())           # increment this stack and...
                              <>         # switch stacks

                                 {}      # pop the top (the counter or 0 from input)
                                   (  )  # push:
                                    {}   # the top (this is a no-op, or pushes a 0)

J , 1 octet

*

Essayez-le en ligne (avec des cas de test)!

C, 24 20 19 18 octets

J'abuse de deux exploits C pour jouer au golf; Ceci est en C (GCC).

f(a){a=a>0?:-!!a;}

Essayez-le en ligne!

Historique des révisions:

1) f(a){return(a>0)-(a<0);}// 24 octets

2) f(a){a=(a>0)-(a<0);}// 20 octets

3) f(a){a=a>0?:-1+!a;}// 19 octets

4) f(a){a=a>0?:-!!a;}// 18 octets

Révision 1: première tentative. Logique simple

Révision 2: Abuse d'un bogue mémoire / pile dans GCC où, pour autant que je sache, une fonction non renvoyée renverra la dernière variable définie dans certains cas.

Révision 3: Abuse du comportement ternaire où un résultat indéfini retournera un résultat conditionnel (c'est pourquoi le retour réel sur mon ternaire est nul)

Révision 4: Soustrayez un cast bool ( !!) de la substitution conditionnelle ternaire pour nilréférencé dans la révision 2.

Ruby, 10 octets

->x{x<=>0}

Perl, 9 octets

Requiert -Esans frais supplémentaires.

say<><=>0

Usage

perl -E 'say<><=>0' <<< -9999
-1
perl -E 'say<><=>0' <<< 9999
1
perl -E 'say<><=>0' <<< -0
0

Je suis heureux avec le pêcheur!

Stack Cats , 6 + 4 = 10 octets

_[:I!:

+4 octets pour les ​ -nmdrapeaux. nest destiné aux entrées / sorties numériques, et comme Stack Cats exige que les programmes soient palindromiques, reproduit mimplicitement le code source pour donner le code source original.

_[:I!:!I:]_

Essayez-le en ligne! Comme c'est le cas pour tous les bons golfeurs Stack Cats, cela a été découvert par force brute, il a battu toutes les tentatives manuelles, et ne peut pas être facilement intégré à un programme plus vaste.

Ajoutez un Dindicateur si vous souhaitez voir une trace de programme étape par étape, c'est-à-dire exécuter avec -nmDet vérifier STDERR / debug.

Stack Cats utilise une bande de piles qui sont implicitement remplies de zéros au bas. Au début du programme, toutes les entrées sont placées dans la pile d'entrées, avec un -1à la base pour séparer les entrées des zéros implicites. A la fin du programme, la pile actuelle est sortie, sauf une base -1si présente.

Les commandes pertinentes ici sont:

_           Perform subtraction [... y x] -> [... y y-x], where x is top of stack
[           Move left one stack, taking top of stack with you
]           Move right one stack, taking top of stack with you
:           Swap top two of stack
I           Perform [ if top is negative, ] if positive or don't move if zero. Then
                negate the top of stack.
!           Bitwise negate top of stack (n -> -n-1)

Notez que toutes ces commandes sont inversables, son inverse étant le miroir de la commande. C’est la prémisse de Stack Cats - tous les programmes de terminaison non triviaux ont une longueur impaire, puisqu’ils s’annulent automatiquement.

On commence avec

               v
               n
              -1
...  0    0    0    0    0  ...

_soustrait, en haut -1-n, et [déplace le résultat d'une pile à gauche:

           v
       -1-n   -1
...  0    0    0    0    0  ...

:swaps top deux et Ine fait rien, puisque le haut de la pile est maintenant zéro. !ensuite, au niveau des bits, le zéro supérieur est inversé en un -1et :les deux premiers sont échangés. !puis au niveau du bit nie le haut, -1-nrevenant à nnouveau dans :

          v
          n
         -1   -1
...  0    0    0    0    0  ...

Maintenant nous avons une branche basée sur I, qui est appliquée à notre original n:

• Si nest négatif, nous déplaçons une pile à gauche et finissons par -nun zéro implicite. :swaps, en mettant un zéro en haut, et ]déplace le zéro en haut de ce que -1nous venons de déplacer. _puis soustrait, laissant la pile finale comme [-1 -1], et une seule -1est sortie puisque la base -1est ignorée.

• Si nest égal à zéro, nous ne bougeons pas et nous :échangeons, en mettant -1sur le dessus. ]déplace ensuite cette gauche -1en haut à droite -1et _soustrait, laissant la pile finale comme [-1 0], affichant le zéro et ignorant la base -1.

• Si nest positif, on déplace un pile et on termine par -nun -1. :swaps, en plaçant -1le dessus, et ]déplace ce -1droit, sur un zéro implicite. _puis soustrait, donnant 0 - (-1) = 1et laissant la pile finale comme [1], qui est sortie.

TI-Basic, 8 octets

median({1,Ans,~1

Solutions alternatives (n'hésitez pas à suggérer plus):

max(~1,min(Ans,1               8  bytes
0:If Ans:Ans/abs(Ans           9  bytes
(Ans>0)-(Ans<0                 10 bytes

MATL , 6 octets

0>EGg-

L'entrée peut être un nombre ou un tableau. Le résultat est un nombre ou un tableau avec les valeurs correspondantes.

Essayez-le en ligne! Ou testez plusieurs cas en utilisant une entrée de tableau.

Explication

Cela évite d'utiliser la fonction de signe intégrée ( ZS).

0>   % Take input implicitly. Push 1 if positive, 0 otherwise
E    % Multiply by 2
Gg   % Push input converted to logical: 1 if nonzero, 0 otherwise
-    % Subtract. Implicitly display

Gelée , 1 octet

Ṡ

TryItOnline!

Le signe monadique atome , Ṡ, fait exactement ce qui est spécifié pour une entrée de nombre entier, que ce soit en tant que programme complet ou en tant que lien monadique (fonction prenant un argument).

Mathematica, 4 octets

Sign

Exactement ce qu'il dit sur l'étain

Octave, 26 à 24 octets

f=@(x)real(asin(x))/pi*2

Ceci est ma première réponse Octave Code-golf , tous les conseils de golf sont appréciés!

Essayez-le en ligne!

L'idée de prendre le asinvient de la question où il est dit output the sign:)

Explication

Remarque: diviser le nombre par piet le multiplier par 2revient à diviser le nombre entier parpi/2

Cas 0:

asin(0)les rendements 0. Prendre la partie réelle de celle-ci et la diviser par pi/2ne fait aucune différence pour la sortie.

Cas positive:

asin(1)les rendements pi/2. asinde tout nombre plus grand que 1donnera pi/2+ nombre complexe. En prenant la partie réelle de celui - ci donne pi/2et en le divisant par pi/2donne1

Cas negative:

asin(-1)les rendements -pi/2. asinde tout nombre inférieur à celui -1qui donnera -pi/2+ nombre complexe. En prenant la partie réelle de celui - ci donne -pi/2et en le divisant par pi/2donne-1

En fait , 1 octet

s

Essayez-le en ligne!

Un autre cas d’exactement ce qui est écrit sur l’étain - sest la fonction de signe.

Sans la fonction intégrée (4 octets):

;A\+

Essayez-le en ligne!

;A\divise la valeur absolue de l'entrée par l'entrée. Cela se traduit -1par des entrées négatives et 1par des entrées positives. Malheureusement, en raison de la gestion des erreurs par Actually (en cas de problème, la commande est ignorée), 0car l'entrée laisse deux 0secondes sur la pile. +corrige cela en les ajoutant (ce qui provoque une erreur avec quoi que ce soit d'autre, donc il est ignoré).

Piet, 188 53 46 41 octets

5bpjhbttttfttatraaearfjearoaearbcatsdcclq

Interprète en ligne disponible ici.

Ce code de piet fait la norme (n>0)-(n<0), car il n’ya pas de vérification de signes intégrée. En fait, il n’ya pas moins que intégré, donc une description plus précise de cette méthode serait (n>0)-(0>n).

Le texte ci-dessus représente l'image. Vous pouvez générer l'image en la collant dans la zone de texte de la page de l'interprète. Pour plus de commodité, j'ai fourni l'image ci-dessous, où la taille du code est de 31 pixels. La grille est là pour la lisibilité et ne fait pas partie du programme. Notez également que ce programme ne croise aucun code blanc; suivez les codes colorés autour de l'image pour suivre le déroulement du programme.

Explication

Instruction    Δ Hue   Δ Lightness   Stack
------------   -----   -----------   --------------------
In (Number)    4       2             n
Duplicate      4       0             n, n
Push [1]       0       1             1, n, n
Duplicate      4       0             1, 1, in, in
Subtract       1       1             0, in, in
Duplicate      4       0             0, 0, in, in
Push [4]       0       1             4, 0, 0, in, in
Push [1]       0       1             1, 4, 0, 0, in, in
Roll           4       1             0, in, in, 0
Greater        3       0             greater, in, 0
Push [3]       0       1             3, greater, in, 0
Push [1]       0       1             1, 3, greater, in, 0
Roll           4       1             in, 0, greater
Greater        3       0             less, greater
Subtract       1       1             sign
Out (Number)   5       1             [Empty]
[Exit]         [N/A]   [N/A]         [Empty]

Pour réduire davantage la taille du fichier, je devrais changer le programme (gasp) au lieu de simplement compresser le fichier comme je le faisais auparavant. Je voudrais supprimer une rangée, ce qui réduirait ce nombre à 36. Je pourrais également développer mon propre interprète, qui aurait un format de saisie beaucoup plus petit, car changer le code pour le rendre plus petit n’est pas ce dont il est question.

Les mods m'ont dit que la taille de fichier globale est ce qui compte pour le code Piet. Comme l'interprète accepte le texte comme entrée valide et que le texte brut a un nombre d'octets beaucoup plus petit que toute image, le texte est le choix évident. Je m'excuse d'être insolent à ce sujet mais je ne fais pas les règles. La méta discussion à ce sujet clarifie mes opinions à ce sujet.

Si vous pensez que cela va à l’encontre de l’esprit de Piet ou si vous souhaitez en discuter davantage pour une raison quelconque, veuillez consulter la discussion sur meta .

Pushy , 7 octets

C'est probablement le programme le plus étrange que j'ai jamais écrit ...

&?&|/;#

Essayez-le en ligne!

Il utilise sign(x) = abs(x) / x, mais avec un explicite sign(0) = 0pour éviter une erreur de division zéro.

          \ Take implicit input
&?   ;    \ If the input is True (not 0):
  &|      \  Push its absolute value
    /     \  Divide
      #   \ Output TOS (the sign)

Cela fonctionne car x / abs(x)est 1 lorsque x est positif et -1 lorsque x est négatif. Si l'entrée est 0, le programme saute à la commande de sortie.

4 octets (non concurrents)

A cause des vacances et du manque de temps, j’ai réécrit complètement l’interprète Pushy. Le programme ci-dessus fonctionne toujours, mais comme la 0 / 0valeur par défaut est 0, les éléments suivants sont plus courts:

&|/#

Essayez-le en ligne!

R, 25 octets

'if'(x<-scan(),x/abs(x),0)

Prend le numéro à STDIN. Puis vérifie si c'est zéro, si non, retourne x/|x|ce qui est l'un 1des -1, et renvoie 0 si x=0.

Ceci sans utiliser les fonctions intégrées signbien sûr.

V 14 12 octets

Merci @DJMcMayhem pour 2 octets. Utilise un reg-ex pour effectuer la substitution. C'est amusant, parce que ce n'est pas intégré. J'ai une fonction plus amusante, mais elle ne fonctionne pas comme prévu.

ͨ-©½0]/±1

Vérifier les cas de test

Cela ne fait que traduire :%s/\v(-)=[^0].*/\11ce qui correspond à un ou plusieurs -suivis de tout sauf 0, suivis de tout nombre quelconque de fois. Il est remplacé par le premier match (donc un -ou rien) et un 1. La regex ne correspond pas à 0, donc ça reste tout seul.

La manière la plus amusante (21 octets)

é
Àé12|DkJòhé-òó^$/a

TryItOnline

Ceci accepte l’entrée comme un argument plutôt que dans la mémoire tampon.

é<CR> Insérer une nouvelle ligne.

Àexécutez l'argument en tant que code V. a -déplacera le curseur à la ligne précédente, et n'importe quel nombre deviendra le compte de la commande suivante

é1insérer (chiffre) 1s »

2| passer à la deuxième colonne

D tout supprimer à partir de la deuxième colonne (ne laissant qu'un seul caractère)

kJ Joignez les deux lignes ensemble.

òhé-òtraduit en: "courir hé-jusqu'à la rupture". Si le 1 était sur la deuxième ligne, cela casse immédiatement après le h. Si c'était sur la première ligne, il insérera un -avant la rupture.

ó^$/aCela corrige le fait que -1, 0, 1laissera un vide, et remplace un blanc au registre des arguments.

C #, 16 15 octets

Solution améliorée grâce à Neil

n=>n>0?1:n>>31;

Sinon, la méthode intégrée est 1 octet plus long:

n=>Math.Sign(n);

Programme complet avec cas de test:

using System;

public class P
{
    public static void Main()
    {
        Func<int,int> f =
        n=>n>0?1:n>>31;

        // test cases:
        for (int i=-5; i<= 5; i++)
            Console.WriteLine(i + " -> " + f(i));
    }
}