Введено введення у вигляді цілого числа без підпису:

13457

Ваша функція / підпрограма повинна повертати:

75431

Оскільки це конкурс популярності, будьте креативними. Творчі рішення використовують незвичні або розумні прийоми для виконання даного завдання.

Обмеження:

• Ви не можете використовувати масиви.
• Ви не можете використовувати рядки.
• Заміна RTL немає ( &#8238)

Окуляри брауні за використання творчої арифметики.

Оскільки це конкурс на популярність, я пропоную не використовувати %оператор modulo ( ) у своєму коді.

Про провідні нулі:

Якщо вхід:

12340

Тоді вихід:

4321

було б прийнятним.

Математика, без модуля!

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__

Брейнфук

В основному, це лише програма, що реверсує вхід.

,[>,]<[.<]

UPD: Як в коментарях вказував Сильстер , у класичних інтерпретаторах / компіляторах Brainfuck (без можливості переходу ліворуч від нульової точки в масиві пам'яті) ця програма не працюватиме за відсутності ">" на початку, тому більш стабільною версія така:

>,[>,]<[.<]

Хаскелл

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

EDIT : Оскільки є пропозиція не використовувати %оператор, я зараз використовую невелику хитрість.

Я знаю, що це не кодовий гольф, але немає причин продовжувати його.

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

Ще одна реалізація 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);
}

Немає рядків, масивів, модулів чи поділів. Натомість ділення шляхом повторного віднімання.

Математика

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

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}

EDIT : Додано прокладку з трьох нулів, оскільки вона TextRecogniseпрацює правильно лише з цілими числами> 999.

Луа

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.

Гольф:

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

EDIT: Щойно побачив редагування модуля.

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

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

Це те, що я придумав, без рядків, без масивів ... Навіть змінних (на 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

ЧЕРТИ

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

: 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

Пітон 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)