Suis-je un numéro personnel?

31

Un nombre propre (également appelé nombre colombien ou devlali) est un nombre naturel x, où l'équation n + <digit sum of n> = xn'a de solution pour aucun nombre naturel n. Par exemple, 21 n'est pas un nombre propre, comme en n = 15résulte 15 + 1 + 5 = 21. En revanche, 20 est un nombre propre, car aucun ne npeut être trouvé qui satisfait une telle égalité.

Comme cette définition fait référence à la somme des chiffres, elle dépend de la base. Aux fins de ce défi, nous ne considérerons que les numéros de base 10, qui sont la séquence A003052 dans l'OEIS. Les numéros automatiques binaires ( A010061 ) et base 100 ( A283002 ) ont également été calalogués.

Le défi

Étant donné un entier positif xen entrée, sortez une valeur véridique si xest un nombre propre en base 10, et une valeur de falsey sinon. Pour des éclaircissements sur les valeurs de vérité et de falsey, reportez-vous à ce méta-post sur le sujet .

Vous pouvez écrire un programme ou une fonction complète, et l'entrée et la sortie peuvent être fournies sur l'un des canaux habituels. Les failles standard sont bien sûr interdites.

Il s'agit de code-golf , donc plus votre réponse est courte (en octets), mieux c'est!

Cas de test

Vérité:

1
3
5
7
9
20
31
86
154
525

Falsey:

2
4
6
8
10
15
21
50
100
500

Lien Sandbox

Classements

Voici un extrait de pile permettant de générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

# Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Afficher l'extrait de code

code-golf  math  decision-problem 
— Sok
source
Il semble y avoir une discussion / un désaccord sur les résultats valides, donc je pense que je n'ai pas été clair sur ce que j'avais l'intention. J'ai ajouté une phrase qui devrait, je l'espère, clarifier les choses, faisant référence à ce méta-post . Désolé si j'ai causé de la confusion à ce sujet!
— Sok
Pas pour créer plus de confusion, mais je pense que cette discussion est pertinente pour expliquer pourquoi il y avait une certaine confusion. Veuillez en tenir compte lorsque vous ferez de futurs défis, car il peut être difficile de publier dans des langues qui n'ont pas de construction if / else si vous utilisez l'ancien consensus.
— FryAmTheEggman
@FryAmTheEggman Je n'avais pas réalisé que le consensus avait changé, je me sens comme un vide maintenant: / Pourtant, j'ai déjà ajouté une précision maintenant, il semble mal de le changer à nouveau. Je garderai cela à l'esprit pour le prochain défi que je publierai. Merci
— Sok
2
Je ne suis pas un numéro! je suis un homme libre!
— David Richerby
1
@DavidRicherby * envoie une balle blanche après vous *
— Sok

Réponses:

7

Java (JDK 10) , 84 octets

i->{for(int n=i;i-->1;)i|=((""+i).chars().map(x->x-48).sum()+i^n)-1>>-1;return~i<0;}

Essayez-le en ligne!

Explication

i->{                                    // IntPredicate
  for(int n=i;i-->1;)                   //  for each number below n
    i|=(                                //   keep the sign of
      (""+i).chars().map(x->x-48).sum() //    sum of digits
      +i                                //    plus the number
      ^n                                //    xor n (hoping for a zero)
     )-1>>-1;                           //    changing that into a negative number if equals to zero
  return~i<0;                           //  return i>=0
}

Crédits

— Olivier Grégoire
source
1
-1 octet:n->{int i=n,r=0;for(;i-->0;)r=(""+i).chars().map(x->x-48).sum()+i==n?1:r;return r<1;}
— Kevin Cruijssen
2
84 octets:i->{for(int n=i;i-->1;)i|=((""+i).chars().map(x->x-48).sum()+i^n)-1>>-1;return~i<0;}
— Nevay
5

05AB1E , 8 octets

LD€SO+ÊW

Essayez-le en ligne! ou en tant que suite de tests

Explication

L          # push range [1 ... input]
 D         # duplicate
  €S       # split each number into a list of digits
    O      # sum digit lists
     +     # add (n + digitSum(n))
      Ê    # check for inequality with input
       W   # min
— Emigna
source
5

Brachylog , 12 octets

¬{⟦∋Iẹ+;I+?}

