Dilemme du disarium

Un Disarium est défini comme un nombre dont:

la somme de ses chiffres alimentés avec leur position respective est égale au nombre d'origine

Votre tâche :

Vous avez une étrange obsession pour les nombres classés comme étant un disarium. La nécessité de suivre les voies du disarium est si grande en vous que vous refusez de lire les pages non numérotées d'un disarium dans un livre donné. Vous avez deux gros problèmes:

1. Votre professeur vient de vous confier la lecture de votre manuel de page nen pagem
2. La semaine dernière, vous vous êtes vraiment cogné la tête et vous n'arrivez pas à vous souvenir comment déterminer par programme si un nombre est considéré comme un disarium.

Le temps presse, le code permettant de déterminer les pages à lire doit être le plus court possible.

Vous devez identifier tout le disarium dans une plage inclusive de ntravers m.

Exemples de disarium :

89 = 8 ¹ + 9 ²

135 = 1 ¹ + 3 ² + 5 ³

518 = 5 ¹ + 1 ² + 8 ³

Il s'agit de code-golf, donc le moins d'octets gagne!

Voici la séquence complète de A032799 .

Perl 6 , 40 39 octets

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

Essayez-le en ligne!

Comment ça marche

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

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

Horrible. Va raccourcir. Commencer à mieux paraître

Voici ma tentative récursive (86 octets):

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

Merci à @Rod pour avoir économisé 4 octets! rangeà enumerateet ainsi de suite.

Perl, 43 octets

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

Essayez-le en ligne!

Regex est vraiment puissant, vous les gars.

Explication

La première chose que le code fait est de lire deux entiers comme entrée via <>et crée une plage du premier au second avec ... Il utilise ensuite la norme mapfonction pour itérer cette gamme, et applique le code suivant à chaque valeur: say if$_==eval s/./+$&**$+[0]/gr. Cela ressemble à du charabia, et c'est en quelque sorte le cas, mais voici ce qui se passe vraiment.

mapstocke implicitement sa valeur actuelle dans la variable $_. De nombreuses fonctions et opérations perl utilisent cette valeur lorsqu'aucune n'est indiquée. Cela inclut les expressions régulières, telles que l' s///opérateur de substitution.

Une expression régulière de substitution se compose de quatre parties:

1. Chaîne à manipuler. Normalement, l'opérateur =~est utilisé pour appliquer une expression régulière à une chaîne, mais si cet opérateur est absent, alors l'expression régulière est appliquée à la variable implicite $_, qui contient notre numéro actuel via la mapfonction.
2. Chaîne à rechercher. Dans ce cas, nous recherchons n'importe quel caractère non nouveau de ligne, indiqué par le caractère générique .. En fait, nous capturons chaque chiffre individuel.
3. Chaîne à remplacer. Nous remplaçons un signe plus +suivi d'une expression mathématique, mélangée à des variables Perl magiques qui facilitent considérablement le tout.

La variable scalaire spéciale $&contient toujours l'intégralité de la dernière capture regex réussie, qui dans ce cas est un seul chiffre. La variable spéciale de tableau @+contient toujours une liste de décalages post - match pour la dernière correspondance réussie, c'est-à-dire l'index du texte après la correspondance. $+[0]est l'index $_du texte suivant immédiatement $&. Dans le cas de 135, nous capturons le chiffre 1et l'index 135du texte immédiatement après (à savoir, 35) est 1, qui est notre exposant. Donc, nous voulons élever $&(1) à la puissance de $+[0](1) et obtenir 1. Nous voulons élever 3 à la puissance de 2 et obtenir 9. Nous voulons élever 5 à la puissance de 3 et obtenir 125.

Si l'entrée était 135, la chaîne résultante est +1**1+3**2+5**3.

4. Indicateurs de modification des expressions rationnelles. Ici, nous utilisons deux drapeaux d'expression régulière - /get /r. /gdit à l'interprète de continuer les remplacements une fois le premier trouvé (sinon nous finirions avec +1**135). /rindique à l'interpréteur de ne pas modifier la chaîne d'origine et de renvoyer à la place ce que serait la chaîne après les remplacements. Ceci est important, car sinon, il écraserait $_et nous en avons besoin à des fins de comparaison.

Une fois la substitution complète effectuée, nous obtenons une expression mathématique, qui est évaluée avec la evalfonction. +1**1+3**2+5**3est évalué dans 1 + 9 + 125 = 135, qui est comparé au nombre d'origine 135. Puisque ces deux sont égaux, le code imprime le nombre.

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

Merci à Arnauld pour avoir économisé 20B et à ETHProductions pour avoir économisé 6B!

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

Usage

Assignez la fonction à une variable et donnez-lui le minimum et le maximum comme arguments. Exemple:

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

Sortie

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

Golf supplémentaire

Cela semble assez bien joué, mais il y a toujours place à amélioration ... Je pense.

JavaScript (Firefox 52+), 68 octets

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

Fonction récursive qui sort via alert. Fonctionne dans Developer Edition de Firefox, que vous pouvez télécharger sur cette page . Les versions précédentes de Firefox ne prennent pas en charge l' **opérateur, et aucun autre navigateur ne prend en charge la [for(a of b)c]syntaxe.

Extrait de test

