Antecedentes

El número 1729 es el número Hardy-Ramanujan. S. Ramanujan (quien es ampliamente considerado como el mejor matemático indio ¹ ) descubrió una propiedad sorprendente cuando GH Hardy lo visitó en un hospital. En las propias palabras de Hardy:

Recuerdo que una vez lo vi cuando estaba enfermo en Putney. Había viajado en el taxi número 1729 y comentó que el número me parecía bastante aburrido, y que esperaba que no fuera un presagio desfavorable. "No", respondió, "es un número muy interesante; es el número más pequeño expresable como la suma de dos cubos de dos maneras diferentes".

Además de eso, tiene muchas otras propiedades increíbles. Una de esas propiedades es que es un número Harshad, es decir, la suma de sus dígitos (1 + 7 + 2 + 9 = 19) es un factor de ello. Eso también, uno especial. Como demostró Masahiko Fujiwara, 1729 es un número entero positivo que, cuando se suman sus dígitos, produce una suma que, cuando se multiplica por su inversión, produce el número original:

1 + 7 + 2 + 9 = 19

19 × 91 = 1729

Un número entero positivo que tiene dicha propiedad es lo que defino como Hardy-Ramanujan- ish Número Harshad, para el propósito de este post. (Puede haber un término técnico para ello, pero no podría encontrarlo, a menos que sea miembro de A110921 )

La tarea

Dado un número entero positivo ncomo entrada, la salida de un valor Truthy o Falsey en función de si la entrada nes una de Hardy-Ramanujan- ish Número Harshad. Salida de verdad, si es así. De lo contrario, salida falsey.

Tenga en cuenta que sólo cuatro de Hardy-Ramanujan- ish existen número de harshad ( 1, 81, 1458y 1729), y se puede escribir código que comprueba la equivalencia con ellos. Pero no creo que sea divertido.

Entrada

Su programa debe tomar un número entero positivo (un número natural, en otras palabras). Puede tomarlo de cualquier manera, excepto suponiendo que esté presente en una variable. Se permite la lectura desde la ventana modal, cuadro de entrada, línea de comando, archivo, etc. Tomar entrada como argumento de función también está permitido.

Salida

Su programa debe generar un valor verdadero o falso. No necesitan ser consistentes. Su programa puede generar cualquier salida, excepto escribir la salida en una variable. Se permite escribir en la pantalla, línea de comando, archivo, etc. La salida con función también returnestá permitida.

Reglas Adicionales

• No debe utilizar una función integrada para realizar la tarea (me pregunto si algún idioma tendrá esa función, pero luego Mathematica ... )

• Se aplican lagunas estándar .

Casos de prueba

Input        Output
1            Truthy (because 1 × 1 (reverse of 1) = 1)
2            Falsey
3            Falsey
4            Falsey
5            Falsey
81           Truthy (because 9 (8 + 1) × 9 (reverse of 9) = 81)
1458         Truthy (because 18 (1 + 4 + 5 + 8) × 81 (reverse of 18) = 1458)
1729         Truthy (because 19 (1 + 7 + 2 + 9) × 91 (reverse of 19) = 1729)
1730         Falsey
2017         Falsey

Criterio ganador

Este es el código de golf , por lo que gana el código más corto en bytes.

¹ _{Cada año, el 22 ^º de diciembre, el cumpleaños de Srinivasa Ramanujan, Día Nacional de Matemáticas se observa en la India. Sus colegas, los de Cambridge, lo compararon con Jacobi, Euler e incluso Newton. Además de ser tan bueno, casi no tenía entrenamiento formal en Matemática Pura , pero aun así, hizo importantes contribuciones al análisis matemático , la teoría de números , las series infinitas y las fracciones continuas . Desafortunadamente, murió a la temprana edad de 32 años con miles de descubrimientos matemáticos en su mente. También se hizo una película sobre él, que se basó en su biografía ,El hombre que conocía el infinito .}

Neim , 5 bytes

𝐬D𝐫𝕋𝔼

Explicación:

Example input: 1729
𝐬      Implicitly convert to digit list and 𝐬um the digits [19]
 D     Duplicate [19, 19]
  𝐫    𝐫everse [19, 91]
   𝕋   mul𝕋iply [1729]
    𝔼  check for 𝔼quality with input [1]
Implicit output: 1

¡Intentalo!

ArnoldC, 888 bytes

