Contexte

Le nombre 1729 est le nombre Hardy-Ramanujan. Une propriété étonnante en a été découverte par S. Ramanujan (qui est largement considéré comme le plus grand mathématicien indien ¹ ), lorsque GH Hardy lui a rendu visite dans un hôpital. Dans les propres mots de Hardy:

Je me souviens être allé le voir une fois quand il était malade à Putney. J'étais monté dans la cabine de taxi numéro 1729 et j'ai remarqué que le numéro me semblait plutôt terne et que j'espérais que ce n'était pas de mauvais augure. "Non," répondit-il, "c'est un nombre très intéressant; c'est le plus petit nombre exprimable comme la somme de deux cubes de deux manières différentes."

En plus de cela, il a de nombreuses autres propriétés étonnantes. L'une de ces propriétés est qu'il s'agit d'un nombre Harshad, c'est-à-dire que la somme de ses chiffres (1 + 7 + 2 + 9 = 19) en est un facteur. Cela aussi, spécial. Comme l'a montré Masahiko Fujiwara, 1729 est un entier positif qui, lorsque ses chiffres sont additionnés, produit une somme qui, multipliée par son inversion, donne le nombre d'origine:

1 + 7 + 2 + 9 = 19

19 × 91 = 1729

Un entier positif ayant un tel bien est ce que je définirais comme Hardy-Ramanujan- de Harshad Nombre, dans le but de ce post. (Il pourrait y avoir un terme technique pour cela, mais je ne l'ai pas trouvé, à moins qu'il ne soit membre de A110921 )

La tâche

Etant donné un entier positif ncomme entrée, la sortie d' une valeur de truthy ou Falsey sur la base de si l'entrée nest une Hardy-Ramanujan- de Harshad Nombre. Sortie véridique, si elle l'est. Sinon, sortez falsey.

Notez que seulement quatre Hardy-Ramanujan- ish nombre harshad existent ( 1, 81, 1458et 1729), et vous pouvez écrire du code qui vérifie l' équivalence avec eux. Mais je ne pense pas que ce sera amusant.

Contribution

Votre programme doit prendre un entier positif (un nombre naturel, en d'autres termes). Il peut le prendre de n'importe quelle manière sauf en supposant qu'il soit présent dans une variable. La lecture à partir de la fenêtre modale, de la zone de saisie, de la ligne de commande, du fichier, etc. est autorisée. Prendre l'entrée comme argument de fonction est également autorisé.

Production

Votre programme doit afficher une valeur true ou falsey. Ils n'ont pas besoin d'être cohérents. Votre programme peut sortir de n'importe quelle façon sauf écrire la sortie dans une variable. L'écriture sur l'écran, la ligne de commande, le fichier, etc. est autorisée. La sortie avec fonction returnest également autorisée.

Règles supplémentaires

• Vous ne devez pas utiliser un intégré pour accomplir la tâche (je me demande si n'importe quelle langue aura un tel intégré, mais Mathematica ... )

• Les échappatoires standard s'appliquent.

Cas de test

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

Critère gagnant

C'est du code-golf , donc le code le plus court en octets gagne!

¹ _{Chaque année, le 22 ^e Décembre, l'anniversaire de Srinivasa Ramanujan, la Journée nationale des mathématiques est observée en Inde. Ses collègues, ceux de Cambridge, le comparaient à Jacobi, Euler et même Newton. En plus d'être si grand, il n'avait presque aucune formation formelle en mathématiques pures , mais il a quand même apporté d'importantes contributions à l'analyse mathématique , à la théorie des nombres , aux séries infinies et aux fractions continues . Malheureusement, il est décédé à un âge précoce de 32 ans avec des milliers de découvertes mathématiques à l'esprit. Un film a également été réalisé sur lui, basé sur sa biographie ,L'homme qui connaissait l'infini .}

Neim , 5 octets

𝐬D𝐫𝕋𝔼

Explication:

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

Essayez!

ArnoldC, 888 octets

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

Je sais, je vérifie juste l'égalité, mais cela ne devrait pas être la partie amusante du programme.

Bonne lecture. :)

Ajout de quelques nouvelles lignes pour une meilleure lisibilité:

Essayez-le en ligne

Assemblage x86, 55 35 33 31 octets:

Suppose un ABI où la valeur de retour est en EAX et les paramètres sont poussés sur la pile ... donc presque tous.

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 octets

ẹ+S↔;S×?

Essayez-le en ligne!

Haskell , 56 55 octets

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

Essayez-le en ligne!

Sans point: (56 octets)

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

Essayez-le en ligne!

Ennuyeux: (24 octets)

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

Essayez-le en ligne!

JavaScript ES6, 59 57 octets

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

Essayez-le en ligne!

Se divise fondamentalement en tableau de chiffres, et se joint à +et évalue cette expression pour sommer essentiellement les chiffres. string*stringconvertira automatiquement les chaînes en pouces. Prend l'entrée sous forme de chaîne

Mathematica, 42 octets

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

Rubis, 69 octets

Essayez d'abord, avec un entier comme entrée:

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

Deuxième essai, avec une chaîne en entrée:

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

Lot, 164 octets

@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 cas de succès, aucune sortie en cas d'échec.

JavaScript (ES6), 72 octets

Il s'agit d'une soumission ES6 valide. Ajoutez f=au début et invoquez comme f(arg).

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

Extrait de test:

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, 111 108 octets

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

Essayez-le en ligne!

Comme c'est généralement le cas pour les solutions JVM compilées statiquement, beaucoup d'octets sont perdus uniquement sur la déclaration de la fonction principale et l'appel à print (). La fonction de la fonction est de 60 octets, ce qui n'est pas mal du tout pour un langage à usage général typé comme Kotlin.

Kotlin, solution ennuyeuse, 69 octets

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

Essayez-le en ligne!

05AB1E , 5 octets

SOÂ*Q

Essayez-le en ligne!

Python 2 , 55 octets

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

Essayez-le en ligne!

Explication

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

Une eval()solution est un peu plus longue de 2 octets ...

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

Solution alternative (non valide?) , 42 29 octets

Cette solution vérifie l'égalité par rapport à tous les nombres.

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

Essayez-le en ligne!

Cheddar , 60 octets

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

Essayez-le en ligne!

NewStack , 16 octets

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

La répartition:

Utiliser 1729 comme exemple

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

N'imprime rien si faux et l'entrée d'origine si vrai.

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 - transformez cela en chaîne, retournez-le de gauche à droite

U - transformer cela en un nombre

* - multiplier les deux dernières valeurs (la somme des chiffres et sa version inversée de gauche à droite)

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

Japt, 8 bytes

¬x
*sÔ¥N

Run it online

Jelly, 8 bytes

DS×ṚḌ$$=

Try it online!

Perl 6, 30 bytes

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

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!

APL (Dyalog), 18 bytes

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

Try it online!

Pari/GP, 56 52 bytes

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

Try it online!

MathGolf, 5 bytes

Σ_x*=

Try it online!

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