¿Soy un número propio?

31

Un número propio (también llamado número colombiano o Devlali) es un número natural x, donde la ecuación n + <digit sum of n> = xno tiene soluciones para ningún número natural n. Por ejemplo, 21 no es un número propio, como n = 15resultado 15 + 1 + 5 = 21. Por otro lado, 20 es un número propio, ya que no nse puede encontrar uno que satisfaga tal igualdad.

Como esta definición hace referencia a la suma de dígitos, depende de la base. Para los propósitos de este desafío, solo consideraremos los números propios de base 10, que son la secuencia A003052 en el OEIS. Los números propios binarios ( A010061 ) y base 100 ( A283002 ) también se han catalogado.

El reto

Dado un entero positivo xcomo entrada, genera un valor verdadero si xes un número propio en base 10, y un valor falso de lo contrario. Para aclarar los valores de verdad y falsey, consulte esta meta publicación sobre el tema .

Puede escribir un programa o función completa, y la entrada y la salida se pueden proporcionar en cualquiera de los canales habituales. Las lagunas estándar están, por supuesto, prohibidas.

Este es el código de golf , ¡así que cuanto más corta sea su respuesta (en bytes), mejor!

Casos de prueba

Verdad:

1
3
5
7
9
20
31
86
154
525

Falsey

2
4
6
8
10
15
21
50
100
500

Enlace de caja de arena

Tablas de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Mostrar fragmento de código

code-golf  math  decision-problem 
— Sok
fuente
Parece haber cierta discusión / desacuerdo sobre los resultados válidos, por lo que creo que no he tenido claro qué era lo que pretendía. Agregué una oración que debería aclarar las cosas, refiriéndome a esta meta publicación . Lo siento si he causado alguna confusión sobre esto.
— Sok
No para causar más confusión, pero creo que esta discusión es relevante sobre por qué hubo cierta confusión. Tenga esto en cuenta cuando haga desafíos futuros, ya que puede ser difícil publicar en idiomas que no tienen construcciones if / else si usa el consenso anterior.
— FryAmTheEggman
@FryAmTheEggman No me había dado cuenta de que el consenso había cambiado, me siento como un numpful ahora: / Aún así, ya he agregado una aclaración ahora, parece incorrecto cambiarlo nuevamente. Lo tendré en cuenta para el próximo desafío que publique. Gracias
— Sok
2
¡No soy ningún tipo de número! Soy un hombre libre!
— David Richerby
1
@DavidRicherby * envía una bola blanca después de ti *
— Sok

Respuestas:

7

Java (JDK 10) , 84 bytes

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

Pruébalo en línea!

Explicación

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

— Olivier Grégoire
fuente
1
-1 byte: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 bytes:i->{for(int n=i;i-->1;)i|=((""+i).chars().map(x->x-48).sum()+i^n)-1>>-1;return~i<0;}
— Nevay
5

Brachylog , 12 bytes

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

Pruébalo en línea!

Explicación

¬{         }    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
— Fatalizar
fuente
1
¿Es false.un valor verdadero por algún método objetivo de una manera que true.no lo es? Por mi parte, no lo creo, y parece que eso estaría respaldado por el meta consenso
— Sok
1
@Sok Agregué 3 bytes poco interesantes para abordar sus inquietudes.
— Fatalize
5

C (gcc) , 70 67 65 bytes

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;}

Pruébalo en línea!

Para eliminar otros 2 bytes, el valor de verdad devuelto ya no es 1, sino el número en sí.

— gastropner
fuente
4

Octava , 49 47 44 bytes

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

Pruébalo en línea!

Explicación:

Intentar hacer la operación en un rango es engorroso y largo, ya que num2strdevuelve una cadena con espacios como separadores si hay más que el número de entrada. Restar 48, por lo tanto, daría algo como: 1 -16 -16 2 -16 -16 3 -16 -16 4para un rango de entrada 1 ... 4 . Deshacerse de todo -16toma muchos bytes.

Por lo tanto, haremos esto con un bucle usando arrayfun. Para cada uno de los números k = 1 .. x , donde x es la entrada, sumamos ky su suma de dígitos, y restamos x. Esto devolverá una matriz con el resultado de esa operación para cada uno de los números en k . Si alguno de los números en la matriz es un cero, el número no es un número propio.

Para las entradas 20y 21, las salidas son:

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

Solo hay elementos distintos de cero para la entrada 20y al menos un elemento distinto de cero para la entrada 21. Eso significa que 20es un número propio y 21no lo es.

