Cung cấp một đầu vào dưới dạng một số nguyên không dấu:

13457

Hàm / chương trình con của bạn sẽ trả về:

75431

Vì đây là một cuộc thi phổ biến, hãy sáng tạo. Các giải pháp sáng tạo sử dụng các kỹ thuật bất thường hoặc thông minh để hoàn thành nhiệm vụ nhất định.

Các ràng buộc:

• Bạn không thể sử dụng mảng.
• Bạn không thể sử dụng chuỗi.
• Không ghi đè RTL ( &#8238)

Brownie điểm cho việc sử dụng mỹ phẩm sáng tạo.

Vì đây là một cuộc thi phổ biến, tôi khuyên bạn không nên sử dụng toán tử modulo ( %) trong mã của mình.

Về số không hàng đầu:

Nếu đầu vào là:

12340

Sau đó, đầu ra:

4321

sẽ được chấp nhận

Toán học, không có 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]]]]

Hãy phá vỡ nó.

Đầu tiên chúng tôi sử dụng một số "mỹ phẩm sáng tạo" để tìm hiểu có bao nhiêu chữ số trong số: length = Ceiling[Log[10, n]];

Tiếp theo, chúng tôi Rasterize số thành một hình ảnh lớn đẹp:

Bây giờ chúng tôi truy vấn hộp giới hạn của hình ảnh đó và điền vào chiều rộng và chiều cao (thực tế sử dụng phần bù đường cơ sở thay vì chiều cao hình ảnh, vì MM thêm một số khoảng trắng bên dưới đường cơ sở trong hình ảnh).

Tiếp theo, NestList trừ đi độ rộng của hình ảnh chia cho chiều dài của chuỗi để cho phép ImageTake nhổ từng ký tự từ cuối hình ảnh một và từng cái được ImageAssemble ghép lại với hình ảnh này:

Sau đó, chúng tôi chuyển nó sang chức năng TextRecognize để nhận dạng ký tự quang học, với kích thước hình ảnh và chất lượng rasterization này có thể nhận ra hoàn hảo đầu ra cuối cùng và cung cấp cho chúng tôi số nguyên:

72641

Logarit và OCR - Nó giống như sô cô la và bơ đậu phộng!

Mới và cải tiến

Phiên bản này loại bỏ số để xử lý hành vi cố chấp của TextRecognize với số lượng nhỏ, và sau đó trừ đi phần đệm ở cuối. Điều này thậm chí hoạt động cho các số một chữ số!

Mặc dù, tại sao bạn lại chạy một thói quen đảo ngược trên một số duy nhất là một bí ẩn đối với tôi. Nhưng chỉ vì mục đích hoàn chỉnh, tôi thậm chí còn làm cho nó hoạt động với các đầu vào bằng 0 và một, thường sẽ bị hỏng vì nhật ký thả nổi không trả về 1 cho chúng.

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

Kịch bản Perl sau đây đọc số dưới dạng đối số dòng lệnh, ví dụ:

    1234567890

Kịch bản Perl sau đây in số qua LuaTeX. Một phông chữ ảo được tạo ra khi đang bay phản chiếu các chữ số theo chiều ngang.

Sau đó, toàn bộ số lại được nhân đôi theo chiều ngang:

Hình ảnh cuối cùng được đọc lại thông qua 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

Về cơ bản, nó chỉ là một chương trình đảo ngược đầu vào.

,[>,]<[.<]

CẬP NHẬT: Như Sylwester đã chỉ ra trong các bình luận, trong các trình thông dịch / trình biên dịch Brainfuck cổ điển (không có khả năng đi từ điểm 0 trong mảng bộ nhớ), chương trình này sẽ không hoạt động nếu không có '>' lúc đầu, nên càng ổn định phiên bản là:

>,[>,]<[.<]

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

Không có mảng, chuỗi hoặc mô đun.

Ngoài ra, tôi biết chúng ta không nên sử dụng danh sách hoặc chuỗi, nhưng tôi thích thời gian ngắn khi bạn làm điều đó:

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

Tôi cho rằng ai đó phải là người tiệc tùng.

Bash

$ rev<<<[Input]

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

Giới hạn kích thước phụ thuộc vào vỏ của bạn, nhưng bạn sẽ ổn trong lý do.

Javascript

EDIT : Vì có một gợi ý không sử dụng %toán tử, tôi sử dụng một mẹo nhỏ bây giờ.

Tôi biết đây không phải là một môn đánh gôn, nhưng không có lý do gì để làm cho nó dài hơn.

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

r(13457) trả lại 75431

Hơn nữa, nó nhanh hơn rất nhiều so với phương thức chuỗi ( n.toString().split('').reverse().join('')):

==> Báo cáo JSPerf <==

Con trăn

Không chắc chắn nếu triển khai này có đủ điều kiện cho toán học sáng tạo

