Dilema del acuario

Un Disarium se define como un número cuyo:

la suma de sus dígitos alimentados con su posición respectiva es igual al número original

Su tarea :

Tienes una extraña obsesión con los números clasificados como un acuario. La necesidad de seguir los caminos del disarium es tan grande en usted que se niega a leer las páginas numeradas que no están en el acuario de cualquier libro. Tienes dos GRANDES problemas:

1. Su profesor acaba de asignarle que lea su libro de texto de una página na otram
2. Te golpeaste la cabeza muy fuerte la semana pasada y parece que no puedes recordar cómo determinar mediante programación si un número se considera un acuario.

El tiempo es esencial, por lo que el código para determinar las páginas que necesitará leer debe ser lo más breve posible.

Debe identificar todo el disuario dentro de un rango inclusivo de nhasta m.

Ejemplos de un acuario :

89 = 8 ¹ + 9 ²

135 = 1 ¹ + 3 ² + 5 ³

518 = 5 ¹ + 1 ² + 8 ³

Este es el código de golf, por lo que gana el menor número de bytes.

Aquí está la secuencia completa de A032799 .

Perl 6 , 40 39 bytes

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

Pruébalo en línea!

Cómo funciona

{                                     }  # 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]

Horrible. Se acortará. Empieza a verse mejor

Aquí está mi intento recursivo (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)

¡Gracias a @Rod por guardar 4 bytes! rangea enumeratey así sucesivamente.

Perl, 43 bytes

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

Pruébalo en línea!

Regex es realmente poderoso, muchachos.

Explicación

Lo primero que hace el código es leer dos enteros como entrada vía <>, y crea un rango del primero al segundo con ... Luego usa la mapfunción estándar para recorrer este rango y aplica el siguiente código a cada valor:say if$_==eval s/./+$&**$+[0]/gr . Esto parece galimatías, y lo es, pero esto es lo que realmente está sucediendo.

mapalmacena implícitamente su valor actual en la variable $_. Muchas funciones y operaciones de Perl usan este valor cuando no se da ninguna. Esto incluye expresiones regulares, como el s///operador de sustitución.

Hay cuatro partes en una expresión regular de sustitución:

1. Cadena para ser manipulada. Normalmente, el operador =~se utiliza para aplicar una expresión regular a una cadena, pero si este operador está ausente, la expresión regular se aplica a la variable implícita $_, que contiene nuestro número actual a través de la mapfunción.
2. Cadena para buscar. En este caso, estamos buscando cualquier carácter único que no sea de nueva línea, indicado por el comodín .. En efecto, estamos capturando cada dígito individual.
3. Cadena para reemplazar con. Estamos sustituyendo un signo más +seguido de una expresión matemática, mezclada con algunas variables mágicas de Perl que hacen que todo sea mucho más fácil.

La variable escalar especial $&siempre contiene la totalidad de la última captura de expresiones regulares exitosa, que en este caso es un solo dígito. La variable de matriz especial @+siempre contiene una lista de compensaciones posteriores a la coincidencia para la última coincidencia exitosa, es decir, el índice del texto después de la coincidencia. $+[0]es el índice $_del texto que sigue inmediatamente $&. En el caso de 135, capturamos el dígito 1y el índice en135 del texto inmediatamente después (es decir, 35) es 1, que es nuestro exponente. Entonces, queremos elevar $&(1) a la potencia de $+[0](1) y obtener 1. Queremos elevar 3 a la potencia de 2 y obtener 9. Queremos elevar 5 a la potencia de 3 y obtener 125.

Si la entrada fue 135 , la cadena resultante es +1**1+3**2+5**3.

4. Banderas modificadoras de expresiones regulares. Aquí estamos usando dos banderas regex - /gy /r. /gle dice al intérprete que continúe con los reemplazos después de encontrar el primero (de lo contrario, terminaríamos con +1**135). /rle dice al intérprete que no modifique la cadena original y, en su lugar, devuelva cuál sería la cadena después de los reemplazos. Esto es importante, porque de lo contrario, se sobrescribiría $_, y lo necesitamos para fines de comparación.

Una vez que se realiza la sustitución completa, obtenemos una expresión matemática, que se evalúa con la evalfunción. +1**1+3**2+5**3se evalúa en 1 + 9 + 125 = 135, que se compara con el número original 135. Como estos dos son iguales, el código imprime el número.

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

¡Gracias a Arnauld por ahorrar 20B y a ETHProductions por ahorrar 6B!

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

Uso

Asigne la función a una variable y dele el mínimo y el máximo como argumentos. Ejemplo:

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

Salida

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

Golf adicional

Esto parece bastante bien, pero siempre hay margen de mejora ... creo.

JavaScript (Firefox 52+), 68 bytes

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

