Bin ich eine Selbstzahl?

31

Eine Selbstzahl (auch als kolumbianische oder Devlali-Zahl bezeichnet) ist eine natürliche Zahl x, bei der die Gleichung n + <digit sum of n> = xkeine Lösung für eine natürliche Zahl enthält n. Beispielsweise ist 21 keine Selbstzahl, wie sich n = 15ergibt 15 + 1 + 5 = 21. Auf der anderen Seite, 20 ist eine Selbst Zahl, da kein nwelche Folgendes erfüllt eine solche Gleichheit gefunden werden kann.

Da diese Definition die Ziffernsumme referenziert, ist sie basisabhängig. Für die Zwecke dieser Herausforderung werden wir nur die Basis-10-Selbstzahlen berücksichtigen, die im OEIS die Sequenz A003052 sind . Binäre ( A010061 ) und Basis 100 ( A283002 ) Selbstnummern wurden ebenfalls kalibriert.

Die Herausforderung

xGeben Sie bei einer positiven Ganzzahl als Eingabe einen Wahrheitswert aus, wenn xes sich um eine Selbstzahl in der Basis 10 handelt, und ansonsten einen Falsey-Wert. Informationen zu Wahrheiten und falschen Werten finden Sie in diesem Meta-Post zum Thema .

Sie können ein komplettes Programm oder eine komplette Funktion schreiben und die Ein- und Ausgabe kann auf jedem der üblichen Kanäle erfolgen. Standardlücken sind natürlich verboten.

Das ist Code-Golf . Je kürzer Ihre Antwort (in Bytes), desto besser!

Testfälle

Wahrheit:

1
3
5
7
9
20
31
86
154
525

Falsey:

2
4
6
8
10
15
21
50
100
500

Sandbox-Link

Bestenlisten

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

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

Code-Snippet anzeigen

code-golf  math  decision-problem 
— Sok
quelle
Es scheint einige Diskussionen / Meinungsverschiedenheiten über gültige Ergebnisse zu geben, daher war mir nicht klar, was ich vorhatte. Ich habe einen Satz hinzugefügt, der hoffentlich die Dinge klären sollte und auf diesen Metapost verweist . Tut mir leid, wenn ich diesbezüglich Verwirrung stiftete!
— Sok
Nicht, um mehr Verwirrung zu stiften, aber ich denke, diese Diskussion ist relevant für die Gründe , warum es Verwirrung gab. Bitte berücksichtigen Sie dies bei zukünftigen Herausforderungen, da es schwierig sein kann, in Sprachen zu posten, die keine if / else-Konstrukte haben, wenn Sie den alten Konsens verwenden.
— FryAmTheEggman
@FryAmTheEggman Ich hatte nicht bemerkt, dass sich der Konsens verschoben hatte, ich fühle mich jetzt wie eine Leere: / Trotzdem habe ich jetzt bereits eine Klarstellung hinzugefügt, es scheint falsch, sie erneut zu ändern. Ich werde es nur für die nächste Herausforderung berücksichtigen, die ich poste. Danke
— Sok
2
Ich bin keine Nummer! Ich bin ein freier Mann!
— David Richerby
1
@DavidRicherby * sendet weiße Kugel nach Ihnen *
— Sok

Antworten:

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

Probieren Sie es online!

Erläuterung

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
}

Credits

— Olivier Grégoire
quelle
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

05AB1E , 8 Bytes

LD€SO+ÊW

Probieren Sie es online! oder als Testsuite

Erläuterung

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

Brachylog , 12 Bytes

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

Probieren Sie es online!

Erläuterung

¬{         }    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
— Tödlich
quelle
1
Ist false.ein wahrer Wert durch irgendeine objektive Methode auf eine Weise, die true.es nicht ist? Ich denke nicht, und es sieht so aus, als würde dies vom Metakonsens
— Sok
1
@Sok Ich habe 3 uninteressante Bytes hinzugefügt, um Ihre Bedenken auszuräumen.
— 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;}

