Eu sou um número próprio?

31

Um número próprio (também chamado de número colombiano ou Devlali) é um número natural x, onde a equação n + <digit sum of n> = xnão tem soluções para nenhum número natural n. Por exemplo, 21 não é um número próprio, pois n = 15resulta em 15 + 1 + 5 = 21. Por outro lado, 20 é um número próprio, pois não npode ser encontrado nenhum que satisfaça essa igualdade.

Como essa definição faz referência à soma dos dígitos, ela depende da base. Para os propósitos deste desafio, consideraremos apenas os números próprios da base 10, que são a sequência A003052 no OEIS. Os números próprios binários ( A010061 ) e base 100 ( A283002 ) também foram calculados.

O desafio

Dado um número inteiro positivo xcomo entrada, xemita um valor verdadeiro se for um número próprio na base 10 e, caso contrário, um valor falsey. Para esclarecimento dos valores de verdade e falsey, consulte este meta post sobre o assunto .

Você pode escrever um programa ou função completo, e entrada e saída podem ser fornecidas em qualquer um dos canais habituais. É claro que as brechas padrão são proibidas.

Isso é código-golfe , portanto, quanto menor a sua resposta (em bytes), melhor!

Casos de teste

Verdade:

1
3
5
7
9
20
31
86
154
525

Falsey:

2
4
6
8
10
15
21
50
100
500

Link sandbox

Classificação

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:

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

Mostrar snippet de código

code-golf  math  decision-problem 
— Sok
fonte
Parece haver alguma discussão / desacordo sobre resultados válidos, então acho que não fui claro sobre o que pretendia. Eu adicionei uma frase que deve esclarecer as coisas, referindo-se a este meta post . Desculpe se eu causei alguma confusão sobre isso!
— Sok
Para não causar mais confusão, mas acho que essa discussão é relevante por que houve alguma confusão. Considere isso ao fazer desafios futuros, pois pode ser difícil publicar em idiomas que não possuem construtores if / else se você usar o consenso antigo.
— FryAmTheEggman 22/03
@FryAmTheEggman Eu não tinha percebido que o consenso havia mudado, agora me sinto meio tonto: / Ainda assim, já adicionei um esclarecimento agora, parece errado mudá-lo novamente. Vou ter isso em mente para o próximo desafio que eu postar. Graças
— Sok
2
Eu não sou nenhum tipo de número! Eu sou um homem livre!
— David Richerby
1
@DavidRicherby * envia bola branca depois de *
— Sok

Respostas:

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

Experimente online!

Explicação

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
fonte
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 22/03
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 22/03
5

05AB1E , 8 bytes

LD€SO+ÊW

Experimente online! ou como um conjunto de testes

Explicação

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
fonte
5

Braquilog , 12 bytes

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

Experimente online!

Explicação

¬{         }    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
fonte
1
Existe false.um valor verdadeiro por qualquer método objetivo de uma maneira que true.não é? Eu pelo menos acho que não, e parece que isso seria apoiado pelo meta consenso #
— Sok
1
@ Sok eu adicionei 3 bytes desinteressantes para resolver suas preocupações.
— Fatalize 22/03/18
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;}

Experimente online!

Para economizar mais 2 bytes, o valor de verdade retornado não é mais 1, mas o número em si.

— gastropner
fonte
4

Oitava , 49 47 44 bytes

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

Experimente online!

Explicação:

Tentar executar a operação em um intervalo é complicado e longo, pois num2strretorna uma sequência com espaços como separadores se houver mais do que o número de entrada. Subtrair 48 daria, portanto, algo como: 1 -16 -16 2 -16 -16 3 -16 -16 4para um intervalo de entrada 1 ... 4 . Livrar-se de tudo isso -16leva muitos bytes.

Portanto, faremos isso com um loop usando arrayfun. Para cada um dos números k = 1 .. x , em que x é a entrada, adicionamos ksua soma de dígitos e subtraímos x. Isso retornará uma matriz de com o resultado dessa operação para cada um dos números em k . Se algum dos números da matriz for zero, o número não é um número próprio.

Para entradas 20 e 21, as saídas são:

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

Existem apenas elementos diferentes de zero para entrada 20 e pelo menos um elemento diferente de zero para entrada 21. Isso significa que 20é um número próprio e 21não é.

O Octave trata uma matriz com pelo menos um zero como falso, como pode ser visto no link TIO.

— Stewie Griffin
fonte
4

MATL , 11 bytes

t:tFYA!Xs+-

