Sono un numero autonomo?

31

Un numero di sé (chiamato anche un numero colombiano o Devlali) è un numero naturale x, dove l'equazione n + <digit sum of n> = xnon ha soluzioni per nessun numero naturale n. Ad esempio, 21 non è un numero autonomo, come n = 15risulta 15 + 1 + 5 = 21. D'altra parte, 20 è un numero di sé, poiché non è npossibile trovare un numero che soddisfi tale uguaglianza.

Poiché questa definizione fa riferimento alla somma delle cifre, dipende dalla base. Ai fini di questa sfida, prenderemo in considerazione solo i numeri autonomi di base 10, che sono la sequenza A003052 nell'OEIS. Anche i numeri binari ( A010061 ) e base 100 ( A283002 ) sono stati registrati.

La sfida

Dato un intero positivo xcome input, emette un valore di verità se xè un numero auto nella base 10 e un valore di falsa in caso contrario. Per chiarimenti sui valori di verità e falsità, fare riferimento a questo meta post sull'argomento .

È possibile scrivere un programma o una funzione completi e input e output possono essere forniti su uno dei normali canali. Le scappatoie standard sono ovviamente vietate.

Questo è code-golf , quindi più breve è la risposta (in byte), meglio è!

Casi test

Truthy:

1
3
5
7
9
20
31
86
154
525

Falsey:

2
4
6
8
10
15
21
50
100
500

Link sandbox

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Mostra snippet di codice

code-golf  math  decision-problem 
— Sok
fonte
Sembra che ci sia qualche discussione / disaccordo su risultati validi, quindi penso di non essere stato chiaro su ciò che intendevo. Ho aggiunto una frase che, si spera, dovrebbe chiarire le cose, facendo riferimento a questo meta post . Scusate se ho creato confusione al riguardo!
— Ha
Non per creare più confusione, ma penso che questa discussione sia rilevante per il motivo della confusione. Si prega di considerare questo quando si affrontano sfide future, poiché può essere difficile pubblicare in lingue che non hanno if / else se si utilizza il vecchio consenso.
— FryAmTheEggman,
@FryAmTheEggman Non mi ero reso conto che il consenso si fosse spostato, ora mi sento intorpidito: / Tuttavia, ho già aggiunto un chiarimento ora, mi sembra sbagliato cambiarlo di nuovo. Lo terrò a mente per la prossima sfida che posterò. Grazie
— Sok
2
Non sono un numero qualsiasi di numeri! Sono un uomo libero!
— David Richerby,
1
@DavidRicherby * manda una pallina bianca dopo di te *
— Prese il

Risposte:

7

Java (JDK 10) , 84 byte

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

Provalo online!

Spiegazione

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
}

Crediti

— 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,
2
84 byte: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 byte

LD€SO+ÊW

Provalo online! o come una suite di test

Spiegazione

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

Brachylog , 12 byte

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

Provalo online!

Spiegazione

¬{         }    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
— Fatalize
fonte
1
È false.un valore truthy con qualsiasi metodo obiettivo in un modo che true.non lo è? Io per primo non la penso così, e sembra che sarebbe supportato dal meta consenso
— Sok
1
@ Ho aggiunto 3 byte poco interessanti per rispondere alle tue preoccupazioni.
— Fatalizza il
5

C (gcc) , 70 67 65 byte

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

Provalo online!

Per radere altri 2 byte, il valore di verità restituito non è più 1, ma il numero stesso.

— gastropner
fonte
4

Ottava , 49 47 44 byte

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

Provalo online!

Spiegazione:

Cercare di eseguire l'operazione su un intervallo è lungo e complicato, poiché num2strrestituisce una stringa con spazi come separatori se sono presenti più numeri di input. Sottraendo 48 si darebbe quindi qualcosa del genere: 1 -16 -16 2 -16 -16 3 -16 -16 4per un intervallo di input 1 ... 4 . Sbarazzarsi di tutti -16richiede un sacco di byte.

Pertanto, lo faremo con un ciclo usando arrayfun. Per ciascuno dei numeri k = 1 .. x , dove x è l'input, aggiungiamo ke la sua somma delle cifre e sottraggiamo x. Ciò restituirà una matrice di con il risultato di tale operazione per ciascuno dei numeri in k . Se uno qualsiasi dei numeri nell'array è zero, il numero non è un numero autonomo.

Per gli ingressi 20e 21, le uscite sono:

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

Esistono solo elementi diversi da zero per l'input 20e almeno un elemento diverso da zero per l'input 21. Ciò significa che 20è un numero autonomo e 21non lo è.

