Fourni une entrée sous la forme d'un entier non signé:

13457

Votre fonction / sous-routine devrait retourner:

75431

Puisque c'est un concours de popularité, soyez créatif. Les solutions créatives utilisent des techniques inhabituelles ou intelligentes pour accomplir une tâche donnée.

Contraintes:

• Vous ne pouvez pas utiliser de tableaux.
• Vous ne pouvez pas utiliser de chaînes.
• Pas de substitution RTL ( &#8238)

Points Brownie pour l'utilisation de l'arithmétique créative.

Comme il s’agit d’un concours de popularité, je vous suggère de ne pas utiliser l’ %opérateur modulo ( ) dans votre code.

À propos des zéros au début:

Si l'entrée est:

12340

Puis la sortie:

4321

serait acceptable.

Mathematica, pas de 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]]]]

Faisons le décomposer.

Nous utilisons d’abord des "arithmétiques créatives" pour savoir combien de chiffres sont dans le nombre: length = Ceiling[Log[10, n]];

Ensuite, nous rastérisons le nombre en une grande image:

Maintenant, nous interrogeons le cadre de sélection de cette image et remplissons la largeur et la hauteur (en utilisant le décalage de la ligne de base au lieu de la hauteur de l'image, car MM ajoute des espaces au-dessous de la ligne de base de l'image).

Ensuite, NestList soustrait récursivement la largeur de l'image, divisée par la longueur de la chaîne, pour permettre à ImageTake de cueillir des caractères à la fin de l'image, l'un après l'autre, et ceux-ci sont réassemblés par cette image:

Ensuite, nous transmettons cela à la fonction TextRecognize pour la reconnaissance optique de caractères qui, à cette taille d'image et à cette qualité de rastérisation, est capable de reconnaître de manière impeccable la sortie finale et de nous donner l'entier:

72641

Logarithmes et OCR - C'est comme le chocolat et le beurre de cacahuète!

Nouveau et amélioré

Cette version compile le numéro pour traiter le comportement obstiné de TextRecognize avec de petits nombres, puis soustrait le pavé à la fin. Cela fonctionne même pour les nombres à un chiffre!

Cependant, pourquoi exécuter une procédure inverse sur un seul numéro est un mystère pour moi. Mais, par souci d’exhaustivité, j’ai même fait en sorte que cela fonctionne pour des entrées de zéro et un, ce qui normalement casserait du fait que le journal au sol ne renverrait pas 1 pour eux.

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

Le script Perl suivant lit le nombre sous forme d'argument de ligne de commande, par exemple:

    1234567890

Le script Perl suivant imprime le numéro via LuaTeX. Une police virtuelle est créée à la volée et reproduit les chiffres horizontalement.

Ensuite, le nombre entier est à nouveau reflété horizontalement:

La dernière image est relue via 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

Fondamentalement, il ne s'agit que d'un programme d'inversion des entrées.

,[>,]<[.<]

UPD: Comme Sylwester l’a souligné dans les commentaires, dans les interpréteurs / compilateurs classiques de Brainfuck (sans possibilité de partir de zéro dans la matrice de mémoire), ce programme ne fonctionnerait pas en l'absence de '>' au début, de sorte que le plus stable la version est:

>,[>,]<[.<]

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

Pas de tableaux, de chaînes ou de modules.

De plus, je sais que nous ne sommes pas censés utiliser de listes ou de chaînes, mais j'aime la brièveté de la procédure:

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;
}

Je suppose que quelqu'un doit être le partypooper.

Frapper

$ rev<<<[Input]

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

Les limites de taille dépendent de votre coquille, mais tout ira bien.

Javascript

EDIT : Puisqu'il est suggéré de ne pas utiliser %opérateur, j'utilise un petit truc maintenant.

Je sais que ce n'est pas un code-golf, mais il n'y a aucune raison de le prolonger.

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

r(13457) résultats 75431

De plus, c'est beaucoup plus rapide que la méthode string ( n.toString().split('').reverse().join('')):

==> Rapport JSPerf <==

Python

Pas sûr que cette implémentation soit qualifiée pour les mathématiques créatives

De plus, l'opérateur% n'a pas été utilisé en soi, bien que l'on puisse affirmer que divmod fait la même chose, mais ensuite la question doit être reformulée :-)