Octave trata una matriz con al menos un cero como falso, como se puede ver en el enlace TIO.

— Stewie Griffin
fuente
4

MATL , 11 bytes

t:tFYA!Xs+-

La salida es una matriz no vacía, que es verdadera si todas sus entradas son distintas de cero, y falsa si contiene uno o más ceros.

Pruébalo en línea! O verifique todos los casos de prueba , incluida la prueba de veracidad / falsedad.

Explicación

Considere la entrada n = 10como un ejemplo.

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
fuente
3

APL (Dyalog) , 14 bytes

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

Pruébalo en línea!

¿Cómo?

               ⍳   range
     (  ⍎¨∘⍕)      digits
     (+/    )      digit sums
   ⍳+              vectorized addition with the range
 ⊢∊                is the input included?
~                  negate
— Uriel
fuente
Eso es 16 bytes. para hacerlos 15: +/⍎¨∘⍕->#+.⍎⍕
— ngn
3

Jalea , 6 bytes

ḟDS+Ɗ€

Para la entrada n , esto devuelve [n] si n es un número propio, [] si no.

Pruébalo en línea!

Cómo funciona

ḟ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
fuente
¿Qué codificación empaqueta estos seis caracteres en solo seis bytes?
— WGroleau el
1
— Dennis
3

J , 28, 24, 22 21 bytes

-1 byte gracias a Conor O'Brien

-2 byts gracias a ngn

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

Pruébalo en línea!

Explicación:

i. una lista 0 .. n-1

( )"+ para cada artículo en la lista

.,.&.": convertirlo a una lista de dígitos,

1# encontrar su suma

+ y agregarlo al artículo

$@-. excluir la lista del argumento y encontrar la forma

— Galen Ivanov
fuente
1
Me doy cuenta de que esta es una publicación anterior, pero "0 i.puede ser "+i.(-1 byte).
— Conor O'Brien
1
@ ConorO'Brien Gracias! Creo que no conocía este tipo de golf en ese entonces; ahora lo uso (cuando lo recuerdo :))
— Galen Ivanov
1
-.@e.->$@-.
— ngn
@ngn Gracias, muy bien!
— Galen Ivanov
1
@GalenIvanov también [:( )"+i.->( )"+@i.
— ngn
2

Python 2, 70 66 bytes

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

EDITAR: -4 gracias a @ user56656

— sonrad10
fuente
1
en python2 puede usar en `i`lugar de str(i)guardar 4 bytes.
— Wheat Wizard
@ user56656 gracias, no sabía sobre eso
— sonrad10
1
Puede soltar el [y ]dentro delsum
— Sr. 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 bytes

!/m+sjdT

Banco de pruebas.

Si se permite el intercambio de valores de verdad / falsedad, entonces podemos eliminar !y obtener 7 bytes en su lugar. Una de las sugerencias de Sok me ayudó a jugar golf 2 bytes.

Explicación

! / m + sjdT - Programa completo. Toma una entrada Q de STDIN, emite Verdadero o Falso.
  m - Mapa sobre el rango [0 ... Q) con una variable d.
     jdT - Convierte d a base 10.
    s - Suma.
   + - Y agrega la suma a d misma.
 / - Contar las ocurrencias de Q en el resultado.
! - Negate. Salida implícita del resultado.
— Sr. Xcoder
fuente
Tenía .AmnQ+dsjdT, no tenía ni idea /. ¡No he usado Pyth correctamente en mucho tiempo parece! +1
— Sok
@Sok /básicamente cuenta las ocurrencias de un elemento en una lista. También puedo usar }, que prueba si un objeto aparece en una lista, pero creo que es el mismo número de bytes.
— Sr. Xcoder
Creo que Sno se requiere: la entrada será un número entero positivo, por lo que tener 0en la lista de mapeo no será un problema. Al menos, parece funcionar para los casos de prueba dados.
— Sok
@Sok Genial, tienes razón! Me afeité un byte más gracias a esto.
— Sr. Xcoder
¿Cómo se +sjdTagrega sjdTa d? Nunca he visto algo así
— RK.
2

Perl 6 , 39 33 bytes

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

¡Pruébalo!

Un bloque desnudo con parámetro único implícito, llamado así:

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

Desde entonces n + digits(n) >= n, podemos calcular el número colombiano para todos los números hasta nuestro valor de consulta y ver si alguno de ellos coincide. Entonces esto calcula el número colombiano para una entrada dada:

{$_ + [+] .comb}

