Memberikan input sebagai integer yang tidak ditandatangani:

13457

Fungsi / subrutin Anda harus kembali:

75431

Karena ini adalah kontes popularitas, jadilah kreatif. Solusi kreatif menggunakan teknik yang tidak biasa atau pintar untuk menyelesaikan tugas yang diberikan.

Kendala:

• Anda tidak dapat menggunakan array.
• Anda tidak dapat menggunakan string.
• Tanpa RTL Override ( &#8238)

Brownie poin untuk menggunakan aritmatika kreatif.

Karena ini adalah kontes popularitas, saya sarankan untuk tidak menggunakan %operator modulo ( ) dalam kode Anda.

Tentang Leading nol:

Jika inputnya adalah:

12340

Maka hasilnya:

4321

akan diterima.

Mathematica, tanpa modulo!

n = 14627;
length = Ceiling[Log[10, n]];
img = Rasterize[n, RasterSize -> 400, ImageSize -> 400];
box = Rasterize[n, "BoundingBox", RasterSize -> 400, ImageSize -> 400];
width = box[[1]]; height = box[[3]];
ToExpression[
 TextRecognize[
  ImageAssemble[
   ImageTake[img, {1, height}, #] & /@ 
    NestList[# - width/length &, {width - width/length, width}, 
     length - 1]]]]

Mari kita jabarkan.

Pertama-tama kita menggunakan beberapa "aritmatika kreatif" untuk mencari tahu berapa digit dalam angka: length = Ceiling[Log[10, n]];

Selanjutnya, kami Rasterize nomor ke gambar besar yang bagus:

Sekarang kita kueri untuk kotak pembatas dari gambar itu, dan mengisi lebar dan tinggi (sebenarnya menggunakan offset dasar alih-alih tinggi gambar, karena MM menambahkan beberapa spasi putih di bawah garis dasar pada gambar).

Selanjutnya, NestList secara berulang mengurangi lebar gambar dibagi dengan panjang string untuk memungkinkan ImageTake memetik karakter dari ujung gambar satu per satu, dan itu disusun kembali oleh ImageAssemble ke gambar ini:

Kemudian kami meneruskannya ke fungsi TextRecognize untuk pengenalan karakter optik, yang pada ukuran gambar ini dan kualitas rasterisasi mampu mengenali hasil akhir tanpa cela dan memberi kami integer:

72641

Logaritma dan OCR - Ini seperti cokelat dan selai kacang!

Baru dan ditingkatkan

Versi ini melengkapi nomor untuk berurusan dengan perilaku keras kepala dari TextRecognize dengan angka kecil, dan kemudian kurangi bantalan pada akhir. Ini bahkan berfungsi untuk angka satu digit!

Padahal, mengapa Anda menjalankan rutinitas terbalik pada satu nomor merupakan misteri bagi saya. Tetapi hanya demi kelengkapan, saya bahkan membuatnya bekerja untuk input nol dan satu, yang biasanya akan rusak karena log lantai tidak mengembalikan 1 untuk mereka.

n = 1;
pad = 94949;
length = If[n == 1 || n == 0, 1, Ceiling[Log[10, n]]];
img = Rasterize[n + (pad*10^length), RasterSize -> 400, 
   ImageSize -> 400];
padlength = length + 5;
box = ImageDimensions[img];
width = box[[1]]; height = box[[2]];
reversed = 
  ImageResize[
   ImageAssemble[
    ImageTake[img, {1, height}, #] & /@ 
     NestList[# - width/padlength &, {width + 1 - width/padlength, 
       width}, padlength - 1]], 200];
recognized = ToExpression[TextRecognize[reversed]];
(recognized - pad)/10^5

Perl / LuaTeX / Tesseract

Skrip Perl berikut membaca angka sebagai argumen baris perintah, misalnya:

    1234567890

Script Perl berikut mencetak nomor melalui LuaTeX. Font virtual dibuat dengan cepat yang mencerminkan digit secara horizontal.

Kemudian seluruh angka dicerminkan secara horizontal:

Gambar terakhir dibaca ulang melalui OCR (tesseract):

    0987654321

#!/usr/bin/env perl
use strict;
$^W=1;

# Get the number as program argument or use a fixed number with all digits.
$_ = shift // 1234567890;

$\="\n"; # append EOL, when printing

# Catch negative number
exit print "NaUI (Not an Unsigned Integer)" if $_ < 0;

# Catch number with one digit.
exit ! print if ($_ = $= = $_) < 10;

undef $\;

# Write TeX file for LuaTeX
open(OUT, '>', 'temp.tex') or die "!!! Error: Cannot write: $!\n";
print OUT<<"END_PRINT";
% Catcode setting for iniTeX (a TeX format is not needed)
\\catcode`\{=1
\\catcode`\}=2
\\def\\mynumber{$_}
END_PRINT
print OUT<<'END_PRINT';
\directlua{tex.enableprimitives('',tex.extraprimitives())}
\pdfoutput=1 % PDF output
% move origin to (0,0)
\pdfhorigin=0bp
\pdfvorigin=0bp
% magnify the result by 5
\mag=5000

% Create virtual font, where the digits are mirrored
\directlua{
  callback.register('define_font',
    function (name,size)
      if name == 'cmtt10-digits' then
        f = font.read_tfm('cmtt10',size)
        f.name = 'cmtt10-digits'
        f.type = 'virtual'
        f.fonts = {{ name = 'cmtt10', size = size }}
        for i,v in pairs(f.characters) do
          if (string.char(i)):find('[1234567890]') then
            v.commands = {
               {'right',f.characters[i].width},
               {'special','pdf: q -1 0 0 1 0 0 cm'},
               {'char',i},
               {'right',-f.characters[i].width},
               {'special','pdf: Q'},
            }
          else
            v.commands = {{'char',i}}
          end
        end
      else
        f = font.read_tfm(name,size)
      end
      return f
    end
  )
}

% Activate the new font
\font\myfont=cmtt10-digits\relax
\myfont

% Put the number in a box and add a margin (for tesseract)
\dimen0=5bp % margin
\setbox0=\hbox{\kern\dimen0 \mynumber\kern\dimen0}
\ht0=\dimexpr\ht0+\dimen0\relax
\dp0=\dimexpr\dp0+\dimen0\relax
\pdfpagewidth=\wd0
\pdfpageheight=\dimexpr\ht0+\dp0\relax

% For illustration only: Print the number with the reflected digits:
\shipout\copy0 % print the number with the reflected digits

% Final version on page 2: Print the box with the number, again mirrored
\shipout\hbox{%
  \kern\wd0
  \pdfliteral{q -1 0 0 1 0 0 cm}%
  \copy0
  \pdfliteral{Q}%
}

% End job, no matter, whether iniTeX, plain TeX or LaTeX
\csname @@end\endcsname\end
END_PRINT

system "luatex --ini temp.tex >/dev/null";
system qw[convert temp.pdf temp%d.png];
system "tesseract temp1.png temp >/dev/null 2>&1";

# debug versions with output on console
#system "luatex --ini temp.tex";
#system qw[convert temp.pdf temp%d.png];
#system "tesseract temp1.png temp";

# Output the result, remove empty lines
open(IN, '<', 'temp.txt') or die "!!! Error: Cannot open: $!\n";
chomp, print while <IN>;
print "\n";
close(IN);

__END__

Brainfuck

Pada dasarnya, ini hanyalah program pembalikan input.

,[>,]<[.<]

UPD: Seperti yang ditunjukkan oleh Sylwester dalam komentar, dalam penafsir / kompiler Brainfuck klasik (tanpa kemungkinan untuk pergi dari titik nol dalam susunan memori) program ini tidak akan berfungsi jika tidak ada '>' di awal, jadi semakin stabil versi adalah:

>,[>,]<[.<]

Haskell

reverseNumber :: Integer -> Integer
reverseNumber x = reverseNumberR x e 0
    where e = 10 ^ (floor . logBase 10 $ fromIntegral x)

reverseNumberR :: Integer -> Integer -> Integer -> Integer
reverseNumberR 0 _ _ = 0
reverseNumberR x e n = d * 10 ^ n + reverseNumberR (x - d * e) (e `div` 10) (n + 1)
    where d = x `div` e

Tidak ada susunan, string, atau modulus.

Juga, saya tahu kita tidak seharusnya menggunakan daftar atau string, tetapi saya suka betapa singkatnya saat Anda melakukan itu:

reverseNumber :: Integer -> Integer
reverseNumber = read . reverse . show

C ++

/* 
A one-liner RECUrsive reveRSE function. Observe that the reverse of a 32-bit unsigned int
can overflow the type (eg recurse (4294967295) = 5927694924 > UINT_MAX), thus the 
return type of the function should be a 64-bit int. 

Usage: recurse(n)
*/

int64_t recurse(uint32_t n, int64_t reverse=0L)
{
    return n ? recurse(n/10, n - (n/10)*10 + reverse * 10) : reverse;
}

Saya kira seseorang harus menjadi partypooper.

Pesta

$ rev<<<[Input]

$ rev<<<321
123
$ rev<<<1234567890
0987654321

Batasan ukuran tergantung pada shell Anda, tetapi Anda akan baik-baik saja.

Javascript

EDIT : Karena ada saran untuk tidak menggunakan %operator, saya menggunakan sedikit trik sekarang.

Saya tahu ini bukan kode-golf, tetapi tidak ada alasan untuk membuatnya lebih lama.

function r(n){v=0;while(n)v=n+10*(v-(n=~~(n/10)));return v}

r(13457) kembali 75431

Selain itu, ini jauh lebih cepat daripada metode string ( n.toString().split('').reverse().join('')):

==> Laporan JSPerf <==

Python

Tidak yakin apakah implementasi ini memenuhi syarat untuk matematika kreatif

Juga% operator tidak digunakan per se, meskipun orang mungkin berpendapat bahwa divmod melakukan hal yang sama, tetapi kemudian Pertanyaan perlu diulang :-)

