Bereitstellung einer Eingabe als vorzeichenlose Ganzzahl:

13457

Ihre Funktion / Subroutine sollte zurückgeben:

75431

Da dies ein Beliebtheitswettbewerb ist, seien Sie kreativ. Kreative Lösungen verwenden ungewöhnliche oder clevere Techniken, um bestimmte Aufgaben zu lösen.

Einschränkungen:

• Sie können keine Arrays verwenden.
• Sie können keine Zeichenfolgen verwenden.
• Keine RTL-Überschreibung ( &#8238)

Brownie-Punkte für die Verwendung kreativer Arithmetik.

Da dies ein Beliebtheitswettbewerb ist, empfehle ich, den modulo ( %) -Operator nicht in Ihrem Code zu verwenden.

Über führende Nullen:

Wenn die Eingabe lautet:

12340

Dann die Ausgabe:

4321

wäre akzeptabel.

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

Lassen Sie es uns aufschlüsseln.

Zuerst verwenden wir einige "kreative Arithmetik", um herauszufinden, wie viele Ziffern die Zahl enthält: length = Ceiling[Log[10, n]];

Als nächstes rastern wir die Zahl zu einem schönen großen Bild:

Nun fragen wir nach dem Begrenzungsrahmen dieses Bildes und füllen die Breite und Höhe (tatsächlich unter Verwendung des Grundlinienversatzes anstelle der Bildhöhe, da MM dem Bild unter der Grundlinie ein Leerzeichen hinzufügt).

Als nächstes subtrahiert NestList rekursiv die Breite des Bildes geteilt durch die Länge des Strings, damit ImageTake Zeichen nacheinander vom Ende des Bildes abziehen kann. Diese werden von ImageAssemble wieder zu diesem Bild zusammengesetzt:

Dann geben wir das an die TextRecognize-Funktion zur optischen Zeichenerkennung weiter, die bei dieser Bildgröße und Rasterqualität die endgültige Ausgabe einwandfrei erkennen und uns die Ganzzahl geben kann:

72641

Logarithmen und OCR - Es ist wie mit Schokolade und Erdnussbutter!

Neu und verbessert

Diese Version füllt die Zahl auf, um mit dem hartnäckigen Verhalten von TextRecognize bei kleinen Zahlen fertig zu werden, und subtrahiert dann das Pad am Ende. Dies funktioniert sogar für einstellige Zahlen!

Es ist mir ein Rätsel, warum Sie für eine einzelne Nummer eine umgekehrte Routine ausführen. Der Vollständigkeit halber habe ich es sogar für Eingaben von Null und Eins funktionieren lassen, was normalerweise zu Fehlern führen würde, da das Protokoll mit Fußboden keine 1 für sie zurückgibt.

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

Das folgende Perl-Skript liest die Nummer als Kommandozeilenargument, zB:

    1234567890

Das folgende Perl-Skript druckt die Nummer über LuaTeX. Im laufenden Betrieb wird eine virtuelle Schriftart erstellt, die die Ziffern horizontal spiegelt.

Dann wird die ganze Zahl wieder horizontal gespiegelt:

Das endgültige Bild wird per OCR (Tesseract) erneut gelesen:

    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

Grundsätzlich handelt es sich nur um ein Umkehrprogramm.

,[>,]<[.<]

UPD: Wie Sylwester in Kommentaren betonte, würde dieses Programm in den klassischen Brainfuck-Interpreten / Compilern (ohne die Möglichkeit, vom Nullpunkt im Speicherarray nach links zu springen) nicht funktionieren, wenn zu Beginn kein> vorhanden wäre, umso stabiler Version ist:

>,[>,]<[.<]

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

Keine Arrays, Strings oder Module.

Ich weiß auch, dass wir keine Listen oder Zeichenfolgen verwenden sollen, aber ich finde es toll, wie kurz es ist, wenn Sie das tun:

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

Ich nehme an, jemand muss der Partypooper sein.

Bash

$ rev<<<[Input]

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

Größenbeschränkungen hängen von Ihrer Muschel ab, aber Sie werden in Ordnung sein.

Javascript

EDIT : Da es einen Vorschlag gibt, %Operator nicht zu verwenden , benutze ich jetzt einen kleinen Trick.

Ich weiß, dass dies kein Code-Golf ist, aber es gibt keinen Grund, es länger zu machen.

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

r(13457) kehrt zurück 75431

Außerdem ist es viel schneller als die String- Methode ( n.toString().split('').reverse().join('')):

==> JSPerf-Bericht <==

Python

Ich bin mir nicht sicher, ob diese Implementierung für die kreative Mathematik geeignet ist

Auch% operator wurde per se nicht verwendet, obwohl man vielleicht argumentieren könnte, dass divmod dasselbe tut, aber dann muss die Frage umformuliert werden :-)