Probieren Sie es online!

Um weitere 2 Bytes zu sparen, ist der zurückgegebene Wahrheitswert nicht mehr 1, sondern die Zahl selbst.

— Gastropner
quelle
4

Oktave , 49 47 44 Bytes

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

Probieren Sie es online!

Erläuterung:

Der Versuch, die Operation in einem Bereich auszuführen, ist umständlich und lang, da num2streine Zeichenfolge mit Leerzeichen als Trennzeichen zurückgegeben wird, wenn mehr als die eingegebene Zahl vorhanden ist. Das Subtrahieren von 48 würde also etwa ergeben: 1 -16 -16 2 -16 -16 3 -16 -16 4für einen Eingabebereich 1 ... 4 . Um all das loszuwerden, sind -16viele Bytes erforderlich.

Deshalb machen wir das mit einer Schleife mit arrayfun . Für jede der Zahlen k = 1 .. x , wobei x die Eingabe ist, addieren wir kund ihre Ziffernsumme und subtrahieren x. Dies gibt ein Array mit dem Ergebnis dieser Operation für jede der Zahlen in k zurück . Wenn eine der Zahlen im Array eine Null ist, ist die Zahl keine Selbstzahl.

Für Eingänge 20und 21sind die Ausgänge:

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

Es gibt nur Nicht-Null-Elemente für die Eingabe 20und mindestens ein Nicht-Null-Element für die Eingabe 21. Das heißt, das 20ist eine Selbstzahl und 21nicht.

Octave behandelt ein Array mit mindestens einer Null als falsch, wie im TIO-Link zu sehen ist.

— Stewie Griffin
quelle
4

MATL , 11 Bytes

t:tFYA!Xs+-

Die Ausgabe ist ein nicht leeres Array, das wahr ist, wenn alle Einträge ungleich Null sind, und falsch, wenn es eine oder mehrere Nullen enthält.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle , einschließlich des Wahrheits- / Falschheitstests.

Erläuterung

Betrachten Sie die Eingabe n = 10als Beispiel.

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

APL (Dyalog) , 14 Bytes

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

Probieren Sie es online!

Wie?

               ⍳   range
     (  ⍎¨∘⍕)      digits
     (+/    )      digit sums
   ⍳+              vectorized addition with the range
 ⊢∊                is the input included?
~                  negate
— Uriel
quelle
Das sind 16 Bytes. um sie 15 zu machen: +/⍎¨∘⍕->#+.⍎⍕
— ngn
3

Gelee , 6 Bytes

ḟDS+Ɗ€

Bei Eingabe von n wird [n] zurückgegeben, wenn n eine Selbstzahl ist, [], wenn nicht.

Probieren Sie es online!

Wie es funktioniert

ḟ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
quelle
Welche Codierung packt diese sechs Zeichen in nur sechs Bytes?
— WGroleau
1
— Dennis
3

J , 28, 24, 22, 21 Bytes

-1 Byte danke an Conor O'Brien

-2 Bytes dank ngn

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

Probieren Sie es online!

Erläuterung:

i. eine Liste 0 .. n-1

( )"+ für jedes Element in der Liste

.,.&.": konvertiere es in eine Liste von Ziffern,

1# finde ihre Summe

+ und füge es dem Gegenstand hinzu

$@-. schließe die Liste aus dem Argument aus und finde die Form

