La forma más creativa de revertir un entero positivo [cerrado]

40

Proporcionó una entrada como un entero sin signo:

13457

Su función / subrutina debería devolver:

75431

Dado que este es un concurso de popularidad, sea creativo. Las soluciones creativas utilizan técnicas inusuales o ingeniosas para lograr la tarea dada.

Restricciones:

  • No puedes usar matrices.
  • No puedes usar cadenas.
  • Sin anulación de RTL ( &#8238)

Brownie señala por usar aritmética creativa.

Como se trata de un concurso de popularidad, sugiero no usar el %operador modulo ( ) en su código.

Acerca de los ceros a la izquierda:

Si la entrada es:

12340

Entonces la salida:

4321

Sería aceptable.

duci9y
fuente
1
¿Es un duplicado de codegolf.stackexchange.com/questions/2823/… ?
microbio
3
@microbian No, ese fue code-golf. Este es un concurso de popularidad.
Victor Stafusa
2
Las personas estarán marcadas si comienzas a cambiar las reglas ahora. Parece que me está yendo bien, solo ejecuta tu próximo desafío a través del sandbox primero: meta.codegolf.stackexchange.com/questions/1117/…
Hosch250
2
¿Qué pasa si 1230es la entrada? ¿Se nos permite salir 321? (De lo contrario, las cadenas son necesarias).
Justin
2
Estoy votando para cerrar esto como fuera de tema porque carece de un criterio de validez objetivo: "ser creativo" es subjetivo.
Mego

Respuestas:

49

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

Vamos a desglosarlo.

Primero usamos algunos "aritmética creativa" para averiguar cuántos dígitos hay en el número: length = Ceiling[Log[10, n]];

A continuación, rasterizamos el número a una bonita imagen grande:

tocar la bocina gran número rasterizado

Ahora consultamos el cuadro delimitador de esa imagen y llenamos el ancho y la altura (en realidad, utilizando el desplazamiento de la línea de base en lugar de la altura de la imagen, porque MM agrega algunos espacios en blanco debajo de la línea de base en la imagen).

A continuación, NestList resta de manera recursiva el ancho de la imagen dividido por la longitud de la cadena para permitir que ImageTake extraiga los caracteres del final de la imagen uno por uno, y ImageAssemble los vuelve a ensamblar a esta imagen:

tocar la bocina gran número invertido

Luego lo pasamos a la función TextRecognize para el reconocimiento óptico de caracteres, que con este tamaño de imagen y calidad de rasterización es capaz de reconocer impecablemente la salida final y darnos el número entero:

72641

Logaritmos y OCR: ¡es como el chocolate y la mantequilla de maní!

Nuevo y mejorado

Esta versión rellena el número para tratar el comportamiento obstinado de TextRecognize con números pequeños, y luego resta el pad al final. ¡Esto incluso funciona para números de un solo dígito!

Sin embargo, por qué ejecutarías una rutina inversa en un solo número es un misterio para mí. Pero solo en aras de la exhaustividad, incluso lo hice funcionar para entradas de cero y uno, que normalmente se romperían porque el registro de piso no devuelve 1 para ellos.

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
Jonathan Van Matre
fuente
2
Gáname a eso. ¡Tienes mi voto! [pero iba a usar C #]
HL-SDK
1
TextRegognizeno funciona para números pequeños. Y tienes un error tipográfico height = b[[3]];. ¡También revisa mi respuesta también, por favor! :)
swish
Otro problema con TextRecognize, es que devuelve una cadena, que no está permitida y también debe convertirla de nuevo en número.
swish
Gracias por detectar el error tipográfico ... Estaba haciendo que los nombres de las variables fueran más fáciles de leer antes de enviarlos y me perdí uno. También arrojó el ToExpression faltante. Y publiqué una revisión que aborda el problema de los números pequeños hasta los dígitos individuales.
Jonathan Van Matre
Wow ... eso es elaborado!
duci9y
39

Perl / LuaTeX / Tesseract

El siguiente script de Perl lee el número como argumento de línea de comando, por ejemplo:

    1234567890

El siguiente script de Perl imprime el número a través de LuaTeX. Se crea una fuente virtual sobre la marcha que refleja los dígitos horizontalmente.

temp0.png

Luego, el número entero se refleja nuevamente horizontalmente:

temp1.png

La imagen final se vuelve a leer a través de 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__
Heiko Oberdiek
fuente
66
+1 para TeX. ¡Necesitamos más respuestas de TeX!
Jonathan Van Matre
25

Brainfuck

Básicamente, es solo un programa de inversión de entrada.

,[>,]<[.<]

UPD: Como Sylwester señaló en los comentarios, en los compiladores / intérpretes clásicos de Brainfuck (sin posibilidad de ir a la izquierda desde el punto cero en la matriz de memoria) este programa no funcionaría en ausencia de '>' al principio, por lo que el más estable la versión es:

>,[>,]<[.<]
Danek
fuente
44
El programa Bf más corto que he visto. Además, muy ordenado.
Nit
2
Sin un >comienzo para hacer una celda cero antes de los datos, esto no funcionará en muchos intérpretes / compiladores.
Sylwester
1
@Danek es cierto, todas las celdas se inicializan a cero y lo primero que debe hacer es leer el primer dígito en la primera celda. [.<]no tiene celda cero para detenerse debido a eso y fallará. Error de bf -n rev1.bfes Error: Out of range! Youwanted to '<' below the first cell.. Si compilas obtienes un segfaultquizás.
Sylwester
3
1 también incluso si BF es todo acerca de las matrices así que no estoy seguro de que se ajuste a la regla No usar arsenal
Michael M.
1
@Nit echo es mucho más corto:,[.,]
Cruncher
20

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

Sin matrices, cadenas o módulos.

Además, sé que se supone que no debemos usar listas o cadenas, pero me encanta lo breve que es cuando haces eso:

reverseNumber :: Integer -> Integer
reverseNumber = read . reverse . show
David Sanders
fuente
2
Un grupo de clientes habituales había maximizado su votación del día, así que tengan paciencia. :)
Jonathan Van Matre
19

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;
}
Ali Alavi
fuente
1
Sería más ?:
genial
@mniip Buena idea
Ali Alavi
+ 1 brillante. Ojalá hubiera más votos a favor.
duci9y
Felicitaciones por atrapar el caso de desbordamiento.
Jonathan Van Matre
18