Essayez-le en ligne!

Explication

¬{         }    Fails if succeeds, suceeds if fails:
  ⟦∋I             I ∈ [0, ..., Input]
    Iẹ+           The sum of the elements (i.e. digits) of I...
       ;I+?       ... with I itself results in the Input
— Fataliser
source
1
Est- false.ce qu'une valeur véridique par une méthode objective d'une manière qui true.ne l'est pas? Pour ma part, je ne pense pas, et il semble que cela serait soutenu par le méta consensus
— Sok
1
@Sok J'ai ajouté 3 octets inintéressants pour répondre à vos préoccupations.
— Fatalize
5

C (gcc) , 70 67 65 octets

i,r,d,j;f(n){for(r=i=n;d=j=--i;r*=d!=n)for(;j;j/=10)d+=j%10;i=r;}

Essayez-le en ligne!

Pour raser 2 autres octets, la valeur véridique renvoyée n'est plus 1, mais le nombre lui-même.

— gastropner
source
4

Octave , 49 47 44 octets

@(x)arrayfun(@(k)k+sum(num2str(k)-48)-x,1:x)

Essayez-le en ligne!

Explication:

Essayer de faire l'opération sur une plage est fastidieux et long, car num2strrenvoie une chaîne avec des espaces comme séparateurs s'il y a plus que le nombre d'entrée. Soustraire 48 donnerait donc quelque chose comme: 1 -16 -16 2 -16 -16 3 -16 -16 4pour une plage d'entrée 1 ... 4 . Se débarrasser de tous les -16prend beaucoup d'octets.

Par conséquent, nous le ferons avec une boucle utilisant arrayfun. Pour chacun des nombres k = 1 .. x , où x est l'entrée, nous additionnons ket sa somme de chiffres, et soustrayons x. Cela retournera un tableau de avec le résultat de cette opération pour chacun des nombres en k . Si l'un des nombres du tableau est un zéro, le nombre n'est pas un nombre propre.

Pour les entrées 20et 21, les sorties sont:

20:  -18, -16, -14, -12, -10, -8, -6, -4, -2, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 2
21:  -19, -17, -15, -13, -11, -9, -7, -5, -3, -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 1, 3

Il n'y a que des éléments non nuls pour l'entrée 20et au moins un élément non nul pour l'entrée 21. Cela signifie que 20c'est un nombre propre, et 21ne l'est pas.

Octave traite un tableau avec au moins un zéro comme faux, comme on peut le voir sur la liaison TIO.

— Stewie Griffin
source
4

MATL , 11 octets

t:tFYA!Xs+-

La sortie est un tableau non vide, qui est vrai si toutes ses entrées sont non nulles et faux s'il contient un ou plusieurs zéros.

Essayez-le en ligne! Ou vérifiez tous les cas de test , y compris le test de véracité / fausseté.

Explication

Considérez l'entrée n = 10comme un exemple.

t       % Implicit input, n. Duplicate
        % STACK: 10, 10
:       % Range
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10]
t       % Duplicate
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10], [1 2 3 4 5 6 7 8 9 10]
FYA!    % Convert to base 10 digits and transpose
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10], [0 0 0 0 0 0 0 0 0 1
                                              1 2 3 4 5 6 7 8 9 0]
Xs      % Sum of each column
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10], [1 2 3 4 5 6 7 8 9 1]
+       % Add, element-wise
        % STACK: 10, [2 4 6 8 10 12 14 16 18 11]
-       % Subtract, element-wise
        % STACK: [8 6 4 2 0 -2 -4 -6 -8 -1]
        % Implicit display
— Luis Mendo
source
3

APL (Dyalog) , 14 octets

~⊢∊⍳+(+/⍎¨∘⍕)¨∘⍳

Essayez-le en ligne!

Comment?

               ⍳   range
     (  ⍎¨∘⍕)      digits
     (+/    )      digit sums
   ⍳+              vectorized addition with the range
 ⊢∊                is the input included?
~                  negate
— Uriel
source
c'est 16 octets. pour les faire 15: +/⍎¨∘⍕->#+.⍎⍕
— ngn
3

Gelée , 6 octets

ḟDS+Ɗ€

Pour l'entrée n , cela renvoie [n] si n est un nombre propre, [] sinon.

Essayez-le en ligne!

