Dylemat Disarium

Disarium jest zdefiniowane jako liczba, której:

suma jego cyfr zasilanych ich odpowiednią pozycją jest równa pierwotnej liczbie

Twoje zadanie :

Masz dziwną obsesję na punkcie liczb zaklasyfikowanych jako disarium. Konieczność podążania ścieżkami disarium jest w tobie tak wielka, że odmawiasz czytania stron nie ponumerowanych w żadnej książce. Masz dwa DUŻE problemy:

1. Twój profesor właśnie wyznaczył cię do przeczytania twojego podręcznika od strony ndo stronym
2. W zeszłym tygodniu naprawdę mocno uderzyłeś się w głowę i wydaje się, że nie pamiętasz, jak programowo ustalić, czy liczba jest uważana za disarium.

Najważniejszy jest czas, więc kod określający strony, które należy przeczytać, musi być jak najkrótszy.

Trzeba zidentyfikować wszystkie disarium ciągu integracyjnego zakresie nthrough m.

Przykłady disarium :

89 = 8 ¹ + 9 ²

135 = 1 ¹ + 3 ² + 5 ³

518 = 5 ¹ + 1 ² + 8 ³

To jest golf golfowy, więc wygrywa najmniej bajtów!

Oto pełna sekwencja A032799 .

Perl 6 , 40 39 bajtów

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

Wypróbuj online!

Jak to działa

{                                     }  # 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 bajtów

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

Okropny. Skróci się. Zaczynam wyglądać lepiej

Oto moja rekurencyjna próba (86 bajtów):

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

Dzięki @Rod za oszczędność 4 bajtów! rangedo enumeratei tak dalej.

Perl, 43 bajty

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

Wypróbuj online!

Regex jest naprawdę potężny.

Wyjaśnienie

Pierwszą rzeczą, jaką robi kod, jest odczytanie dwóch liczb całkowitych na wejściu <>i utworzenie zakresu od pierwszej do drugiej za pomocą ... Następnie wykorzystuje standardową mapfunkcję iterację tego zakresu, i stosuje następujący kod do każdej wartości: say if$_==eval s/./+$&**$+[0]/gr. To wygląda jak bełkot i tak jest, ale oto, co się naprawdę dzieje.

mapniejawnie przechowuje swoją bieżącą wartość w zmiennej $_. Wiele funkcji i operacji Perla używa tej wartości, gdy nie podano żadnej. Obejmuje to wyrażenia regularne, takie jak s///operator podstawienia.

Wyrażenie zastępcze składa się z czterech części:

1. Ciąg do manipulowania. Zwykle operator =~jest stosowany do stosowania wyrażenia regularnego do łańcucha, ale jeśli ten operator jest nieobecny, to wyrażenie regularne jest stosowane do zmiennej niejawnej $_, która zawiera naszą bieżącą liczbę za pośrednictwem mapfunkcji.
2. Ciąg do wyszukania. W tym przypadku szukamy dowolnego znaku nieliniowego oznaczonego symbolem wieloznacznym .. W efekcie przechwytujemy każdą pojedynczą cyfrę.
3. Ciąg do zastąpienia. Zastępujemy znak plus, +po którym następuje wyrażenie matematyczne, połączone z pewnymi magicznymi zmiennymi Perla, które znacznie ułatwiają wszystko.

Specjalna zmienna skalarna $&zawsze zawiera całość ostatniego udanego przechwytywania wyrażenia regularnego, która w tym przypadku jest pojedynczą cyfrą. Specjalna zmienna tablicowa @+zawsze zawiera listę przesunięć pocztowych dla ostatniego udanego dopasowania, tj. Indeks tekstu po dopasowaniu. $+[0]jest indeksem $_tekstu bezpośrednio po nim $&. W przypadku 135, przechwytujemy cyfrę 1, a indeks w 135tekście zaraz potem (mianowicie 35) wynosi 1, co jest naszym wykładnikiem. Chcemy więc podnieść $&(1) do potęgi $+[0](1) i uzyskać 1. Chcemy podnieść 3 do potęgi 2 i uzyskać 9. Chcemy podnieść 5 do potęgi 3 i uzyskać 125.

Jeśli dane wejściowe były 135, wynikowy ciąg to +1**1+3**2+5**3.

4. Flagi modyfikujące Regex. Tutaj używamy dwóch flag wyrażeń regularnych - /gi /r. /gmówi tłumaczowi, aby kontynuował zastępowanie po znalezieniu pierwszego (w przeciwnym razie byśmy mieli +1**135). /rmówi interpreterowi, aby nie modyfikował oryginalnego ciągu znaków , a zamiast tego zwraca ciąg znaków po zamianach. Jest to ważne, ponieważ w przeciwnym razie nadpisze $_i potrzebujemy go do celów porównawczych.

Po zakończeniu całego podstawienia otrzymujemy wyrażenie matematyczne, które jest oceniane za pomocą evalfunkcji. +1**1+3**2+5**3jest obliczany na 1 + 9 + 125 = 135, który jest porównywany z pierwotnym numerem 135. Ponieważ te dwa są równe, kod wypisuje liczbę.