Pelaksanaan

r=lambda n:divmod(n,10)[-1]*10**int(__import__("math").log10(n))+r(n /10)if n else 0

demo

>>> r(12345)
54321
>>> r(1)
1

Bagaimana cara kerjanya?

Ini adalah solusi divmod rekursif * Solusi ini menentukan digit paling signifikan dan kemudian mendorongnya ke akhir nomor. *

Namun Implementasi Python Lain

def reverse(n):
    def mod(n, m):
        return n - n / m * m
    _len = int(log10(n))
    return n/10**_len + mod(n, 10)*10**_len + reverse(mod(n, 10**_len)/10)*10 if n and _len else n

Bagaimana cara kerjanya?

Ini adalah solusi rekursif yang menukar angka ekstrim dari angka tersebut

Reverse(n) = Swap_extreme(n) + Reverse(n % 10**int(log10(n)) / 10) 
             ; n % 10**log10(n) / n is the number without the extreme digits
             ; int(log10(n)) is the number of digits - 1
             ; n % 10**int(log10(n)) drops the most significant digit
             ; n / 10 drops the least significant digit

Swap_extreme(n) = n/10**int(log10(n)) + n%10*10**int(log10(n))
             ; n%10 is the least significant digit
             ; n/10**int(log10(n)) is the most significant digit

