Предоставляется ввод в виде целого числа без знака:

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

Логарифмы и распознавание текста - это как шоколад и арахисовое масло!

Новый и улучшенный

Эта версия дополняет число, чтобы справиться с упрямым поведением 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 / Тессеракт

Следующий скрипт 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: как указывал Сильвестер в комментариях, в классических интерпретаторах / компиляторах 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

Ограничения по размеру зависят от вашей оболочки, но вы будете в пределах разумного.

Javascript

РЕДАКТИРОВАТЬ : так как есть предложение не использовать% оператор, я использую небольшую хитрость сейчас.

Я знаю, что это не код-гольф, но нет никаких причин, чтобы продлить его.

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 * Это решение определяет наименее значимую цифру, а затем помещает ее в конец числа. *

Еще одна реализация Python

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 цифр, и 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

С

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

Нет строк, массивов, модулей или делений. Вместо этого деление путем повторного вычитания.

Mathematica

Создание изображения из числа, его отражение, разбиение на цифры. Тогда есть две альтернативы:

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

Когда дан вход 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

C #

При этом не используются строки или массивы, но используется Stack<T>тип .NET (EDIT: первоначально использовался оператор модуля; теперь удален).

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.

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

РЕДАКТИРОВАТЬ: Только что видел модуль редактирования.

Гольф (без модуля):

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

Python (легко делается в сборке)

Обращает биты байта. Очки за то, что не делали то же самое, что и все остальные?

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

ВПЕРЕД

Давайте создадим новое слово

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

С

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