ระบุอินพุตเป็นจำนวนเต็มที่ไม่ได้ลงนาม:

13457

ฟังก์ชั่น / รูทีนย่อยของคุณควรกลับมา:

75431

เนื่องจากนี่คือการประกวดความนิยมจงสร้างสรรค์ โซลูชันที่สร้างสรรค์ใช้เทคนิคที่ผิดปกติหรือชาญฉลาดในการทำงานให้สำเร็จ

ข้อ จำกัด :

• คุณไม่สามารถใช้อาร์เรย์
• คุณไม่สามารถใช้สตริง
• ไม่มีการแทนที่ RTL ( &#8238)

จุดบราวนี่สำหรับการใช้งานเลขคณิตสร้างสรรค์

เนื่องจากนี่เป็นการประกวดความนิยมฉันขอแนะนำไม่ให้ใช้ตัวดำเนินการ modulo ( %) ในรหัสของคุณ

เกี่ยวกับศูนย์นำ:

หากอินพุตคือ:

12340

จากนั้นผลลัพธ์:

4321

จะเป็นที่ยอมรับ

Mathematica ไม่มีแบบโมดูโล!

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

มาทำลายมันกันเถอะ

ก่อนอื่นเราใช้ "ความคิดสร้างสรรค์เชิงสร้างสรรค์" เพื่อหาจำนวนตัวเลขในจำนวน: length = Ceiling[Log[10, n]];

ต่อไปเราจะเปลี่ยนภาพเป็นภาพขนาดใหญ่ที่ดี:

ตอนนี้เราทำการค้นหากล่องขอบของรูปภาพนั้นและเติมความกว้างและความสูง (จริง ๆ แล้วใช้การชดเชยพื้นฐานแทนความสูงของรูปภาพเนื่องจาก MM เพิ่มช่องว่างด้านล่างด้านล่างพื้นฐานในรูปภาพ)

ถัดไป NestList จะลบความกว้างของรูปภาพซ้ำโดยหารด้วยความยาวของสตริงเพื่อเปิดใช้งาน ImageTake เพื่อดึงอักขระจากส่วนท้ายของภาพทีละภาพและประกอบไปด้วย ImageAssemble ต่อภาพนี้:

จากนั้นเราจะส่งต่อไปยังฟังก์ชัน TextRecognize สำหรับการรู้จำอักขระด้วยแสงซึ่งขนาดภาพนี้และคุณภาพการแรสเตอร์ทำให้สามารถรับรู้ผลลัพธ์สุดท้ายได้อย่างไม่มีที่ติและให้จำนวนเต็มกับเรา:

72641

ลอการิทึมและ OCR - มันก็เหมือนกับช็อคโกแลตและเนยถั่ว!

ใหม่และปรับปรุง

รุ่นนี้ใส่ตัวเลขเพื่อจัดการกับพฤติกรรมการดื้อรั้นของ TextRecognize ด้วยตัวเลขขนาดเล็กจากนั้นจึงลบแผ่นอิเล็กโทรดออกในตอนท้าย สิ่งนี้สามารถใช้ได้กับตัวเลขหลักเดียว!

แม้ว่าทำไมคุณถึงเรียกใช้รูทีนย้อนกลับบนหมายเลขเดียวเป็นสิ่งที่ลึกลับสำหรับฉัน แต่เพื่อความสมบูรณ์ฉันยังทำให้มันทำงานได้กับอินพุตของศูนย์และอีกอันหนึ่งซึ่งโดยปกติแล้วจะพังเพราะบันทึกปูพื้นไม่ส่งคืน 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

สคริปต์ Perl ต่อไปนี้จะอ่านตัวเลขเป็นอาร์กิวเมนต์บรรทัดคำสั่งเช่น:

    1234567890

สคริปต์ Perl ต่อไปนี้พิมพ์หมายเลขผ่าน LuaTeX แบบอักษรเสมือนจริงถูกสร้างขึ้นในทันทีที่สะท้อนตัวเลขในแนวนอน

จากนั้นจำนวนทั้งหมดจะถูกสะท้อนอีกครั้งในแนวนอน:

ภาพสุดท้ายถูกอ่านซ้ำผ่าน 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

โดยทั่วไปเป็นเพียงโปรแกรมย้อนกลับอินพุต

,[>,]<[.<]

UPD: ตามที่Sylwesterชี้ให้เห็นในความคิดเห็นในนักแปล / คอมไพเลอร์ Brainfuck แบบดั้งเดิม (ไม่มีความเป็นไปได้ที่จะจากจุดศูนย์ในอาร์เรย์หน่วยความจำ) โปรแกรมนี้จะไม่ทำงานหากไม่มี '>' ในตอนเริ่มต้น รุ่นคือ:

>,[>,]<[.<]

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

ไม่มีอาร์เรย์สตริงหรือโมดูลัส

นอกจากนี้ฉันรู้ว่าเราไม่ควรใช้รายการหรือสายอักขระ แต่ฉันชอบความสั้นเมื่อคุณทำเช่นนั้น:

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

ฉันคิดว่าใครบางคนจะต้องเป็นปาร์ตี้

ทุบตี

$ rev<<<[Input]

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

ข้อ จำกัด ด้านขนาดขึ้นอยู่กับเชลล์ของคุณ แต่คุณจะใช้ได้ในเหตุผล

จาวาสคริ

แก้ไข : เนื่องจากมีข้อเสนอแนะที่จะไม่ใช้%โอเปอเรเตอร์ฉันจึงใช้เล่ห์เหลี่ยมเล็กน้อยในตอนนี้

ฉันรู้ว่านี่ไม่ใช่รหัสกอล์ฟ แต่ไม่มีเหตุผลที่จะทำให้มันยาวขึ้น

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

r(13457) ผลตอบแทน 75431

ยิ่งกว่านั้นมันเร็วกว่าเมธอดstring ( n.toString().split('').reverse().join('')):

==> รายงาน JSPerf <==

หลาม

ไม่แน่ใจว่าการใช้งานนี้ผ่านการรับรองสำหรับคณิตศาสตร์สร้างสรรค์หรือไม่

% โอเปอเรเตอร์ก็ไม่ได้ถูกใช้ด้วยเช่นกัน แต่ใคร ๆ ก็อาจเถียงว่า divmod ทำแบบเดียวกัน แต่ก็ต้องตอบคำถามใหม่ :-)