IT'S SHOWTIME
HEY CHRISTMAS TREE i
YOU SET US UP 0
GET YOUR ASS TO MARS i
DO IT NOW
I WANT TO ASK YOU A BUNCH OF QUESTIONS AND I WANT TO HAVE THEM ANSWERED IMMEDIATELY
HEY CHRISTMAS TREE a
YOU SET US UP 0
GET TO THE CHOPPER a
HERE IS MY INVITATION 1
YOU ARE NOT YOU YOU ARE ME i
ENOUGH TALK
HEY CHRISTMAS TREE b
YOU SET US UP 0
GET TO THE CHOPPER b
HERE IS MY INVITATION 81
YOU ARE NOT YOU YOU ARE ME i
ENOUGH TALK
HEY CHRISTMAS TREE c
YOU SET US UP 0
GET TO THE CHOPPER c
HERE IS MY INVITATION 1458
YOU ARE NOT YOU YOU ARE ME i
ENOUGH TALK
HEY CHRISTMAS TREE d
YOU SET US UP 0
GET TO THE CHOPPER d
HERE IS MY INVITATION 1729
YOU ARE NOT YOU YOU ARE ME i
ENOUGH TALK
HEY CHRISTMAS TREE res
YOU SET US UP 0
GET TO THE CHOPPER res
HERE IS MY INVITATION a
CONSIDER THAT A DIVORCE b
CONSIDER THAT A DIVORCE c
CONSIDER THAT A DIVORCE d
ENOUGH TALK
TALK TO THE HAND res
YOU HAVE BEEN TERMINATED

Lo sé, solo verifico la igualdad, pero esa no debería ser la parte divertida del programa.

Disfruta leyéndolo. :)

Se agregaron algunas líneas nuevas para facilitar la lectura:

Pruébalo en línea

Conjunto x86, 55 35 33 31 bytes:

Asume un ABI donde el valor de retorno está en EAX y los parámetros se insertan en la pila ... así que casi todos ellos.

00000000: 8B 44 24 04        mov         eax,dword ptr [esp+4]
00000004: 48                 dec         eax
00000005: 74 16              je          0000001D
00000007: 83 E8 50           sub         eax,50h
0000000A: 74 11              je          0000001D
0000000C: 2D 61 05 00 00     sub         eax,561h
00000011: 74 0A              je          0000001D
00000013: 2D 0F 01 00 00     sub         eax,10Fh
00000018: 74 03              je          0000001D
0000001A: 33 C0              xor         eax,eax
0000001C: C3                 ret
0000001D: 40                 inc         eax
0000001E: C3                 ret

Brachylog , 8 bytes

ẹ+S↔;S×?

Pruébalo en línea!

Haskell , 56 55 bytes

f n|m<-sum$read.pure<$>show n=n==m*(read.reverse.show)m

Pruébalo en línea!

Punto libre: (56 bytes)

(==)<*>((*)=<<read.reverse.show).sum.map(read.pure).show

Pruébalo en línea!

Aburrido: (24 bytes)

(`elem`[1,81,1458,1729])

Pruébalo en línea!

JavaScript ES6, 59 57 bytes

x=>(q=eval([...x].join`+`)+'')*[...q].reverse().join``==x

Pruébalo en línea!

Básicamente se divide en una matriz de dígitos, y se une +y evalúa esa expresión para sumar básicamente los dígitos. string*stringconvertirá automáticamente cadenas en int. Toma la entrada como una cadena

Mathematica, 42 bytes