— Galen Ivanov
quelle
1
Ich weiß , dies ist eine alte Post, aber "0 i.kann sein "+i.(-1 Byte).
— Conor O'Brien
1
@ ConorO'Brien Danke! Ich glaube, ich kannte diese Art von Golf damals nicht. Jetzt benutze ich es (wenn ich mich erinnere :))
— Galen Ivanov
1
-.@e.->$@-.
— ngn
@ngn Danke, sehr schön!
— Galen Ivanov
1
@GalenIvanov auch [:( )"+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]==[]

BEARBEITEN: -4 dank @ user56656

— sonrad10
quelle
1
In Python2 können Sie `i`statt str(i)4 Bytes speichern.
— Wheat Wizard
@ user56656 danke, das wusste ich nicht
— sonrad10
1
Sie können das [und ]innerhalb dessum
— Mr. 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

Testsuite.

Wenn das Austauschen von Wahrheits- / Falschwerten zulässig ist, können wir das löschen !und stattdessen 7 Bytes abrufen . Einer von Sok Vorschlägen hat mir geholfen, 2 Bytes Golf zu spielen.

Erläuterung

! / m + sjdT - Volles Programm. Nimmt einen Eingang Q von STDIN und gibt entweder True oder False aus.
  m - Karte über den Bereich [0 ... Q) mit einer Variablen d.
     jdT - Wandle d in Basis 10 um.
    s - Summe.
   + - Und addiere die Summe zu d selbst.
 / - Zähle die Vorkommen von Q im Ergebnis.
! - Verneinen. Das Ergebnis implizit ausgeben.
— Mr. Xcoder
quelle
Ich hatte .AmnQ+dsjdT, ich hatte keine Ahnung /. Ich habe Pyth anscheinend schon lange nicht mehr richtig benutzt! +1
— Sok
@Sok /zählt grundsätzlich die Vorkommen eines Elements in einer Liste. Ich kann auch benutzen }, um zu testen, ob ein Objekt in einer Liste erscheint, aber ich denke, das ist die gleiche Anzahl von Bytes.
— Mr. Xcoder
Ich denke, das Sist nicht erforderlich - die Eingabe wird eine positive Ganzzahl sein, also 0wird es kein Problem sein , in der Zuordnungsliste zu sein? Zumindest scheint es für die gegebenen Testfälle zu funktionieren.
— Sok
@Sok Super, du hast recht! Ich habe mich dadurch um ein weiteres Byte reduziert.
— Mr. Xcoder
Wie funktioniert +sjdThinzufügen sjdTzu d? Ich habe so etwas noch nie gesehen
— RK.
2

Perl 6 , 39 33 Bytes

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

Versuch es!

Ein leerer Block mit einem impliziten einzelnen Parameter, der wie folgt aufgerufen wird:

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

Seitdem n + digits(n) >= nkönnen wir nur die kolumbianische Zahl für alle Zahlen bis zu unserem Abfragewert berechnen und prüfen, ob eine davon übereinstimmt. Dies berechnet also die kolumbianische Zahl für eine bestimmte Eingabe:

{$_ + [+] .comb}

Was wir auf alle Werte anwenden, bis zu unserem Ziel:

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

Aber es ist uns nur wichtig, ob einer von ihnen übereinstimmt, und nicht, was diese Werte sind, also können wir, wie von @nwellenhof hervorgehoben, Folgendes sagen:

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

Der Rest ist nur Nötigung zum Narren und Einwickeln in einen Block.

39 Bytes

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

TIO-Testlink von @Emigna

@nwellenhof wies darauf hin, dass mit grep 6 Bytes gespart würden!

— Phil H
quelle
1
Coole Lösung! Sie können zu Testzwecken einen TIO-Link hinzufügen .
— 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)}

Probieren Sie es online!

-4 Verwenden Sie all inverse anstelle von
-1, indem Sie! = In ^ by @ jonathan-allan
-1 ändern, indem Sie Mengen von @ovs verwenden

— Rick Rongen
quelle
2

Japt -d! , 6 Bytes

N¥U+ìx

Versuch es

Original, 8 Bytes

Gibt die eingegebene Nummer für truthy oder zurück 0 Falsch" zurück. Wenn nur das leere Array in JavaScript falsch wäre, könnten dies 7 Bytes sein.

ÂNkUÇ+ìx

Versuch es

Erläuterung

             :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

Versuch es

             :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
— Zottelig
quelle
1

Netzhaut , 55 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

.+
*

Eingabe xin Unary konvertieren .