การดำเนินงาน

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

การสาธิต

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

มันทำงานยังไง?

นี่เป็นโซลูชัน divmod แบบเรียกซ้ำ * วิธีนี้จะกำหนดตัวเลขที่สำคัญน้อยที่สุดแล้วจึงผลักไปที่จุดสิ้นสุดของตัวเลข *

อีกหนึ่งการดำเนินการของหลาม

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

มันทำงานยังไง?

นี่เป็นโซลูชันแบบเรียกซ้ำซึ่งสลับตัวเลขจากจำนวนมาก

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

ตัวอย่าง 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

เพื่อที่จะตรงกันข้ามผู้ประกอบการโมดูโลใช้มากเกินไป:

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

โปรดทราบว่าสิ่งนี้จะย้อนกลับ 5 หลักเสมอและจำนวนเต็ม 32 บิตจะล้นสำหรับค่าอินพุตมากกว่า 39045

C #

ต่อไปนี้เป็นวิธีดำเนินการโดยไม่มีตัวดำเนินการ Modulus ( %) และคณิตศาสตร์อย่างง่าย

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

ทุบตี

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

ไม่มีสตริงอาร์เรย์โมดูลัสหรือการหาร แต่ให้หารด้วยการลบซ้ำ

มาติกา

ทำให้ภาพออกมาจากตัวเลขสะท้อนให้เห็นถึงมันแบ่งออกเป็นตัวเลข จากนั้นมีทางเลือกสองทาง:

1. เปรียบเทียบแต่ละภาพของตัวเลขสะท้อนกับภาพก่อนหน้าเตรียมไว้แทนที่ด้วยตัวเลขที่สอดคล้องกันและสร้างตัวเลขออกมาจากนี้

2. สะท้อนทุกหลักแยกกันสร้างภาพใหม่และส่งผ่านไปยังฟังก์ชั่นการจดจำรูปภาพ

ฉันทำทั้งสองอย่าง

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}