(s=Tr@IntegerDigits@#)IntegerReverse@s==#&

Rubí, 69 bytes

Primer intento, con un entero como entrada:

->i{(x=i.to_s.split'').inject(0){|s,a|s+a.to_i}*(x[-1]+x[0]).to_i==i}

Segundo intento, con una cadena como entrada:

->i{(x=i.split('').map &:to_i).inject(0,&:+)*(x[-1]*10+x[0])==i.to_i}

Lote, 164 bytes

@set/an=%1,s=0
:s
@set/as+=n%%10,n/=10
@if %n% gtr 0 goto s
@set/an=s,r=0
:r
@set/ar=r*10+n%%10,n/=10
@if %n% gtr 0 goto r
@set/an=%1-r*s
@if %n%==0 echo 1

Imprime 1 en caso de éxito, sin salida en caso de error.

JavaScript (ES6), 72 bytes

Esta es una presentación válida de ES6. Agregue f=al principio e invoque como f(arg).

n=>(y=[...`${n}`].reduce((c,p)=>+c+ +p))*[...`${y}`].reverse().join``==n

Fragmento de prueba:

let f =

n=>(y=[...`${n}`].reduce((c,p)=>+c+ +p))*[...`${y}`].reverse().join``==n

console.log(1 + " -> " + f(1))
console.log(81 + " -> " + f(81))
console.log(1458 + " -> " + f(1458))
console.log(1729 + " -> " + f(1729))
console.log((randomNum = Math.floor(Math.random() * 10000) + 1) + " -> " + f(randomNum))

Kotlin, 111108 bytes

fun main(a:Array<String>)=print(a[0].sumBy{c->"$c".toInt()}.run{"${this*"$this".reversed().toInt()}"}==a[0])

Pruébalo en línea!

Como es típico en las soluciones JVM compiladas estáticamente, se pierden muchos bytes solo en la declaración de la función principal y llamando a print (). La carne de la función es de 60 bytes, lo que no está nada mal para un lenguaje de tipo estático de propósito general como Kotlin.

Kotlin, solución aburrida, 69 bytes

fun main(a:Array<String>)=print(a[0].toInt()in setOf(1,81,1458,1729))

Pruébalo en línea!

05AB1E , 5 bytes

SOÂ*Q

Pruébalo en línea!

Python 2 , 55 bytes

def f(n):x=sum(map(int,`n`));return x*int(`x`[::-1])==n

Pruébalo en línea!

Explicación

def f(n):                           # define a function f that takes an argument n
    x = sum(                        # assign to x the sum of...
            map(int, `n`))          # ...the integer conversion of all elements in stringified n
    return x * int(                 # return True if x times the integer conversion of...
                   `x`[::-1])       # ...the stringified x reversed...
                              == n  # ...equals n

Una eval()solución es un bit 2 bytes más larga ...

def f(n):x=eval('+'.join(`n`));return x*int(`x`[::-1])==n

Solución alternativa (¿no válida?) , 42 29 bytes

Esta solución verifica la igualdad contra todos los números.

lambda n:n in[1,81,1458,1729]

Pruébalo en línea!

Cheddar , 60 bytes

(n,g=x->x?g(x/10|0)+x%10:0)->n==g(n)*number::("%d"%g(n)).rev

Pruébalo en línea!

NewStack , 16 bytes

ḟᵢ¹f YΣ©Eᴙx| ∏=f

El desglose:

Usando 1729 como ejemplo

ḟᵢ                 Define new function equal to input.               []
  ¹                Add 1 to stack.                                   [1]
   f               Multiply stack by the function.                   [1729]
     Y             Split the stack into digits.                      [1,7,2,9]
      Σ            Sum the stack.                                    [19]
       ©           Duplicate stack.                                  [19,19]
        E  |       Define new value for the first element            [19,19]
         ᴙx        Reverse first element.                            [91,19]
             ∏     Take the product.                                 [1729]
              =f   Remove from stack if not equal to the function.   [1729]

No imprime nada si es falso, y la entrada original si es verdadero.

MATL , 11 bytes

tV!UstVPU*=

Pruébalo en línea!

t - tomar entrada y duplicarla

V!U - dividirlo en dígitos individuales

s - suma esos dígitos

t - duplicar esa suma

VP - Conviértalo en una cuerda, gírelo de izquierda a derecha

U - convertir eso de nuevo en un número

* - multiplique los dos últimos valores (la suma de dígitos y su versión invertida de izquierda a derecha)

= - verifique si esto es igual a la entrada original (que es el único otro valor en la pila)

Japt, 8 bytes

¬x
*sÔ¥N

Ejecútalo en línea

Jalea , 8 bytes

DS×ṚḌ$$=

Pruébalo en línea!

Perl 6 , 30 bytes

{my \n=sum .comb;$_==n*n.flip}

PHP , 52 bytes

<?=strrev($x=array_sum(str_split($argn)))*$x==$argn;

Pruébalo en línea!

PHP , 36 bytes

<?=in_array($argn,[1,81,1458,1729]);

Pruébalo en línea!

APL (Dyalog) , 18 bytes

{(⍵=⍎∘⌽×⍎)⍕+/⍎¨⍕⍵}

Pruébalo en línea!

Pari / GP , 56 52 bytes

n->n==(s=sumdigits(n))*fromdigits(Vecrev(digits(s)))

Pruébalo en línea!

MathGolf , 5 bytes

Σ_x*=

Pruébalo en línea!

Prácticamente lo mismo que la solución de Neim byte por byte.