Lv`_+

Erstellen Sie einen Bereich von xbis 1.

_+
$&$.&

Suffixieren Sie den Dezimalwert jedes Werts nmit seinem unären Wert.

^_+
$&¶$&

Machen Sie eine Kopie von x.

\d
*

Konvertieren Sie jede Dezimalstelle von nin unär, und fügen Sie die Ziffern der vorhandenen Kopie von hinzu n.

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

Überprüfen Sie, ob xin einem der Ergebnisse angezeigt wird.

0

Kehre das Ergebnis um.

— Neil
quelle
1

JavaScript (ES6), 52 51 Bytes

1 Byte dank @ l4m2 eingespart

Gibt 0 oder 1 zurück .

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

Probieren Sie es online!

— Arnauld
quelle
n=>(g=k=>k?n-eval([...k+'k'].join`+`)&&g(k-1):1)(n)
— 14 m²,
1

Retina , 24 Bytes

.+
*

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

Probieren Sie es online!

Könnten 18 Bytes sein, wenn die Eingabe unär ist, aber die andere Retina-Antwort verwendet auch Dezimalzahlen, so dass ich angenommen habe, dass die Verwendung von Dezimalzahlen für einen faireren Vergleich sorgen würde.

Erläuterung

.+
*

Wandelt die Eingabe in eine unäre Zahl um und verwendet sie _als unäre Ziffer.


$.`¶$`

Fügen Sie an jeder Position in der Zeichenfolge (dh am Anfang, am Ende und zwischen jedem Zeichenpaar) Folgendes ein:, $.`die Länge des Präfixes (oder die mit Nullen versehene Position der Übereinstimmung) , einen Zeilenumbruch $`, das Präfix selbst (dh eine unäre Darstellung der nullindizierten Position). ZB wenn die Eingabe wäre 3und wir die unäre Darstellung hätten___ , würde dies ergeben:

0
_1
__2
___3
___

Mit anderen Worten, wir erhalten eine Zeile für jede Zahl von 0 bis zur Eingabe (einschließlich), die sowohl eine unäre als auch eine dezimale Darstellung dieser Zahl enthält.

\d
*

Wir konvertieren jede Ziffer in eine unäre Zahl, wodurch die Ziffernsumme in jeder Zeile effektiv berechnet und der Zahl selbst hinzugefügt wird (alles in einer unären Zahl).

D`

Deduplizieren Sie Zeilen. Dies löscht keine doppelten Zeilen, sondern löscht sie nur in leere Zeilen. Wenn also eine Zahl von 0 bis zur Eingabe plus deren Ziffernsumme der Eingabe entspricht, wird die letzte Zeile gelöscht. Ansonsten bleibt die letzte Zeile bestehen.

.\z

Überprüfen Sie, ob sich in der letzten Zeile noch ein Zeichen befindet. Wir können nicht verwenden $, da dies auch vor einem nachgestellten Zeilenumbruch passt (genau dort, wo wir nicht hinschauen möchten).

— Martin Ender
quelle
1

Bash + GNU Coreutils, 91 Bytes

Gibt wahr oder falsch zurück.

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

Kotlin , 48 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Add ++ , 27 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

Stax , 8 Bytes

Å8avj╒Éπ

Führen Sie es aus und debuggen Sie es

Erläuterung

ASCII-Äquivalent:

{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=ist ein Stax-Programm, das alle Zahlen ausgibt, deren Summe der sich selbst hinzugefügten Ziffern der Eingabe entspricht. Zum Beispiel für 101die Ausgabe wäre 91und100 , jeweils in einer eigenen Zeile.

Führen Sie es aus und debuggen Sie es

— Weijun Zhou
quelle
1

Pyt , 7 Bytes

ĐřĐŚ+∈¬

Probieren Sie es online!

Wenn das Austauschen von Wahrheits- / Falschwerten zulässig ist, ¬kann das Ende für 6 Byte gelöscht werden.

Erläuterung:

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

J , 20 Bytes

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

Probieren Sie es 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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.