부호없는 정수로 입력을 제공했습니다.

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의 고집스러운 동작을 처리하기 위해 숫자를 채우고 작은 숫자를 뺍니다. 심지어 한 자리 숫자에서도 작동합니다!

그럼에도 불구하고 왜 단일 번호에서 역순으로 실행해야하는지는 미스터리입니다. 그러나 완전성을 위해 0과 1의 입력에 대해서도 작동하도록 만들었습니다. 바닥 로그가 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 인터프리터 / 컴파일러에서 (메모리 배열에서 0 포인트에서 벗어날 가능성이 없음)이 프로그램은 처음에 '>'가 없으면 작동하지 않으므로 더 안정적입니다. 버전은 :

>,[>,]<[.<]

하스켈

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

누군가 가 partypooper이어야 한다고 생각 합니다.

세게 때리다

$ 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

또한 문자열 메소드 ( 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

예제 실행

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 자리를 거꾸로하며 39045보다 큰 입력 값에 대해서는 32 비트 정수가 오버플로됩니다.

씨#

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

씨

#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에서만 올바르게 작동 하기 때문에 세 개의 0으로 채워지는 패딩이 추가되었습니다 .

루아

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

사용 된 배열이나 문자열이 없습니다. 숫자는 숫자로 분리되고 인수 목록을 사용하여 다시 어셈블됩니다.

파이썬 2

"부호없는 정수"가 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

입력이 주어지면 1230출력 0321합니다.

추신

/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

씨#

이것은 문자열이나 배열을 사용하지 않지만 .NET Stack<T>유형을 사용합니다 (편집 : 원래 사용 된 계수 연산자; 이제 제거됨)

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로 게시 할 수도 있습니다.

골프 :

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

언 골프 드 :

#include <stdio.h>

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

편집 : 방금 모듈 편집을 보았다.

골프 (모듈러스 없음) :

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

언 골프 (탄성율 없음) :

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

산출

세 가지 샘플 실행

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

앞으로

새로운 단어를 만들어 봅시다

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

여기에서는 단어 U /를 사용하여 나머지와 몫을 반환하고 나머지는 배당이 0이 될 때까지 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))

씨

#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

파이썬 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)