introduzione

Prendiamo il numero 180. Questo è un numero interessante perché la somma delle cifre di questo numero è uguale a:

1 + 8 + 0 = 9

E la versione quadrata di questo numero, oppure:

180² = 32400 > 3 + 2 + 4 + 0 + 0 = 9

Questi sono entrambi 9 . La somma delle cifre del numero originale e il numero al quadrato sono uguali. Naturalmente, questo si trova anche su OEIS: A058369 .

Compito

Dato un numero intero non negativo n, emettere il numero nth positivo con questa condizione.

Casi di test ( indicizzati zero )

Input > Output

0 > 1
1 > 9
2 > 10
3 > 18
4 > 19
5 > 45
6 > 46
7 > 55
8 > 90
9 > 99
10 > 100
11 > 145
12 > 180
13 > 189
14 > 190
15 > 198
16 > 199
17 > 289
18 > 351
19 > 361

L'input può anche essere 1-indicizzato se ti va meglio.

Questo è code-golf , quindi vince l'invio con il minor numero di byte!

Gelatina, 13 byte

,²DS€=/
1dz#Ṫ

L'input è 1 indicizzato. Provalo online!

Come funziona

1dz#Ṫ    Main link. Argument: n (index)

1        Set the return value to 1.
   #     Execute ... until ... matches have been found.
 Ç         the helper link
  ³        n
    Ṫ    Extract the last match.


,²DS€=/  Helper link. Argument: k (integer)

,²       Pair k with k².
  D      Convert each to decimal.
   S€    Compute the sum of each list of base 10 digits.
     =/  Reduce by equality.

Haskell, 54 byte

s=sum.map(read.pure).show
([x|x<-[1..],s x==s(x^2)]!!)

Esempio di utilizzo: ([x|x<-[1..],s x==s(x^2)]!!) 17-> 289.

s calculates the digit sum:

                    show     -- turn number into a string
     map(read.pure)          -- turn every character (the digits) in to a
                             -- one element string and convert back to integer
sum                          -- sum those integers

main function:

[x|x<-[1..]            ]     -- make a list of all x starting from 1
           ,s x==s(x^2)      -- where s x == s (x^2)
                        !!   -- pick nth element from that list

JavaScript (ES6), 76 73 72 byte

n=>eval("for(q=s=>eval([...s+''].join`+`),i=1;q(i)!=q(i*i)||n--;i++);i")

Ho impiegato 30 minuti a cercare di farlo funzionare fino a quando ho capito che stavo producendo la variabile sbagliata: |

Questo è a zero.

Perl 6, 47 46 byte

{(grep {$_.comb.sum==$_².comb.sum},1..*)[$_]}

05AB1E , 10 9 8 byte

µNÐn‚1öË

1-indicizzati.

-1 byte grazie a @Emigna rimuovendo l'implicito ½(aumento counter_variabledopo ogni iterazione) alla fine
-1 byte grazie a @Grimy rimuovendo il duplicato SOusando‚1ö

Provalo online.

Spiegazione:

µ         # Loop while the counter_variable is not equal to the (implicit) input yet:
 NÐ       #  Push the 0-based loop index three times
   n      #  Take the square of this index
          #   i.e. 180 → 32400
    ‚     #  Pair it with the index
          #   i.e. 180 and 32400 → [180,32400]
     1ö   #  Convert both numbers from base-1 to base-10, which basically sums the digits
          #   i.e. [180,32400] → [9,9]
       Ë  #  Check if both sums are equal
          #   i.e. [9,9] → 1 (truthy)
          #  (if they are: implicitly increase the counter_variable by 1)
          # (after the loop: implicitly print the top of the stack, which is the remaining
          #  copy of the index from the triplicate we've used)

Mathematica, 64 byte