Implementierung

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

Demo

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

Wie funktioniert es?

Dies ist eine rekursive Divmod-Lösung. * Diese Lösung ermittelt die niedrigstwertige Ziffer und schiebt sie dann an das Ende der Zahl. *

Noch eine Python-Implementierung

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

Wie funktioniert es?

Dies ist eine rekursive Lösung, bei der die extremen Ziffern der Zahl vertauscht werden

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

Beispiellauf

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

Um genau zu sein, eine Überbeanspruchung des Modulo-Operators:

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

Beachten Sie, dass dies immer 5 Stellen umkehrt und 32-Bit-Ganzzahlen bei Eingabewerten über 39045 überlaufen.

C #

Hier ist eine Möglichkeit, dies ohne den Modulus ( %) -Operator und nur mit einfacher Arithmetik zu tun .

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

Keine Strings, Arrays, Module oder Divisionen. Stattdessen Division durch wiederholte Subtraktion.

Mathematica

Aus Zahlen ein Bild machen, es reflektieren, in Ziffern aufteilen. Dann gibt es zwei Alternativen:

1. Vergleichen Sie jedes Bild einer reflektierten Ziffer mit vorbereiteten früheren Bildern, ersetzen Sie es durch die entsprechende Ziffer und bilden Sie daraus die Zahl.

2. Reflektieren Sie jede Ziffer einzeln, erstellen Sie ein neues Bild und übergeben Sie es an die Bilderkennungsfunktion.

Ich habe beides getan

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}

BEARBEITEN : Das Auffüllen mit drei Nullen wurde hinzugefügt, da es TextRecognisenur bei Ganzzahlen> 999 korrekt funktioniert.

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

Keine Arrays oder Zeichenfolgen verwendet. Die Nummer wird in Ziffern aufgeteilt und anhand der Argumentliste wieder zusammengesetzt.

Python2

Angenommen, "Ganzzahl ohne Vorzeichen" ist 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

Bei Eingabe 1230wird ausgegeben 0321.

Nachsatz

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

Keine Arrays, keine Strings, keine Variablen.

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

Das gleiche ohne mod(das ist nur eine Abkürzung, also kein großer Unterschied):

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

Dies verwendet keine Strings oder Arrays, sondern den .NET- Stack<T>Typ (EDIT: ursprünglich verwendeter Modul-Operator; jetzt entfernt)

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

Insofern ist die offensichtliche Lösung in ein paar anderen Sprachen dargestellt, könnte es auch in C posten.

Golf gespielt:

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: Habe gerade den Modul bearbeitet.

Golf (kein Modul):

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

Ungolfed (kein Modul):

#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

Dies ist das, was ich mir ausgedacht habe, keine Zeichenketten, keine Arrays ... nicht einmal Variablen (in Java wohlgemerkt):

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 Eine lesbarere Version

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

Power Shell

Eine schnelle Lösung in PowerShell. Es werden weder implizit noch explizit Arrays oder Zeichenfolgen verwendet.

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

Testen:

PS > rev(13457)
75431

PS > rev(rev(13457))
13457

Python (leicht in der Montage gemacht)

Kehrt die Bits eines Bytes um. Punkte dafür, dass nicht genau dasselbe getan wurde, was alle anderen getan haben?

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

Beispiel

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

AUSGABE

Drei Probeläufe

Test mit Nullen

Es kehrt auch schwebende Zahlen um !!!

Wenn Sie diesen Code ausführen möchten , führen Sie ihn auf Ihrem Computer aus, da während der Laufzeit eine temporäre Datei erstellt wird und ich nicht sicher bin, ob Online-Compiler eine temporäre Datei auf Ihrem Computer erstellen würden

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
}

Dann:

• reverse(12345) Ausgänge 54321
• reverse(3240) Ausgänge 423
• reverse(6342975) Ausgänge 5792436

Fission

$SX/
\S?L
K\O

Dieses Programm kehrt die Eingabe um.

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

FORTH

Lassen Sie uns ein neues Wort erstellen

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

Hier wird das Wort U / verwendet, das den Rest und den Quotienten zurückgibt. Der Rest wird als Zahl in einem Feld mit einer Länge von 1 Zeichen ausgegeben, bis die Dividende Null ist. Es wird kein String verwendet, zumindest bis etwas an das Video gesendet wird. Ich verwende keinen Modulo-Operator, sondern eine Ganzzahldivision mit Rest und Quotient. Lass es uns versuchen

12345 REV 54321
ok

Turing-Maschinencode

Verwenden Sie die Syntax von hier.

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

Probieren Sie es online!

Python

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

Stapel

Verpasste den Teil, in dem es darum ging, keine Saiten zu verwenden - na ja.

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