Disarium Dilemma

Ein Disarium ist definiert als eine Zahl, deren:

Die Summe der mit der jeweiligen Position versorgten Ziffern entspricht der ursprünglichen Nummer

Ihre Aufgabe :

Sie sind von Zahlen besessen, die als Disarium eingestuft werden. Das Bedürfnis, den Wegen des Disariums zu folgen, ist in Ihnen so groß, dass Sie es ablehnen , Seiten in einem bestimmten Buch zu lesen, die nicht mit Disarien nummeriert sind. Sie haben zwei BIG Probleme:

1. Ihr Professor hat Sie soeben beauftragt, Ihr Lehrbuch von Seite nzu Seite zu lesenm
2. Sie haben letzte Woche einen schweren Schlag auf den Kopf bekommen und können sich anscheinend nicht erinnern, wie Sie programmgesteuert feststellen können, ob eine Zahl als Disarium angesehen wird.

Zeit ist von entscheidender Bedeutung, daher muss der Code zur Bestimmung der zu lesenden Seiten so kurz wie möglich sein.

Sie müssen alle von der disarium innerhalb einer inklusiven Bereich von identifizieren , ndurch m.

Beispiele für ein Disarium :

89 = 8 ¹ + 9 ²

135 = 1 ¹ + 3 ² + 5 ³

518 = 5 ¹ + 1 ² + 8 ³

Das ist Code-Golf, also gewinnt die geringste Anzahl von Bytes!

Hier ist die vollständige Sequenz von A032799 .

Perl 6 , 40 39 Bytes

{grep {$_==sum .comb Z**1..*},$^a..$^b}

Probieren Sie es online!

Wie es funktioniert

{                                     }  # A lambda.
                              $^a..$^b   # Range between the two lambda arguments.
 grep {                     },           # Return numbers from that range which satisfy:
               .comb Z  1..*             #  Digits zipped with the sequence 1,2,3,...,
                      **                 #  with exponentiation operator applied to each pair,
           sum                           #  and those exponents summed,
       $_==                              #  equals the number.

Python2, 98 89 88 84 Bytes

lambda n,m:[x for x in range(n,m+1)if sum(int(m)**-~p for p,m in enumerate(`x`))==x]

Schrecklich. Wird kürzer. Fängt an, besser auszusehen

Hier ist mein rekursiver Versuch (86 Bytes):

f=lambda n,m:[]if n>m else[n]*(sum(int(m)**-~p for p,m in enumerate(`n`))==n)+f(n+1,m)

Vielen Dank an @Rod für das Speichern von 4 Bytes! rangezu enumerateund so weiter.

Perl, 43 Bytes

map{say if$_==eval s/./+$&**$+[0]/gr}<>..<>

Probieren Sie es online!

Regex ist wirklich mächtig, Leute.

Erläuterung

Der Code liest zunächst zwei Ganzzahlen als Eingabe über <>und erstellt mit einen Bereich von der ersten zur zweiten ... Es verwendet dann die mapStandardfunktion Iterierte durch diesen Bereich und wendet den folgenden Code auf jeden Wert: say if$_==eval s/./+$&**$+[0]/gr. Das sieht nach Kauderwelsch aus und ist es auch, aber hier ist, was wirklich passiert.

mapspeichert implizit seinen aktuellen Wert in der Variablen $_. Viele Perl-Funktionen und -Operationen verwenden diesen Wert, wenn keiner angegeben ist. Dies schließt reguläre Ausdrücke wie den s///Substitutionsoperator ein.

Ein Substitutionsregex besteht aus vier Teilen:

1. Zu manipulierende Zeichenfolge. Normalerweise wird der Operator =~verwendet, um einen regulären Ausdruck auf einen String anzuwenden. Fehlt dieser Operator jedoch, wird der reguläre Ausdruck auf die implizite Variable angewendet, die $_über die mapFunktion unsere aktuelle Nummer enthält .
2. Zeichenfolge, nach der gesucht werden soll. In diesem Fall suchen wir nach einem einzelnen Nicht-Zeilenumbruch-Zeichen, das durch den Platzhalter gekennzeichnet ist .. Tatsächlich erfassen wir jede einzelne Ziffer.
3. Zeichenfolge, durch die ersetzt werden soll. Wir ersetzen ein Pluszeichen, +gefolgt von einem mathematischen Ausdruck, gemischt mit einigen magischen Perl-Variablen, die alles erheblich vereinfachen.