Supongo que alguien tiene que ser el fiestero.

Golpetazo

$ rev<<<[Input]

 

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

Las limitaciones de tamaño dependen de su caparazón, pero estará bien dentro de lo razonable.

Liendre
fuente
2
bien jugado señor. bien jugado
usuario
44
¿Cómo es que no es una cuerda?
No es que Charles
1
Esto podría ser una cadena. ¿Estás seguro de que bash toma la entrada como números enteros cuando es posible?
duci9y
3
Todo es una cadena en Bash a menos que se declare lo contrario, por ejemplo declare -i. Comparar foo=089y declare -i foo=089(número octal no válido).
l0b0
3
Según el comentario de @ l0b0, esta respuesta no es válida.
duci9y
15

Javascript

EDITAR : ya que hay una sugerencia para no usar% operador, ahora uso un pequeño truco.

Sé que este no es un código de golf, pero no hay razón para hacerlo más largo.

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

r(13457) devoluciones 75431

Además, es mucho más rápido que el método de cadena ( n.toString().split('').reverse().join('')):

ingrese la descripción de la imagen aquí

==> Informe JSPerf <==

Michael M.
fuente
2
¿Qué pasa con el uso en ~~lugar de Math.floor?
Victor Stafusa
Sí, eso sería más corto, pero menos comprensible.
Michael M.
2
¿No es este el método de reversión de enteros del libro de texto? Creo que he escrito este algoritmo para la tarea.
user2357112 es compatible con Monica
Al igual que con el comentario anterior, este es solo el algoritmo de inversión de enteros estándar. Por lo que puedo ver, la parte creativa es solo el uso de en ~~lugar de Math.floor(el cambio sugerido por @Victor)
Bertie Wheen
+1 para pruebas de rendimiento. Todas las grandes mentes creativas realizan pruebas de rendimiento temprano y con frecuencia. : D
Jonathan Van Matre
10

Pitón

No estoy seguro si esta implementación califica para matemática creativa

Además,% operator no se usó per se, aunque uno podría argumentar que divmod hace lo mismo, pero luego la pregunta debe reformularse :-)

Implementación

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

manifestación

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

¿Como funciona?

Esta es una solución recursiva divmod * Esta solución determina el dígito menos significativo y luego lo empuja al final del número. *

Otra implementación de 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

¿Como funciona?

Esta es una solución recursiva que intercambia los dígitos extremos del número

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

