fundo

O número 1729 é o número Hardy-Ramanujan. Uma propriedade incrível foi descoberta por S. Ramanujan (que é amplamente considerado o maior matemático indiano ¹ ), quando GH Hardy o visitou em um hospital. Nas próprias palavras de Hardy:

Lembro-me de uma vez ir vê-lo quando estava doente em Putney. Eu tinha andado de táxi número 1729 e observei que o número me parecia um tanto monótono e que esperava que não fosse um presságio desfavorável. "Não", respondeu ele, "é um número muito interessante; é o menor número expressável como a soma de dois cubos de duas maneiras diferentes".

Além disso, possui muitas outras propriedades incríveis. Uma dessas propriedades é que é um número Harshad, ou seja, a soma de seus dígitos (1 + 7 + 2 + 9 = 19) é um fator disso. Isso também, um especial. Como Masahiko Fujiwara mostrou, 1729 é um número inteiro positivo que, quando seus dígitos são somados, produz uma soma que, quando multiplicada por sua reversão, produz o número original:

1 + 7 + 2 + 9 = 19

19 × 91 = 1729

Um número inteiro positivo tendo tal propriedade é o que eu defino como Hardy-Ramanujan- ish Harshad Número, para o propósito deste post. (Pode haver um termo técnico para ele, mas não consigo encontrá-lo, a menos que seja membro do A110921 )

A tarefa

Dado um número inteiro positivo ncomo entrada, um valor de saída truthy ou Falsey com base em se a entrada né um equilíbrio de Hardy-Ramanujan- ish Número Harshad. Saída de verdade, se for. Caso contrário, falsey de saída.

Note-se que apenas quatro Hardy-Ramanujan- ish existe número harshad ( 1, 81, 1458e 1729), e você pode escrever código que verifica equivalência com eles. Mas não acho que isso seja divertido.

Entrada

Seu programa deve ter um número inteiro positivo (um número natural, em outras palavras). Pode levar de qualquer maneira, exceto assumindo que ele esteja presente em uma variável. A leitura da janela modal, caixa de entrada, linha de comando, arquivo etc. é permitida. Tomar entrada como argumento de função também é permitido.

Resultado

Seu programa deve gerar um valor de verdade ou falsey. Eles não precisam ser consistentes. Seu programa pode produzir de qualquer maneira, exceto gravar a saída em uma variável. É permitido escrever na tela, linha de comando, arquivo etc. A saída com função também returné permitida.

Regras adicionais

• Você não deve usar um built-in para realizar a tarefa (imagino que qualquer idioma tenha esse built-in, mas depois o Mathematica ... )

• Aplicam-se brechas padrão .

Casos de teste

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ério vencedor

Isso é código-golfe , então o código mais curto em bytes vence!

¹ _{Todos os anos, no dia 22 ^nd de dezembro, o aniversário de Srinivasa Ramanujan, Dia Nacional da Matemática é observado na Índia. Seus colegas, aqueles em Cambridge, o compararam a Jacobi, Euler e até Newton. Além de ser tão bom, ele quase não tinha treinamento formal em Matemática Pura , mas ainda assim, fez importantes contribuições à análise matemática , teoria dos números , séries infinitas e frações contínuas . Infelizmente, ele morreu aos 32 anos, com milhares de descobertas matemáticas em sua mente. Também foi feito um filme sobre ele, baseado em sua biografia ,O homem que conhecia o infinito .}

Neim , 5 bytes

𝐬D𝐫𝕋𝔼

Explicação:

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

Tente!

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

Eu sei, apenas procuro igualdade, mas essa não deve ser a parte divertida do programa.

Gostam de ler. :)

Adicionadas algumas novas linhas para facilitar a leitura:

Experimente online

Montagem x86, 55 35 33 31 bytes:

Assume uma ABI em que o valor de retorno está no EAX e os parâmetros são pressionados na pilha ... então quase todos eles.

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

Braquilog , 8 bytes

ẹ+S↔;S×?

Experimente online!

Haskell , 56 55 bytes

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

Experimente online!

Sem ponto: (56 bytes)

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

Experimente online!

Chato: (24 bytes)

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

Experimente online!

JavaScript ES6, 59 57 bytes

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

Experimente online!

Divide-se basicamente em uma matriz de dígitos e une-se a +e avalia essa expressão para somar basicamente os dígitos. string*stringconverterá automaticamente as strings em ints. Recebe entrada como uma string

Mathematica, 42 bytes

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

Ruby, 69 bytes

Primeira tentativa, com número inteiro como entrada:

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

Segunda tentativa, com string 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 com sucesso, sem saída com falha.

JavaScript (ES6), 72 bytes

Este é um envio ES6 válido. Adicione f=no início e chame like f(arg).

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

Snippet de teste:

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 bytes

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

Experimente online!

Como é típico para soluções JVM compiladas estaticamente, muitos bytes são perdidos apenas na declaração da função principal e na chamada print (). A estrutura da função é de 60 bytes, o que não é ruim para uma linguagem de uso geral estaticamente tipada como o Kotlin.

Kotlin, solução chata, 69 bytes

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

Experimente online!

05AB1E , 5 bytes

SOÂ*Q

Experimente online!

Python 2 , 55 bytes

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

Experimente online!

Explicação

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

Uma eval()solução é um pouco mais 2 bytes ...

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

Solução alternativa (inválida?) , 42 29 bytes

Esta solução verifica a igualdade em relação a todos os números.

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

Experimente online!

Cheddar , 60 bytes

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

Experimente online!

NewStack , 16 bytes

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

O colapso:

Usando 1729 como exemplo

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

Imprime nada se falso, e a entrada original se verdadeira.

MATL , 11 bytes

tV!UstVPU*=

Experimente online!

t - pegue a entrada e duplique

V!U - divida-o em dígitos individuais

s - somar esses dígitos

t - duplicar essa soma

VP - transforme isso em uma corda, vire-a da esquerda para a direita

U - transformar isso de volta em um número

* - multiplique os dois últimos valores (a soma dos dígitos e sua versão invertida da esquerda para a direita)

= - verifique se é igual à entrada original (que é o único outro valor na pilha)

Japonês, 8 bytes

¬x
*sÔ¥N

Execute on-line

Geléia , 8 bytes

DS×ṚḌ$$=

Experimente online!

Perl 6 , 30 bytes

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

PHP , 52 bytes

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

Experimente online!

PHP , 36 bytes

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

Experimente online!

APL (Dyalog) , 18 bytes

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

Experimente online!

Pari / GP , 56 52 bytes

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

Experimente online!

MathGolf , 5 bytes

Σ_x*=

Experimente online!

Praticamente o mesmo que o byte da solução Neim por byte.