la mise en oeuvre

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

démo

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

Comment ça marche?

Ceci est une solution divmod récursive * Cette solution détermine le chiffre le moins significatif puis le pousse à la fin du nombre. *

Encore une autre implémentation Python

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

Comment ça marche?

C'est une solution récursive qui permute les chiffres extrêmes du nombre

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

Exemple Run

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

Juste pour être contraire, une surutilisation de l'opérateur modulo:

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

Notez que cela inverse toujours 5 chiffres et que les entiers 32 bits débordent pour des valeurs d'entrée supérieures à 39045.

C #

Voici un moyen de le faire sans l' %opérateur Modulus ( ) et juste une simple arithmétique.

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

Frapper

> 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);
}

Pas de chaînes, tableaux, modules ou divisions. Au lieu de cela, division par soustraction répétée.

Mathematica

Créer une image hors numéro, la refléter, la partitionner en chiffres. Ensuite, il y a deux alternatives:

1. Comparez chaque image d'un chiffre réfléchi avec les images précédentes préparées, remplacez-la par le chiffre correspondant et construisez le numéro à partir de celui-ci.

2. Réfléchissez chaque chiffre séparément, créez une nouvelle image et transmettez-la à la fonction de reconnaissance d'image.

J'ai fait les deux

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 : Ajout du remplissage de trois zéros, car ne TextRecognisefonctionne correctement qu'avec des entiers> 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

Pas de tableaux ou de chaînes utilisés. Le numéro est divisé en chiffres et réassemblé à l'aide de la liste d'arguments.

Python2

Suppose que "entier non signé" est 32 bits

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

Lorsqu'elle reçoit une entrée 1230, elle sort 0321.

Postscript

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

Pas de tableaux, pas de chaînes, pas de variables.

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

Le même sans mod(qui est juste un raccourci, donc pas de grande différence):

/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 #

Ceci n'utilise pas de chaînes ni de tableaux, mais utilise le Stack<T>type .NET (EDIT: opérateur de module utilisé à l'origine; maintenant supprimé)

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

En ce sens que la solution évidente est représentée dans quelques autres langues, vous pouvez aussi l’afficher en C.

Golfé:

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

Ungolfed:

#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: Je viens de voir le module éditer.

Golfé (sans module):

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

Ungolfed (pas de module):

#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);
}

Java

Voici ce que je propose, sans chaînes, ni tableaux ... pas même de variables (en Java, cela ne vous dérange pas):

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;
}

EDIT Une version plus lisible

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

Une solution rapide dans PowerShell. Aucun tableau ou chaîne utilisé, implicitement ou explicitement.

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

Essai:

PS > rev(13457)
75431

PS > rev(rev(13457))
13457

python (facile à assembler)

Inverse les bits d'un octet. Des points pour ne pas faire exactement la même chose que tout le monde?

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

Exemple

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;
}  

SORTIE

Trois échantillons

Test avec des zéros

Cela aussi inverse les nombres flottants !!!

Si vous souhaitez exécuter ce code, exécutez-le sur votre ordinateur car il crée un fichier temporaire pendant son exécution et je ne sais pas si les compilateurs en ligne créeraient un fichier temporaire sur votre ordinateur.

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
}

Ensuite:

• reverse(12345) les sorties 54321
• reverse(3240) les sorties 423
• reverse(6342975) les sorties 5792436

Fission

$SX/
\S?L
K\O

Ce programme inverse l'entrée.

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

FORTH

Créons un nouveau mot

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

Ici, il utilise le mot U / qui renvoie le reste et le quotient, le reste est envoyé en sortie sous forme de nombre dans un champ de 1 caractère, jusqu'à ce que le dividende soit égal à zéro. Aucune chaîne n'est utilisée, du moins jusqu'à ce que quelque chose soit envoyé à la vidéo. Je n'utilise pas d'opérateur modulo, j'utilise plutôt une division entière avec reste et quotient. Essayons

12345 REV 54321
ok

Code de la machine de Turing

En utilisant la syntaxe à partir d' ici.

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

Essayez-le en ligne!

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;
}

Lot

Vous avez manqué la partie sur le fait de ne pas utiliser de chaînes - bien.

@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)