a=Tr@*IntegerDigits;Nest[NestWhile[#+1&,#+1,a@#!=a[#^2]&]&,1,#]&

Semplice funzione anonima. Zero indicizzati.

Pyth, 15

e.fqsjZTsj^Z2TQ

1 byte grazie a DenkerAffe!

Provalo qui o esegui una Test Suite .

Utilizza l'opzione 1 indicizzata.

Implementazione ingenua con .fcui si ottengono i primi nnumeri che corrispondono alla condizione data.

MATL , 24 23 byte

x`@2:^"@V!Us]=?@]NG<]1$

Utilizza un input basato su 1.

Provalo online!

x        % take inpout and delete it (gets copied into clipboard G)
`        %   do...while
  @      %   push loop iteration index: candidate number, n
  2:^    %   array [n n^2]
  "      %   for each element of that array 
    @    %     push that element 
    V!U  %     get its digits (to string, transpose, to number)
    Xs   %     compute their sum
  ]      %   end for each
  =      %   are the two sums equal?
  ?      %   if so
    @    %     the candidate number is valid: push it
  ]      %   end if
  NG<    %   is number of elements in stack less than input?
]        % if so, proceed with next iteration. End do...while. 
1$       % specify 1 input for implicit display: only top of stack

Julia, 79 66 byte

f(n,x=0,i=1,s=c->sum(digits(c)))=x<n?f(n,x+(s(i)==s(i^2)),i+1):i-1

Questa è una funzione ricorsiva che accetta un numero intero e restituisce un numero intero. Utilizza l'indicizzazione basata su 1.

Memorizziamo alcune cose come argomenti di funzione:

• n : L'ingresso
• x : Un contatore per quanti numeri con questa condizione abbiamo trovato
• i : Un numero per verificare la condizione
• s : Una funzione per calcolare la somma delle cifre del suo input

Mentre xè inferiore all'input, si ricorre, aumentando xse isoddisfa la condizione e incrementando i. Una volta x == n, torniamo i, ma dobbiamo sottrarre 1 perché sarà stato incrementato troppe volte.

Convesso 0,2, 36 35 byte

Convex è un nuovo linguaggio che sto sviluppando che è fortemente basato su CJam e Golfscript. L'interprete e l'IDE sono disponibili qui . L'input è un numero intero negli argomenti della riga di comando. Gli indici sono a base singola. Utilizza la codifica CP-1252 .

