introduction

Prenons le nombre 180. C'est un nombre intéressant car la somme des chiffres de ce nombre est égale à:

1 + 8 + 0 = 9

Et la version au carré de ce nombre, ou:

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

Ceux - ci sont à la fois 9 . La somme des chiffres du nombre d'origine et du nombre au carré est identique. Bien sûr, cela se trouve également à OEIS: A058369 .

Tâche

Étant donné un entier non négatif n, sortez le ne nombre positif avec cette condition.

Cas de test ( indexés zéro )

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'entrée peut également être indexée 1 si cela vous convient mieux.

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Gelée, 13 octets

,²DS€=/
1dz#Ṫ

L'entrée est indexée sur 1. Essayez-le en ligne!

Comment ça marche

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 octets

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

Exemple d'utilisation: ([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 octets

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

J'ai passé 30 minutes à essayer de le faire fonctionner jusqu'à ce que je réalise que je produisais la mauvaise variable: |

Ceci est indexé zéro.

Perl 6, 47 46 octets

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

05AB1E , 10 9 8 octets

µNÐn‚1öË

1 indexé.

-1 octet grâce à @Emigna en supprimant l'implicite ½(augmentation counter_variableaprès chaque itération) à la fin
-1 octet grâce à @Grimy supprimant le doublon SOen utilisant‚1ö

Essayez-le en ligne.

Explication:

µ         # 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 octets

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

Fonction anonyme simple. Zéro indexé.

Pyth, 15

e.fqsjZTsj^Z2TQ

1 octet grâce à DenkerAffe!

Essayez-le ici ou exécutez une suite de tests .

Utilise l'option 1 indexée.

Implémentation naïve utilisant .fqui obtient les premiers nnombres qui correspondent à la condition donnée.

MATL , 24 23 octets

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

Utilise une entrée basée sur 1.

Essayez-le en ligne!

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 octets

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

Il s'agit d'une fonction récursive qui accepte un entier et renvoie un entier. Il utilise une indexation basée sur 1.

Nous stockons quelques éléments comme arguments de fonction:

• n : L'entrée
• x : Un compteur pour combien de nombres avec cette condition nous avons trouvé
• i : Un numéro pour vérifier l'état
• s : Une fonction pour calculer la somme des chiffres de son entrée

Alors que xest inférieur à l'entrée, nous récursions, incrémentant xsi iremplit la condition et incrémentant i. Une fois x == n, nous revenons i, mais nous devons soustraire 1 car il aura été incrémenté une fois de plus.

Convexe 0,2, 36 35 octets

Convex est un nouveau langage que je développe qui est fortement basé sur CJam et Golfscript. L'interprète et l'IDE peuvent être trouvés ici . L'entrée est un entier dans les arguments de la ligne de commande. Les index sont à base unique. Utilise l' encodage CP-1252 .

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

Mathematica, 63 60 61 59 octets

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

En faisant cela, l'autre réponse est apparue, mais je les bat d'un seul octet et je poste ceci avant que l'on ne joue au golf. Un indexé.

Rétine, 103 octets

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

x

Certainement golfable.

Utilise la nouvelle fonction Retina% pour la quadrature (donc ne fonctionne pas encore avec la version en ligne).

Mathcad, 70 50 octets

Mathcad n'a pas de fonctions intégrées pour convertir un nombre en sa chaîne de chiffres, donc la fonction utilisateur d (a) fait ce travail. Un programme parcourt ensuite les entiers positifs, testant l'égalité des sommes, jusqu'à ce qu'il ait accumulé n nombres dans le vecteur v. Le programme est évalué à l'aide de l'opérateur =, qui affiche le vecteur de résultat. ( Notez que l'ensemble du programme apparaît exactement comme indiqué ci-dessous sur la feuille de calcul Mathcad )

Programme mis à jour: suppose l'initialisation par défaut de a à zéro et utilise le fait que Mathcad renvoie la valeur de la dernière instruction évaluée dans un programme.
Utilise l'ordre d'évaluation des expressions pour incrémenter la variable a dans la première sommation (et qui est ensuite disponible pour une utilisation dans la somme des carrés)

Programme d'origine: renvoie un vecteur de tous les nombres jusqu'à n.

Japt , 15 octets

1 indexé

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

Essayez-le

Java 8, 113 octets

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 indexé

Explication:

Essayez-le en ligne.

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 octets

Comprend +1pour-p

1 basé

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

Essayez-le en ligne!

TI-BASIC 66 62 octets

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$ ième terme dans la séquence.

La fonction d'assistance génère la somme des chiffres de la valeur en Ans.

Exemples:

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

Explication:

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

Remarque: TI-BASIC est un langage à jetons. Le nombre de caractères n'est pas égal au nombre d'octets.

J , 62 octets

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

Essayez-le en ligne!

1 indexé. J encore une fois mal performé sur ces "nième" tâches, à cause de la mécanique de tenue de livres excessive.

APL (NARS), 49 caractères, 98 octets

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

1 index, 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 octets

♪╒gÆ‼Σ²Σ=§

Essayez-le en ligne!

Explication

ú$10^n$ , le script réussira toujours. Cependant, cela met une limite pratique au calcul qui est très faible.

♪            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