JavaScript (ES7), 105 91 89 88 83 79 82 81 bajtów

Dzięki Arnauld za uratowanie 20B i ETHProductions za uratowanie 6B!

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

Stosowanie

Przypisz funkcję do zmiennej i podaj jako minimum i maksimum jako argumenty. Przykład:

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

Wydajność

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

Dalsza gra w golfa

Wygląda na to, że gra w golfa dość dobrze, ale zawsze jest miejsce na poprawę ... Myślę, że.

JavaScript (Firefox 52+), 68 bajtów

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

Funkcja rekurencyjna wysyłana przez alert. Działa w wersji dla programistów przeglądarki Firefox, którą można pobrać na tej stronie . Poprzednie wersje Firefoksa nie obsługują **operatora i żadna inna przeglądarka nie obsługuje [for(a of b)c]składni.

Testowy fragment kodu

To używa .mapzamiast interpretacji tablic, a Math.powzamiast tego **, więc powinno działać we wszystkich przeglądarkach, które obsługują ES6.

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 bajtów

Zaoszczędź 2 bajty dzięki Emignie

ŸvygLySmOyQ—

Wypróbuj 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 bajtów

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

Nie najkrótsze podejście, ale całkiem urocze. Na pewno jest wiele disariów; niezły dowód można znaleźć na stronie OEIS. To są wszystkie z nich.

R, 100 bajtów

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

Nienazwana funkcja, która przyjmuje ni m. Jak zawsze w R, dzielenie liczb całkowitych na wektor cyfr numerycznych jest żmudne i pochłania wiele bajtów. To sprawia, że ​​funkcja jest stosunkowo powolna i działa tylko dla 32-bitowych liczb całkowitych.

Galaretka , 11 bajtów

D*J$S⁼
rÇÐf

Wypróbuj online!

Zmniejszono to z 16 do 11, z pewną pomocą @miles!

Wyjaśnienie:

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 bajty

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

Wypróbuj online!

Wyjaśnienie

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 bajtów

Ÿvy©SDgLsmO®Qi®}})

Wypróbuj online!

Python 2.X, 92 bajty

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 bajtów

Pełne podejście programowe, obecnie tej samej długości co rozwiązanie lambda.

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

Wypróbuj online!

Japt, 15 bajtów

òV f_¥Zì £XpYÄÃx

Przetestuj online!To była współpraca między @obarakon a mną.

Jak to działa

ò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

W najnowszej wersji Japt xakceptuje funkcję jako argument, co pozwala nam zagrać w inny bajt:

òV f_¥Zì x@XpYÄ

Przetestuj online!

Clojure, 107 bajtów

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

Implementacja równania jest strasznie długa.

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..])]

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

Check each number i in the range [n..m]. The digits are extracted by turning i into a string (show) and making each char a one element string (pure) which is turned into an integer again (read). Zip those numbers element wise with [1..] via the function ^ and take the sum.

PHP, 92 91 88 bytes

3 bytes saved thanks @AlexHowansky

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

takes input from command line arguments; prints a trailing comma. Run with -r.

Mathematica, 59 bytes

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

Unnamed function taking two integer arguments and returning a list of integers. (d=IntegerDigits@#)^Range@Length@d produces the list of digits of a number to the appropriate powers; Tr[...]==# detects whether the sum of those digit-powers equals the original number.

MATLAB, 88 73 bytes

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

Original answer:

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

num2str(n)-'0' splits a n into a vector of its digits, and 1:floor(log10(n))+1 is a vector holding one to the number of digits in n. Thanks to log for the golf down to an anonymous function, saving 15 bytes.

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

Try it online! Usage: 5 ! 175

This checks each number in the range n to m if its a disarium number and is hence quite slow for big m.

Faster version: (93 bytes)

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

Try it 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 defining pow on TIO because for some reason it didn't auto include pow. My computer did, so I'm going to roll with that.

Try it online!

MATL, 16 bytes

&:"@tFYAtn:^s=?@

Try it 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 only has 32-bit arithmetic which has no way of comparing the last disarium number, but if you insist on string comparisons, then for 402 bytes:

@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]

I haven't had a chance to run this yet (doing this on my phone).

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: Changing the for loop's variable name from & to i saved three spaces.

Explanation

For each value in the input range:

• convert it to a string with +""
• use zipWithIndex to produce a list of tuples containing a char of the digit and its index
• fold the list by returning each char's int value minus 48 (lines up to 0-9) to the power of its list index plus one (to start at ^1)
• if the result matches the input, print it

Comments

Finally got around to learning how fold and zipWithIndex work. I'm unhappy with the int conversions, but I am pleased with the succinctness of fold and zipWithIndex.

Octave, 88 87 bytes

Thanks to MattWH for saving a byte (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)))

To run:

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

Explanation

@(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);     
 }

}

Can be shortened in some way, but I don't see it at the moment.

@TuukkaX Thanks for saving 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;}

Explanation

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)))

After creating this code, it's become apparent that there are a limited number of disariums, so it might be more feasible to check for these explicitly rather than using so much list comprehension which is tough on big inputs to this solution.

Try it online!