Octave considera un array con almeno uno zero come falso, come si può vedere nel collegamento TIO.

— Stewie Griffin
fonte
4

MATL , 11 byte

t:tFYA!Xs+-

L'output è un array non vuoto, che è vero se tutte le sue voci sono diverse da zero e falsa se contiene uno o più zeri.

Provalo online! Oppure verifica tutti i casi di test , incluso il test di veridicità / falsità.

Spiegazione

Considera l'input n = 10come esempio.

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 byte

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

Provalo online!

Come?

               ⍳   range
     (  ⍎¨∘⍕)      digits
     (+/    )      digit sums
   ⍳+              vectorized addition with the range
 ⊢∊                is the input included?
~                  negate
— Uriel
fonte
sono 16 byte. per farli 15: +/⍎¨∘⍕->#+.⍎⍕
— ngn
3

Gelatina , 6 byte

ḟDS+Ɗ€

Per l'ingresso n , questo restituisce [n] se n è un numero autonomo, [] in caso contrario.

Provalo online!

Come funziona

ḟ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
Quale codifica racchiude questi sei caratteri in soli sei byte?
— GrGreau
1
— Dennis,
3

J , 28, 24, 22 21 byte

-1 byte grazie a Conor O'Brien

-2 byts grazie a ngn

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

Provalo online!

Spiegazione:

i. un elenco 0 .. n-1

( )"+ per ogni elemento nell'elenco

.,.&.": convertilo in un elenco di cifre,

1# trova la loro somma

+ e aggiungilo all'elemento

$@-. escludi l'elenco dall'argomento e trova la forma

— Galen Ivanov
fonte
1
Mi rendo conto che questo è un vecchio post, ma "0 i.può essere "+i.(-1 byte).
— Conor O'Brien,
1
@ ConorO'Brien Grazie! Penso di non conoscere questo tipo di golf a quei tempi; ora lo uso (quando ricordo :))
— Galen Ivanov il
1
-.@e.->$@-.
— ngn
@ngn Grazie, davvero gentile!
— Galen Ivanov,
1
@GalenIvanov also [:( )"+i.->( )"+@i.
— ngn
2

Python 2, 70 66 byte

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

MODIFICA: -4 grazie a @ user56656

— sonrad10
fonte
1
in python2 puoi usare `i`invece di str(i)salvare 4 byte.
— Wheat Wizard
@utente56656 grazie, non lo sapevo
— sonrad10
1
Puoi rilasciare [e ]dentro ilsum
— Mr. Xcoder il
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 byte

!/m+sjdT

Suite di test.

Se è consentito lo scambio di valori di verità / falsità, è possibile rilasciare !invece 7 byte. Uno dei Sok 's suggerimenti mi ha aiutato a golf 2 byte.

Spiegazione

! / m + sjdT - Programma completo. Prende un input Q da STDIN, genera True o False.
  m - Mappa sull'intervallo [0 ... Q) con una variabile d.
     jdT - Converti d in base 10.
    s - Somma.
   + - E aggiungi la somma a d stesso.
 / - Conta le occorrenze di Q nel risultato.
! - Nega. Emette implicitamente il risultato.
— Mr. Xcoder
fonte
Non avevo .AmnQ+dsjdTidea di /. Python non lo uso da molto tempo, a quanto pare! +1
— Chiamato il
@Sok /conta sostanzialmente le occorrenze di un elemento in un elenco. Posso anche usare }, che verifica se un oggetto appare in un elenco, ma penso che sia lo stesso numero di byte.
— Mr. Xcoder,
Penso che Snon sia necessario: l'input sarà un numero intero positivo, quindi avere 0nell'elenco di mapping non sarà un problema? Almeno, sembra funzionare per i casi di test indicati.
— Ha
@Sok Ottimo, hai ragione! Mi sono rasato un altro byte grazie a questo.
— Mr. Xcoder,
Come si +sjdTaggiunge sjdTa d? Non ho mai visto niente del genere
— RK.
2

Perl 6 , 39 33 byte

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

Provalo!

Un blocco nudo con singolo parametro implicito, chiamato così:

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

Da allora n + digits(n) >= n, possiamo semplicemente calcolare il numero colombiano per tutti i numeri fino al nostro valore di query e vedere se qualcuno di loro corrisponde. Quindi questo calcola il numero colombiano per un dato input:

{$_ + [+] .comb}

Che applichiamo a tutti i valori fino al nostro obiettivo:

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