1\{\__2#¶{s:~:+}%:={\(\)\}{)\}?}h;(

Mathematica, 63 60 61 59 byte

Select[Range[9^#],Equal@@Tr/@IntegerDigits/@{#,#^2}&][[#]]&

Mentre faccio questa, l'altra risposta è saltata fuori ma li sto battendo per un singolo byte e sto postando questo prima che uno venga giocato a golf. Uno indicizzato.

Retina, 103 byte

\d+
$*1 x
{`x+
$.0$*x¶$.0$*a¶$.0$*b
%`b
$_
a+|b+
$.0
\d
$*
+`1¶1
¶
1(.*)¶¶$|¶[^d]+
$1x
}`^ ?x

x

Decisamente golfabile.

Utilizza la nuova funzione Retina% per la quadratura (quindi non funziona ancora con la versione online).

Mathcad, 70 50 byte

Mathcad non ha funzioni integrate per convertire un numero nella sua stringa di cifre, quindi la funzione utente d (a) fa questo lavoro. Un programma quindi scorre attraverso gli interi positivi, verificando l'uguaglianza delle somme, fino a quando non ha accumulato n numeri nel vettore v. Il programma viene valutato usando l'operatore =, che visualizza il vettore del risultato. ( Nota che l'intero programma appare esattamente come mostrato sotto nel foglio di lavoro di Mathcad )

Programma aggiornato: presuppone l'inizializzazione predefinita di a zero e sfrutta il fatto che Mathcad restituisce il valore dell'ultima istruzione valutata in un programma.
Utilizza l'ordine di valutazione delle espressioni per incrementare la variabile a nella prima somma (e che è quindi disponibile per l'uso nella somma del quadrato)

Programma originale: restituisce un vettore di tutti i numeri fino a n.

Japt , 15 byte

1-indicizzato

_ìx ¶Z²ìx «U´}a

Provalo

Java 8, 113 byte

n->{int r=0;for(;n>=0;)if((++r+"").chars().map(c->c-48).sum()==(r*r+"").chars().map(c->c-48).sum())n--;return r;}

0-indicizzato

Spiegazione:

Provalo online.

n->{           // Method with integer as both parameter and return-type
  int r=0;     //  Result-integer, starting at 0
  for(;n>=0;)  //  Loop as long as `n` is zero or positive
    if((++r    //   Increase `r` by 1 first
       +"").chars().map(c->c-48).sum()
               //   And if the sum of its digits
       ==(r*r+"").chars().map(c->c-48).sum())
               //   equals the sum of the digit of its square
      n--;     //    Decrease `n` by 1
  return r;}   //  Return the result

Perl 5 -p , 53 byte

Include +1per-p

1 basato

#!/usr/bin/perl -p
$.++while$_-=!eval+("-($.) ".$.**2)=~s/\B/+/gr;$_=$.

Provalo online!

TI-BASIC 66 62 byte

Ans→N:While X<N:IS>(A,A::A:prgmA:Ans→B:A²:prgmA:If B=Ans:IS>(X,N:End:A
sum(int(10fPart(Ans₁₀^(seq(⁻X-1,X,0,log(Ans

$n$Ans
$n$ esimo termine nella sequenza.

La funzione di aiuto genera la somma delle cifre del valore in Ans.

Esempi:

3:prgmCDGF1E
             10
5:prgmCDGF1E
             19
8:prgmCDGF1E
             55
10:prgmCDGF1E
             99

Spiegazione:

Ans→N:While X<N:IS>(A,A::A:prgmA:Ans→B:A²:prgmA:If B=Ans:IS>(X,N:End:A ;prgmCDGF1E

Ans→N            ;store the input in N
While X<N        ;loop until the Nth term has been reached
IS>(A,A:         ;add 1 to A
                 ; (Increment A and skip the next statement if A>A)
A                ;leave A in Ans
prgmA            ;call the helper program below
Ans→B            ;store the result of the helper program in B
A²               ;square A and leave the result in Ans
prgmA            ;call the helper program below
                 ; (result is in Ans)
If B=Ans         ;if the two results are equal
IS>(X,N          ;add 1 to X
                 ; (Increment X and skip the next statement if X>N)
End
A                ;leave A in Ans
                 ;implicit print of Ans

sum(int(10fPart(Ans₁₀^(seq(⁻X-1,X,0,log(Ans   ;prgmA

                      seq(⁻X-1,X,0,log(Ans    ;generate a list...
                                              ; using X as the variable,
                                              ; starting at 0,
                                              ; ending at the log of Ans,
                                              ; and evaluating "⁻X-1" for each element
                                              ; (implicit increment of 1)
                   ₁₀^(                       ;raise 10 to the power of each element
                Ans                           ;multiply each element by the input
          fPart(                              ;remove the integer part from each element
        10                                    ;multiply each element by 10
    int(                                      ;round each element to the nearest integer
sum(                                          ;then sum the resulting list

Nota: TI-BASIC è un linguaggio tokenizzato. Il conteggio dei caratteri non equivale al conteggio dei byte.

J , 62 byte

[:{:({.@](>:@[,],[#~(=&(1#."."0@":)*:)@[)}.@])^:(#@]<1+[)^:_&1

Provalo online!

1 indicizzato. J, ancora una volta, non sta eseguendo bene su questi "ennesimi" compiti, a causa dell'eccessiva meccanica di contabilità.

APL (NARS), 49 caratteri, 98 byte

r←h w;c
c←r←0
→2×⍳∼=/+/¨(⍎¨⍕)¨r,r×r+←1⋄→2×⍳w>c+←1

1 indicizzato, test:

  h¨⍳20
1 9 10 18 19 45 46 55 90 99 100 145 180 189 190 198 199 289 351 361 

MathGolf , 10 byte

♪╒gÆ‼Σ²Σ=§

Provalo online!

Spiegazione

ú$10^n$

♪            push 1000
 ╒           range(1,n+1)
  gÆ         filter list using the next 5 operators
    ‼        apply next two commands to TOS
     Σ       sum(list), digit sum(int)
      ²      pop a : push(a*a) (square)
       Σ     sum(list), digit sum(int) (pushes the digit sum of the square)
        =    pop(a, b), push(a==b) (compares the two)
         §   get from array (returns the <input>th item from the filtered list