Función recursiva que sale a través de alert. Funciona en la Edición para desarrolladores de Firefox, que puede descargar en esta página . Las versiones anteriores de Firefox no son compatibles con el **operador, y ningún otro navegador es compatible con la [for(a of b)c]sintaxis.

Fragmento de prueba

Esto utiliza en .maplugar de una comprensión de matriz, y en Math.powlugar de **, por lo que debería funcionar en todos los navegadores que admitan 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 bytes

Guardado 2 bytes gracias a Emigna

ŸvygLySmOyQ—

Pruébalo en línea!

Ÿ            # 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)}

No es el enfoque más corto, pero sí uno muy lindo. Hay finitamente muchos acuarios; ver la página de OEIS para una buena prueba. Estos son todos ellos.

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

Función sin nombre que toma ny m. Como siempre en R, dividir enteros en un vector de dígitos numéricos es tedioso y consume muchos bytes. Esto hace que la función sea relativamente lenta y solo funciona para enteros de 32 bits.

Jalea , 11 bytes

D*J$S⁼
rÇÐf

Pruébalo en línea!

¡Lo conseguí de 16 a 11, con ayuda de @miles!

Explicación:

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

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

Un enfoque de programa completo, actualmente de la misma longitud que la solución 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

Pruébalo en línea!

Japt, 15 bytes

òV f_¥Zì £XpYÄÃx

¡Pruébelo en línea! Esta fue una colaboración entre @obarakon y yo.

Cómo funciona

ò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

En la última versión de Japt, xacepta una función como argumento, lo que nos permite jugar a otro byte:

òV f_¥Zì x@XpYÄ

¡Pruébelo en línea!

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)

La implementación de la ecuación es terriblemente larga.

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

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

Verifique cada número ien el rango[n..m] . Los dígitos se extraen convirtiéndolos ien una cadena ( show) y haciendo que cada carácter sea una cadena de un elemento ( pure) que se convierte nuevamente en un entero ( read). Comprime esos elementos con [1..]la función ^y toma el sum.

PHP, 92 91 88 bytes

3 bytes guardados gracias @AlexHowansky

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

toma datos de los argumentos de la línea de comandos; imprime una coma final. Corre con -r.

Mathematica, 59 bytes

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

Función sin nombre que toma dos argumentos enteros y devuelve una lista de enteros. (d=IntegerDigits@#)^Range@Length@dproduce la lista de dígitos de un número a las potencias apropiadas; Tr[...]==#detecta si la suma de esas potencias de dígitos es igual al número original.

MATLAB, 88 73 bytes

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

Respuesta original:

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

num2str(n)-'0'divide a nen un vector de sus dígitos, y 1:floor(log10(n))+1es un vector que contiene uno para el número de dígitos n. Gracias por iniciar sesión en el golf hasta una función anónima, ahorrando 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

Pruébalo en línea!Uso:5 ! 175

Esto comprueba cada número en el rango nde msi es un número de disarium y, por lo tanto, es bastante lento para grandesm .

Versión más rápida: (93 bytes)

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

Pruébalo en línea!

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

Encabezado que define pow en TIO porque por alguna razón no incluyó automáticamente pow. Mi computadora lo hizo, así que voy a rodar con eso.

Pruébalo en línea!

MATL , 16 bytes

&:"@tFYAtn:^s=?@

Pruébalo en línea!

&:        % 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

Lote, 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 solo tiene una aritmética de 32 bits que no tiene forma de comparar el último número de disarium, pero si insiste en las comparaciones de cadenas, entonces para 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]

Todavía no he tenido la oportunidad de ejecutar esto (hacerlo en mi teléfono).

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 editar: Cambiar el nombre de la variable de bucle de partir &a iguardados tres espacios.

Explicación

Para cada valor en el rango de entrada:

• convertirlo a una cadena con +""
• utilizar zipWithIndex para producir una lista de tuplas que contienen un carácter del dígito y su índice
• doblar la lista devolviendo el valor int de cada carácter menos 48 (líneas hasta 0-9) a la potencia de su índice de lista más uno (para comenzar en ^ 1)
• si el resultado coincide con la entrada, imprímalo

Comentarios

Finalmente pude aprender cómo foldy zipWithIndextrabajar. No estoy satisfecho con las intconversiones, pero estoy satisfecho con la brevedad de foldy zipWithIndex.

Octava, 88 87 bytes

Gracias a MattWH por guardar un 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)))

Correr:

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

Explicación

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

Versión sin golf:

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

}

Se puede acortar de alguna manera, pero no lo veo en este momento.

@TuukkaX Gracias por guardar 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;}

Explicación

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

Después de crear este código, se hace evidente que hay un número limitado de disarios, por lo que podría ser más factible verificarlos explícitamente en lugar de utilizar tanta comprensión de la lista que es difícil para las grandes entradas de esta solución.

Pruébalo en línea!