Égalité dans la somme des chiffres

23

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 , donc la soumission avec le moins d'octets gagne!

Adnan
la source
Si personne ne l'a encore repéré, seuls les nombres équivalents à 0 ou 1 (mod 9) peuvent apparaître dans la liste.
Neil
@MamaFunRoll Um ... non. Désolé. Les nombres avec des racines numériques de 5 ont des carrés dont la racine numérique est 7.
Neil
@Neil owait nvm
Mama Fun Roll
J'ai écrit un prédicat Brachylog pour déterminer si l'entrée est ou non un terme de cette séquence, mais je n'ai pas pu faire fonctionner la recherche-nième passe-partout, je vais donc le laisser dans un commentaire:^₂;?{ẹ+}ᵛ
Chaîne non liée

Réponses:

5

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.
Dennis
la source
4

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
nimi
la source
4

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.

Downgoat
la source
1
J'ai l'impression que transformer cela en une fonction récursive raccourcirait beaucoup cela ...
Mama Fun Roll
4

Perl 6, 47 46 octets

{(grep {$_.comb.sum==$_².comb.sum},1..*)[$_]}
Raccourcis clavier
la source
4

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)
Kevin Cruijssen
la source
2
Vous n'avez pas besoin ½ici car c'est implicite
Emigna
1
-1: µNDn‚1öË. est comme SOmais vectorise, ce qui nous permet d'éviter la duplication de code.
Grimmy
@Grimy Merci encore. J'ai également ajouté cela comme astuce à mon petit article de conseils. :)
Kevin Cruijssen
3

Mathematica, 64 octets

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

Fonction anonyme simple. Zéro indexé.

LegionMammal978
la source
3

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.

FryAmTheEggman
la source
Vous pouvez enregistrer un octet en le supprimant hsi vous utilisez l'indexation 1 qui est explicitement autorisée.
Denker
@DenkerAffe Oh, merci je devrais lire de plus près: P
FryAmTheEggman
2

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
Luis Mendo
la source
1
très bien que MATL soit enfin répertorié parmi les compilateurs distants là-bas!.
Abr001am
1

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.

Alex A.
la source
1

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;(
GamrCorps
la source
1

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

CalculatorFeline
la source
Échec d'entrée >2457. Augmenter simplement votre valeur Rangen'aidera pas, car A058369[n]/nne semble pas converger.
murphy
Mieux? filler +
CalculatorFeline
10^#serait plus court que 2^#*9. Bien sûr, cela devient trop lent après que n soit supérieur à environ 6 ...
feersum
Pourquoi pas 9^#? Fil
CalculatorFeline
Avez-vous une preuve que f (n) <= 9 ^ n? (10 est évident car 10 ^ n est toujours une solution).
feersum
1

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

randomra
la source
1

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)

entrez la description de l'image ici

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

entrez la description de l'image ici

Stuart Bruff
la source
0

Japt , 15 octets

1 indexé

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

Essayez-le

Hirsute
la source
0

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
Kevin Cruijssen
la source
0

Perl 5 -p , 53 octets

Comprend +1pour-p

1 basé

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

Essayez-le en ligne!

Ton Hospel
la source
0

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

nAns
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.

Tau
la source
0

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.

Jonas
la source
0

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 
RosLuP
la source
0

MathGolf , 10 octets

♪╒gÆ‼Σ²Σ=§

Essayez-le en ligne!

Explication

údixn , 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
maxb
la source
Peut-être que je devrais simplement créer un chat pour MathGolf .. Quoi qu'il en soit, j'ai une question: existe-t-il des modules internes pour remplacer, diviser par, et autres pour les chaînes? J'ai l'impression que la compression peut économiser des octets ici, mais je ne sais pas si les prédéfinis existent pour l'accomplir.
Kevin Cruijssen
Il y a un chat MathGolf fermé. J'ai essayé de le garder en vie, mais dernièrement, j'ai été submergé de travail, et il a continué à se fermer. Je ne veux pas déranger les mods à chaque fois. Pour répondre à votre question, MathGolf n'était pas vraiment destiné à gérer les opérations de chaîne, mais j'ai implémenté des fonctionnalités de gestion de chaîne pour gérer certains défis de base. Comme vous l'avez remarqué, il y a encore beaucoup à désirer. Si j'ajoute quelque chose, ce sera probablement quelque chose de similaire à ce que possède 05AB1E, mais je n'ai pas vraiment eu de temps libre pour le développement de MathGolf ces derniers mois.
max