Lo que aplicamos a todos los valores hasta nuestro objetivo:

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

Pero solo nos importa si alguno de ellos coincide, no cuáles son esos valores, por lo que, como señaló @nwellenhof, podemos grep:

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

El resto es solo coerción para bool y envolver en un bloque.

39 bytes

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

Enlace de prueba TIO proporcionado por @Emigna

¡@nwellenhof señaló que usar grep ahorraría 6 bytes!

— Phil H
fuente
1
¡Solución genial! Puede agregar un enlace TIO para fines de prueba.
— Emigna
1
— nwellnhof
— Jo King
2

Python 3 , 60 , 56 , 55 , 54 bytes

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

Pruébalo en línea!

-4 usando todo inverso en lugar de cualquier
-1 cambiando! = A ^ por @ jonathan-allan
-1 usando conjuntos por @ovs

— Rick Rongen
fuente
2

Japt -d! , 6 bytes

N¥U+ìx

Intentalo

Original, 8 bytes

Devuelve el número de entrada para verdadero o 0para falso. Si solo la matriz vacía fuera falsey en JavaScript, esto podría ser de 7 bytes.

ÂNkUÇ+ìx

Intentalo

Explicación

             :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

Alternativa

Ç+ìxÃe¦U

Intentalo

             :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
— Lanudo
fuente
1

Retina , 55 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

.+
*

Convierta la entrada xa unario.

Lv`_+

Crea un rango de xabajo a 1.

_+
$&$.&

Sufije el valor decimal de cada uno na su valor unario.

^_+
$&¶$&

Haz una copia de x.

\d
*

Convierta cada dígito decimal de na unario, agregando así los dígitos a la copia existente de n.

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

Comprueba si xaparece en alguno de los resultados.

0

Invierte el resultado.

— Neil
fuente
1

JavaScript (ES6), 52 51 bytes

Guardado 1 byte gracias a @ l4m2

Devuelve 0 o 1 .

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

Pruébalo en línea!

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

Retina , 24 bytes

.+
*

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

Pruébalo en línea!

Podría ser de 18 bytes con entrada dada en unario, pero la otra respuesta de Retina también usa decimal, así que pensé que usar decimal haría una comparación más justa.

Explicación

.+
*

Convierta la entrada a unario, utilizando _como dígito unario.


$.`¶$`

En cada posición de la cadena (es decir, principio, final y entre cada par de caracteres), inserte: $.`la longitud del prefijo (o la posición de coincidencia indexada a cero) , un salto de línea $`, el prefijo en sí (es decir una representación unaria de la posición indexada a cero). Por ejemplo, si la entrada fue 3y tendríamos la representación unaria ___, esto resultaría en:

0
_1
__2
___3
___

En otras palabras, obtenemos una línea para cada número desde 0 hasta la entrada (inclusive), que contiene una representación unaria y decimal de ese número.

\d
*

Convertimos cada dígito a unario, que efectivamente calcula la suma de dígitos en cada línea y la agrega al número mismo (todo en unario).

D`

Líneas deduplicadas. En realidad, esto no elimina líneas duplicadas, solo las borra para dejarlas vacías. Entonces, si cualquier número de 0 a la entrada más su suma de dígitos es igual a la entrada, la última línea se borrará. De lo contrario, la última línea permanece en su lugar.

.\z

Comprueba si todavía hay un personaje en la última línea. No podemos usar $, porque eso también coincide frente a un salto de línea final (que es exactamente donde no queremos mirar).

— Martin Ender
fuente
1

Bash + GNU Coreutils, 91 Bytes

Devuelve verdad o falsedad.

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

Kotlin , 48 bytes

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

Pruébalo en línea!

Explicación:

(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
fuente
1

Agregar ++ , 27 bytes

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

Pruébalo en línea!

Cómo funciona

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
fuente
1

Stax , 8 bytes

Å8avj╒Éπ

Ejecutar y depurarlo

Explicación

ASCII equivalente:

{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=es un programa Stax que genera todos los números cuya suma de dígitos agregados es igual a la entrada. Por ejemplo, para 101la salida sería 91y 100, cada uno en una línea separada.

Ejecutar y depurarlo

— Weijun Zhou
fuente
1

Pyt , 7 bytes

ĐřĐŚ+∈¬

Pruébalo en línea!

Si se permite intercambiar valores de verdad / falsedad, entonces ¬al final se puede descartar por 6 bytes.

Explicación:

        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
fuente
1

J , 20 bytes

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

Pruébalo en línea!

                  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
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.