Cela utilise .mapau lieu d'une compréhension de tableau, et Math.powau lieu de **, il devrait donc fonctionner dans tous les navigateurs qui prennent en charge 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 octets

Enregistré 2 octets grâce à Emigna

ŸvygLySmOyQ—

Essayez-le en ligne!

Ÿ            # 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 octets

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

Pas l'approche la plus courte, mais plutôt mignonne. Il y a infiniment de disariums; voir la page OEIS pour une belle preuve. Ce sont tous.

R, 100 octets

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

Fonction sans nom qui prend net m. Comme toujours dans R, la division d'entiers en un vecteur numérique est fastidieuse et consomme beaucoup d'octets. Cela rend la fonction relativement lente et ne fonctionne que pour les entiers 32 bits.

Gelée , 11 octets

D*J$S⁼
rÇÐf

Essayez-le en ligne!

Je suis passé de 16 à 11, avec l'aide de @miles!

Explication:

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 octets

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

Essayez-le en ligne!

Explication

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 octets

Ÿvy©SDgLsmO®Qi®}})

Essayez-le en ligne!

Python 2.X, 92 octets

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 octets

Une approche programme complète, actuellement de la même longueur que la solution 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

Essayez-le en ligne!

Japt, 15 octets

òV f_¥Zì £XpYÄÃx

Testez-le en ligne! C'était une collaboration entre @obarakon et moi.

Comment ça marche

ò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

Dans la dernière version de Japt, xaccepte une fonction comme argument, ce qui nous permet de jouer un autre octet au golf:

òV f_¥Zì x@XpYÄ

Testez-le en ligne!

Clojure, 107 octets

#(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 mise en œuvre de l'équation est terriblement longue.

TI-Basic, 85 octets

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 octets

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

Exemple d'utilisation 5 # 600-> [5,6,7,8,9,89,135,175,518,598].

Vérifiez chaque numéro ide la plage [n..m]. Les chiffres sont extraits en se transformant ien chaîne ( show) et en faisant de chaque caractère une chaîne à un élément ( pure) qui est à nouveau transformée en entier ( read). Compressez ces chiffres par élément [1..]via la fonction ^et prenez le sum.

PHP, 92 91 88 octets

3 octets enregistrés grâce à @AlexHowansky

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

prend l'entrée des arguments de la ligne de commande; imprime une virgule de fin. Courez avec -r.

Mathematica, 59 octets

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

Fonction sans nom prenant deux arguments entiers et renvoyant une liste d'entiers. (d=IntegerDigits@#)^Range@Length@dproduit la liste des chiffres d'un nombre aux puissances appropriées; Tr[...]==#détecte si la somme de ces puissances numériques est égale au nombre d'origine.

MATLAB, 88 73 octets

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

Réponse originale:

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

num2str(n)-'0'divise a nen un vecteur de ses chiffres et 1:floor(log10(n))+1est un vecteur contenant un au nombre de chiffres de n. Merci de vous connecter pour le golf à une fonction anonyme, économisant 15 octets.

Haskell , 82 76 75 octets

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

Essayez-le en ligne! Usage:5 ! 175

Ce vérifie chaque numéro dans la gamme nde msi son numéro de disarium et est donc assez lent pour le grand m.

Version plus rapide: (93 octets)

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

Essayez-le en ligne!

C (gcc) , 136 octets

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

En-tête définissant pow sur TIO car pour une raison quelconque, il n'inclut pas automatiquement pow. Mon ordinateur l'a fait, donc je vais rouler avec ça.

Essayez-le en ligne!

MATL , 16 octets

&:"@tFYAtn:^s=?@

Essayez-le en ligne!

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

Lot, 115 octets

@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 n'a qu'une arithmétique 32 bits qui n'a aucun moyen de comparer le dernier numéro de disarium, mais si vous insistez sur les comparaisons de chaînes, alors pour 402 octets:

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

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

Je n'ai pas encore eu l'occasion de faire ça (en faisant ça sur mon téléphone).

Scala, 132 129 octets

(% :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: Changer le nom de variable de la boucle for de &à itrois espaces enregistrés.

Explication

Pour chaque valeur dans la plage d'entrée:

• le convertir en chaîne avec +""
• utiliser zipWithIndexpour produire une liste de tuples contenant un caractère du chiffre et son index
• replier la liste en renvoyant la valeur int de chaque caractère moins 48 (lignes jusqu'à 0-9) à la puissance de son index de liste plus un (pour commencer à ^ 1)
• si le résultat correspond à l'entrée, imprimez-le

commentaires

Enfin, j'ai appris à travailler foldet à zipWithIndextravailler. Je ne suis pas satisfait des intconversions, mais je suis satisfait de la brièveté de foldet zipWithIndex.

Octave, 88 87 octets

Merci à MattWH d'avoir sauvé un octet (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)))

Courir:

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

Explication

@(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 octets

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

Version non-golfée:

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

}

Peut être raccourci d'une certaine manière, mais je ne le vois pas pour le moment.

@TuukkaX Merci d'avoir économisé 6 octets.

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

Explication

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

Python 3: 131 octets

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

Après avoir créé ce code, il est devenu évident qu'il existe un nombre limité de disariums, il pourrait donc être plus faisable de les vérifier explicitement plutôt que d'utiliser autant de compréhension de liste, ce qui est difficile pour les grandes entrées de cette solution.

Essayez-le en ligne!