Ejecución de ejemplo

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
Abhijit
fuente
Lo hace. +5 puntos de brownie .
duci9y
@downvoter: ¿Puedes responder qué está mal con esta respuesta?
Abhijit
usted, señor, merece mi
aprobación
9

Solo para ser contrario, un uso excesivo del operador de módulo:

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

Tenga en cuenta que esto siempre invierte 5 dígitos, y los enteros de 32 bits se desbordarán para valores de entrada superiores a 39045.

señal de neón
fuente
8

DO#

Aquí hay una manera de hacerlo sin el %operador Modulus ( ) y simplemente aritmética simple.

int x = 12356;
int inv = 0;
while (x > 0)
{
    inv = inv * 10 + (x - (x / 10) * 10);
    x = x / 10;
}
return inv;
davidsbro
fuente
Tienes un módulo, simplemente lo definiste tú mismo.
Benjamin Gruenbaum
Si lo se. Se supone que no debemos usar el %operador. :) Pero entiendo lo que quieres decir, mi texto fue un poco engañoso.
davidsbro
7

Golpetazo

> fold -w1 <<<12345 | tac | tr -d '\n'
54321
Nik O'Lai
fuente
6

do

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

Sin cadenas, matrices, módulo o división. En cambio, división por sustracción repetida.

David Conrad
fuente
6

Mathematica

Hacer una imagen fuera del número, reflejarla, dividirla en dígitos Entonces hay dos alternativas:

  1. Compare cada imagen de un dígito reflejado con imágenes preparadas anteriormente, reemplácela con el dígito correspondiente y construya el número a partir de esto.

  2. Refleje cada dígito por separado, construya una nueva imagen y páselo a la función de reconocimiento de imagen.

Hice ambas

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}

EDITAR : Se agregó relleno de tres ceros, porque TextRecognisefunciona correctamente solo con enteros> 999.

silbido
fuente
Felicitaciones por la doble reflexión. Todo buen programador debe usar la reflexión siempre que sea posible. ;-) Sin embargo, su primer método no funciona para su ejemplo en mi sistema en MM9.
Jonathan Van Matre
Eso sí que es creativo.
David Sanders
Obtuve los mejores resultados alternando 9 y 4 en mi pad (todos los 9 o todos los 1 tendían a ocasionar fallas ocasionales de OCR), pero eso probablemente se deba a la diferencia en las fuentes.
Jonathan Van Matre
5

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

No se utilizan matrices ni cadenas. El número se divide en dígitos y se vuelve a ensamblar utilizando la lista de argumentos.

mniip
fuente
Lua no tiene matrices de todos modos. Tiene tablas: P De lo contrario, los varargs son matrices
Nowayz
@Nowayz Tiene tablas que pueden parecerse a matrices. Por eso no se me permite usarlos. Y los varargs no son matrices: P
mniip
¡Pero lo estás usando %! : P
ntoskrnl
5

Python2

Asume que "entero sin signo" es de 32 bits

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

Cuando se le da entrada 1230, sale 0321.

barra de pastebin.com 0mr8spkT
fuente
Acabo de ver la edición del operador de módulo ... ¿debería eliminar esta publicación?
pastebin.com slash 0mr8spkT
77
No creo que deba eliminarlo, porque es una sugerencia para no usarlo, no una regla:"Since this is a popularity contest, I suggest not using the modulus (%) operator in your code."
ProgramFOX
Además de esa enorme declaración si es prácticamente el arte ASCII.
Jonathan Van Matre
4

Posdata

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

Sin matrices, sin cadenas, sin variables.

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

Lo mismo sin mod(que es solo un atajo, así que no hay gran diferencia):

/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
usuario2846289
fuente
4

DO#

Esto no utiliza cadenas ni matrices, pero sí utiliza el Stack<T>tipo .NET (EDITAR: operador de módulo utilizado originalmente; ahora eliminado)

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;
    }
}
Edmund Schweppe
fuente
4

do

En ese sentido, la solución obvia está representada en un par de otros idiomas, también podría publicarse en C.

Golfizado:

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

Sin golf:

#include <stdio.h>

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

EDITAR: acabo de ver la edición del módulo.

Golfizado (sin módulo):

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

Sin golf (sin módulo):

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

Java

Esto es lo que se me ocurrió, sin cadenas, sin matrices ... ni siquiera variables (en Java, me importa):

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

EDITAR Una versión más legible

