Podano dane wejściowe jako liczbę całkowitą bez znaku:

13457

Twoja funkcja / podprogram powinien zwrócić:

75431

Ponieważ jest to konkurs popularności, bądź kreatywny. Kreatywne rozwiązania wykorzystują nietypowe lub sprytne techniki do wykonania danego zadania.

Ograniczenia:

• Nie możesz używać tablic.
• Nie możesz używać łańcuchów.
• Bez zastąpienia RTL ( &#8238)

Punkty Brownie za korzystanie z kreatywnej arytmetyki.

Ponieważ jest to konkurs popularności, sugeruję, aby nie używać %operatora modulo ( ) w kodzie.

O wiodących zerach:

Jeśli dane wejściowe to:

12340

Następnie dane wyjściowe:

4321

byłby do przyjęcia.

Mathematica, bez 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]]]]

Rozbijmy to.

Najpierw używamy „kreatywnej arytmetyki”, aby dowiedzieć się, ile cyfr jest w liczbie: length = Ceiling[Log[10, n]];

Następnie rasteryzujemy liczbę do ładnego dużego obrazu:

Teraz pytamy o ramkę graniczną tego obrazu i wypełniamy szerokość i wysokość (faktycznie używając przesunięcia linii bazowej zamiast wysokości obrazu, ponieważ MM dodaje trochę białych znaków poniżej linii bazowej na obrazie).

Następnie NestList rekurencyjnie odejmuje szerokość obrazu podzieloną przez długość łańcucha, aby umożliwić ImageTake wyrywanie znaków z końca obrazu jeden po drugim, a te są ponownie składane przez ImageAssemble do tego obrazu:

Następnie przekazujemy to do funkcji TextRecognize do optycznego rozpoznawania znaków, która przy tym rozmiarze obrazu i jakości rasteryzacji jest w stanie bezbłędnie rozpoznać ostateczny wynik i podać nam liczbę całkowitą:

72641

Logarytmy i OCR - To jak czekolada i masło orzechowe!

Nowe i ulepszone

Ta wersja wypisuje liczbę, aby poradzić sobie z upartym zachowaniem TextRecognize z małymi liczbami, a następnie odejmuje pad na końcu. Działa to nawet w przypadku liczb jednocyfrowych!

Jednak dlaczego miałbyś wykonywać odwrotną procedurę dla jednego numeru, to dla mnie tajemnica. Ale tylko ze względu na kompletność, nawet sprawiłem, że działał on dla danych wejściowych równych zero i jeden, co normalnie by się zepsuło, ponieważ log logiczny nie zwraca dla nich 1.

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

Poniższy skrypt Perla odczytuje liczbę jako argument wiersza poleceń, np .:

    1234567890

Poniższy skrypt Perla drukuje liczbę za pośrednictwem LuaTeX. Wirtualna czcionka jest tworzona w locie, która odzwierciedla cyfry w poziomie.

Następnie cała liczba jest ponownie dublowana poziomo:

Ostateczny obraz jest ponownie czytany za pomocą 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

Zasadniczo jest to tylko program odwracający dane wejściowe.

,[>,]<[.<]

UPD: Jak zauważył Sylwester w komentarzach, w klasycznych interpretatorach / kompilatorach Brainfuck (bez możliwości przejścia w lewo od punktu zerowego w tablicy pamięci) ten program nie działałby przy braku „>” na początku, więc im bardziej stabilny wersja jest:

>,[>,]<[.<]

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

Brak tablic, łańcuchów lub modułu.

Wiem też, że nie powinniśmy używać list ani ciągów, ale uwielbiam to, jak krótko to robisz:

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

Podejrzewam, że ktoś musi być partypooper.

Grzmotnąć

$ rev<<<[Input]

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

Ograniczenia rozmiaru zależą od twojej powłoki, ale będziesz w porządku z rozsądku.

JavaScript

EDYCJA : Ponieważ istnieje sugestia, aby nie używać %operatora, teraz używam małej sztuczki.

Wiem, że to nie jest golf golfowy, ale nie ma powodu, aby go przedłużać.

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

r(13457) zwroty 75431

Co więcej, jest znacznie szybszy niż metoda string ( n.toString().split('').reverse().join('')):

==> Raport JSPerf <==

Pyton

Nie jestem pewien, czy ta implementacja kwalifikuje się do matematyki twórczej

Nie użyto również operatora% jako takiego, choć można argumentować, że divmod robi to samo, ale wtedy należy przeformułować Pytanie :-)

Realizacja

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