Comment ça marche

ḟDS+Ɗ€  Main link. Argument: n

     €  Call the link to the left for each k in [1, ..., n].
    Ɗ     Drei; combine the three links to the left into a monadic chain.
 D          Decimal; map k to the array of its digits in base 10.
  S         Take the sum.
   +        Add k to the sum of the k's digits.
ḟ       Filterfalse; promote n to [n], then remove all elements that appear in the
        array to the right.
        This returns [n] if the array doesn't contain n, [] if it does.
— Dennis
source
Quel encodage regroupe ces six caractères en seulement six octets?
— WGroleau
1
— Dennis
3

J , 28, 24, 22 21 octets

-1 octet grâce à Conor O'Brien

-2 octets grâce à ngn

$@-.(+1#.,.&.":)"+@i.

Essayez-le en ligne!

Explication:

i. une liste 0 .. n-1

( )"+ pour chaque élément de la liste

.,.&.": le convertir en une liste de chiffres,

1# trouver leur somme

+ et l'ajouter à l'article

$@-. exclure la liste de l'argument et trouver la forme

— Galen Ivanov
source
1
Je me rends compte que c'est un ancien message, mais "0 i.peut être "+i.(-1 octet).
— Conor O'Brien
1
@ ConorO'Brien Merci! Je pense que je ne connaissais pas ce genre de golf à l'époque; maintenant je l'utilise (quand je me souviens :))
— Galen Ivanov
1
-.@e.->$@-.
— ngn
@ngn Merci, vraiment sympa!
— Galen Ivanov
1
@GalenIvanov également [:( )"+i.->( )"+@i.
— ngn
2

Python 2, 70 66 octets

lambda x:[i for i in range(x)if i+sum([int(j)for j in`i`])==x]==[]

EDIT: -4 grâce à @ user56656

— sonrad10
source
1
en python2, vous pouvez utiliser `i`au lieu de str(i)pour enregistrer 4 octets.
— Wheat Wizard
@ user56656 merci, je n'en savais rien
— sonrad10
1
Vous pouvez déposer le [et ]à l'intérieur dusum
— M. Xcoder
lambda x:[i for i in range(x)if i+sum(map(int,`i`))==x]==[]
— B. Eckles
lambda x:all(i+sum(map(int,`i`))-x for i in range(x))
— B. Eckles
2

Pyth , 8 octets

!/m+sjdT

Suite de tests.

Si l'échange de valeurs véridiques / fausses est autorisé, nous pouvons supprimer le !et obtenir 7 octets à la place. Une des suggestions de Sok m'a aidé à jouer au golf sur 2 octets.

Explication

! / m + sjdT - Programme complet. Prend une entrée Q de STDIN, sort soit True ou False.
  m - Carte sur la plage [0 ... Q) avec une variable d.
     jdT - Convertit d en base 10.
    s - Somme.
   + - Et ajoutez la somme à d lui-même.
 / - Comptez les occurrences de Q dans le résultat.
! - Niez. Sortie implicite du résultat.
— M. Xcoder
source
J'en avais .AmnQ+dsjdT, je n'en avais aucune idée /. Je n'ai pas utilisé Pyth correctement depuis longtemps, semble-t-il! +1
— Sok
@Sok /compte essentiellement les occurrences d'un élément dans une liste. Je peux également utiliser }, qui teste si un objet apparaît dans une liste, mais je pense que c'est le même nombre d'octets.
— M. Xcoder
Je pense que ce Sn'est pas obligatoire - l'entrée sera un entier positif, donc avoir 0dans la liste de mappage ne sera pas un problème? Au moins, cela semble fonctionner pour les cas de test donnés.
— Sok
@Sok Super, tu as raison! J'ai rasé un octet de plus grâce à cela.
— M. Xcoder
Comment +sjdTs'ajoute sjdTà d? Je n'ai jamais rien vu de tel
— RK.
2

Perl 6 , 39 33 octets

{!grep $_,map {$_+[+] .comb},^$_}

Essaye le!

Un bloc nu avec un seul paramètre implicite, appelé ainsi:

say {!grep $_,map {$_+[+] .comb},^$_}(500);
> False
say {!grep $_,map {$_+[+] .comb},^$_}(525);
> True

Depuis n + digits(n) >= n, nous pouvons simplement calculer le nombre colombien pour tous les nombres jusqu'à notre valeur de requête et voir si l'un d'eux correspond. Donc, cela calcule le nombre colombien pour une entrée donnée:

{$_ + [+] .comb}

Que nous appliquons à toutes les valeurs jusqu'à notre objectif:

(^$_).map({$_+[+] .comb})

Mais nous nous soucions seulement de savoir si l'une d'entre elles correspond, pas quelles sont ces valeurs, donc comme l'a souligné @nwellenhof, nous pouvons grep:

grep $_, map {$_+[+] .comb}, ^$_

Le reste est juste de la coercition à bool et enveloppé dans un bloc.

39 octets

{!((^$_).map({$_+[+] .comb}).any==$_)}

Lien de test TIO fourni par @Emigna

@nwellenhof a souligné que l'utilisation de grep permettrait d'économiser 6 octets!

— Phil H
source
1
Solution cool! Vous pouvez ajouter un lien TIO à des fins de test.
— Emigna
1
— nwellnhof
— Jo King
2

Python 3 , 60 , 56 , 55 , 54 octets

lambda x:{x}-{n+sum(map(int,str(n)))for n in range(x)}

Essayez-le en ligne!

-4 en utilisant tous les inverses au lieu de
-1 en changeant! = En ^ par @ jonathan-allan
-1 en utilisant les ensembles de @ovs

— Rick Rongen
source
2

Japt -d! , 6 octets

N¥U+ìx

L'essayer

Original, 8 octets

Renvoie le numéro d'entrée pour véridique ou 0pour falsey. Si seulement le tableau vide était falsey en JavaScript, cela pourrait être 7 octets.

ÂNkUÇ+ìx

L'essayer

Explication

             :Implicit input of integer U
   UÇ        :Generate the range [0,U) and pass each Z through a function
      ì      :  Digits of Z
       x     :  Reduce by addition
     +       :  Add to Z
  k          :Remove the elements in that array
 N           :From the array of inputs
            :Bitwise NOT NOT (~~), casts an empty array to 0 or a single element array to an integer

Alternative

Ç+ìxÃe¦U

L'essayer

             :Implicit input of integer U
Ç            :Generate the range [0,U) and pass each Z through a function
  ì          :  Digits of Z
   x         :  Reduce by addition
 +           :  Add to Z
    Ã        :End function
     e       :Every
      ¦U     :  Does not equal U
— Hirsute
source
1

Rétine , 55 octets

.+
*
Lv`_+
_+
$&$.&
^_+
$&¶$&
\d
*
Cms`^(_+)\b.*¶\1\b
0

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

.+
*

Convertissez l'entrée xen unaire.

Lv`_+

Créez une plage de xbas en haut 1.

_+
$&$.&

Suffixez la valeur décimale de chacun nà sa valeur unaire.

^_+
$&¶$&

Faites une copie de x.

\d
*

Convertissez chaque chiffre décimal de nen unaire, ajoutant ainsi les chiffres à la copie existante de n.

Cms`^(_+)\b.*¶\1\b

Vérifiez si xapparaît dans l'un des résultats.

0

Inversez le résultat.

— Neil
source
1

JavaScript (ES6), 52 51 octets

1 octet enregistré grâce à @ l4m2

Renvoie 0 ou 1 .

n=>(g=k=>k?eval([...k+'k'].join`+`)-n&&g(k-1):1)(n)

Essayez-le en ligne!

— Arnauld
source
n=>(g=k=>k?n-eval([...k+'k'].join`+`)&&g(k-1):1)(n)
— l4m2
1

Rétine , 24 octets

.+
*

$.`¶$`
\d
*
D`
.\z

Essayez-le en ligne!

Cela pourrait être de 18 octets avec une entrée donnée en unaire, mais l'autre réponse Retina utilise également la décimale, donc j'ai pensé que l'utilisation de la décimale ferait une comparaison plus juste.

Explication

.+
*

Convertissez l'entrée en unaire, en utilisant _comme chiffre unaire.


$.`¶$`

À chaque position de la chaîne (c'est-à-dire au début, à la fin et entre chaque paire de caractères), insérez:, $.`la longueur du préfixe (ou la position indexée zéro de la correspondance) ,, un saut de ligne,, $`le préfixe lui-même (c'est-à-dire une représentation unaire de la position indexée zéro). Par exemple, si l'entrée était 3et que nous aurions la représentation unaire ___, cela se traduirait par:

0
_1
__2
___3
___

En d'autres termes, nous obtenons une ligne pour chaque nombre de 0 à l'entrée (incluse), qui contient à la fois une représentation unaire et décimale de ce nombre.

\d
*

Nous convertissons chaque chiffre en unaire, qui calcule efficacement la somme des chiffres sur chaque ligne et l'ajoute au nombre lui-même (le tout en unaire).

D`

Lignes dédoublonnées. Cela ne supprime pas réellement les lignes en double mais les efface simplement en lignes vides. Donc, si un nombre de 0 à l'entrée plus sa somme de chiffres est égal à l'entrée, la dernière ligne sera effacée. Sinon, la dernière ligne reste en place.

.\z

Vérifiez s'il y a encore un caractère sur la dernière ligne. Nous ne pouvons pas l'utiliser $, car cela correspond également devant un saut de ligne de fin (qui est exactement là où nous ne voulons pas regarder).

— Martin Ender
source
1

Bash + GNU Coreutils, 91 octets

Retourne véridique ou fausse.

e=1;for((i=1;i<=$1;i++));{ [ $(bc<<<`grep -o . <<<$i|tr '\n' +`$i) -eq $1 ]&&e=0; };exit $e
— rexkogitans
source
1

Kotlin , 48 octets

x->(1..x).all{v->"$v".sumBy{it.toInt()-48}+v!=x}

Essayez-le en ligne!

Explication:

(1..x)      // Range of numbers from 1 to x
.all{v->    // Function expression that checks if ALL values evaluate to tru
"$v"        // Convert the value into a string
.sumBy{it.toInt()-48} // For each character, get the ASCII char value, subtract 48 in order to get it back to the numerical value, and then sum it up
+v          // Add the original number
!=x}        // Ensure that it does not equal the input
— Makotosan
source
1

Ajouter ++ , 27 octets

D,g,@,BDB+A+BK=
L,RbUABkºg!

Essayez-le en ligne!

Comment ça marche

D,g,@,		; Create a monadic function 'g'
		; Example argument:		[15]
	BD	; Digits;		STACK = [[1 5]]
	B+	; Sum;			STACK = [6]
	A+	; Add argument;		STACK = [21]
	BK=	; Equals input;		STACK = [1]

L,		; Create a lambda function
		; Example argument:		[21]
	RbUABk	; Push range;		STACK = [1 2 3 ... 19 20 21]
	ºg	; Any true from 'g';	STACK = [1]
	!	; Logical NOT;		STACK = [0]
— caird coinheringaahing
source
1

Stax , 8 octets

Å8avj╒Éπ

Exécuter et déboguer

Explication

Équivalent ASCII:

{cE+|+x=f!
{       f     Filter [1..input] with block
 cE           Decimal digits of current value
   +|+        Sum of digits and the current value
      x=      Equals input
         !    Logical not, maps empty array to 1 and non-empty array to 0

fcE+|+x=est un programme Stax qui produit tous les nombres dont la somme des chiffres ajoutés à lui-même est égale à l'entrée. Par exemple pour 101la sortie serait 91et 100, chacun sur une ligne distincte.

Exécuter et déboguer

— Weijun Zhou
source
1

Pyt , 7 octets

ĐřĐŚ+∈¬

Essayez-le en ligne!

Si l'échange de valeurs vérité / fausse est autorisé, ¬la fin peut être supprimée pour 6 octets.

Explication:

        Implicit input
Đ       Duplicate input
ř       Get [1,2,...,input]
Đ       Duplicate the top of the stack
Ś       Get the sum of the digits of each element in the array
+       Add the top two items on the stack element-wise
∈       Is the input in the list?
¬       Negate the top of the stack
        Implicit print
— mudkip201
source
1

J , 20 octets

#@-.i.+1#.10#.inv i.

Essayez-le en ligne!

                  i.     Range [0,n-1]
          10#.inv        To base 10
       1#.               Sum the digits
    i.+                  Plus the corresponding number
  -.                     Remove from the input, leaves an empty list if it was a self number.
#@                       An empty list is truthy, so return the length instead.
— FrownyFrog
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.