Ma ci importa solo se qualcuno di loro corrisponde, non quali sono questi valori, quindi, come sottolineato da @nwellenhof, possiamo grep:

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

Il resto è solo coercizione per booling e avvolgersi in un blocco.

39 byte

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

Link al test TIO fornito da @Emigna

@nwellenhof ha sottolineato che l'utilizzo di grep consente di risparmiare 6 byte!

— Phil H
fonte
1
Soluzione fantastica! È possibile aggiungere un collegamento TIO a scopo di test.
— Emigna,
1
— nwellnhof,
— Jo King il
2

Python 3 , 60 , 56 , 55 , 54 byte

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

Provalo online!

-4 usando tutto l'inverso invece di qualsiasi
-1 cambiando! = In ^ di @ jonathan-allan
-1 usando i set di @ovs

— Rick Rongen
fonte
2

Japt -d! , 6 byte

N¥U+ìx

Provalo

Originale, 8 byte

Restituisce il numero di input per verità o 0per falsità. Se solo l'array vuoto fosse falso in JavaScript, questo potrebbe essere 7 byte.

ÂNkUÇ+ìx

Provalo

Spiegazione

             :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

Provalo

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

Retina , 55 byte

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

Provalo online! Il link include casi di test. Spiegazione:

.+
*

Converti input xin unario.

Lv`_+

Crea un intervallo dal xbasso al 1.

_+
$&$.&

Suffissa il valore decimale di ciascuno nal suo valore unario.

^_+
$&¶$&

Fai una copia di x.

\d
*

Converti ogni cifra decimale nin unaria, aggiungendo così le cifre alla copia esistente di n.

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

Controlla se xappare in nessuno dei risultati.

0

Invertire il risultato.

— Neil
fonte
1

JavaScript (ES6), 52 51 byte

Salvato 1 byte grazie a @ l4m2

Restituisce 0 o 1 .

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

Provalo online!

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

Retina , 24 byte

.+
*

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

Provalo online!

Potrebbero essere 18 byte con input fornito in unario, ma anche l'altra risposta Retina usa i decimali, quindi ho pensato che usare i decimali avrebbe reso un confronto più equo.

Spiegazione

.+
*

Converti input in unario, usando _come cifra unaria.


$.`¶$`

Ad ogni posizione nella stringa (ovvero inizio, fine e tra ogni coppia di caratteri), inserisci:, $.`la lunghezza del prefisso (o la posizione con indice zero della corrispondenza) , un avanzamento di riga $`, il prefisso stesso (es. una rappresentazione unaria della posizione indicizzata zero). Ad esempio, se l'input fosse 3e avremmo la rappresentazione unaria ___, ciò comporterebbe:

0
_1
__2
___3
___

In altre parole, otteniamo una riga per ogni numero da 0 all'input (inclusivo), che contiene una rappresentazione sia unaria che decimale di quel numero.

\d
*

Convertiamo ogni cifra in unario, che calcola efficacemente la somma delle cifre su ogni riga e la aggiunge al numero stesso (tutto in unario).

D`

Linee deduplicate. Questo in realtà non elimina le righe duplicate ma le cancella semplicemente in righe vuote. Quindi, se qualsiasi numero compreso tra 0 e l'input più la somma delle cifre è uguale all'input, l'ultima riga verrà cancellata. Altrimenti, l'ultima riga rimane al suo posto.

.\z

Controlla se c'è ancora un personaggio nell'ultima riga. Non possiamo usarlo $, perché questo corrisponde anche di fronte a un avanzamento riga finale (che è esattamente dove non vogliamo guardare).

— Martin Ender
fonte
1

Bash + GNU Coreutils, 91 byte

Restituisce verità o falsità.

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 byte

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

Provalo online!

Spiegazione:

(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

Aggiungi ++ , 27 byte

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

Provalo online!

Come funziona

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 byte

Å8avj╒Éπ

Esegui ed esegui il debug

Spiegazione

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=è un programma Stax che genera tutti i numeri la cui somma di cifre aggiunte a se stessa è uguale all'input. Ad esempio per 101l'output sarebbe 91e 100, ciascuno su una riga separata.

Esegui ed esegui il debug

— Weijun Zhou
fonte
1

Pyt , 7 byte

ĐřĐŚ+∈¬

Provalo online!

Se è consentito lo scambio di valori di verità / falsità, ¬alla fine può essere eliminato per 6 byte.

Spiegazione:

        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 byte

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

Provalo 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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.