próbny

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

Jak to działa?

Jest to rekurencyjne rozwiązanie divmod * To rozwiązanie określa najmniej znaczącą cyfrę, a następnie przesuwa ją na koniec numeru. *

Jeszcze inna implementacja w języku 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

Jak to działa?

Jest to rozwiązanie rekurencyjne, które zamienia skrajne cyfry z liczby

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

Przykładowy bieg

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

Wręcz przeciwnie, nadużywanie operatora modulo:

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

Zauważ, że zawsze odwraca to 5 cyfr, a 32-bitowe liczby całkowite przepełnią się dla wartości wejściowych większych niż 39045.

DO#

Oto sposób na zrobienie tego bez %operatora Modulus ( ) i po prostu prostej arytmetyki.

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

Grzmotnąć

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

do

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

Bez ciągów, tablic, modułu lub podziału. Zamiast tego dzielenie przez powtarzające się odejmowanie.

Matematyka

Tworzenie obrazu z liczby, odzwierciedlanie go, dzielenie go na cyfry. Istnieją dwie alternatywy:

1. Porównaj każdy obraz odbitej cyfry z przygotowanymi wcześniejszymi obrazami, zamień go na odpowiednią cyfrę i utwórz z tego liczbę.

2. Odbij każdą cyfrę osobno, stwórz nowy obraz i przekaż go do funkcji rozpoznawania obrazu.

Zrobiłem oba

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}

EDYCJA : Dodano dopełnianie trzech zer, ponieważ TextRecognisedziała poprawnie tylko przy liczbach całkowitych> 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

Nie użyto tablic ani łańcuchów. Liczba jest dzielona na cyfry i ponownie składana za pomocą listy argumentów.

Python2

Zakłada, że ​​„liczba całkowita bez znaku” jest 32-bitowa

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

Po podaniu danych 1230wyjściowych 0321.

Postscriptum

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

Bez tablic, bez ciągów, bez zmiennych.

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

To samo bez mod(co jest tylko skrótem, więc nie ma dużej różnicy):

/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

DO#

Nie używa żadnych ciągów ani tablic, ale używa Stack<T>typu .NET (EDYCJA: pierwotnie używany operator modułu; teraz usunięty)

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

do

Ponieważ oczywiste rozwiązanie jest reprezentowane w kilku innych językach, równie dobrze można go opublikować w C.

Gra w golfa:

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

Nie golfowany:

#include <stdio.h>

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

EDYCJA: Właśnie zobaczyłem edycję modułu.

Gra w golfa (bez modułu):

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

Nie golfowany (bez modułu):

#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

Oto, co wymyśliłem, bez ciągów, bez tablic ... nawet zmiennych (w Java mam na myśli):

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

EDYCJA Bardziej czytelna wersja

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

Szybkie rozwiązanie w PowerShell. Żadne tablice ani ciągi znaków, niejawne lub jawne.

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

Testowanie:

PS > rev(13457)
75431

PS > rev(rev(13457))
13457

python (łatwo zrobić w asemblerze)

Odwraca bity bajtu. Punkty za nie robienie dokładnie tego samego, co wszyscy inni?

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

przykład

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

WYNIK

Trzy przebiegi próbne

Testuj z zerami

To także odwraca liczby zmiennoprzecinkowe !!!

Jeśli chcesz uruchomić ten kod, uruchom go na swoim komputerze, ponieważ tworzy on plik tymczasowy podczas jego działania i nie jestem pewien, czy kompilatory online utworzyłyby plik tymczasowy na twoim komputerze

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
}

Następnie:

• reverse(12345) wyjścia 54321
• reverse(3240) wyjścia 423
• reverse(6342975) wyjścia 5792436

Rozszczepienie

$SX/
\S?L
K\O

Ten program odwraca wejście.

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

NAPRZÓD

Stwórzmy nowe słowo

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

Tutaj używa słowa U /, które zwraca resztę i iloraz, reszta jest wysyłana do wyjścia jako liczba w polu o długości 1 znaku, aż dywidenda wyniesie zero. Ciąg nie jest używany, przynajmniej dopóki coś nie zostanie wysłane do wideo. Nie używam operatora modulo, zamiast tego używam dzielenia liczb całkowitych z resztą i ilorazem. Spróbujmy

12345 REV 54321
ok

Kod maszynowy Turinga

Korzystając ze składni stąd.

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

Wypróbuj online!

Pyton

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

do

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

Partia

Przegapiłem część dotyczącą nieużywania ciągów - no cóż.

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