Die spezielle skalare Variable $&enthält immer die Gesamtheit der letzten erfolgreichen Regex-Erfassung, in diesem Fall eine einzelne Ziffer. Die spezielle Array-Variable @+enthält immer eine Liste der Postmatch-Offsets für die letzte erfolgreiche Übereinstimmung, dh den Index des Texts nach der Übereinstimmung. $+[0]ist der Index im $_unmittelbar folgenden Text $&. Im Fall von 135erfassen wir die Ziffer 1und der Index im 135Text unmittelbar danach (nämlich 35) ist 1, was unser Exponent ist. Also wollen wir $&(1) auf die Potenz von $+[0](1) erhöhen und 1 bekommen. Wir wollen 3 auf die Potenz von 2 erhöhen und 9 bekommen. Wir wollen 5 auf die Potenz von 3 erhöhen und 125 bekommen.

Wenn die Eingabe war 135, ist die resultierende Zeichenfolge +1**1+3**2+5**3.

4. Regex-Änderungsflags. Hier verwenden wir zwei Regex-Flags - /gund /r. /gWeist den Interpreter an, die Ersetzungen fortzusetzen, nachdem der erste gefunden wurde (andernfalls würden wir am Ende mit enden +1**135). /rWeist den Interpreter an, die ursprüngliche Zeichenfolge nicht zu ändern und stattdessen die Zeichenfolge zurückzugeben, die nach den Ersetzungen verwendet werden soll. Dies ist wichtig, da es sonst überschreiben würde $_und wir es zu Vergleichszwecken benötigen.

Sobald die gesamte Substitution abgeschlossen ist, erhalten wir einen mathematischen Ausdruck, der mit der evalFunktion ausgewertet wird . +1**1+3**2+5**3ausgewertet wird 1 + 9 + 125 = 135, die mit der ursprünglichen Nummer verglichen wird 135. Da diese beiden gleich sind, gibt der Code die Nummer aus.

JavaScript (ES7), 105 91 89 88 83 79 82 81 Byte

Danke an Arnauld für die Einsparung von 20B und an ETHProductions für die Einsparung von 6B!

a=>b=>[...Array(b).keys()].filter(c=>c>=a&([...c+''].map(d=>c-=d**++e,e=0),!c))

Verwendung

Weisen Sie die Funktion einer Variablen zu und geben Sie das Minimum und das Maximum als Argumente an. Beispiel:

f=a=>b=>[...Array(b).keys()].filter(c=>c>=a&([...c+''].map(d=>c-=d**++e,e=0),!c))
f(0)(90)

Ausgabe

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 89]

Weiteres Golfen

Das scheint ziemlich gut zu sein, aber es gibt immer Raum für Verbesserungen ... denke ich.

JavaScript (Firefox 52+), 68 Byte

f=(n,m)=>(e=0,[for(d of t=n+'')t-=d**++e],t||alert(n),n-m&&f(n+1,m))

Rekursive Funktion, die über ausgibt alert. Funktioniert in der Developer Edition von Firefox, die Sie auf dieser Seite herunterladen können . Frühere Versionen von Firefox unterstützen den **Operator nicht und kein anderer Browser unterstützt die [for(a of b)c]Syntax.

Testschnipsel

Diese verwendet .mapanstelle eines Arrays Verständnis, und Math.powstatt **, so dass es in allen Browsern , dass die Unterstützung ES6 funktionieren sollte.

f=(n,m)=>(e=0,[...t=n+''].map(d=>t-=Math.pow(d,++e)),t||alert(n),n-m&&f(n+1,m))

f(0,100)

05AB1E , 12 Bytes

2 Bytes dank Emigna gespart

ŸvygLySmOyQ—

Probieren Sie es online!

Ÿ            # push [a .. b]
 vy          # for each
   gL        # push [1 .. num digits]
     yS      # push [individual digits]
       m     # push [list of digits to the power of [1..num digits] ]
        O    # sum
         yQ— # print this value if equal

Python 3, 100 Bytes

lambda n,m:{*range(10),89,135,175,518,598,1306,1676,2427,2646798,0xa8b8cd06890f2773}&{*range(n,m+1)}

Nicht der kürzeste Ansatz, aber ein ziemlich süßer. Es gibt endlich viele Disarien; Einen guten Beweis finden Sie auf der OEIS-Seite. Das sind alles.

R, 100 Bytes

function(n,m,x=n:m)x[sapply(x,function(y)sum(as.integer(el(strsplit(c(y,""),"")))^(1:nchar(y)))==y)]

Unbenannte Funktion, die nund dauert m. Wie immer in R ist das Aufteilen von ganzen Zahlen in einen numerischen Ziffernvektor mühsam und verbraucht viele Bytes. Dies macht die Funktion relativ langsam und funktioniert nur für 32-Bit-Ganzzahlen.