Ngoài ra, toán tử% không được sử dụng cho mỗi se, mặc dù người ta có thể lập luận rằng divmod cũng làm như vậy, nhưng sau đó Câu hỏi cần phải được đăng lại :-)

Thực hiện

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

bản giới thiệu

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

Làm thế nào nó hoạt động?

Đây là một giải pháp divmod đệ quy * Giải pháp này xác định chữ số có nghĩa ít nhất và sau đó đẩy nó đến cuối con số. *

Một triển khai Python khác

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

Làm thế nào nó hoạt động?

Đây là một giải pháp đệ quy hoán đổi các chữ số cực trị từ số

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

Chạy ví dụ

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

Ngược lại, một sự lạm dụng của toán tử modulo:

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

Lưu ý rằng điều này luôn đảo ngược 5 chữ số và số nguyên 32 bit sẽ tràn cho các giá trị đầu vào hơn 39045.

C #

Đây là một cách để làm điều đó mà không cần %toán tử Modulus ( ) và chỉ là số học đơn giản.

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

Bash

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

Không có chuỗi, mảng, mô đun hoặc phân chia. Thay vào đó, chia bằng phép trừ lặp đi lặp lại.

Toán học

Tạo một hình ảnh ra khỏi số, phản chiếu nó, phân vùng nó thành các chữ số. Sau đó, có hai lựa chọn thay thế:

1. So sánh từng hình ảnh của một chữ số phản ánh với các hình ảnh được chuẩn bị trước đó, thay thế nó bằng chữ số tương ứng và xây dựng số trong số này.

2. Phản ánh mỗi chữ số một cách riêng biệt, xây dựng một hình ảnh mới và chuyển nó đến chức năng nhận dạng hình ảnh.

Tôi đã làm cả hai

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 : Đã thêm phần đệm của ba số 0, vì chỉ TextRecognisehoạt động chính xác với số nguyên> 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

Không có mảng hoặc chuỗi được sử dụng. Số được chia thành các chữ số và được ghép lại bằng danh sách đối số.

Python2

Giả sử "số nguyên không dấu" là 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

Khi cho đầu vào 1230, nó đầu ra 0321.

Bản thảo

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

Không có mảng, không có chuỗi, không có biến.

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

Giống nhau mà không có mod(chỉ là một phím tắt, vì vậy không có sự khác biệt lớn):

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

Điều này không sử dụng chuỗi hoặc mảng, nhưng sử dụng Stack<T>loại .NET (EDIT: toán tử mô đun được sử dụng ban đầu; hiện đã bị xóa)

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

Trong đó, giải pháp rõ ràng được trình bày bằng một vài ngôn ngữ khác, cũng có thể đăng nó bằng C.

Chơi gôn

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

Ung dung:

#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: Chỉ cần xem chỉnh sửa mô-đun.

Chơi gôn (không có mô-đun):

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

Ungolfed (không có mô-đun):

#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

Đây là cái tôi đã nghĩ ra, không có chuỗi, không có mảng ... thậm chí không có biến (trong Java tôi nhớ bạn):

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 Một phiên bản dễ đọc hơn

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

Một giải pháp nhanh chóng trong PowerShell. Không có mảng hoặc chuỗi được sử dụng, ngầm hoặc rõ ràng.

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

Kiểm tra:

PS > rev(13457)
75431

PS > rev(rev(13457))
13457

python (dễ dàng thực hiện trong lắp ráp)

Đảo ngược các bit của một byte. Điểm không làm chính xác những gì người khác đã làm?

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

thí dụ

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

ĐẦU RA

Ba mẫu chạy

Kiểm tra với số không

Nó cũng đảo ngược số trôi nổi !!!

Nếu bạn muốn chạy mã này thì hãy chạy nó trên máy tính của bạn vì nó tạo một tệp tạm thời trong thời gian chạy và tôi không chắc liệu trình biên dịch trực tuyến có tạo tệp tạm thời trên máy tính của bạn không

Bản thảo 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
}

Sau đó:

• reverse(12345) đầu ra 54321
• reverse(3240) đầu ra 423
• reverse(6342975) đầu ra 5792436

Phân hạch

$SX/
\S?L
K\O

Chương trình này đảo ngược đầu vào.

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

FORTH

Hãy tạo một từ mới

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

Ở đây, nó sử dụng từ U / trả về phần còn lại và thương, phần còn lại được gửi đến đầu ra dưới dạng số trong một trường dài 1 ký tự, cho đến khi cổ tức bằng không. Không có chuỗi nào được sử dụng, ít nhất là cho đến khi một cái gì đó được gửi đến video. Tôi không sử dụng toán tử modulo, thay vào đó tôi sử dụng phép chia số nguyên với phần dư và thương. Hãy thử

12345 REV 54321
ok

Mã máy Turing

Sử dụng cú pháp từ đây.

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

Hãy thử trực tuyến!

Con trăn

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

Mẻ

Bỏ lỡ phần về việc không sử dụng chuỗi - oh tốt.

@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

Con trăn 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)