A saída é uma matriz não vazia, que é verdadeira se todas as suas entradas são diferentes de zero e falsas se contiver um ou mais zeros.

Experimente online! Ou verifique todos os casos de teste , incluindo teste de veracidade / falsidade.

Explicação

Considere a entrada n = 10como um exemplo.

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

APL (Dyalog) , 14 bytes

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

Experimente online!

Quão?

               ⍳   range
     (  ⍎¨∘⍕)      digits
     (+/    )      digit sums
   ⍳+              vectorized addition with the range
 ⊢∊                is the input included?
~                  negate
— Uriel
fonte
isso é 16 bytes. para torná-los 15: +/⍎¨∘⍕->#+.⍎⍕
— ngn
3

Gelatina , 6 bytes

ḟDS+Ɗ€

Para a entrada n , isso retorna [n] se n for um número próprio, [] se não.

Experimente online!

Como 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
fonte
Qual codificação agrupa esses seis caracteres em apenas seis bytes?
— WGroleau
1
— Dennis
3

J , 28, 24, 22 21 bytes

-1 byte graças a Conor O'Brien

-2 bytes graças a ngn

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

Experimente online!

Explicação:

i. uma lista 0 .. n-1

( )"+ para cada item da lista

.,.&.": converta-o em uma lista de dígitos,

1# encontre sua soma

+ e adicione-o ao item

$@-. excluir a lista do argumento e encontrar a forma

— Galen Ivanov
fonte
1
Sei que este é um post antigo, mas "0 i.pode ser "+i.(-1 byte).
— Conor O'Brien
1
@ ConorO'Brien Obrigado! Eu acho que não conhecia esse tipo de golfe naquela época; agora eu uso (quando me lembro :))
— Galen Ivanov
1
-.@e.->$@-.
— ngn 23/07
@ngn Obrigado, muito bom!
— Galen Ivanov
1
@GalenIvanov also [:( )"+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]==[]

EDIT: -4 graças a @ user56656

— sonrad10
fonte
1
em python2, você pode usar em `i`vez de str(i)salvar 4 bytes.
— Assistente de trigo
@ user56656 obrigado, eu não sabia sobre isso
— sonrad10
1
Você pode soltar o [e ]dentro dosum
— Sr. Xcoder 22/03
lambda x:[i for i in range(x)if i+sum(map(int,`i`))==x]==[]
— B. Eckles 22/03/19
lambda x:all(i+sum(map(int,`i`))-x for i in range(x))
— B. Eckles 22/03/19
2

Pitão , 8 bytes

!/m+sjdT

Suíte de teste.

Se a troca de valores verdadeiros / falsos for permitida, podemos !remover o e obter 7 bytes. Uma das sugestões de Sok me ajudou a obter 2 bytes de golfe.

Explicação

! / m + sjdT - Programa completo. Pega uma entrada Q de STDIN, produz True ou False.
  m - Mapa acima do intervalo [0 ... Q) com uma variável d.
     jdT - Converta d na base 10.
    s - soma.
   + - E adicione a soma ao próprio d.
 / - Conte as ocorrências de Q no resultado.
! Negar. Saída implícita do resultado.
— Mr. Xcoder
fonte
Eu tinha .AmnQ+dsjdT, não tinha ideia /. Não uso Pyth corretamente há muito tempo! 1
— Sok
O @Sok /basicamente conta as ocorrências de um elemento em uma lista. Também posso usar }, que testa se um objeto aparece em uma lista, mas acho que é a mesma contagem de bytes.
— Mr. Xcoder
Eu acho que Snão é necessário - a entrada será um número inteiro positivo, portanto, ter0 na lista de mapeamento não será um problema? Pelo menos, parece funcionar para os casos de teste fornecidos.
— 22618 Sok
@ Sok Ótimo, você está certo! Raspei mais um byte graças a isso.
— Mr. Xcoder
Como +sjdTadiciona sjdTa d? Eu nunca vi nada assim
— RK.
2

Perl 6 , 39 33 bytes

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

Experimente!

Um bloco vazio com parâmetro único implícito, chamado assim:

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

Desde então n + digits(n) >= n, podemos apenas calcular o número colombiano para todos os números até o valor da consulta e ver se algum deles corresponde. Portanto, isso calcula o número colombiano para uma determinada entrada:

{$_ + [+] .comb}

Que aplicamos a todos os valores até nossa meta:

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