Jelly , 11 Bytes

D*J$S⁼
rÇÐf

Probieren Sie es online!

Habe es von 16 auf 11 geschafft, mit etwas Hilfe von @miles!

Erläuterung:

rÇÐf    Main link, arguments are m and n
r       Generate a list from m to n
 Ç      Invoke the helper link
  Ðf    And filter out all that don't return 1 on that link

D*J$S⁼  Helper link, determines if item is Disarium
D       Break input (the current item of our list in Main) into digits (135 --> [1, 3, 5])
  J$    Create a range from 1 to x, where x is the number of digits             [1, 2, 3]
 *      Raise each digit to the power of their respective index 
    S⁼  And return a 1 if the sum of powers is equal to the helper-link's input

CJam , 23 Bytes

q~),\>{_Ab_,,:).#:+=},p

Probieren Sie es online!

Erläuterung

q~                      Get and eval all input
  ),\>                  Get the range between m and n, inclusive
      {                 For each number in the range...
       _Ab               Duplicate and get the list of digits
          _,,:)          Duplicate the list, take its length, make the range from 1 to length
               .#        Vectorize with exponentiation; computes first digit^1, second^2, etc
                 :+      Sum the results
                   =     Compare to the original number
                    },  Filter the range to only numbers for which the above block is true
                      p Print nicely

05AB1E , 18 Bytes

Ÿvy©SDgLsmO®Qi®}})

Probieren Sie es online!

Python 2.X, 92 Bytes

lambda m,n:[k for k in range(m,n+1)if sum(int(j)**(i+1) for i,j in enumerate(list(`k`)))==k]

Python 2 , 84 Bytes

Ein vollständiger Programmansatz, der derzeit genauso lang ist wie die Lambda-Lösung.

a,b=input()
while a<=b:
 t=p=0
 for x in`a`:p+=1;t+=int(x)**p
 if t==a:print a
 a+=1

Probieren Sie es online!

Japt, 15 Bytes

òV f_¥Zì £XpYÄÃx

Online testen! Dies war eine Zusammenarbeit zwischen @obarakon und mir.

Wie es funktioniert

òV f_¥Zì £XpYÄÃx   // Implicit: U, V = input integers
òV                 // Create the inclusive range [U...V].
   f_              // Filter to only the items Z where...
               x   //   the sum of
      Zì           //   the decimal digits of Z,
         £XpYÄÃ    //   where each is raised to the power of (index + 1),
     ¥             //   is equal to Z.
                   // Implicit: output result of last expression

Akzeptiert in der neuesten Version von Japt xeine Funktion als Argument, mit der wir ein weiteres Byte abarbeiten können :

òV f_¥Zì x@XpYÄ

Online testen!

Clojure, 107 Bytes

#(for[i(range %(inc %2)):when(=(int(apply +(map(fn[i v](Math/pow(-(int v)48)(inc i)))(range)(str i))))i)]i)

Die Umsetzung der Gleichung ist furchtbar lang.

TI-Basic, 85 Bytes