Contoh Jalankan

reverse(123456) = 123456/10^5 + 123456 % 10 * 10^5 + reverse(123456 % 10 ^ 5 / 10)
                = 1           + 6 * 10 ^ 5 + reverse(23456/10)
                = 1           + 600000     + reverse(2345)
                = 600001 + reverse(2345)
reverse(2345)   = 2345/10^3 + 2345 % 10 * 10^3 + reverse(2345 % 10 ^ 3 / 10)
                = 2         + 5 * 10^3 + reverse(345 / 10)
                = 2         + 5000     + reverse(34)
                = 5002                 + reverse(34)
reverse(34)     = 34/10^1 + 34 % 10 * 10^1 + reverse(34 % 10 ^ 1 / 10)
                = 3       + 40             + reverse(0)
                = 43 + reverse(0)
reverse(0)      = 0

Thus

reverse(123456) = 600001 + reverse(2345)
                = 600001 + 5002 + reverse(34)
                = 600001 + 5002 + 43 + reverse(0)
                = 600001 + 5002 + 43 + 0
                = 654321

Justru sebaliknya, terlalu sering menggunakan operator modulo:

unsigned int reverse(unsigned int n)
    {return n*110000%1099999999%109999990%10999900%1099000%100000;}

Perhatikan bahwa ini selalu membalikkan 5 digit, dan bilangan bulat 32 bit akan melebihi nilai input lebih dari 39045.

C #

Inilah cara untuk melakukannya tanpa %operator Modulus ( ) dan hanya aritmatika sederhana.

int x = 12356;
int inv = 0;
while (x > 0)
{
    inv = inv * 10 + (x - (x / 10) * 10);
    x = x / 10;
}
return inv;

Pesta

> fold -w1 <<<12345 | tac | tr -d '\n'
54321

C

#include <stdio.h>

