È questo un numero Harshad Hardy-Ramanujan-Number-ish?


16

sfondo

Il numero 1729 è il numero Hardy-Ramanujan. Una straordinaria proprietà fu scoperta da S. Ramanujan (che è ampiamente considerato come il più grande matematico indiano 1 ), quando GH Hardy lo visitò in un ospedale. Nelle stesse parole di Hardy:

Ricordo che una volta lo avrei visto quando era malato a Putney. Avevo guidato sul taxi numero 1729 e ho osservato che il numero mi sembrava piuttosto noioso e che speravo non fosse un presagio sfavorevole. "No", rispose, "è un numero molto interessante; è il numero più piccolo esprimibile come la somma di due cubi in due modi diversi."

Oltre a ciò, ha molte altre incredibili proprietà. Una di queste proprietà è che è un numero di Harshad, cioè la somma delle sue cifre (1 + 7 + 2 + 9 = 19) ne è un fattore. Anche quello, uno speciale. Come ha mostrato Masahiko Fujiwara, il 1729 è un numero intero positivo che, sommando le sue cifre, produce una somma che, moltiplicata per l'inversione, produce il numero originale:

1 + 7 + 2 + 9 = 19

19 × 91 = 1729

Un numero intero positivo con tale proprietà è ciò che definisco Hardy-Ramanujan- ish Harshad Number, ai fini di questo post. (Potrebbe esserci un termine tecnico per questo, ma non sono riuscito a trovarlo, a meno che non sia membro dell'A110921 )


L'obiettivo

Dato un intero positivo ncome ingresso, uscita un valore truthy o falsey a seconda che l'ingresso nè un Hardy-Ramanujan- ish numero Harshad. Uscita veritiera, se lo è. Altrimenti, output falso.

Si noti che solo quattro Hardy-Ramanujan- ish esistono numero di harshad ( 1, 81, 1458e 1729), ed è possibile scrivere codice che verifica l'equivalenza con loro. Ma non penso che sarà divertente.


Ingresso

Il tuo programma dovrebbe assumere un numero intero positivo (un numero naturale, in altre parole). Può prenderlo in qualsiasi modo, tranne supponendo che sia presente in una variabile. È consentita la lettura da finestra modale, casella di input, riga di comando, file ecc. È consentito anche prendere input come argomento di funzione.


Produzione

Il tuo programma dovrebbe generare un valore di verità o falsità. Non devono essere coerenti. Il tuo programma può produrre in qualsiasi modo tranne che scrivere l'output in una variabile. È consentita la scrittura su schermo, riga di comando, file ecc. Anche l'output con funzione returnè consentito.


Regole aggiuntive

  • Non devi usare un built-in per eseguire l'operazione (mi chiedo che qualsiasi lingua abbia tale built-in, ma poi Mathematica ... )

  • Si applicano scappatoie standard .


Casi 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

Criterio vincente

Questo è , quindi vince il codice più corto in byte!


1 Ogni anno, il 22 ° dicembre, il compleanno di Srinivasa Ramanujan, Nazionale Matematica Day viene osservato in India. I suoi colleghi, quelli di Cambridge, lo paragonarono a Jacobi, Euler e persino a Newton. Oltre ad essere così bravo, non aveva quasi nessuna formazione formale in Matematica pura , ma ha comunque dato importanti contributi all'analisi matematica , alla teoria dei numeri , alle serie infinite e alle continue frazioni . Sfortunatamente, è morto in giovane età di 32 anni con migliaia di scoperte matematiche nella sua mente. È stato anche girato un film su di lui, basato sulla sua biografia ,L'uomo che sapeva l'infinito .


4
"ma non devi scrivere codice che controlli l'equivalenza con loro." Questo è un requisito del programma non osservabile .
Martin Ender,

@MartinEnder Ma allora sarà solo il numero uguale a 1729, 1458, 81 o 1 . Non penso che sarà divertente.
Arjun,

2
Perché i downvotes?
Arjun,

Prova: la somma digitale massima di un numero con n cifre è 9n. Il contrario di 9n sarebbe al massimo 90n. Quindi, il prodotto sarebbe al massimo 810n ^ 2, che deve avere n cifre, quindi deve essere almeno 10 ^ (n-1). Quando n = 7, è praticamente fatto, quindi è sufficiente controllare fino al 999999.
Perdita suora

6
Penso che dovresti solo permettere di verificare l'equivalenza con loro. Quel tipo di risposte otterrebbe comunque dei voti negativi e probabilmente in alcuni casi sarà più lungo.
Okx,

Risposte:


12

Neim , 5 byte

𝐬D𝐫𝕋𝔼

Spiegazione:

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

Provalo!


Gli altri 4 byte non sono stampabili? Conto 1 byte
GamrCorps il

1
@GamrCorps Sembra che non siano supportati dal tuo browser. Ecco un'immagine: puu.sh/wpETt/9f92af18e0.png
Okx

1
Bello, ma 5 byte in quale codifica? :-) Dei 5 caratteri qui, 𝐬 (U + 1D42C MATEMATICO BOLD S PICCOLO) , 𝐫 (U + 1D42B MATEMATICO BOLD SM R) , 𝕋 (U + 1D54B MATEMATICO MATERIALE DOPPIO STRUCK T) e 𝔼 (U + 1D53C MATEMATICO CAPITALE DOPPIO STRUCK E) occupano ciascuno 4 byte in UTF-8 (anche in UTF-16 e in (ovviamente) UTF-32). Quindi in realtà si tratta di 17 byte, anche se immagino che si potrebbe definire una codifica personalizzata ottimizzata per ASCII + quei caratteri.
ShreevatsaR,