Input 
For(I,X,Y
If I<=9 or sum(I={89,135,175,518,598,1306,1676,2427,2646798,12157692622039623539
Disp I
End

Haskell, 61 Bytes

n#m=[i|i<-[n..m],i==sum(zipWith(^)(read.pure<$>show i)[1..])]

Anwendungsbeispiel 5 # 600-> [5,6,7,8,9,89,135,175,518,598].

Überprüfen Sie jede Zahl iim Bereich [n..m]. Die Ziffern werden extrahiert durch Drehen iin eine Zeichenfolge ( show) und machen jeden char ein eine Element - String ( pure) , die in eine Ganzzahl gedreht wird wieder ( read). Zippen Sie das Zahlenelement mit [1..]über die Funktion ^und nehmen Sie das sum.

PHP, 92 91 88 Bytes

3 Bytes gespeichert dank @AlexHowansky

for([,$n,$m]=$argv;$n<=$m;$s-$n++?:print"$s,")for($i=$s=0;_>$b=($n._)[$i++];)$s+=$b**$i;

Nimmt Eingaben von Befehlszeilenargumenten entgegen. druckt ein nachstehendes Komma. Laufen Sie mit -r.

Mathematica, 59 Bytes

Select[Range@##,Tr[(d=IntegerDigits@#)^Range@Length@d]==#&]&

Unbenannte Funktion, die zwei Ganzzahlargumente verwendet und eine Liste von Ganzzahlen zurückgibt. (d=IntegerDigits@#)^Range@Length@derzeugt die Liste der Ziffern einer Zahl mit den entsprechenden Befugnissen; Tr[...]==#Erkennt, ob die Summe dieser Ziffernkräfte der ursprünglichen Zahl entspricht.

MATLAB, 88 73 Bytes

@(n,m)find(arrayfun(@(n)n==sum((num2str(n)-48).^(1:log10(n)+1)),n:m))+n-1

Ursprüngliche Antwort:

function g(n,m);a=n:m;a(arrayfun(@(n)n==sum((num2str(n)-'0').^(1:floor(log10(n))+1)),a))

num2str(n)-'0'teilt a nin einen Vektor seiner Ziffern auf und 1:floor(log10(n))+1ist ein Vektor, der eins zur Anzahl der Ziffern in enthält n. Dank einer anonymen Funktion, die 15 Bytes spart , können Sie sich für den Golf anmelden .

Haskell , 82 76 75 Bytes

n!m=[x|x<-[n..m],x==x#(length.show)x]
0#i=0
n#i=(div n 10)#(i-1)+mod n 10^i

Probieren Sie es online! Verwendung:5 ! 175

Dies überprüft jede Zahl im Bereich, num mfestzustellen , ob es sich um eine Disarium-Nummer handelt, und ist daher für große Zahlen recht langsam m.

Schnellere Version: (93 Bytes)

n!m=[x|x<-[0..9]++[89,135,175,518,598,1306,1676,2427,2646798,12157692622039623539],x>=n,x<=m]

Probieren Sie es online!

C (gcc) , 136 Bytes

r[]={0,0};f(n){if(n)f(n/10),r[1]=pow((n%10),*r)+r[1]+.5,r[0]++;else*r=1,r[1]=0;}g(m,x){for(;m<=x;m++){f(m);if(m==r[1])printf("%d,",m);}}

Header, der pow auf TIO definiert, weil aus irgendeinem Grund pow nicht automatisch eingeschlossen wurde. Mein Computer hat es getan, also werde ich damit anfangen.

Probieren Sie es online!

MATL , 16 Bytes

&:"@tFYAtn:^s=?@

Probieren Sie es online!

&:        % Input two n, m implicitly. Push array [n n+1 ... m]
"         % For each k in that array
  @       %   Push k
  tFYA    %   Duplicate. Convert to decimal digits
  tn:     %   Duplicate. Push [1 2 ... d], where d is the number of digits
  ^       %   Element-wise power
  s       %   Sum of array
  =       %   Compare with previous copy of k: is it equal?
  ?       %   If so
    @     %     Push k
          %   End, implicit
          % End, implicit
          % Display stack, implicit

Batch, 115 Bytes

@for %%d in (0 1 2 3 4 5 6 7 8 9 89 135 175 518 598 1306 1676 2427 2646798)do @if %%d geq %1 if %%d leq %2 echo %%d

Batch hat nur eine 32-Bit-Arithmetik, mit der die letzte Disarium-Nummer nicht verglichen werden kann. Wenn Sie jedoch auf String-Vergleichen bestehen, gilt für 402 Bytes Folgendes:

@echo off
for %%d in (0 1 2 3 4 5 6 7 8 9 89 135 175 518 598 1306 1676 2427 2646798 12157692622039623539)do call:c %1 %%d&&call:c %%d %2&&echo %%d
exit/b
:c
call:p %1 %2
set r=%s%
call:p %2 %1
:g
if %r:~,1% lss %s:~,1% exit/b0
if %r:~,1% gtr %s:~,1% exit/b1
if %r%==%s% exit/b0
set r=%r:~1%
set s=%s:~1%
goto g
:p
set s=%1
set t=%2
:l
set s=0%s%
set t=%t:~1%
if not "%t%"=="" goto l

Python 2, 100 Bytes

for i in range(input(),input()+1):x=sum(int(`i`[n])**-~n for n in range(len(`i`)));print("",x)[x==i]

Ich hatte noch keine Chance, dies auszuführen (dies auf meinem Telefon zu tun).

Scala, 132 129 Bytes

(% :Int,^ :Int)=>for(i<- %to^)if(((0/:(i+"").zipWithIndex)((z,f)=>{z+BigInt(f._1.toInt-48).pow(f._2+1).intValue}))==i)println(i)

129 edit: Ändert den Variablennamen der for-Schleife von &auf igespeicherte drei Leerzeichen.

Erläuterung

Für jeden Wert im Eingabebereich:

• konvertiere es in einen String mit +""
• Verwenden Sie zipWithIndexdiese Option, um eine Liste von Tupeln zu erstellen, die ein Zeichen der Ziffer und ihres Index enthalten
• falten Sie die Liste, indem Sie den int-Wert jedes Zeichens minus 48 (Zeilen bis 0-9) auf die Potenz seines Listenindex plus eins setzen (um bei ^ 1 zu beginnen)
• Wenn das Ergebnis mit der Eingabe übereinstimmt, drucken Sie es aus

Bemerkungen

Endlich habe ich gelernt, wie foldund wie ich zipWithIndexarbeite. Ich bin mit den intKonvertierungen unzufrieden , aber ich bin mit der Prägnanz von foldund zufrieden zipWithIndex.

Oktave, 88 87 Bytes

Dank an MattWH für das Speichern eines Bytes (f (x) -48 vs f (x) - '0')

@(n,m,f=@num2str,a=n:m)a(a==cell2mat(arrayfun(@(x){sum((f(x)-48).^(1:nnz(f(x))))},a)))

Zu rennen:

>> f=@(n,m,f=@num2str,a=n:m)a(a==cell2mat(arrayfun(@(x){sum((f(x)-'0').^(1:nnz(f(x))))},a))) 
>> f(0,1000)
ans = 
      1     2     3     4     5     6     7     8     9    89   135   175   518   598

Erläuterung

@(n,m,                                              % Create an anonymous function and pass it n and m as paramteres
    f=@num2str,                                     % Will be using the num2str mehtod twice, set the variable f to the handle to save on bytes
        a=n:m)                                      % Create a vector 'a' and populate it with the numbers n through m
            a(a==                                   % Logically index into a, where the values of a match Disarium numbers
                cell2mat(                           % Convert the cell array returned by arrayfun into a matrix, so we can use it in the logical index
                    arrayfun(@(x){                  % Call the following function on every element of a, using the index named 'x'
                        sum(                        % Sum the matrix that results from the following computation
                            (f(x)-'0')              % Convert the value at index x into a string, then break it into a matrix by subtracting the string '0'.
                                                    % This results in the matrix [1 3 5] for the number 135.
                                .^                  % Compute the element-wise power with the following matrix
                                    (1:nnz(f(x)))   % Create a matrix with the range 1 to the length of the number at index x. This results in the matrix 
                                                    % [1 2 3] for the number 135.
                        )                           % Closes the sum statement
                    },a)                            % Closes the arrayfun statement, passing the matrix a to be operated on
                )
            )

C 175 169 Bytes

f(a,b){for(j=a;j<b;j++){n,i=0,x=0;s=0;n=j;while(n!=0){n/=10;i++;}a[i];n=j;while(n!=0){a[i-x-1]=n%10;n/=10;x++;}for(x=0;x<i;x++)s+=(int)pow(a[x],x+1);if(j==s)printf("%d ",s);}}

Ungolfed-Version:

void f(int a, int b)
{

  for(int j=a; j<b;j++)
  {
    int n,i=0,x=0;
    int s=0;
    n=j;

   //Convert each number from 'n' to 'm' and store it in an int array 
   while(n)
   {
     n/=10;
     i++;     
   }
   int a[i]; 

   n=j;       
   while(n)
   {
    a[i-x-1]=n%10;
    n/=10;
    x++;     
   }

  //Calculate sum of digits powered with their respective position
  for(x=0;x<i;x++)
   s+=(int)pow(a[x], x+1);

   //Print Desarium
   if(j==s)
    printf("%d ", sum);     
 }

}

Kann irgendwie gekürzt werden, aber ich sehe es im Moment nicht.

@ TuukkaX Vielen Dank für das Speichern von 6 Bytes.

Java

s->{long i=0,j=0,c,d;for(;j!=s;){String []f=Long.toString(i).split("");for(d=0,c=0;d<f.length;)c+=Math.pow(Long.valueOf(f[d]),++d);if(i==c)j++;}return i;}

Erläuterung

s    - index
i    - iteration variable
j    - matches
c    - sum of each digit^its index
d    - index of digit in i

Python 3: 131 Bytes

n=int(input())
m=int(input())
R=[x for x in range(n,m+1)]
O=[sum(map(int,str(x)))for x in R]
F=[(x**(O.index(x)))for x in O]
L=[x for x in F for w in R if x==w]
print(list(set(L)))

Nach der Erstellung dieses Codes hat sich herausgestellt, dass es nur eine begrenzte Anzahl von Disarien gibt. Daher ist es möglicherweise sinnvoller, diese explizit zu überprüfen, als so viel Listenverständnis zu verwenden, das große Eingaben in diese Lösung erschwert.

Probieren Sie es online!