/** 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;
}
oiZo
fuente
Haga que su código sea más legible, esto no es código golf. Gracias.
duci9y
1
Este es mi primer intento, espero que la versión actualizada sea mejor :-)
oiZo
Sí lo es. Gracias. Bienvenido a Code Golf. Yo también soy nuevo. :)
duci9y
3

Potencia Shell

Una solución rápida en PowerShell. No se utilizan matrices ni cadenas, ya sea implícita o explícitamente.

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

Pruebas:

PS > rev(13457)
75431

PS > rev(rev(13457))
13457
microbiano
fuente
3

Python (hecho fácilmente en ensamblaje)

Invierte los bits de un byte. ¿Puntos por no hacer exactamente lo mismo que todos los demás?

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

ejemplo

byte: 10101010
01010101
qwr
fuente
1
¿Funcionaría para la entrada de muestra para producir la salida de muestra?
duci9y
3

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

SALIDA

Tres ejecuciones de muestra
ingrese la descripción de la imagen aquí

Prueba con ceros

ingrese la descripción de la imagen aquí

¡También invierte números flotantes!

ingrese la descripción de la imagen aquí

Si desea ejecutar este código , ejecútelo en su computadora porque crea un archivo temporal durante su tiempo de ejecución y no estoy seguro de si los compiladores en línea harían un archivo temporal en su computadora

Mukul Kumar
fuente
¿No está escribiendo en un archivo convirtiéndolo en una cadena?
duci9y
string es una combinación de caracteres con un carácter nulo al final, por lo que no es una cadena sino solo una combinación de caracteres
Mukul Kumar
Una cadena es una secuencia de caracteres. Lo sentimos, pero esta respuesta no cumple con las restricciones.
duci9y
su definición de cadenas es incorrecta, vaya a este sitio web ( cs.stmarys.ca/~porter/csc/ref/c_cpp_strings.html ) y lea el último párrafo detenidamente. La cadena es una combinación de caracteres TERMINADOS CON '\ 0'
Mukul Kumar
1
Lo siento, estás hablando de cuerdas C. Estoy hablando de cuerdas en general. Tu respuesta no califica.
duci9y
2

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
}

Luego:

  • reverse(12345) salidas 54321
  • reverse(3240) salidas 423
  • reverse(6342975) salidas 5792436
MT0
fuente
2

Fisión

$SX/
\S?L
K\O

Este programa invierte la entrada.

$ echo -n '12345' | fsn tac.fsn
54321
C0deH4cker
fuente
1
Simplemente pasaste por alto el "¿Existía el lenguaje de programación antes de que se hiciera la pregunta?" prueba en este caso. La fisión parece una entrada genial al mundo de esolang, algo así como "Befunge en ácido con un estante lleno de libros de física de partículas". ¡Agradable!
Jonathan Van Matre
2

ADELANTE

Creo que esto es lo opuesto a lo popular ... pero usar Forth siempre es creativo ...

Vamos a crear una nueva palabra.

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

Aquí, usa la palabra U / que devuelve el resto y el cociente, el resto se envía a la salida como número dentro de un campo de 1 carácter de largo, hasta que el dividendo sea cero. No se utiliza ninguna cadena, al menos hasta que se envíe algo al video. No uso un operador de módulo, en su lugar uso la división de enteros con resto y cociente. Intentemos

12345 REV 54321
ok

Emulador ZX Spectrum

Mattsteel
fuente
¿Dónde consigo ese emulador?
gato
World of Spectrum tiene muchos emuladores listados aquí worldofspectrum.org/emulators.html
Mattsteel
2

Código de máquina de Turing

Usando la sintaxis de aquí.

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

Pruébalo en línea!

SuperJedi224
fuente
1

Pitón

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))
Jayanth Koushik
fuente
rev(1230)da 321. Supongo que realmente debería dar 0321?
pastebin.com slash 0mr8spkT
¿Es eso incorrecto? Si solo estamos tratando con números, no con cadenas, entonces 0321 y 321 son equivalentes, ¿verdad?
Jayanth Koushik
Debe ser 321 a mi entender. La pregunta no permitía el uso de cadenas. Entonces debería ser 321.
microbio
No sé ... esperando la respuesta del OP. Solo estoy señalando esto, no digo que esté mal. Perdón por la confusion.
pastebin.com slash 0mr8spkT
Actualicé la pregunta.
duci9y
1

do

#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;
}
usuario17901
fuente
1

Lote

Perdí la parte de no usar cuerdas, oh, bueno.

@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
carne sin carne
fuente
1

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)
vanchagreen
fuente