int main(void) {
    int r = 0, x;
    scanf("%d", &x);
    while (x > 0) {
        int y = x;
        x = 0;
        while (y >= 10) { y -= 10; ++x; }
        r = r*10 + y;
    }
    printf("%d\n", r);
}

Tidak ada string, array, modulus atau pembagian. Sebaliknya, pembagian dengan pengurangan berulang.

Mathematica

Membuat gambar dari angka, memantulkannya, mempartisinya menjadi digit. Lalu ada dua alternatif:

1. Bandingkan setiap gambar dari digit yang dipantulkan dengan gambar yang disiapkan sebelumnya, gantilah dengan digit yang sesuai dan buat nomor dari ini.

2. Refleksikan setiap digit secara terpisah, buat gambar baru, dan berikan ke fungsi pengenalan gambar.

Saya melakukan keduanya

reflectNumber[n_?IntegerQ] := 
 ImageCrop[
  ImageReflect[
   Image@Graphics[
     Style[Text@NumberForm[n, NumberSeparator -> {".", ""}], 
      FontFamily -> "Monospace", FontSize -> 72]], 
   Left -> Right], {Max[44 Floor[Log10[n] + 1], 44], 60}]
reflectedDigits = reflectNumber /@ Range[0, 9];
reverse[0] := 0
reverse[n_?IntegerQ /; n > 0] := 
 Module[{digits}, 
  digits = ImagePartition[reflectNumber[1000 n], {44, 60}];
  {FromDigits[
    digits[[1]] /. (d_ :> # /; d == reflectedDigits[[# + 1]] & /@ 
       Range[0, 9])],
   ToExpression@
    TextRecognize[
     ImageAssemble[
      Map[ImageReflect[#, Left -> Right] &, digits, {2}]]]}]
reverse[14257893]
> {39875241, 39875241}

EDIT : Menambahkan padding dari tiga nol, karena TextRecognisehanya berfungsi dengan benar dengan bilangan bulat> 999.

Lua

function assemble(n,...)
    if ... then
        return 10*assemble(...)+n
    end
    return 0
end
function disassemble(n,...)
    if n>0 then
        return disassemble(math.floor(n/10),n%10,...)
    end
    return ...
end
function reverse(n)
    return assemble(disassemble(n))
end

Tidak ada array atau string yang digunakan. Nomor tersebut dibagi menjadi digit dan disusun kembali menggunakan daftar argumen.

Python2

Diasumsikan "bilangan bulat bertanda" adalah 32-bit

import math
import sys
a=input()
p=int(math.log(a, 10))
b=a
while b%10==0:
    sys.stdout.write('0') # if 1-char string is not allowed, use chr(48) instead
    b=b/10

if p==0:
    print a
elif p==1:
    print a%10*10+a/10
elif p==2:
    print a%10*100+a%100/10*10+a/100
elif p==3:
    print a%10*1000+a%100/10*100+a%1000/100*10+a/1000
elif p==4:
    print a%10*10000+a%100/10*1000+a%1000/100*100+a%10000/1000*10+a/10000
elif p==5:
    print a%10*100000+a%100/10*10000+a%1000/100*1000+a%10000/1000*100+a%100000/10000*10+a/100000
elif p==6:
    print a%10*1000000+a%100/10*100000+a%1000/100*10000+a%10000/1000*1000+a%100000/10000*100+a%1000000/100000*10+a/1000000
elif p==7:
    print a%10*10000000+a%100/10*1000000+a%1000/100*100000+a%10000/1000*10000+a%100000/10000*1000+a%1000000/100000*100+a%10000000/1000000*10+a/10000000
elif p==8:
    print a%10*100000000+a%100/10*10000000+a%1000/100*1000000+a%10000/1000*100000+a%100000/10000*10000+a%1000000/100000*1000+a%10000000/1000000*100+a%100000000/10000000*10+a/100000000
elif p==9:
    print a%10*1000000000+a%100/10*100000000+a%1000/100*10000000+a%10000/1000*1000000+a%100000/10000*100000+a%1000000/100000*10000+a%10000000/1000000*1000+a%100000000/10000000*100+a%1000000000/100000000*10+a/1000000000

Ketika diberi input 1230, output 0321.

Nota bene

/rev{0 exch{dup 10 mod 3 -1 roll 10 mul add exch 10 idiv dup 0 eq{pop exit}if}loop}def

Tanpa array, tanpa string, tanpa variabel.

gs -q -dBATCH -c '/rev{0 exch{dup 10 mod 3 -1 roll 10 mul add exch 10 idiv dup 0 eq{pop exit}if}loop}def 897251 rev ='
152798

Sama tanpa mod(yang hanya jalan pintas, jadi tidak ada perbedaan besar):

/rev {
    0 exch {
        dup
        10 idiv dup
        3 1 roll 10 mul sub
        3 -1 roll 10 mul add exch 
        dup 0 eq {pop exit} if
    } loop
} def

C #

Ini tidak menggunakan string atau array, tetapi tidak menggunakan Stack<T>tipe NET. (EDIT: operator modulus awalnya digunakan; sekarang dihapus)

public class IntegerReverser
{
    public int Reverse(int input)
    {
        var digits = new System.Collections.Generic.Stack<int>();
        int working = input;
        while (working / 10 > 0)
        {
            digits.Push(working - ((working / 10) * 10));
            working = working / 10;
        }
        digits.Push(working);
        int result = 0;
        int mult = 1;
        while (digits.Count > 0)
        {
            result += digits.Pop() * mult;
            mult *= 10;
        }
        return result;
    }
}

C

Dalam hal solusi yang jelas diwakili dalam beberapa bahasa lain, mungkin juga mempostingnya dalam C.

Golf:

r;main(n){scanf("%d",&n);for(;n;n/=10)r=r*10+n%10;printf("%d",r);}

Tidak Disatukan:

#include <stdio.h>

int main()
{
     int n, r = 0;
     scanf("%d", &n);
     for(;n;n/=10)
     { 
          r = r * 10 + n % 10;
     }
     printf("%d", r);
}

EDIT: Baru saja melihat edit modulus.

Golf (tanpa modulus):

r;main(n){scanf("%d",&n);for(;n;n/=10)r=r*10+(n-10*(n/10));printf("%d",r);}

Tidak disatukan (tidak ada modulus):

#include <stdio.h>

int main()
{
     int n, r, m = 0;
     scanf("%d", &n);
     for(;n;n/=10)
     { 
          r=r*10+(n-10*(n/10));
     }
     printf("%d", r);
}

Jawa

Ini adalah ini saya telah datang dengan, tidak ada string, tidak ada array ... bahkan variabel (di Jawa saya keberatan):

public static int reverse(int n) {
    return n/10>0?(int)(modulo(n,10)*Math.pow(10, count(n)))+reverse(n/10):(int)(modulo(n,10)*Math.pow(10,count(n)));
}

public static int count(int i) {
    return (i = i/10)>0?count(i)+1:0;
}

public static int modulo(int i,int j) {
    return (i-j)>=0?modulo(i-j, j):i;
}

Sunting Versi yang lebih mudah dibaca

/** Method to reverse an integer, without the use of String, Array (List), and %-operator */
public static int reverse(int n) {
    // Find first int to display
    int newInt = modulo(n,10);
    // Find it's position
    int intPos = (int) Math.pow(10, count(n));
    // The actual value
    newInt = newInt*intPos;
    // Either add newInt to the recursive call (next integer), or return the found
    return (n/10>0) ? newInt+reverse(n/10) : newInt;
}

/** Use the stack, with a recursive call, to count the integer position */
public static int count(int i) {
    return (i = i/10)>0?count(i)+1:0;
}

/** A replacement for the modulo operator */
public static int modulo(int i,int j) {
    return (i-j)>=0?modulo(i-j, j):i;
}

PowerShell

Solusi cepat di PowerShell. Tidak ada array atau string yang digunakan, baik secara implisit atau eksplisit.

function rev([int]$n) {
    $x = 0
    while ($n -gt 0) {
        $x = $x * 10
        $x += $n % 10
        $n = [int][math]::Floor($n / 10)
    }
    $x
}

Pengujian:

PS > rev(13457)
75431

PS > rev(rev(13457))
13457

python (mudah dilakukan dalam perakitan)

Membalikkan bit byte. Poin untuk tidak melakukan hal yang sama persis seperti yang dilakukan orang lain?

x = int(input("byte: "), 2)
x = ((x * 8623620610) & 1136090292240) % 1023
print("{0:b}".format(x).zfill(8))

contoh

byte: 10101010
01010101

C ++

#include<iostream>
#include<conio.h>
#include<fstream>
using namespace std;
int main()
{
    int i,size;
    float num;
    char ch;
    cout<<"enter the number \t: ";
    cin>>num;
    ofstream outf("tmp.tmp");
    outf<<num;
    outf.close();
    ifstream inf("tmp.tmp");
    inf.seekg(0,ios::end);
    size=inf.tellg();
    inf.seekg(-1,ios::cur);
    cout<<"Reverse of it\t\t: ";
    for(i=0;i<size;i++)
    {
        inf>>ch;
        if(ch!='0'||i!=0)
        cout<<ch;
        inf.seekg(-2,ios::cur);
    }
    inf.close();
            remove("tmp.tmp");
    getch();
    return 0;
}  

KELUARAN

Tiga sampel berjalan

Uji dengan nol

Itu juga membalik angka mengambang !!!

Jika Anda ingin menjalankan kode ini maka jalankan di komputer Anda karena itu membuat file sementara selama waktu-nya dan saya tidak yakin apakah kompiler online akan membuat file sementara di komputer Anda

ECMAScript 6

reverse=x=>{
    var k=-(l=(Math.log10(x)|0)),
        p=x=>Math.pow(10,x),
        s=x*p(l);
    for(;k;k++) s-=99*(x*p(k)|0)*p(l+k);
    return s
}

Kemudian:

• reverse(12345) output 54321
• reverse(3240) output 423
• reverse(6342975) output 5792436

Pembelahan

$SX/
\S?L
K\O

Program ini membalikkan input.

$ echo -n '12345' | fsn tac.fsn
54321

FORTH

Mari kita buat kata baru

: REV 
  BEGIN
    S->D 10 U/
    SWAP 1 .R
  DUP 0= UNTIL 
CR ;

Di sini, ia menggunakan kata U / yang mengembalikan sisa dan hasil bagi, sisanya dikirim ke output sebagai angka dalam panjang bidang 1 karakter, hingga dividen adalah nol. Tidak ada string yang digunakan, setidaknya sampai sesuatu dikirim ke video. Saya tidak menggunakan operator modulo, melainkan saya menggunakan divisi integer dengan sisa dan hasil bagi. Mari mencoba

12345 REV 54321
ok

Kode Mesin Turing

Menggunakan sintaks dari sini.

0 * * l 0
0 _ # r 2
2 # # r 2
2 0 # l A
2 1 # l B
2 2 # l C
2 3 # l D
2 4 # l E
2 5 # l F
2 6 # l G
2 7 # l H
2 8 # l I
2 9 # l J
2 _ _ l Z
A * * l A
A _ 0 l Q 
B * * l B
B _ 1 l Q 
C * * l C
C _ 2 l Q
D * * l D
D _ 3 l Q
E * * l E
E _ 4 l Q
F * * l F
F _ 5 l Q
G * * l G
G _ 6 l Q
H * * l H
H _ 7 l Q
I * * l I
I _ 8 l Q
J * * l J
J _ 9 l Q
Q # # r 2
Q * * r Q
Z # _ l Z
Z * * l ZZ
ZZ _ * r ZZZ
ZZ * * l ZZ
ZZZ 0 _ r ZZZ
ZZZ * * * halt

Cobalah online!

Python

import itertools

def rev(n):
    l = next(m for m in itertools.count() if n/10**m == 0)
    return sum((n-n/10**(i+1)*10**(i+1))/10**i*10**(l-i-1) for i in range(l))

C

#include <stdio.h>

int c(int n) {
    return !n ? 0 : 1+c(n/10);
}

int p(int n) {
    return !n ? 1 : 10*p(n-1);
}

int r(int n) {
    return !n ? 0 : n%10*p(c(n/10))+r(n/10);
}

int main() {
    printf("%d\n", r(13457));

    return 0;
}

Batch

Merindukan bagian tentang tidak menggunakan string - oh well.

@echo off
setLocal enableDelayedExpansion enableExtensions
for /f %%a in ('copy /Z "%~dpf0" nul') do set "ASCII_13=%%a"
set num=%~1
set cnum=%num%
set len=0
:c
if defined num set num=%num:~1%&set /a len+=1&goto :c
set /a len-=1
for /L %%a in (%len%,-1,0) do set /p "=!ASCII_13!!cnum:~%%a,1!"<nul

Python 2

import math

def reverseNumber(num):
    length = int(math.ceil(math.log10(num)))
    reversed = 0

    for i in range(0, length):
        temp = num // math.pow(10, length - i - 1)
        num -= temp * math.pow(10, length - i - 1)
        reversed += int(temp * math.pow(10, i))

    return reversed

print reverseNumber(12345)