[Question]
  [
When a number is shown on a calculator, it's possible to consider what various transformations of that number would look like. For example, on a seven-segment display, 2 is shown like this:
![enter image description here](https://i.stack.imgur.com/QZZ8w.png)
And when flipped horizontally it looks like this:
![enter image description here](https://i.stack.imgur.com/YA69d.png)
As such, the mirror image of 2 is 5.
The task in this challenge is to take a single-digit number, and return the number that's its mirror image (if possible). If its mirror image does not look like a number, return the number rotated 180 degrees (if possible). If neither of these are the case, return -1.
Here's the full list of inputs and outputs your program needs to handle:
```
Input   Output
0       0
1       -1
2       5
3       -1
4       -1
5       2
6       9
7       -1
8       8
9       6
```
As a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") challenge, the shortest code wins!
  
[Answer]
## Haskell - ~~43~~ 31
43 characters without anything fancy.
```
f 0=0
f 8=8
f 2=5
f 5=2
f 6=9
f 9=6
f _= -1
```
Got it down to 31 characters by making it a partial function.
```
f=([0,-1,5,-1,-1,2,9,-1,8,6]!!)
```
[Answer]
# GolfScript, 15 14
I read the spec again and found that the input must be a string.
```
"0.5..29.86"\?
```
To run:
```
echo -n 2 | ruby golfscript.rb a.gs
```
Old version(which has integer input):
```
[0.5..2 9.8 6]?
```
The newer one(14 byte) is somewhat inspired by the [CJam answer by aditsu](https://codegolf.stackexchange.com/a/31987/).
[Answer]
## PowerShell - 27
```
'0 5  29 86'.indexof($args)
```
[Answer]
# Python 2.x - 28
```
'015..29.86'.find(`input()`)
```
[Answer]
# JavaScript ~~37~~ 36
```
alert("0_5__29_86".search(prompt()))
```
[Answer]
**BEFUNGE 93 - ~~18~~ ~~14~~ 20 Bytes**
I guess the commentators are right, though Befunge being a 2d language lines are kinda different. Still, in this instant, the commentators are right.
```
&1g01g-.  
! &  #* )'
```
Steps:
```
&
```
Reads input as a numerical value x, and pushes it on the stack.
```
1g
```
Gets the character value c (so, like '!' = 33, or '\*' = 42. An empty cell = 32) at position x, 1.
```
01g-.
```
Reads the character value of cell 0,1 (33), subtracts it from c, and outputs it as a numerical value.
[Answer]
# CJam, 20 bytes
```
q25691347`"5296W"er~
```
[Try it online.](http://cjam.aditsu.net/)
### Output
```
$ for i in {0..9}; { cjam <(echo 'q25691347`"5296W"er~') <<< $i; echo; }
0
-1
5
-1
-1
2
9
-1
8
6
```
### How it works
```
q          " Read from STDIN. The leaves a string on the stack.            ";
25691347`  " Push the string '25691347'.                                   ";
"5296W"    " Push the string '5296W'.                                      ";
er         " Perform character transliteration.                            ";
~          " Evaluate the result. Examples: '2' returns 2, 'W' returns -1. ";
```
[Answer]
# Java - 49
```
long f(int a){return(0x790a300601L>>(a*4)&15)-1;}
```
Here, `0x790a300601` is a value stuffed with the desired outputs, with one added to make them positive. The values are stored in nibbles within the value, so a bit of shifting and masking is required to pop them out.
# Java - 100 (fun option)
```
int f(int a){Random r=new Random(0x2000A2F47D6Fl);int b=0;for(;a>=0;a--)b=r.nextInt(11)-1;
return b;}
```
Not the smallest option, but a bit of fun. I found a random seed that produces the correct values when called *X* times (where 0 >= *X* <= 9).
[Answer]
# JavaScript (ECMAScript 6) 25
```
x=>'1060039097'[x]-(x!=6)
```
# JavaScript (ECMAScript 5) 43
```
function f(x){return'1060039097'[x]-(x!=6)}
```
UPDATE: edc65 has suggested a much better technique. toothbrush has suggested a much better language. At this point, my primary contributions are debugging and gumption.
[Answer]
# bash 29
```
tr 1-9 x5xx29x86|sed s/x/-1/g
```
e.g.
```
$ echo 0 1 2 3 4 5 6 7 8 9 | tr 1-9 x5xx29x86|sed s/x/-1/g
0 -1 5 -1 -1 2 9 -1 8 6
```
[Answer]
# [Kona](https://github.com/kevinlawler/kona) - 29
This function returns the element `x` from the array `0 -1 5...`
```
f:{0 -1 5 -1 -1 2 9 -1 8 6@x}
```
Examples:
```
> f 2
  5
> f 5
  2
> f 8
  8
```
[Answer]
# JavaScript 36 ~~37~~ ~~41~~
```
alert('0x'+'65b558f5ec'[prompt()]-6)
```
as ES6 function - 27:
```
f=v=>'0x'+'65b558f5ec'[v]-6
```
[Answer]
# Sclipting, 11 characters
```
걄럣뉥밈결⓷方分결剩貶
```
Finally I have found a Windows computer with Visual Studio installed to build its interpreter. And it has defeated my GolfScript code easily.
It reads `18453063256\11\?/11%(` in GolfScript.
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 22 bytes
```
⊢⌷{1-⍨⎕A⍳'BAGAADKAJH'}
```
Explanation:
```
⊢⌷{1-⍨⎕A⍳'BAGAADKAJH'}
      ⎕A⍳'BAGAADKAJH'     ⍝ numeric vector 2 1 7 1 1 4 11 1 10 8
   1-⍨                    ⍝ decrement:     1 0 6 0 0 3 10 0  9 7
⊢⌷                        ⍝ value at index ⍵ in the lut
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/qG@qp/@jtgkG/9OApMajrkWPerZXG@o@6l0BlHJ81LtZ3cnR3dHRxdvRy0O9VhOkAagw7dAKAwVDBSMF4/8A "APL (Dyalog Extended) – Try It Online")
[Answer]
# J - ~~28~~ 27 bytes
You know what I like? Simplicity (28 bytes). Note that in J, `_1` is negative one (-1).
```
f=:{&0 _1 5 _1 _1 2 9 _1 8 6
```
Add a little complexity and you have 27 bytes.
```
f=:-{&0 2 _3 4 5 3 _3 8 0 3
```
Example:
```
   f 2
5
   f 6
9
   f 5
2
...
```
[Answer]
# CJam - 14
Input/output version:
```
"0 5  29 86"q#
```
Stack version (assumes the number is on the stack):
```
[0W5WWY9W8 6]=
```
Try them at <http://cjam.aditsu.net/>
[Answer]
# Perl, 27 26
Count includes the `p` flag
```
y/2569/5296/,s/[1347]/-1/
```
Usage:
```
$ echo 7 | perl -pe y/2569/5296/,s/[1347]/-1/
-1
```
***Wait, did Perl just beat J? :)***
[Answer]
## ECMAScript 6, 24
```
f=x=>~-++'0n5nn29n86'[x]
```
Using normal JavaScript it would be 33:
```
alert(~-++'0n5nn29n86'[prompt()])
```
[Answer]
# [Marbelous](https://github.com/marbelous-lang) 34 bytes
```
}0
=6=9=2=5=0=8?0
+3-3+3-3....--
```
It's not the shortest solution, but it's not the longest either.
**How it works**
`}0` spawns a marble representing the first command line input. This marble drops down the next tick, onto the `=6` cell. `=6` is a comparison cell, it pushes any marble with value 6 down and all others to the right. This line-up of comparison cells pushes marbles right until they equal a desired value. 0 and 8 just fall through and get printed when tehy fall off the bottom of the board, 6 and 2, and 9 and 5 first get 3 added to them, subtracted from them respectively. If a marble doesn't equal any of the desired values, it lands on the `?0` cell, which turn any marble into a 0 marble1. This marble then gets decremented and falls off the board.
1 A `?n` marble technically turns any marble into a marble between 0 and n. This has the nice side effect that `?0` turns anything into 0.
[Answer]
# MATLAB - 35
I would wrap this in a function with `n` as the only parameter.
```
f=[0,-1,5,-1,-1,2,9,-1,8,6];
f(n+1)
```
35 characters.
[Answer]
# TI-BASIC, ~~24~~ 22
```
-1+int(11fPart(11^Ans.0954191904
```
This encodes the possible outputs in a lookup table stored as a base-11 floating point number; the (N+1)th base-11 digit after the decimal point is extracted from the table to get the value of the inverted digit. In base 11 the number is `.106003A097`, and the digits of this less one are exactly `0,-1,5,-1,-1,2,9,-1,8,6`.
edc65's trick of subtracting one in the case of 6 leads to this 24-byte solution, where `⑩^(` is a single one-byte token:
```
-(Ans≠6)+int(10fPart(.1060039097⑩^(Ans
```
The string approach is 29 bytes:
```
-(Ans≠6)+expr(inString("1060039097",Ans+1,1
```
The array approach (which Ypnpyn also took) is 30 bytes, assuming the number is stored in X:
```
{1,0,6,0,0,3,10,0,9,7}-1:Ans(X+1
```
24 -> 22: Removed two extra digits of precision in the magic constant.
[Answer]
# C - 47 bytes [was 48 Bytes]
```
f(i){return(int[]){1,0,6,0,0,3,10,0,9,7}[i]-1;}
```
To add I/O (which other answers didn't always) for 86 bytes:
```
main(i){i=(int[]){1,0,6,0,0,3,10,0,9,7}[getchar()-48]-1;i<0?puts("-1"):putchar(i+48);}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 13 bytes
```
0®5®®Y9®8 6¹@
```
[Try it online!](https://tio.run/nexus/05ab1e#@29waJ3poXWH1kVaHlpnoWB2aKfD//@WX/PydZMTkzNSAQ "05AB1E – TIO Nexus")
-3 thanks to [Emigna](/users/47066).
Explanation:
```
0®5®®Y9®8 6¹@ Takes an integer from STDIN.
0®5®®Y9®8 6   Push 0, r=-1, 5, r=-1, r=-1, Y=2, 9, r=-1, 8, 6.
           ¹  Push first input item.
            @ Pop and push the 0-indexed stack item at the respective index.
```
[Answer]
# Python - 34
```
f=lambda n:ord("A@F@@CJ@IG"[n])-65
```
[Answer]
## Java, 58 ~~59~~
```
int f(int i){int[]a={1,0,6,0,0,3,10,0,9,7};return a[i]-1;}
```
OR
```
int f(int i){return new int[]{1,0,6,0,0,3,10,0,9,7}[i]-1;}
```
[Answer]
## JavaScript 42 37
Run it on the console of your browser
```
alert(~-[1,,6,,,3,10,,9,7][prompt()])
```
[Answer]
# C - 117 108 106 77 76 bytes
```
a[]={1,0,6,0,0,3,10,0,9,7};main(int c,char**b){printf("%d",a[*b[1]-48]-1);}
```
Not the best language for golfing, but oh well...  
Compile with `gcc progname.c -o progname`. (Ignore the warnings, or add `-include stdio.h` to the compile command.)
> 
> Usage: ./progname <number>
> 
> 
> 
**EDIT**
As per @bebe's suggestion, here is an example that takes the input from STDIN instead:
# C - 68 51 bytes
```
main(){printf("%d","106003:097"[getchar()-48]-49);}
```
[Answer]
# J (24, function)
(the input panel isn't playing nice. Paste the following in a python interpreter and my answer shall be revealed:)
```
print "f=:{&(_3+3 u:'^C^B^B^E^L^B^K\t')"
```
[Answer]
# Clojure - 36
```
#(case % 2 5 5 2 6 9 9 6 0 0 8 8 -1)
```
[Answer]
# Perl, 22B
`perl -pe "y/25690/52960/or$_=-1"`
Based off <https://codegolf.stackexchange.com/a/32012/19039>, but shorter. 1B penalty for -p.
]