Is this a Hardy-Ramanujan-Number-ish Harshad Number?

Question

Background

The number 1729 is the Hardy-Ramanujan number. An amazing property of it was discovered by S. Ramanujan (who is widely regarded as the greatest Indian mathematician¹), when G.H. Hardy paid a visit to him in a hospital. In Hardy's own words:

I remember once going to see him when he was ill at Putney. I had ridden in taxi cab number 1729 and remarked that the number seemed to me rather a dull one, and that I hoped it was not an unfavorable omen. "No," he replied, "it is a very interesting number; it is the smallest number expressible as the sum of two cubes in two different ways."

Besides that, it has many other amazing properties. One such property is that it's a Harshad Number, i.e the sum of its digits (1+7+2+9=19) is a factor of it. That too, a special one. As Masahiko Fujiwara showed, 1729 is a positive integer which, when its digits are added together, produces a sum which, when multiplied by its reversal, yields the original number:

1+7+2+9 = 19

19 × 91 = 1729

A positive integer having such property is what I define as Hardy-Ramanujan-ish Harshad Number, for the purpose of this post. (There might be a technical term for it, but I couldn't find it, unless it's member of A110921)

---

The Task

Given a positive integer n as input, output a truthy or falsey value based on whether the input n is a Hardy-Ramanujan-ish Harshad Number. Output truthy, if it is. Otherwise, output falsey.

Note that only four Hardy-Ramanujan-ish Harshad Numbers exist (1,81,1458 and 1729), and you can write code which checks for equivalence with them. But I don't think that will be fun.

---

Input

Your program should take a positive integer (a natural number, in other words). It may take it in any way except assuming it to be present in a variable. Reading from modal window, input box, command line, file etc. is allowed. Taking input as function argument is allowed as well.

---

Output

Your program should output a truthy or falsey value. They need not be consistent. Your program may output in any way except writing the output to a variable. Writing to screen, command line, file etc. is allowed. Outputting with function return is allowed as well.

---

Additional Rules

• You must not use a built-in to accomplish the task (I wonder any language will have such built-in, but then Mathematica...)

• Standard Loopholes apply.

---

Test Cases

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

---

Winning Criterion

This is code-golf, so the shortest code in bytes wins!

---

¹_{Every year, on 22^nd December, the birthday of Srinivasa Ramanujan, National Mathematics Day is observed in India. His colleagues, those in Cambridge, compared him to Jacobi, Euler, and even Newton. Besides being so great, he had almost no formal training in Pure Mathematics, but still, he made important contributions to mathematical analysis, number theory, infinite series, and continued fractions. Unfortunately, he died at an early age of 32 with thousands of mathematical discoveries in his mind. A film was also made on him, which was based on his biography, The Man Who Knew Infinity.}

Answer 1

Neim, 5 bytes

D

Explanation:

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

Try it!

Answer 2

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

I know, I just check for equality, but that shouldn't be the fun part of the program.

Enjoy reading it. :)

Added some newlines there for easier readability:

Try it online

Answer 3

x86 Assembly, 55 35 33 31 bytes:

Assumes an ABI where the return value is in EAX and parameters are pushed on the stack... so almost all of them.

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

Answer 4

Brachylog, 8 bytes

ẹ+S↔;S×?

Try it online!

Answer 5

Haskell, 56 55 bytes

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

Try it online!

---

Pointfree: (56 bytes)

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

Try it online!

---

Boring: (24 bytes)

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

Try it online!

Answer 6

JavaScript ES6, 59 57 bytes

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

Try it online!

Basically splits into digit array, and joins with + and evals that expression to basically sum the digits. string*string will automatically convert strings into ints. Takes input as a string

Answer 7

JavaScript (ES6), 72 bytes

This is valid ES6 submission. Add f= at the start and invoke like f(arg).

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

---

Test Snippet:

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

Answer 8

Mathematica, 42 bytes

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

Answer 9

Ruby, 69 Bytes

First try, with integer as input:

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

Second try, with string as input:

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

Answer 10

Batch, 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

Prints 1 on success, no output on failure.

Answer 11

Kotlin, 111 108 bytes

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

Try it online!

As is typical for statically compiled JVM solutions, a lot of bytes are lost on just the main function declaration and calling print(). The meat of the function is 60ish bytes, which is not bad at all for a general purpose statically typed language like Kotlin.

Kotlin, boring solution, 69 bytes

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

Try it online!

Answer 12

Python 2, 55 bytes

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

Try it online!

Explanation

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

An eval() solution is a bit 2 bytes longer...

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

Alternate (invalid?) solution, 42 29 bytes

This solution checks for equality against all of the numbers.

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

Try it online!

Answer 13

05AB1E, 5 bytes

SOÂ*Q

Try it online!

Answer 14

Cheddar, 60 bytes

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

Try it online!

Answer 15

NewStack, 16 bytes

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

The breakdown:

Using 1729 as example

ḟᵢ                 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]

Prints nothing if false, and the original input if true.

Answer 16

MATL, 11 bytes

tV!UstVPU*=

Try it online!

t - take input and duplicate it

V!U - split it into individual digits

s - sum those digits

t - duplicate that sum

VP - turn that into a string, flip it left to right

U - turn that back into a number

* - multiply the last two values (the digit-sum and its left-to-right flipped version)

= - check if this is equal to the original input (which is the only other value in stack)

Answer 17

Japt, 8 bytes

¬x
*sÔ¥N

Run it online

Answer 18

Jelly, 8 bytes

DS×ṚḌ$$=

Try it online!

Answer 19

PHP, 52 bytes

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

Try it online!

PHP, 36 bytes

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

Try it online!

Answer 20

Perl 6, 30 bytes

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

Answer 21

APL (Dyalog), 18 bytes

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

Try it online!

Answer 22

Pari/GP, 56 52 bytes

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

Try it online!

Answer 23

MathGolf, 5 bytes

Σ_x*=

Try it online!

Pretty much the same as the Neim solution byte for byte.