İmzasız bir tamsayı olarak girdi girdi:

13457

İşlev / alt rutininizin geri dönmesi gerekir:

75431

Bu bir popülerlik yarışması olduğu için yaratıcı olun. Yaratıcı çözümler verilen görevi gerçekleştirmek için sıra dışı veya zeki teknikleri kullanır.

Kısıtlamalar:

• Dizileri kullanamazsınız.
• Dizeleri kullanamazsınız.
• RTL Geçersiz Kılma Yok ( &#8238)

Brownie yaratıcı aritmetik kullanmaya işaret ediyor.

Bu bir popülerlik yarışması olduğundan, modulo ( %) operatörünü kodunuzda kullanmamanızı öneririm .

Önde gelen sıfırlar hakkında:

Giriş ise:

12340

Sonra çıktı:

4321

kabul edilebilir olurdu.

Mathematica, modulo yok!

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

Yıkalım.

Öncelikle, sayıdaki kaç rakam olduğunu bulmak için bazı "yaratıcı aritmetik" kullanırız: length = Ceiling[Log[10, n]];

Ardından, sayıyı güzel ve büyük bir resme Rasterleştiriyoruz:

Şimdi o görüntünün sınırlayıcı kutusunu sorguluyoruz ve genişliği ve yüksekliği dolduruyoruz (aslında görüntü yüksekliği yerine görüntü taban çizgisi uzaklığını kullanıyoruz, çünkü MM görüntüdeki taban çizgisinin altına biraz boşluk ekler).

Daha sonra, NestList, ImageTake'in görüntünün sonundan karakterleri tek tek toplamasını sağlamak için dizenin uzunluğuna bölünerek görüntünün genişliğini tekrar tekrar çıkarır ve bunlar bu görüntüye ImageAssemble tarafından yeniden birleştirilir:

Daha sonra, bu görüntü boyutunda ve rasterleştirme kalitesinde nihai çıktıyı kusursuz bir şekilde tanıyabilen ve bize tamsayı veren optik karakter tanıma için TextRecognize işlevine geçiyoruz:

72641

Logaritmalar ve OCR - Çikolata ve fıstık ezmesi gibi!

Yeni ve geliştirilmiş

Bu sürüm, TextRecognise'ın küçük sayılarla ilgili davranışını engellemek için sayıyı dağıtır ve ardından pedi sonunda çıkartır. Bu tek haneli sayılar için bile işe yarar!

Yine de, neden tek bir numara üzerinde ters rutin çalıştırıyor olmanız benim için gizemli. Ama sadece tamlık uğruna, sıfır ve bir girdiler için bile çalışmasını sağladım, bu normalde kırılacaktı çünkü kütük kütük onlar için 1 döndürmedi.

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

Aşağıdaki Perl betiği, sayıyı komut satırı argümanı olarak okur, örneğin:

    1234567890

Aşağıdaki Perl betiği, LuaTeX aracılığıyla numarayı yazdırır. Anında, yatay olarak basamakları yansıtan sanal bir yazı tipi oluşturulur.

Sonra tüm sayı tekrar yatay olarak yansıtılır:

Son görüntü OCR (yeniden tesseract) ile yeniden okunur:

    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

Temel olarak, sadece bir giriş ters programdır.

,[>,]<[.<]

UPD: Sylwester yorumlarda da belirtildiği gibi, klasik Brainfuck tercümanlarında / derleyicilerinde (bellek dizisindeki sıfır noktasından ayrılma olasılığı olmadan) bu program başlangıçta '>' yokluğunda çalışmaz, dolayısıyla daha kararlı sürüm:

>,[>,]<[.<]

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

Dizi, dize veya modül yok.

Ayrıca, liste veya karakter dizileri kullanmamamız gerektiğini biliyorum, fakat bunu yaparken ne kadar kısa olduğunu seviyorum:

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

Sanırım birinin parti sahibi olması gerekiyor.

darbe

$ rev<<<[Input]

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

Boyut sınırlamaları kabuğunuza bağlıdır, ancak gerekçede iyi olacaksınız.

JavaScript

EDIT : %Operatör kullanmamak için bir öneri olduğu için , şimdi küçük bir numara kullanıyorum.

Bunun kod golfü olmadığını biliyorum, ama daha uzun yapmak için hiçbir neden yok.

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

r(13457) döner 75431

Üstelik string metodundan ( n.toString().split('').reverse().join('')) çok daha hızlıdır :

==> JSPerf raporu <==

piton

Bu uygulamanın yaratıcı matematik için uygun olup olmadığından emin değil

Ayrıca,% operatörü kendi başına kullanılmadı, ancak divmod'un da aynı şeyi yapabileceğini iddia etse de, o zaman Sorunun tekrarlanması gerekiyor :-)

uygulama

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

gösteri

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

O nasıl çalışır?

Bu özyinelemeli bir divmod çözümü * Bu çözüm en az anlamlı basamağı belirler ve ardından sayının sonuna kadar iter. *

Yine Bir Python Uygulaması

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

O nasıl çalışır?

Bu, aşırı haneleri sayıdan alan bir özyinelemeli çözümdür.

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

Örnek Çalıştırma

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

Aksine, modulo operatörünün aşırı kullanımı:

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

Bunun her zaman 5 basamağı tersine çevirdiğini ve 39045'ten daha fazla giriş değeri için 32 bit tam sayıların taşacağını unutmayın.

C #

Modulus ( %) operatörü ve basit aritmetik olmadan yapmanın bir yolu .

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

darbe

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

Dizi, dizi, modül veya bölme yok. Bunun yerine, tekrarlanan çıkarma ile bölme.

Mathematica

Sayının dışında bir resim yapmak, onu yansıtmak, rakamlara bölmek. O zaman iki alternatif var:

1. Yansıtılmış bir basamağın her görüntüsünü daha önce hazırlanmış görüntülerle karşılaştırın, karşılık gelen basamakla değiştirin ve bu sayıyı oluşturun.

2. Her basamağı ayrı ayrı yansıtın, yeni bir görüntü oluşturun ve görüntü tanıma işlevine geçirin.

İkisini de yaptım

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 : Üç sıfır eklenmiş dolgu eki, çünkü TextRecogniseyalnızca> 999 tamsayılarıyla doğru çalışıyor.

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

Diziler veya dizeler kullanılmaz. Sayı rakamlara bölünür ve bağımsız değişkenler listesi kullanılarak yeniden birleştirilir.

Python2

"İmzasız tamsayı" nın 32-bit olduğunu varsayar

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

Giriş 1230yapıldığında, çıkışlar 0321.

dipnot

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

Dizi yok, dizi yok, değişken yok.

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

Aynı olmadan mod(ki sadece bir kısayol, bu yüzden büyük bir fark yok):

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

Bu, dizeler veya diziler kullanmaz, ancak .NET Stack<T>türünü kullanır (EDIT: başlangıçta kullanılan modül işleci; şimdi kaldırıldı)

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

Buradaki bariz çözüm birkaç başka dilde temsil edilmekte olup, bunu C de yayınlayabilir.

golfed:

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: Sadece modül düzenlemesini gördüm.

Golf (modül yok):

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

Ungolfed (modül yok):

#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

Karşılaştığım şey bu, dizge yok, dizi yok ... değişken bile değil (Java'da aklımda):

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 Daha okunabilir bir sürüm

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

Güç kalkanı

PowerShell'de hızlı bir çözüm. Örtülü veya açık şekilde diziler veya dizeler kullanılmaz.

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

Test yapmak:

PS > rev(13457)
75431

PS > rev(rev(13457))
13457

python (montajda kolayca yapılır)

Bir baytın bitlerini ters çevirir. Herkesin yaptığını aynı şeyi yapmadığı için puan?

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

örnek

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

ÇIKTI

Üç örnek çalışması

Sıfırlarla test et

Ayrıca yüzen sayıları tersine çevirir !!!

İsterseniz bu kodu çalıştırmak için onun çalışma zamanında sırasında geçici dosya oluşturur çünkü sonra bilgisayarda çalıştırın ve emin çevrimiçi derleyiciler bilgisayarınızda geçici bir dosya yapmak olsaydı değilim

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
}

Sonra:

• reverse(12345) çıktılar 54321
• reverse(3240) çıktılar 423
• reverse(6342975) çıktılar 5792436

fizyon

$SX/
\S?L
K\O

Bu program girişi tersine çevirir.

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

ORTAYA

Yeni bir kelime oluşturalım

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

Burada, kalanı ve kısmi döndüren U / kelimesini kullanır, kalanı temettü sıfır olana kadar 1 karakter uzunluğundaki bir alan içindeki sayı olarak çıktıya gönderilir. Hiçbir dize, en azından videoya bir şey gönderilene kadar kullanılmaz. Bir modulo operatörü kullanmıyorum, bunun yerine kalanı ve bölümleri ile tamsayı bölmesini kullanıyorum. Hadi deneyelim

12345 REV 54321
ok

Turing Makine Kodu

Buradan sözdizimini kullanarak .

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

Çevrimiçi deneyin!

piton

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

Grup, yığın, parça, bir defada alınan miktar

Dizeleri kullanma konusundaki kısmı kaçırdım - peki.

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