[Question]
  [
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
 
 
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/2823/edit).
Closed 2 years ago.
[Improve this question](/posts/2823/edit) 
Write a function (or equivalent subprogram) to accept a single integer valued argument and return a (similarly typed) value found by reversing the order of the base-10 digits of the argument.
For example given 76543 return 34567 
  
[Answer]
# HTML 21 7 chars (1 char if I'm cheeky...)
```
&#8238;n
```
replace `n` with your number
[Answer]
Python
`int(str(76543)[::-1])`
**EDIT:**
Shorter solution as suggested by @gnibbler:
```
int(`76543`[::-1])
```
or, if above is unclear:
```
x=76543
int(`x`[::-1])
```
[Answer]
**Universal (language *agnostic/independent*)**
If you want to use **only numbers** (avoid converting the number to string) and **don't** want to use some **specific** library (to be universal for any language):
```
x = 76543 # or whatever is your number
y = 0
while x > 0:
    y *= 10
    y += ( x %10 )
    x /= 10 # int division 
```
This is python, but it could be done in any language, because it's just a math method.
[Answer]
## Perl 6
```
+$n.flip
```
or:
```
$n.flip
```
for dynamically typed code.
Numbers got string methods due to language design.
[Answer]
# J - 6 characters + variable
```
".|.":y
```
Where y is your value.
[Answer]
## APL (3)
```
⍎⌽⍕
```
Usage:
```
⍎⌽⍕12345 => 54321
```
[Answer]
# Vim
 17 chars
```
:se ri<CR>C<C-R>"
```
[Answer]
# PHP, 9 chars
```
(int)strrev(123);
```
To do it short where `N` is a constant: 
```
strrev(N)
```
[Answer]
# Befunge (3 characters)
Complete runnable program:
```
N.@
```
Where `N` is your number. Rules say "accept *a single integer* valued argument"; In Befunge you can only enter integers from 0 to 9.
[Answer]
### Language-independent/mathematics
Inspired by Kiril Kirov's answer above. I got curious about the mathematical properties of reversing a number, so I decided to investigate a bit.
Turns out if you plot the difference `n - rev(n)` for natural numbers `n` in some base `r`, you get patterns like this (`(n - rev(n)) / (r - 1)`, for `r=10`, wrapped at `r` columns, red denotes negative number):
![table of differences](https://i.stack.imgur.com/vra3X.png)
This sequence could be generated as such (pseudocode):
```
for i=1 to r:
  output 0
for m=0, 1, …
  for k=1 to (r-1):
    for d=1 to r^m:
      for i=0 to (r-1):
        output (r-1) * (r+1)^m * (k - i)
```
If you store these values in a list/array, then `n - arr[n]` would get you the reversed form of `n`. Now, to "mathematically golf" this, we'd ideally want a closed-form expression that gives us the n:th value in the sequence, so that we could have a closed-form expression for solving the entire task. Unfortunately, I haven't been able to find such an expression... but it *looks* like it should be possible. :(
So yeah, not so much a code-golf as a mathematical curiosity, but if there is a closed-form expression of the above sequence it might actually be useful in proper PL golf submissions.
[Answer]
# Haskell, ~~28~~ 24 characters
```
f=read.reverse.show.(+0)
```
[Answer]
**Scala - 33 Chars**
```
def r(a:Int)=(a+"").reverse.toInt
```
[Answer]
## Python 3+
### Function form: 28 characters
```
r=lambda i:int(str(i)[::-1])
```
### (Sub)program form: 25 characters
```
print(input()[::-1])
```
I consider some of the other Python examples to be cheating, or at least cheap, due to using hardcoded input and/or not fully satisfying the requirements.
[Answer]
# Ruby (14)
```
x = 13456
x.to_s.reverse
```
[Answer]
It is possible to convert a number a string, then reverse the string and then convert that string back to number. This kind of feature is probably available in all language. If you are looking for a more mathematical method then this might help:
```
int n = 76543;
int r = 0;
while (n > 0) {
    r *= 10;
    r += n % 10;
    n /= 10;
}
```
[Answer]
## Golfscript, 5 chars
```
`-1%~
```
This takes an argument on the stack and leaves the result on the stack. I'm exploiting the "subprogram" option in the spec: if you insist on a function, that's four chars more leaving it on the stack:
```
{`-1%~}:r
```
[Answer]
In shell scripting :
```
  echo "your number"|rev
```
Hope this was useful :)
[Answer]
Kinda late but
## APL, 3
```
⍎⌽⍞
```
If you insists on a function
```
⍎∘⌽∘⍕
```
[Answer]
# Mathematica, 14 bytes
```
IntegerReverse
```
This is not competing, because this function was only added in last week's 10.3 release, but for completeness I thought I'd add the only ever (I think?) built-in for this task.
[Answer]
You could do the following in Java. Note that this converts to String and back and is not a mathematical solution.
```
public class test {
    public static int reverseInt(int i) {
        return Integer.valueOf((new StringBuffer(String.valueOf(i))).reverse().toString());
    }
    public static void main(String[] args) {
        int i = 1234;
        System.out.println("reverse("+i+") -> " + reverseInt(i));
    }
}
```
[Answer]
Depends on what you mean by short (javascript):
```
alert(String(123).split('').reverse().join('')),
```
[Answer]
# Lua
Numbers and strings are interchangeable, so this is trivial
```
string.reverse(12345)
```
[Answer]
This one *ACTUALLY* takes an input, unlike some of the rest:
```
print`input()`[::-1]
```
Python btw.
[Answer]
## Actionscript
43 characters. num as the parameter to the function:
```
num.toString().split('').reverse().join('')
```
[Answer]
# Groovy
```
r={"$it".reverse() as BigDecimal}
assert r(1234) == 4321
assert r(345678987654567898765) == 567898765456789876543
assert r(345346457.24654654) == 45645642.754643543
```
[Answer]
# Perl, 11 chars
The `p` flag is needed for this to work, included in the count.
Usage:
```
$ echo 76543 | perl -pE '$_=reverse'
```
[Answer]
# Clojure (42 chars)
```
#(->> % str reverse(apply str)read-string)
```
Example usage:
```
(#(->> % str reverse(apply str)read-string) 98321)
```
returns 12389
[Answer]
# Common Lisp - 60 chars
```
(first(list(parse-integer(reverse(write-to-string '4279)))))
```
will get you 9724.
[Answer]
# K, 3 bytes:
```
.|$
```
Evaluate (`.`) the reverse (`|`) of casting to a string (`$`).
Usage example:
```
  .|$76543
34567
```
[Answer]
# [rs](https://github.com/kirbyfan64/rs), 20 bytes
```
#
+#(.*)(.)/\2#\1
#/
```
Technically, this doesn't count (rs was created earlier this year), but I didn't see any other regex-based answers, and I thought this was neat.
[Live demo.](http://kirbyfan64.github.io/rs/index.html?script=%23%0A%2B%23(.*)(.)%2F%5C2%23%5C1%0A%23%2F&input=34567)
## Explanation:
```
#
```
Insert a pound character at the beginning of the string. This is used as a marker.
```
+#(.*)(.)/\2#\1
```
Continuously prepend the last character of the main string to the area before the marker until there are no characters left.
```
#/
```
Remove the marker.
]