3
@ShreevatsaR Neim sembra usare la propria codepage
The_Lone_Devil

@The_Lone_Devil Ah che lo spiegherebbe, grazie!
ShreevatsaR,

15

ArnoldC, 888 byte

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 so, controllo solo l'uguaglianza, ma non dovrebbe essere la parte divertente del programma.

Buona lettura. :)

Aggiunte alcune nuove righe lì per una più facile leggibilità:

Provalo online


6
Mi piaci. Ecco perché ti ucciderò per ultimo.
David Conrad,

12

x86 Assembly, 55 35 33 31 byte:

Presuppone un ABI in cui il valore di ritorno è in EAX e i parametri vengono inseriti nello stack ... quindi quasi tutti.

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



4

JavaScript ES6, 59 57 byte

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

Provalo online!

Fondamentalmente si divide in un array di cifre e si unisce a +tale espressione e la somma per fondamentalmente sommare le cifre. string*stringconvertirà automaticamente le stringhe in ints. Accetta l'input come stringa


2

Mathematica, 42 byte

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

2

Rubino, 69 byte

Primo tentativo, con intero come input:

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

Secondo tentativo, con stringa come input:

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

.split('')può essere fatto.chars
Conor O'Brien il

2

Lotto, 164 byte

@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

Stampa 1 in caso di successo, nessun output in caso di errore.


2

JavaScript (ES6), 72 byte

Questa è una presentazione ES6 valida. Aggiungi f=all'inizio e invoca like f(arg).

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

Snippet di prova:

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


Come ho appreso di recente, la risposta immediata alla tua sfida è disapprovata.
Shaggy,

@Shaggy Ma valido.
Okx,

3
E di solito declassano coloro che non si interessano della comunità.
Leaky Nun,

1
@Okx, non secondo le persone che hanno subito fatto il downvoting e mi hanno rimproverato di averlo fatto. Dobbiamo essere coerenti sull'opportunità o meno di questa pratica.
Shaggy,

3
Lo penso perché dà al poster della sfida un vantaggio iniquo in quanto è possibile che possano raccogliere una sfida, risolverla e quindi pubblicarla.
totalmente umano il

2

Kotlin, 111 108 byte

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

Provalo online!

Come è tipico per le soluzioni JVM compilate staticamente, molti byte vengono persi solo sulla dichiarazione della funzione principale e chiamando print (). La carne della funzione è di 60 byte, il che non è affatto male per un linguaggio tipicamente statico tipicamente usato come Kotlin.

Kotlin, soluzione noiosa, 69 byte

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

Provalo online!



1

Python 2 , 55 byte

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

Provalo online!

Spiegazione

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()soluzione è un po ' più lunga di 2 byte ...

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

Soluzione alternativa (non valida?) , 42 29 byte

Questa soluzione verifica l'uguaglianza rispetto a tutti i numeri.

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

Provalo online!


Soluzione alternativa alternativa, stessa durata:[1,81,1458,1729].__contains__
musicman523


1

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.


Moltiplica lo stack per la funzione . Non l'ho capito. Significa questo input?
Arjun,

Sì e no, dopo ¹, lo stack è composto da [1]. E poiché abbiamo definito fo f(x)per eguagliare il tuo input, moltiplicare ogni elemento nello stack per la funzione fsta essenzialmente sostituendo il 1con il nostro input. (Perché [1] * f(x)= [f])
Graviton,

1

MATL , 11 byte

tV!UstVPU*=

Provalo online!

t - accetta input e duplicalo

V!U - dividerlo in singole cifre

s - somma quelle cifre

t - duplicare tale somma

VP - trasformalo in una stringa, capovolgilo da sinistra a destra

U - Trasformalo in un numero

* - moltiplica gli ultimi due valori (la somma cifre e la sua versione capovolta da sinistra a destra)

= - controlla se questo è uguale all'input originale (che è l'unico altro valore nello stack)








Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.