แก้ไข : เพิ่มช่องว่างภายในสามศูนย์เนื่องจากTextRecogniseทำงานอย่างถูกต้องกับจำนวนเต็ม> 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

ไม่มีอาร์เรย์หรือสตริงที่ใช้ จำนวนถูกแบ่งออกเป็นตัวเลขและประกอบใหม่โดยใช้รายการอาร์กิวเมนต์

Python2

ถือว่า "จำนวนเต็มไม่ได้ลงนาม" คือ 32- บิต

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

เมื่อได้รับการป้อนข้อมูลมันจะออกผลลัพธ์12300321

ป.ล.

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

ไม่มีอาร์เรย์ไม่มีสตริงไม่มีตัวแปร

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

เดียวกันโดยไม่ต้องmod(ซึ่งเป็นเพียงทางลัดจึงไม่แตกต่างกันมาก):

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

สิ่งนี้ไม่ใช้สตริงหรืออาร์เรย์ แต่ใช้Stack<T>ชนิด. NET (แก้ไข: เดิมใช้ตัวดำเนินการโมดูลัส แต่ตอนนี้ถูกลบ)

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

ในการที่วิธีการแก้ปัญหาที่ชัดเจนมีตัวแทนในภาษาอื่น ๆ อีกสองภาษาเช่นกันอาจโพสต์ไว้ใน C

แข็งแรงเล่นกอล์ฟ:

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

แก้ไข: เพิ่งเห็นโมดูลัสแก้ไข

Golfed (ไม่มีโมดูลัส):

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

Ungolfed (ไม่มีโมดูลัส):

#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 ฉันคำนึงถึงคุณ):

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

แก้ไขรุ่นที่อ่านได้มากขึ้น

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

ทางออกที่รวดเร็วใน PowerShell ไม่มีการใช้อาร์เรย์หรือสตริงไม่ว่าโดยนัยหรือชัดแจ้ง

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

การทดสอบ:

PS > rev(13457)
75431

PS > rev(rev(13457))
13457

หลาม (ประกอบง่าย)

ฝืนบิตของไบต์ คะแนนสำหรับการไม่ทำสิ่งเดียวกันกับที่คนอื่นทำ

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

ตัวอย่าง

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

เอาท์พุท

ตัวอย่างการวิ่งสามครั้ง

ทดสอบด้วยเลขศูนย์

มันฝืนตัวเลขลอย !!!

หากคุณต้องการเรียกใช้รหัสนี้ให้เรียกใช้บนคอมพิวเตอร์ของคุณเพราะมันจะสร้างไฟล์ชั่วคราวในช่วงเวลาทำงานและฉันไม่แน่ใจว่าคอมไพเลอร์ออนไลน์จะทำไฟล์ชั่วคราวบนคอมพิวเตอร์ของคุณหรือไม่

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
}

แล้ว:

• reverse(12345) เอาท์พุท 54321
• reverse(3240) เอาท์พุท 423
• reverse(6342975) เอาท์พุท 5792436

การแยก

$SX/
\S?L
K\O

โปรแกรมนี้ย้อนกลับอินพุต

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

FORTH

มาสร้างคำใหม่กันเถอะ

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

ที่นี่จะใช้คำว่า U / ที่ส่งคืนส่วนที่เหลือและความฉลาดทางส่วนที่เหลือจะถูกส่งไปยังเอาท์พุทเป็นจำนวนภายในความยาว 1 ตัวอักษรสนามจนกระทั่งเงินปันผลเป็นศูนย์ ไม่มีการใช้สตริงอย่างน้อยก็จนกว่าจะมีบางอย่างถูกส่งไปยังวิดีโอ ฉันไม่ได้ใช้ตัวดำเนินการแบบโมดูโล แต่ฉันจะใช้การหารจำนวนเต็มด้วยส่วนที่เหลือและความฉลาด มาลองกัน

12345 REV 54321
ok

รหัสเครื่องทัวริง

ใช้ไวยากรณ์จากที่นี่

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

ลองออนไลน์!

หลาม

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

ชุด

พลาดส่วนหนึ่งเกี่ยวกับการไม่ใช้สตริง - โอ้ดี

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