Mas nós apenas nos importamos se algum deles corresponde, não quais são esses valores; portanto, como apontado por @nwellenhof, podemos grep:

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

O resto é apenas coerção para bool e empacotamento em um bloco.

39 bytes

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

Link de teste do TIO fornecido por @Emigna

@nwellenhof apontou que usar grep economizaria 6 bytes!

— Phil H
fonte
1
Solução legal! Você pode adicionar um link TIO para fins de teste.
— Emigna
1
— Nwellnhof 22/03
— Jo King
2

Python 3 , 60 , 56 , 55 , 54 bytes

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

Experimente online!

-4 usando todo inverso em vez de
-1 mudando! = Para ^ por @ jonathan-allan
-1 usando conjuntos por @ovs

— Rick Rongen
fonte
2

Japt -d! , 6 bytes

N¥U+ìx

Tente

Original, 8 bytes

Retorna o número de entrada para verdade ou 0 para truthy falsey. Se apenas a matriz vazia fosse falsey em JavaScript, isso poderia ser de 7 bytes.

ÂNkUÇ+ìx

Tente

Explicação

             :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

Alternativo

Ç+ìxÃe¦U

Tente

             :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
— Shaggy
fonte
1

Retina , 55 bytes

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

Experimente online! O link inclui casos de teste. Explicação:

.+
*

Converter entrada xpara unário.

Lv`_+

Crie um intervalo de xbaixo a 1.

_+
$&$.&

Sufixe o valor decimal de cada um nao seu valor unário.

^_+
$&¶$&

Faça uma cópia de x.

\d
*

Converta cada dígito decimal de nem unário, adicionando os dígitos à cópia existente de n.

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

Verifique se xaparece em algum dos resultados.

0

Inverta o resultado.

— Neil
fonte
1

JavaScript (ES6), 52 51 bytes

Guardado 1 byte graças a @ l4m2

Retorna 0 ou 1 .

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

Experimente online!

— Arnauld
fonte
n=>(g=k=>k?n-eval([...k+'k'].join`+`)&&g(k-1):1)(n)
— L4m2 22/03/19
1

Retina , 24 bytes

.+
*

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

Experimente online!

Poderia ter 18 bytes com a entrada dada em unário, mas a outra resposta da Retina também usa decimal, então imaginei que usar decimal faria uma comparação mais justa.

Explicação

.+
*

Converta a entrada em unário, usando _como dígito unário.


$.`¶$`

Em cada posição na string (isto é, começo, fim e entre cada par de caracteres), insira:, $.`o comprimento do prefixo (ou a posição indexada em zero da partida) , um avanço de linha $`, o próprio prefixo (ou seja, uma representação unária da posição indexada a zero). Por exemplo, se a entrada fosse 3e teríamos a representação unária ___, isso resultaria em:

0
_1
__2
___3
___

Em outras palavras, obtemos uma linha para cada número de 0 à entrada (inclusive), que mantém uma representação unária e decimal desse número.

\d
*

Convertemos cada dígito em unário, o que efetivamente calcula a soma dos dígitos em cada linha e a adiciona ao número em si (todos em unário).

D`

Desduplicar linhas. Na verdade, isso não exclui linhas duplicadas, mas apenas as limpa para linhas vazias. Portanto, se qualquer número de 0 à entrada mais sua soma de dígitos for igual à entrada, a última linha será limpa. Caso contrário, a última linha permanecerá no lugar.

.\z

Verifique se ainda há um personagem na última linha. Não podemos usar $, porque isso também corresponde à frente de um avanço de linha à direita (que é exatamente onde não queremos olhar).

— Martin Ender
fonte
1

Bash + GNU Coreutils, 91 bytes

Retorna verdade ou falsidade.

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

Kotlin , 48 bytes

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

Experimente online!

Explicação:

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

Adicionar ++ , 27 bytes

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

Experimente online!

Como 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
fonte
1

Stax , 8 bytes

Å8avj╒Éπ

Execute e depure

Explicação

Equivalente 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=é um programa Stax que gera todos os números cuja soma de dígitos adicionados a si mesma é igual à entrada. Por exemplo, para 101a saída seria 91e 100, cada um em uma linha separada.

Execute e depure

— Weijun Zhou
fonte
1

Pyt , 7 bytes

ĐřĐŚ+∈¬

Experimente online!

Se a troca de valores verdadeiros / falsos for permitida, então ¬no final poderá ser eliminado por 6 bytes.

Explicação:

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

J , 20 bytes

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

Experimente online!

                  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
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.